Case study

In che modo gli ingegneri di Instagram Direct hanno creato un'architettura UI AI-native con Jetpack Compose e ridotto del 33% il costo dei token per sessione dell'agente

Tempo di lettura: 11 min

Questo blog post è stato scritto in collaborazione con il team di Meta

Instagram Direct è una delle piattaforme principali di Instagram, che gestisce miliardi di messaggi degli utenti ogni giorno. Nel corso degli anni, il team ha spremuto ogni micro-ottimizzazione possibile dal sistema di visualizzazione Android legacy. Tuttavia, la manutenzione e l'espansione di una superficie legacy fortemente ottimizzata creano un debito tecnico e un overhead di progettazione significativi, soprattutto perché i team adottano sempre più UI dichiarative e assistenti di coding AI. 

L'adozione di Jetpack Compose per Instagram Direct è andata oltre la tipica modernizzazione della UI. Il team ha creato un codebase UI AI-native che è più piccolo del 50% rispetto all'implementazione originale, ottenendo al contempo una riduzione del 35% del tempo di esecuzione dell'agente AI, il 32% in meno di scambi tra ingegneri e agenti e una riduzione del 33% del costo dei token. In stretta collaborazione con Google, il team ha adottato Jetpack Compose mantenendo al contempo un livello di prestazioni elevato. Grazie alle ottimizzazioni delle prestazioni, Meta e Google hanno migliorato Compose non solo per Instagram, ma anche per il più ampio ecosistema di sviluppatori Android.

Modernizzazione del codebase su larga scala

L'AI è diventata rapidamente un compagno quotidiano per gli ingegneri del settore e la sua applicazione a un codebase su larga scala come Instagram produce già reali vantaggi in termini di produttività. Il team di Instagram Direct ha fissato un obiettivo più ambizioso. Anziché limitarsi a indirizzare gli strumenti AI verso il codice esistente, il team ha riprogettato il codebase e la sua architettura in modo che fossero AI-native, moltiplicando l'impatto dell'AI ben oltre ciò che il solo retrofitting può offrire.

Il team di Instagram Direct ha scelto Jetpack Compose come componente chiave per la creazione di un'architettura UI AI-native. La sua natura dichiarativa garantisce che il codice sia conciso, prevedibile e strutturalmente più facile da analizzare per i modelli di AI, con meno effetti collaterali, meno stato implicito e confini dei componenti più chiari.

La migrazione a Jetpack Compose ha richiesto un'attenta pianificazione. Centinaia di milioni di persone inviano messaggi su Instagram ogni giorno, quindi la migrazione doveva essere graduale, fluida e senza interruzioni dell'esperienza, mentre il team riprogettava l'architettura della base sottostante. Per illustrare la portata della sfida: i singoli componenti dell'interfaccia utente possono essere visualizzati in oltre 160 permutazioni di stato distinte e una singola schermata di conversazione gestisce più di 200 tipi di messaggi distinti.

Product Design 1.png

Quando si esegue la migrazione di un codebase di queste dimensioni a Compose, si è tentati di scegliere la via più semplice e incorporare i componenti dell'UI di Compose nella gerarchia di oggetti View esistente. Come passaggio incrementale durante una migrazione graduale, è perfettamente valido. Tuttavia, a lungo termine, l'integrazione di Compose all'interno di un codebase basato su visualizzazioni rappresenta una sfida. Gli strumenti AI spesso seguono il percorso che presenta minori resistenze. Se combini codice UI dichiarativo e imperativo, è probabile che l'AI li unisca in modo errato, introducendo bug impercettibili, debito tecnico e regressioni delle prestazioni. 

Creazione di un'architettura UI AI-native

Alla scala di Instagram, un certo grado di astrazione architettonica è inevitabile ed è ciò che mantiene l'app gestibile man mano che cresce. Considera un pattern comune, in cui ogni tipo di elemento RecyclerView viene modellato come discendente di una classe base RecyclerViewItem personalizzata che espone i consueti hook del ciclo di vita come onBind.

Esempio 1

