Novidades do Swift

Olá! Esta é a sessão Novidades do Swift. Eu sou Holly. E eu sou Allan. Hoje mostraremos os novos recursos e as melhorias do Swift 6.2. As melhorias visam tornar você um programador mais produtivo do Swift, não importa onde você escreve o código ou o tipo de código que escreve. Abordaremos as melhorias no fluxo de trabalho para escrever, criar e depurar código. Exploraremos as novas APIs da biblioteca de tarefas básicas de programação. Mostraremos como o Swift pode ser adotado nas camadas da pilha de software. Conheceremos os novos recursos de linguagem que facilitam o uso de concorrência e ajudam você a atingir o desempenho máximo quando precisar. As mudanças abordadas hoje foram desenvolvidas juntas em código aberto. A organização swiftlang no GitHub cresceu e tem mais de 50 projetos, incluindo o compilador, o site swift.org, as bibliotecas principais e de teste e outros componentes importantes que são a base o ecossistema maior. Além de migrar projetos para swiftlang, criamos o sistema de compilação do Xcode de código aberto: o Swift Build. O Swift Build suporta o processo de compilação dos sistemas da Apple. Há um esforço de código aberto para adotar o Swift Build como o sistema de compilação de baixo nível do Swift Package Manager. Isso unifica o mecanismo de compilação entre o Xcode e as cadeias de ferramentas do swift.org. Leia mais sobre o Swift Build na publicação do blog "O próximo capítulo das tecnologias Swift Build". Um dos mais novos membros do projeto swiftlang é um gerenciador de versões: o Swiftly. A comunidade de código aberto desenvolveu o Swiftly para simplificar gerenciamento do conjunto de o ferramentas do Swift no Linux. O Swiftly já é compatível com o macOS. Encontre a versão 1.0 em swift.org. Com um comando, você pode instalar o conjunto mais recente do Swift. Você pode instalar instantâneo noturno de uma ramificação do GitHub para testar recursos da linguagem em desenvolvimento. No Xcode, os conjuntos de ferramentas instalados pelo Swiftly estão no menu do Toolchain. Se você criar um app, ainda precisará usar o conjunto de ferramentas do Xcode para enviar seu app à App Store. No VS Code, selecione as cadeias de ferramentas instaladas pelo Swiftly com o comando Toolchain. Saiba mais sobre o Swiftly 1.0 no blog do Swift. As melhorias para começar a usar o Swift vão além da instalação das ferramentas. A página inicial swift.org tem nova aparência e foco renovado: ajudar você a se aprofundar em diferentes áreas, de apps a serviços de nuvem e sistemas integrados. Isso é uma colaboração com o grupo de trabalho do site do Swift. Nunca foi tão fácil começar a usar o Swift. Allan mostrará como o Swift 6.2 traz mais flexibilidade para criar um ambiente de desenvolvimento adequado. Obrigado, Holly. A versão atual do Swift tem muitas melhorias úteis nos fluxos de trabalho de desenvolvimento, não importa como você escreve o código do Swift. Elas incluem uma variedade de fluxos de trabalho, incluindo escrita de código, compilação e depuração. Se você desenvolve no VS Code, vamos começar conferindo as novidades deste ano.

A extensão do Swift no marketplace do VS Code agora é oficialmente verificada e distribuída pela swift.org. Ela também ganhou novos recursos no ano passado. O primeiro é a indexação em segundo plano. No Swift 6.1, ativamos a indexação em segundo plano por padrão para projetos Swift PM no VS Code e em outros IDEs. Isso permite que recursos do editor, como acessar a definição, sejam atualizados conforme se faz alterações no projeto. Agora os resultados da conclusão de código no VS Code estão mais relevantes com as melhorias feitas no SourceKit-LSP. A depuração também foi simplificada. A compatibilidade com LLDB é incluída automaticamente ao instalar a extensão do Swift. A versão mais recente da extensão também inclui um novo painel de projetos, o que facilita a localização das dependências, destinos e tarefas do pacote. E a extensão do Swift para VS Code inclui uma nova forma de ver a documentação do projeto. Abra a prévia de DocC ao lado do código, e ele será atualizado em tempo real enquanto você digita. A extensão do Swift para VS Code é desenvolvida em código aberto. Você a encontra no GitHub, na organização swiftlang. Vamos falar sobre melhorias na criação de códigos do Swift disponíveis para você em todos os lugares. Um dos aspectos mais importantes da produtividade é o desempenho das ferramentas. O Swift 6.2 melhora os tempos de compilação limpa de projetos que usam APIs com base em macro. Imagine que você tem um projeto que usa uma macro de um pacote imaginário chamado Stringify. Antes, para criar os projetos, o Swift PM primeiro tinha que buscar as fontes de swift-syntax, que é uma biblioteca que viabiliza as macros. Em seguida, ele compilaria swift-syntax, o plug-in da macro Stringify e, por fim, o código. A compilação de swift-syntax podia ser armazenada em cache, mas ainda aumentava o tempo da compilação limpa. Isso pode ser bem perceptível em um ambiente de integração contínua. Para acelerar a compilação, as versões do Swift PM e do Xcode aceitam as dependências pré-compiladas de swift-syntax. Isso elimina uma etapa cara da compilação e, em alguns projetos, reduz o tempo de compilação limpa em alguns minutos.

Se você tem um pacote que fornece macros, seus clientes poderão aproveitar essa otimização, desde que o pacote dependa de uma versão codificada de swift-syntax. Mas a produtividade nem sempre se resume ao desempenho de compilações. Às vezes, tentar resolver os problemas encontrados pelo compilador é o que causa lentidão. Por exemplo, ao escrever código concorrente no modo de linguagem Swift 6, o compilador pode detectar corridas de dados que você precisa evitar. Esse erro identifica algo importante, mas isso não significa que a solução do problema seja óbvia. Por isso, no Swift 6.2, começamos a expandir a documentação disponível para muitas categorias de diagnósticos. Essas explicações estendidas de avisos e erros comuns ajudam você a entender o problema e fornecem soluções concretas. Você pode acessar a documentação no seu IDE e online em swift.org. Controlar os diagnósticos também pode ser importante. Por exemplo, para manter o código livre de avisos, use o ajuste "avisos como erros". Isso funciona bem para avisos simples de resolver, mas outros, como os avisos de APIs descontinuadas, não devem ter a solução imediata forçada. O Swift 6.2 oferece flexibilidade para você escolher os avisos que devem ser tratados como erros. Você pode tratar todos os avisos como erros por padrão, mas abrir uma exceção para declarações descontinuadas. Mas, se quer apenas impedir a exibição de algumas categorias de avisos, você pode promover esses avisos a erros. Adicionar controles para avisos do compilador é um exemplo de um esforço da comunidade para melhorar o Swift para desenvolvedores. Agradecemos aos autores da proposta e a todos que participaram das discussões nos fóruns. Por fim, vamos dar uma olhada em algumas melhorias na depuração no Swift 6.2.

Nesta versão, melhoramos muito a experiência de depuração de código assíncrono. Ao conferir o código em execução em uma tarefa do Swift, o LLDB agora acompanha a execução em funções assíncronas, mesmo que isso exija a troca de threads. Entender os depuradores do modelo centrado em tarefas do Swift permite mostrar a tarefa sendo executada. Você pode dar um nome à tarefa para facilitar a identificação. Os nomes das tarefas aparecerão nos perfis do Instruments registrados com o modelo de concorrência do Swift. Você pode usar novos comandos, como swift task info, para obter mais informações sobre a tarefa em execução, como sua prioridade e tarefas secundárias. Por fim, as sessões de depuração serão mais responsivas com os módulos compilados explicitamente, um recurso do sistema de compilação que permite paralelismo e reutilização ao criar dependências de módulos. Antes dos módulos compilados explicitamente, a compilação e o depurador do Xcode usavam gráficos de módulo separados. Agora o depurador pode reutilizar os módulos da compilação. Então, na primeira vez que você executar p ou po no depurador, o comando será avaliado mais rápido porque as informações de tipo já estarão disponíveis. Os módulos explicitamente compilados estão ativados por padrão no Xcode 26. Essas são apenas algumas das melhorias de ferramentas no Swift este ano. A seguir, apresentarei algumas atualizações importantes nas principais bibliotecas do Swift que você usa todos os dias. As bibliotecas são úteis em todos os tipos de tarefas, e as bibliotecas principais do Swift têm elementos essenciais para escrever código no Swift. O Swift 6.2 moderniza mais a superfície de APIs do Foundation e fornece novas APIs para simplificar as tarefas de programação. Para melhorar o uso do Swift para tarefas de script, o grupo de trabalho do Foundation lançou um pacote com APIs para iniciar um subprocesso. Você começa adicionando e importando o novo pacote de subprocesso. Depois, inicia um subprocesso chamando a função de execução e aguardando o resultado. Se você fornecer uma string com o nome do processo, o método de execução buscará o executável com base na variável de ambiente $PATH.