class ChatItem(
  val features: FeatureFlagProvider
) : RecyclerViewItem<ComposeViewHolder, ChatUiState> {

  // Imperative context:
  // AI could often take the path of least resistance and generate a mutable
  // state here, dispatched outside the ChatUiState. This class survives
  // re-bindings and is shared across multiple items, ultimately leading to
  // unexpected, hard-to-reproduce bugs.
  var isPinned: Boolean = false

  override fun onBind(holder: ComposeViewHolder, uiState: ChatUiState) {
      // Imperative context
      val isPinnedChatsEnabled = features.isEnabled("pinned_chats_feature")

      // Declarative context
      holder.composeView.setContent {

        // Blending imperative and declarative contexts
        if (isPinnedChatsEnabled) {
          Button(onClick = { isPinned = !isPinned }) {
            Text(if (isPinned) "Unpin" else "Pin")
          }
        }
        
        ...
      }
  }
}


Nello snippet riportato sopra, si insinuano due problemi. Innanzitutto, il flag isPinnedChatsEnabled viene letto nel codice imperativo e poi acquisito all'interno di una funzione lambda di Compose, un accoppiamento sottile tra i paradigmi. In secondo luogo, isPinned è un campo modificabile nell'elemento stesso anziché in ChatUiState, quindi sopravvive alla nuova associazione e al riciclo di RecyclerView tra le righe, con conseguenti perdite e bug difficili da riprodurre.

Anche quando il codice viene ripulito assegnando all'elemento una funzione @Composable dedicata, i problemi rimangono gli stessi.

Esempio 2

class ChatItem(
  val features: FeatureFlagProvider
) : ComposeRecyclerViewItem<ChatUiState> {

  // Imperative context
  val isPinnedChatsEnabled = features.isEnabled("pinned_chats_feature")
  var isPinned: Boolean = false

  // Declarative context
  @Composable
  override fun Content(uiState: ChatUiState) {

 
    // Blending imperative and declarative contexts
    if (isPinnedChatsEnabled) {
      Button(onClick = { isPinned = !isPinned }) {
        Text(if (isPinned) "Unpin" else "Pin")
      }
    }

    ...
  }
}

Questo è un esempio volutamente semplice, ma illustra un problema più ampio: meno limiti vengono dati all'AI, minore è la qualità del codice che produce nel tempo. I guardrail e le competenze sono utili, ma non sono sufficienti da soli, perché quando l'AI incontra un ostacolo, spesso lo aggira per sbloccarsi.

Per rendere il codebase compatibile con l'AI, è necessario seguire due regole pratiche: 

  • Riduci al minimo la dipendenza dal contesto personalizzato. Più conoscenze specifiche e personalizzate del codebase sono necessarie a un agente AI per apportare una modifica corretta, minore è la qualità del suo output. Più il codebase è vicino alle best practice note, migliori saranno i risultati dell'AI.
  • Un codebase AI-first deve applicare i propri limiti. Colmare le lacune di progettazione con le skill di AI non è scalabile, poiché ogni skill caricata nel contesto costa token e può peggiorare le prestazioni dell'agente. È l'architettura stessa che deve farsi carico di questo peso. Gli agenti AI seguono naturalmente il percorso di minor resistenza, quindi il design dovrebbe fare in modo che questo percorso porti a un codice corretto e di alta qualità, rendendo al contempo difficili e costose da esprimere le decisioni di progettazione scadenti.

Un elemento dell'elenco può comunque essere rappresentato dalla propria astrazione, ma in questo caso tutto il codice Compose si trova nel costruttore, quindi non ha accesso ai membri o allo stato della classe e la sua unica origine di argomenti è il costruttore. In questo modo, è equivalente a una semplice funzione @Composable, pur rispettando l'architettura esistente.

Esempio 3

class ChatItem(
  val features: FeatureFlagProvider,
  val onPin: (Boolean) -> Unit,
) : ComposeItem<ChatUiState>(

 
   // Compose UI
   content = { uiState: ChatUiState ->
    val isPinnedChatsEnabled = features.isEnabled("pinned_chats_feature")

    if (isPinnedChatsEnabled) {
      Button(onClick = { onPin(!uiState.isPinned) }) {
        Text(if (uiState.isPinned) "Unpin" else "Pin")
      }
    }
    
    ...
  },
)