Na maioria dos casos, você inicia um subprocesso usando FilePath para especificar o caminho completo até um executável. Quando o subprocesso termina, você pode inspecionar o status de saída, a saída padrão e outras informações sobre a execução do processo. A biblioteca de subprocessos tem mais recursos que oferecem controle refinado sobre a execução do processo, opções de ajuste específicas da plataforma e mais. É possível explorar toda a superfície da API no repositório swift-subprocess. O pacote está na versão 0.1, e o feedback relativo à sua adoção embasará a API que será lançada na versão 1.0. O grupo de trabalho do Foundation também aprimorou as APIs mais usadas em projetos de apps. Responder a notificações do UIKit é muito comum em apps iOS, mas o código para observar uma notificação é propenso a erros. Você precisa ter cuidado para registrar um nome de notificação que o objeto aceite publicar. Se houver erro, o retorno de chamada de notificação não será executado. As informações sobre a notificação ficam em um dicionário sem tipo, que requer assinatura manual usando a chave e a conversão dinâmica de resultado certas para o tipo correto. Mesmo quando a publicação da notificação é garantida na thread principal, ainda haverá erros de concorrência ao acessar APIs de agentes principais. Nomes de notificação e cargas úteis agora são compatíveis com tipos concretos. Os tipos concretos permitem que o compilador verifique se o objeto aceita o tipo de notificação para o qual você se registra. Eles também eliminam o boilerplate ao trabalhar com a carga útil de notificação. O tipo de notificação especifica onde ela é publicada. Você pode acessar livremente as APIs de agente principal se a notificação for publicada nesse agente. Um MainActorMessage de conformidade garante que a notificação seja sempre publicada de forma síncrona na thread principal. Uma AsyncMessage de conformidade significa que a notificação é publicada de forma assíncrona em uma thread arbitrária. Tipos de notificação concretos estão disponíveis no SDK para notificações publicadas por frameworks como UIKit e Foundation. Você também pode adicionar tipos de notificação concretos em suas notificações. A transmissão das notificações do sistema para os observadores registrados têm como base um padrão de observação mais geral. A biblioteca de observações fornece APIs de uso geral para monitorar automaticamente alterações de estado no gráfico de um objeto.

Você pode escolher uma classe no controle de observação usando a macro @Observable. O Swift 6.2 apresenta uma maneira de transmitir mudanças de estado com um AsyncSequence de um tipo observável. Comece criando uma instância do novo tipo de observação com um fechamento. No fechamento, calcule o valor que deseja observar nas alterações. Aqui, destaco a string que descreve o estado atual do jogador e quero um novo valor cada vez que a pontuação for atualizada ou o jogador receber um novo item. Você obterá um valor atualizado com base nas propriedades observáveis usadas no fechamento. As atualizações ocorrem transacionalmente. O controle de uma atualização começa quando uma das propriedades observáveis no fechamento tem willSet chamado. E termina na próxima espera, onde o código é suspenso. O valor atualizado incluirá todas as alterações síncronas em outras propriedades entre esses dois pontos do código. Dessa forma, as atualizações síncronas de várias propriedades não levam a atualizações de observação com o objeto em um estado inconsistente.

Se atualizar de forma síncrona a pontuação e o item, receberei só um valor atualizado com as duas alterações. O tipo de observação está em conformidade com AsyncSequence. Você pode iterar valores atualizados usando um loop for-await. Como desenvolvedores, escrevemos testes todos os dias. Swift Testing é uma biblioteca multiplataforma que fornece macros para descrever e organizar testes, como o atributo @Test para declarar uma função de teste. Você usa as macros expect e require para validar as suposições, e o Swift Testing fornece informações acionáveis quando uma expectativa ou requisito falha. Mas, às vezes, as falhas de teste são difíceis de escolher, especialmente se falharem apenas em ambientes remotos como o CI. Compreender uma falha de teste pode exigir mais contexto sobre os dados usados no teste.