La migrazione di un codebase di queste dimensioni è un'impresa enorme. Per molto tempo, le centinaia di componenti UI che costituiscono la maggior parte di Direct UI hanno dovuto coesistere con le loro controparti legacy, con entrambe gestite in parallelo. I workflow di AI hanno contribuito a rendere possibile questa migrazione parallela accelerando il processo di scrittura di enormi quantità di codice. Questo approccio ha consentito al team di Direct di eseguire la migrazione in tempi record, senza interrompere il resto del team, che ha continuato a rilasciare le funzionalità che migliorano l'esperienza di milioni di persone ogni giorno.

Più ingegneri hanno eseguito i propri agenti AI su una knowledge base condivisa di competenze e convenzioni riutilizzabili create durante la migrazione. In questo modo, i workflow e le best practice sono stati sincronizzati in tutto il team, anziché essere riscoperti da ogni singolo ingegnere. All'interno di ogni piattaforma, il team ha eseguito la migrazione nelle seguenti fasi:

  • Scrivi tutto il codice Compose con l'AI.
  • Perfezionarla, gestendo i casi limite e colmando i divari di prestazioni, fino a quando la UI non è stata implementata per utenti reali in un test pubblico.

Suddividere il lavoro in due fasi per schermata consente a un ingegnere di muoversi rapidamente nell'intera superficie, definendo l'architettura e i casi limite complessi in anticipo. Con questa base, gli altri possono concentrarsi sulla preparazione dell'UI pronto per la produzione senza doversi fermare per prendere queste decisioni tecniche, mantenendo la migrazione complessiva rapida.

I risultati della migrazione hanno convalidato l'approccio. Per le piattaforme Instagram Direct di cui è stata eseguita la migrazione, Jetpack Compose ha consentito al team di ridurre del 50% la quantità totale di codice dell'interfaccia utente. Meno codice deve generare l'AI, maggiore è la qualità dell'output e minore è il costo dei token per attività. 

Quote-Pavlo-New.jpg

Un'analisi interna dei dati del codebase Android per Instagram Direct ha confrontato le sessioni degli agenti AI che lavorano su Compose UI con le stesse attività che utilizzano Android Views. I miglioramenti in termini di efficienza sono stati evidenti in due dimensioni:

  • Per carattere di codice inserito: Compose ha richiesto il 32% in meno di scambi tra ingegnere e agente e il 35% in meno di tempo di esecuzione dell'agente (il tempo trascorso da quando un agente inizia a lavorare alla richiesta di un ingegnere fino a quando restituisce una risposta).
  • Per sessione dell'agente: il costo complessivo dei token è diminuito del 33% con Compose rispetto a Views.

Riportiamo sia l'efficienza dell'output sia i numeri delle sessioni tipiche perché sono risultati utili in modo indipendente. I dati relativi agli scambi tra l'engineer e l'agente e al tempo di esecuzione confrontano l'utilizzo delle risorse per unità di output finale, mentre il dato relativo ai token confronta il costo totale di una sessione tipica dell'agente.

I dati hanno anche rivelato una differenza costante nel modo in cui i due framework gestiscono il codice complesso o fragile. Meta monitora questo aspetto utilizzando uno scoring del rischio delle modifiche al codice, che valuta la qualità complessiva del codice e la probabilità che una modifica causi incidenti in produzione. L'analisi ha misurato l'efficienza delle risorse di un agente utilizzando una combinazione di consumo di token, tempo di esecuzione dell'agente e interazioni tra ingegnere e agente. Man mano che i file accumulano un punteggio di rischio più elevato, le sessioni degli agenti AI diventano naturalmente meno efficienti in termini di risorse. 

Quando il punteggio di rischio accumulato di un file raddoppia, la UI implementata con Android Views riduce l'efficienza delle risorse dell'agente del 30% (per carattere atterrato). Nelle stesse circostanze, la riduzione della UI di Jetpack Compose è solo del 9%

Grazie alla partnership tra Google e Meta, il team di Instagram Direct ha portato una nuova prospettiva all'adozione di Compose, affrontandola attraverso la lente della preparazione della codebase all'AI, non solo una riscrittura della UI. Questo lavoro ha rivelato la forza di Compose come base per la creazione di codebase e architetture AI-first, soprattutto se applicate alla scala di app come Instagram.

Ottimizzazioni delle prestazioni 

Instagram Direct è una delle piattaforme più importanti dell'app e le persone si aspettano che sia sempre veloce e reattiva. L'adozione di Jetpack Compose ha comportato una riscrittura sostanziale della UI e l'obiettivo principale era preservare l'esperienza di alta qualità senza regressioni.

Anni di iterazione avevano già spinto l'implementazione legacy basata su View di Instagram a un livello di prestazioni eccezionalmente elevato e il team doveva soddisfare lo stesso standard passando a un framework UI completamente nuovo.

Instagram misura centinaia, se non migliaia, di metriche sul rendimento. Per l'adozione di Compose, i tre aspetti più importanti sono stati:

  • Time to Interactive: il tempo che intercorre tra l'apertura della schermata e la possibilità di utilizzarla.
  • Tempo di caricamento completo: il tempo che intercorre tra l'apertura della schermata e il caricamento completo di tutti i contenuti (ad es. le immagini).
  • Prestazioni di scorrimento: la fluidità dello scorrimento dello schermo, senza frame persi.

Queste metriche vengono monitorate in fase di runtime in produzione, consentendo di eseguire test A/B per confrontare la UI di Compose di cui è stata eseguita la migrazione con la UI precedente e valutare l'impatto di questo sforzo sulle prestazioni.

Un modo comune per approcciare una migrazione di questo tipo è iniziare con poco, spostando un numero limitato di componenti dell'interfaccia utente, raccogliendo dati e studiando il loro comportamento. Sebbene utili, questi primi risultati forniscono solo un quadro parziale, fornendo falsi negativi rispetto all'adozione di Compose perché:

  • Non rappresentativo: un componente UI di cui è stata eseguita la migrazione può fornire dati utili sul suo rendimento complessivo su una determinata schermata. Tuttavia, i diversi componenti si comportano in modo diverso per motivi che non possono essere generalizzati, quindi non è sempre possibile estrapolare i dati.
  • Costo di interoperabilità: un piccolo componente Compose all'interno di un codebase View di grandi dimensioni comporta un costo di bridging imprevedibile tra i due sistemi. Questo overhead distorce la misurazione, quindi i primi risultati su piccola scala non riflettono l'aspetto effettivo della migrazione completa.

Il risultato è che le migrazioni di piccole dimensioni, sebbene utili, non riflettono sempre l'impatto completo di Compose. Più una superficie viene migrata end-to-end senza interruzioni di bridging, più l'immagine diventa chiara e migliore in termini di prestazioni.

Le schermate principali di Instagram Direct sono basate su lunghi elenchi di vari tipi di articolo, originariamente implementati con RecyclerView. L'architettura si basa su astrazioni personalizzate per la scalabilità, ma rimane legata al ciclo di vita del sistema basato su View.

Diagram 1.png

L'attività principale del team è stata la migrazione graduale di diverse centinaia di singoli elementi dell'elenco a Compose all'interno dell'architettura esistente basata su RecyclerView, implementandoli in produzione in piccoli gruppi indipendenti nell'ambito di test A/B, il tutto senza modifiche visibili all'esperienza di messaggistica dell'utente.

Il principale svantaggio di questa configurazione è una significativa dipendenza dal sistema View legacy tramite un'architettura RecyclerView di base, anche dopo la migrazione completa di ogni elemento dell'elenco a Compose. Come naturale passo successivo, il team ha deciso di investire nella sostituzione dell'architettura di base basata su RecyclerView con l'alternativa nativa di Compose, LazyColumn.