O Swift 6.2 tem anexos personalizados que ajudam a diagnosticar falhas de teste. Você pode adicionar um anexo a um teste. Basta chamar o método Attachment.record. Você pode anexar tipos de biblioteca, como Data e String, e implementar suporte a anexos para seus tipos em o conformidade com o protocolo anexável. O Swift 6.2 também permite testes de saída para que você teste o código que espera encerrar sob determinadas condições. Se você escrever uma função que valida suposições sobre parâmetros de entrada por meio de pré-condições, poderá escrever um caso de teste que será bem-sucedido quando a pré-condição falhar.

Escreva um teste de saída passando o argumento processExitsWith para #expect ou #require. Ao escrever um teste de saída, o Swift Testing inicia um novo processo para executar o teste e você pode validar se o processo é encerrado com um código ou indicador de saída específico ou um status de falha. Essas bibliotecas de uso geral permitem que você escreva e teste códigos do Swift portáteis em todo o projeto, mesmo além do código do app. Na Apple, usamos o Swift em toda a nossa pilha de software. Nós o usamos para firmware, apps e frameworks e serviços online em grande escala. Você pode aproveitar as melhorias no Swift 6.2 ao escrever código para dispositivos integrados, componentes críticos de segurança e servidores. Você também pode direcioná-lo a algumas novas plataformas. Vamos começar na parte inferior da pilha com o Swift integrado. O Swift integrado é um subconjunto do Swift que permite escrever código direcionado aos ambientes mais restritos, como firmware para dispositivos integrados e kernels de sistema operacional. É um modo de compilação compatível com os principais recursos do Swift, como tipos de valor e referência, fechamentos, opcionais, tratamento de erros, genéricos e mais. Na Apple, estamos usando o Swift integrado em alguns softwares de nível mais baixo executados no iPhone. Por exemplo, no iOS 26, o Swift integrado é executado no coprocessador que gerencia o acesso às páginas de memória compartilhada entre a CPU e GPU. Para testar o Swift integrado, saiba mais na sessão "Usar o Swift integrado em baixo nível". O Swift 6.2 expande o Swift integrado com novos recursos. Ele abrange as APIs de string completa do Swift, incluindo a interpolação de strings. O item any types do Swift, que pode representar valores de tipos em conformidade com um protocolo, está disponível quando o protocolo é restrito a tipos de classe. A biblioteca padrão do Swift também está ganhando InlineArray e Span, que são duas novas APIs para trabalhar de modo eficiente com regiões da memória. Esses tipos, que Holly abordará em mais detalhes, são perfeitos para o tipo de código sensível ao desempenho encontrado em programas integrados. Conforme o Swift integrado fica cada vez mais robusto, a comunidade cria exemplos que você pode usar para começar seus próprios projetos incorporados. Confira-os no GitHub, no repositório swift-embedded-examples. Um dos benefícios do Swift integrado é que ele permite escrever software de baixo nível em linguagem segura para a memória por padrão. O Memory Safe Code é mais seguro, e temos trabalhado para tornar o Swift ainda melhor para códigos com os mais fortes requisitos de segurança. Às vezes, você precisa escrever código para realizar uma ação não segura. Ao integrar uma dependência escrita em C, por exemplo, é comum usar uma API que utiliza ponteiros. Em contextos críticos de segurança, códigos não seguros devem ser evitados. Se não puder ser evitado, deve ser fácil de identificar. É por isso que apresentamos o novo recurso *opt-in* no Swift 6.2: o strict memory safety. Esse modo requer que todos os usos de APIs inseguras sejam reconhecidos explicitamente no código-fonte. As anotações que o modo requer ajudam a identificar as partes do código que precisam de atenção extra em termos de segurança. Com o novo modo, o Swift 6.2 aceita novas anotações para cabeçalhos C e C++ que causam a importação das APIs para o Swift usando tipos ergonômicos e seguros, como Span. Para saber mais sobre os novos recursos de interoperabilidade, confira "Combinar C, C++ e Swift com segurança". Nos sistemas da Apple, adotamos uma proteção de memória rigorosa em dois componentes essenciais para a segurança: WebKit e um subsistema do app Mensagens que analisa mensagens e anexos recebidos. Os dois componentes lidam com entradas não confiáveis, o que aumenta a importância da limitação do uso de APIs não seguras. Agora, vamos ver como o Swift vem sendo usado no ecossistema de servidores.

O Swift é muito importante nos serviços na Apple. A cada segundo, milhões de solicitações são processadas por serviços de back-end viabilizados pelo Swift. Um desses serviços é responsável por alertar os usuários sobre senhas comprometidas por terem sido encontradas em violações de dados. Criado com Java, esse serviço foi recentemente reescrito no Swift. Os benefícios foram incríveis. Com o código nativo eficiente do Swift e o gerenciamento de memória determinística, a taxa de transferência do serviço subiu em 40%, mas os requisitos de hardware diminuíram pra a metade.

Muitos de vocês estão se beneficiando da adoção do Swift no servidor. Por exemplo, os engenheiros da Cultured Code reimplementaram o back-end do app popular Things, chamado Things Cloud, em Swift e escreveram sobre a experiência em swift.org.

No Things Cloud, o uso do Swift reduziu em 3x os custos com computação, melhorando os tempos médios de resposta em 400%. Além do desempenho melhor, outro benefício da adoção do Swift foi a chance de usar a mesma linguagem e ferramentas no desenvolvimento de clientes e servidores. Uma parte fundamental para que as equipes criem back-ends de servidor com o Swift são suas bibliotecas. O Swift tem um ecossistema crescente de pacotes que abrange vários casos de uso essenciais. Há bibliotecas para rede, drivers de banco de dados, observabilidade, streaming de mensagens, entre outros. Uma grande atualização foi o lançamento do gRPC Swift versão 2. O gRPC é um pacote moderno e de alto desempenho para criar APIs de serviço. Alguns destaques da versão 2 são APIs modernizadas que usam a concorrência do Swift, o código do Swift idiomático gerado e uma camada de transporte conectável de alto desempenho. Os mantenedores do gRPC Swift escreveram uma publicação no blog swift.org sobre isso. Confira para saber mais. A interoperabilidade com C, Objective-C e C++ é um dos principais pontos fortes do Swift. Você pode melhorar aos poucos as bases de código escritas nessas linguagens adotando o Swift em um arquivo de cada vez. No ecossistema de servidores, muitos apps são escritos em Java, e achamos que há uma grande chance de oferecer a adoção incremental do Swift nessas bases de código também. Por isso, no ano passado, anunciamos um novo e interessante projeto de código aberto chamado swift-java para fazer as linguagens interoperarem perfeitamente.

Com o swift-java, você pode criar associações que permitem que o código do Swift chame o código do Java, e vice-versa. Essas associações são criadas para abranger as representações nativas de valores de cada linguagem sem sobrecarga excessiva. As associações Java para código do Swift podem utilizar a tecnologia de interface externa mais moderna do Java ou retornar ao JNI, se necessário. O projeto swift-java está em fase experimental e evoluindo rapidamente. Para saber como ele funciona, confira "Explorar a interoperabilidade entre Swift e Java".

Ao trabalhar em apps que têm os componentes de cliente e servidor, você precisa de um fluxo de trabalho que teste localmente o código nos ambientes. A Apple está lançando uma biblioteca de conteinerização de código aberto que para a criação de ferramentas baseadas em contêineres do Linux executados no Mac. A biblioteca é totalmente implementada em Swift e projetada com foco em segurança, privacidade e desempenho. Esse é um ótimo exemplo de uso do Swift para desenvolvimento em nível de sistemas. Para saber mais sobre essa biblioteca, Confira "Conhecer a conteinerização". Acesse o repositório de conteinerização no GitHub, onde você encontra binários de linha de comando para executar contêineres. Por fim, confira algumas atualizações nas plataformas que o Swift aceita. O Swift 6.2 é oficialmente compatível com o FreeBSD, um sistema operacional popular em servidores e plataformas integradas. Além disso, o Swift será compatível com o WebAssembly, também conhecido como Wasm. O WebAssembly é uma plataforma de máquina virtual focada em portabilidade, segurança e alto desempenho. Os desenvolvedores podem criar apps de cliente e servidor para o Wasm e implantá-los no navegador ou em outros tempos de execução. A compatibilidade com o WebAssembly começou como um projeto da comunidade. No início do ano, o projeto atingiu um marco importante com um documento de visão para suporte oficial ao WebAssembly no Swift. Vamos conferir a compatibilidade com o Wasm em ação. Tenho um app escrito em Swift que carrega um modelo 3D de um arquivo e o renderiza no navegador. Confira a nova aparência do app.