Ciò significa che i componenti della UI di Compose devono essere astratti dal framework in cui sono racchiusi, pur rimanendo compatibili con RecyclerView e LazyColumn contemporaneamente. Altrettanto importante è la possibilità di passare da un'esperienza all'altra in fase di runtime tramite i flag di funzionalità, per consentire i test A/B.

Diagram 2.png

Sebbene i nuovi elementi di Compose siano compatibili in modo nativo con LazyColumn e possano essere inseriti in un albero di composizione ininterrotto, è stata creata un'API di interoperabilità per inserirli anche in un RecyclerView. In questo modo è stato possibile implementare la configurazione di LazyColumn nell'ambito di un test A/B fianco a fianco con RecyclerView, riutilizzando gli stessi elementi di Compose e perfezionando le prestazioni, senza interrompere il resto del team che creava e perfezionava le funzionalità.

La scalabilità, la complessità e la sensibilità di Instagram anche alle più piccole regressioni hanno rappresentato una sfida unica per Jetpack Compose. Per affrontarli, è stata necessaria una partnership iterativa e pratica. Lavorando a stretto contatto, gli ingegneri di Google e Meta hanno analizzato le metriche per individuare e progettare nuove funzionalità di Compose per soddisfare o superare i benchmark basati sulle visualizzazioni. Come risultato di questa partnership, spiccano le seguenti aggiunte a Jetpack Compose: composizione con possibilità di pausa con LazyLayoutCacheWindows e monitoraggio della visibilità. 

Composizione che può essere messa in pausa con LazyLayoutCacheWindows

La composizione che può essere messa in pausa (attivata per impostazione predefinita in Compose 1.10) consente di comporre elementi di elenchi lazy costosi in modo incrementale tra i frame per evitare jank. Se abbinata a LazyLayoutCacheWindow (aggiunta in Compose 1.9), la combinazione migliora notevolmente la fluidità dello scorrimento. Nei recenti test interni di Meta, la combinazione della composizione Pausable con un singolo viewport LazyLayoutCacheWindow ha ridotto i cali di frame di grandi dimensioni al minuto (LFD/m) di circa il 13% rispetto a Compose standard. La finestra della cache da sola ha ridotto il tempo di circa l'8% rispetto alla stessa base di riferimento. LFDs/m è una metrica interna utilizzata da Meta per monitorare i rallentamenti evidenti durante lo scorrimento.

Quote-Fabio.jpg


L'utilizzo di un LazyLayoutCacheWindow nella tua app prepara e conserva gli elementi fuori schermo all'interno di una banda basata su pixel attorno alla viewport per consentire scorrimenti rapidi. Per sfruttare LazyLayoutCacheWindows nella tua app, puoi utilizzare l'ultima versione di Compose 1.13.0-alpha03 e configurarla come mostrato nell'esempio seguente:

val cacheWindow = LazyLayoutCacheWindow(ahead = 150.dp, behind = 100.dp)
// OR
val cacheWindow = LazyLayoutCacheWindow(aheadFraction = 0.5f, behindFraction = 0.3f)

LazyColumn(state = state, cacheWindow = cacheWindow) {
    ...
}

Esistono due modi per configurare la finestra della cache. Entrambi descrivono la stessa cosa: quanti contenuti fuori schermo mantenere composti, ma in unità diverse.

  • Dp: lunghezza assoluta fissa. ahead = 150.dp mantiene 150 dp di contenuti composti oltre il bordo visibile, indipendentemente dal dispositivo.
  • Float: frazione dell'area visibile. aheadFraction = 0.5f mantiene metà schermo composto in anticipo, quindi la quantità assoluta si adatta all'altezza dello schermo supportando vari fattori di forma: di più su un tablet o un pieghevole aperto, di meno su uno smartphone compatto. 

Il team di Instagram ha ottimizzato le frazioni float della finestra della cache specificamente per la struttura dei contenuti e le dimensioni degli elementi di Direct. Poiché i valori ideali variano a seconda dei parametri specifici della UI, trovare il giusto equilibrio richiede un po' di sperimentazione.

Logging delle impressioni con onVisibilityChanged