O app está em execução na máquina virtual Wasm, e o logotipo do Swift é renderizado usando um padrão da web experimental: o WebGPU.

O app usa o JavascriptKit, que é um pacote de código aberto desenvolvido pela organização SwiftWasm. Posso usar essa biblioteca para interagir com o tempo de execução do JavaScript por meio de APIs nativas do Swift. Para tornar o binário final o mais compacto possível, compilo o app usando o Swift integrado. Na maioria das vezes, ele é apenas código do Swift normal.

Por exemplo, adicionei alguns utilitários de geometria que usam genéricos. E meu analisador de arquivos de objeto Wavefront usa as APIs String nativas do Swift.

Vamos adicionar animações. Vou pular para o método de atualização do renderizador.

Para testar o modelo, a rotação do logotipo precisa ser atualizada em cada quadro.

Vamos testar. Para executar o app novamente, acionei uma tarefa no painel do projeto. A tarefa é configurada para invocar o Swift Build para compilar o app Wasm. Em seguida, ele reduz o binário, executando algumas ferramentas de minimização na saída da compilação. Por fim, ele inicia um servidor online para hospedar o conteúdo. Ficou ótimo. O Swift é uma ótima linguagem e uma ótima escolha em toda a pilha de software. O Swift prioriza a segurança e a usabilidade, fornecendo ferramentas para que programadores avançados escrevam códigos complexos e os ajustem para obter o máximo desempenho. E você pode aprender os recursos de linguagem, conforme necessário. Você pode começar com o básico e se aprofundar em recursos avançados quando quiser.

No Swift 6.2, a linguagem evolui e está mais fácil de usar para iniciantes e especialistas. Fornecemos um caminho mais acessível para introduzir a concorrência em um projeto. Deixamos a linguagem mais eficiente para especialistas que escrevem códigos críticos para o desempenho. Vamos começar com as atualizações de desempenho. O tipo Array é uma lista ordenada de elementos e é um dos tipos de dados mais comumente usados em projetos do Swift. Recursos de Array, como o redimensionamento dinâmico, facilitam o uso e são adequados a muitas tarefas. Mas a flexibilidade tem um custo. Para ajudar no redimensionamento dinâmico, uma matriz armazena uma referência a um buffer alocado em pilha. Quando elementos são adicionados e a matriz está na capacidade máxima, a nova memória é alocada dinamicamente e os elementos existentes são copiados. Ao criar o perfil do código crítico de desempenho que usa Array em um caminho ativo, você notará a alocação de memória ou a contagem de referência do buffer de matriz que precisa eliminar. Se o tamanho de uma matriz nunca mudar, não é necessário pagar o custo da alocação da pilha. InlineArray é um novo tipo de matriz de tamanho fixo com armazenamento em linha para seus elementos. O tamanho é parte do tipo, escrito em colchetes angulares antes do tipo de elemento.

Em vez de armazenar uma referência em um buffer que contém os elementos, os elementos de um InlineArray são armazenados diretamente. Isso significa que os elementos podem ser armazenados na pilha ou diretamente em outros tipos sem alocação de pilha adicional. InlineArrays podem armazenar tipos copiáveis e não copiáveis. Ao armazenar tipos copiáveis, o próprio InlineArray pode ser copiado e os valores dos elementos são copiados. A escrita do tamanho como parte do tipo é feita com um novo recurso genérico para permitir números inteiros como parâmetros de tipo. Assim como o tipo de elemento, o tamanho de um InlineArray pode ser inferido de um literal de matriz. Se você escrever uma matriz alinhada de 1, 2 e 3, o tipo será inferido como um InlineArray de 3 inteiros. Saber o tamanho de um InlineArray em tempo de compilação também permite mais otimizações, como a eliminação da verificação de limites quando o índice for menor que o tamanho. Um tipo de contêiner geralmente precisa fornecer acesso direto ao armazenamento subjacente. Isso é útil para executar o processamento local na memória contígua sem precisar saber o layout do contêiner original. Por exemplo, uma função pode permitir a operação direta no armazenamento contíguo de um Array ou InlineArray. Antes do Swift 6.2, a solução comum era recorrer aos ponteiros não seguros, que são eficientes, mas são propensos a erros.

O novo tipo Span é uma abstração que fornece acesso rápido e direto à memória contígua sem comprometer a segurança da memória. A biblioteca padrão fornece uma propriedade de extensão para os tipos de contêineres com armazenamento contíguo para seus elementos, incluindo Array, ArraySlice, InlineArray e mais.

A extensão mantém a segurança da memória garantindo que a memória contígua permaneça válida enquanto você usa Span. Essas garantias definem os problemas de segurança de memória inerentes aos ponteiros, incluindo o uso após modificações livres e sobrepostas. Elas são verificadas em tempo de compilação sem sobrecarga de tempo de execução. Por exemplo, modificar o contêiner à original impedirá o acesso extensão posteriormente. Após a modificação, você não poderá acessar a variável Span novamente.

Uma extensão também não pode durar mais que o contêiner original. Isso é chamado de dependência de vida útil e impede que o armazenamento subjacente seja destruído enquanto ainda pode ser acessado por meio da extensão. Para aprender novas maneiras de controlar o desempenho com InlineArray e Span, confira "Melhore o uso da memória e o desempenho com o Swift". Para entender as características de desempenho do código do Swift, confira "Explore Swift performance".

Outro aspecto do desempenho é a capacidade de resposta, quando um programa precisa executar várias tarefas ao mesmo tempo. A programação concorrente é difícil porque o compartilhamento de memória entre várias tarefas é propenso a erros que levam a um comportamento imprevisível. A segurança de raio de dados no Swift 6 evita os erros no tempo de compilação. Escreva código concorrente sem medo de incluir falhas no tempo de execução difíceis de depurar. Em muitos casos, o código mais natural para escrever é propenso a corridas de dados, causando erros do compilador que você precisa resolver. Uma classe com estado mutável, como a classe PhotoProcessor, é segura desde que você não a acesse de maneira concorrente. Ela tem um método assíncrono para extrair um adesivo calculando o assunto dos dados de imagem fornecidos. Tentar chamar extractSticker do código da interface no agente principal resulta em um erro que informa que a chamada pode causar corridas de dados. Isso ocorre porque há vários lugares na linguagem que descarregam o trabalho para o segundo plano implicitamente, mesmo que você nunca precise de código para executar em paralelo.

O Swift 6.2 altera essa filosofia para permanecer com thread única por padrão até que você use a concorrência.

Com as alterações de linguagem, o Swift 6.2 se tornou o código mais natural para escrever dados livres de corrida por padrão. Isso fornece um caminho mais acessível para introduzir a concorrência em um projeto. Ao usar concorrência para executar o código em paralelo, a segurança de corrida da dados protege você. Primeiro, facilitamos a chamada de funções assíncronas em tipos com estado mutável. Em vez de descarregar funções assíncronas que não estão vinculadas a um agente específico, a função continuará sendo executada no agente do qual foi chamada. Isso elimina corridas de dados porque os valores passados para a função assíncrona nunca são enviados para fora do agente. As funções assíncronas podem descarregar o trabalho na implementação, mas os clientes não precisam se preocupar com seu estado mutável.

Em seguida, facilitamos a implementação de conformidades nos principais tipos de agentes. Tenho um protocolo chamado Exportable e estou tentando implementar uma conformidade para a classe StickerModel do agente principal. O requisito de exportação não tem isolamento de agente, então a linguagem presumiu que poderia ser chamada de fora do agente principal e impediu que StickerModel usasse o estado do agente principal na implementação.