L'API onVisibilityChanged (aggiunta in Compose 1.9.0) è un altro risultato chiave della partnership tecnica tra Google e Meta. Offre alle piattaforme Jetpack Compose su larga scala un modo coerente per sapere quando un componibile è effettivamente visibile sullo schermo, sostituendo le implementazioni personalizzate e create manualmente utilizzate in passato. Solo all'interno di Instagram Direct, questi indicatori di visibilità vengono utilizzati in centinaia di file per supportare le metriche sulla qualità del prodotto che dipendono dal fatto che gli elementi UI siano stati effettivamente mostrati alle persone.

Prestazioni di avvio

L'adozione di Jetpack Compose per Instagram Direct ha portato a miglioramenti imprevisti delle prestazioni in altre aree dell'app. Il runtime di Jetpack Compose comporta un costo di avvio che paghi una sola volta e, poiché la messaggistica è un'area ad alto traffico spesso visitata all'inizio di una sessione utente, altre aree di Instagram che si basano su Compose hanno registrato notevoli miglioramenti delle prestazioni.

Le prestazioni di avvio della UI di Compose all'interno di Instagram Direct sono state ottimizzate utilizzando i profili di riferimento, che precompilano i percorsi del codice più utilizzati al momento dell'installazione, in modo che Compose esegua il rendering rapidamente fin dal primo avvio.

Lessons from the Instagram Direct migration to Jetpack Compose 

  • Jetpack Compose offre un ritorno sull'investimento immediato: non è necessario utilizzare workflow di AI avanzati per trarre vantaggio da Compose. Con una riduzione del codice di circa il 50%, il codice da gestire è minore e la superficie di attacco per i bug è ridotta.
  • La progettazione di un'architettura AI-native ha portato a risultati significativi, tra cui una riduzione del 35% del tempo di esecuzione degli agenti AI, una riduzione del 32% degli scambi tra ingegneri e agenti e una riduzione del 33% del costo dei token.
  • Sebbene esistano numerose API di interoperabilità e supporto per la combinazione di View e Compose, punta a eseguire la migrazione di superfici più grandi rispetto ai singoli componenti di piccole dimensioni. In questo modo, la UI rimane all'interno di una singola gerarchia di composizione ininterrotta e vengono sbloccate tutte le migliori ottimizzazioni delle prestazioni native di Compose.
  • Abbina la composizione Pausable con LazyLayoutCacheWindow: l'abbinamento di questi due elementi produce risultati migliori rispetto alle sole finestre di cache. Con la sola finestra della cache, un elemento pesante potrebbe comunque tentare di eseguire la composizione in un unico passaggio, superando potenzialmente il budget dei frame.
  • Contribuisci a Compose Meta ha collaborato con il team di Jetpack Compose per dare vita ai propri feedback e alle proprie idee all'interno di Compose. Lavorare su un toolkit open source significa che tutti noi beneficiamo della correzione dei bug e dei miglioramenti delle prestazioni apportati a livello centrale. Quindi, facci sapere il tuo feedback.

L'adozione di Jetpack Compose ha consentito di ottenere notevoli vantaggi nello sviluppo assistito dall'AI, semplificando al contempo l'ingegneria dell'UI quotidiana di Instagram. L'approccio dichiarativo riduce il codice boilerplate, semplifica la comprensione dello stato e migliora la produttività complessiva degli sviluppatori. Il team di ingegneri di Instagram non vede l'ora di portare Compose su più piattaforme dell'app e di continuare la collaborazione tra Google e Meta per apportare ulteriori miglioramenti agli utenti di Instagram e Jetpack Compose. 

Se non hai ancora provato Compose, ora con l'assistenza AI, la migrazione a Jetpack Compose è più semplice che mai.

Riconoscimenti. Ringraziamo Michal Zielinski e Matthew Du di Meta, e Andrei Shikov e George Mount di Google, per il loro lavoro volto a migliorare le prestazioni di Compose attraverso la collaborazione tra Meta e Google. Ringraziamo anche Gary Ye di Meta per aver contribuito a portare Compose su Instagram Direct e Gopal Juneja di Meta per aver supportato questo impegno attraverso la data science.

Continua a leggere