O Swift 6.2 permite essas conformidades. Uma conformidade que precisa do estado do agente principal é chamada de conformidade *isolated*. Isso é seguro porque o compilador garante que a conformidade de um agente principal só seja usada no agente principal. Posso criar um tipo ImageExporter que adiciona um StickerModel a uma matriz de itens Exportable, desde que ele permaneça no agente principal. Se eu permitir que ImageExporter seja usado de qualquer lugar, o compilador impedirá a adição de StickerModel à matriz porque não é seguro chamar a exportação em StickerModel de fora do agente principal. Com conformidades isoladas, só é preciso resolver problemas de segurança de corrida de dados quando o código indica que a conformidade é usada concorrentemente.

Variáveis globais e estáticas são propensas a corridas de dados porque permitem que o estado mutável seja acessado de qualquer lugar.

A maneira mais comum de proteger o estado global é com o agente principal. E é comum anotar uma classe inteira com o agente principal para proteger todo seu estado mutável, especialmente em um projeto que não tem muitas tarefas concorrentes. Você pode modelar um programa que seja totalmente de thread única escrevendo @MainActor em tudo o projeto.

Para facilitar a modelagem de código de thread única, incluímos um modo para inferir o agente principal por padrão. Isso elimina erros de segurança de raio de dados sobre variáveis globais e estáticas inseguras, chamadas para outras funções do agente principal, como as do SDK, e muito mais, já que o agente principal protege todo o estado mutável. Ele também reduz as anotações de concorrência no código que seja principalmente de thread única. Esse modo é ótimo para projetos que fazem a maior parte do trabalho no agente principal, e o código concorrente é encapsulado em tipos ou arquivos específicos. É opcional e recomendado para apps, scripts e outros alvos executáveis. Descarregar o trabalho para o segundo plano ainda é importante para o desempenho, como manter os apps responsivos ao realizar tarefas que exigem muito da CPU. Aqui está a implementação do método extractSticker no PhotoProcessor. Primeiro, ele verifica se já extraiu um adesivo para uma imagem para retornar o adesivo armazenado em cache imediatamente. Se o adesivo não tiver sido armazenado em cache, ele extrairá o assunto dos dados da imagem e criará um novo adesivo. O método extractSubject executa um processamento de imagem caro que não quero para bloquear o agente principal ou qualquer outro agente. Posso descarregar esse trabalho usando o atributo @concurrent. @concurrent garante que uma função seja executada no pool de threads concorrrentes, liberando o agente para executar outras tarefas ao mesmo tempo. Essas alterações de linguagem funcionam juntas para tornar a concorrência mais acessível. Você começa escrevendo um código que é executado no agente principal por padrão, onde não há risco de corridas de dados. Quando você começa a usar funções assíncronas, elas são executadas onde forem chamadas. Ainda não há risco de corridas de dados porque todo o código ainda é executado no agente principal. Quando você quiser adotar a concorrência para melhorar o desempenho, será fácil descarregar código específico no segundo plano para execução em paralelo. Para saber mais sobre o uso de concorrência na prática, confira "Aprimore um app usando a concorrência do Swift". Para saber mais sobre os conceitos fundamentais de concorrência, confira "Adote os recursos de concorrência do Swift". Algumas dessas alterações de linguagem são opcionais porque exigem alterações no projeto para serem adotadas. Localize e ative as alterações de linguagem de concorrência acessíveis na seção Swift Compiler - Concurrency nos ajustes de compilação do Xcode. Você também pode ativar esses recursos em um arquivo de manifesto do pacote Swift usando a API SwiftSettings. O Swift 6.2 inclui ferramentas de migração para ajudar você a fazer as alterações de código necessárias automaticamente. Saiba mais sobre as ferramentas de migração em swift.org/migration. Essas melhorias na concorrência foram embasados no seu feedback sobre a adoção da segurança de dados nos projetos. Se você relatou uma falha, fez uma pergunta sobre um erro de concorrência que não entendeu, revisou uma proposta de desenvolvimento no fóruns ou criou alterações de linguagem, seu feedback fez a diferença. Agradecemos por ajudar a tornar a concorrência mais acessível para todos. Se você quiser participar da melhoria do Swift, junte-se a nós no fóruns em swift.org. Todos estão convidados a participar dos avanços da linguagem e do ecossistema, e adoraríamos saber mais sobre seus projetos na seção Community Showcase. Você também pode usar os fóruns para ficar em dia com tudo o que acontece no Swift, como conferências, encontros, redes sociais e muito mais. Agradecemos sua participação. Nos vemos nos fóruns.