Transcript

00:00:00(beschwingte Musik) - Hallo zusammen.
00:00:06Ich bin Lydia.
00:00:07Mein Titel ist eigentlich Head of Propaganda bei BUN.
00:00:11Und wenn ihr mich ein bisschen kennt,
00:00:13wisst ihr,
00:00:13dass ich gerne über JavaScript-Runtimes und Performance spreche.
00:00:17Bevor ich zu BUN kam,
00:00:18war ich ein paar Jahre bei Vercel und habe Next-Entwicklern beigebracht,
00:00:22Apps schneller zu bauen.
00:00:24Ich bin sehr aufgeregt,
00:00:25heute hier zu sein und euch zu zeigen,
00:00:28wie viel besser es werden kann,
00:00:30wenn wir Next Framework Performance mit BUNs Runtime Performance kombinieren.
00:00:35Aber bevor ich über BUN selbst spreche,
00:00:38möchte ich einen Schritt zurückgehen und euch zeigen,
00:00:41was Frameworks wie Next.js überhaupt so besonders macht.
00:00:45Sie haben wirklich redefiniert,
00:00:47wie wir Performance im Web sehen.
00:00:49Es hat nicht nur Websites schneller gemacht.
00:00:52Es hat jeden Teil des Prozesses optimiert.
00:00:55Wir bekamen intelligenteres Bundling mit Webpack und jetzt mit Turbo Pack.
00:00:59Wir bekamen eingebaute Bild- und Schriftoptimierung.
00:01:02Wir bekamen effizientes serverseitiges Rendering,
00:01:05statisches Rendering und jetzt haben wir ISR und RSC,
00:01:09um Datenabruf direkt in die Komponente zu bringen.
00:01:12All diese Verbesserungen haben erweitert,
00:01:15was das Framework optimieren kann,
00:01:17aber wirklich nur bis zu einem gewissen Punkt.
00:01:21Es gab da immer diese eine grundlegende Schicht,
00:01:23die Next.js bisher nicht optimieren konnte.
00:01:26Und das liegt nicht an mangelnder technischer Arbeit oder Fähigkeit,
00:01:30sondern es ist einfach außerhalb von Nexts Bereich.
00:01:34Und das ist die Runtime selbst.
00:01:37Normalerweise,
00:01:37wenn du Next dev startest oder auf Vercel deployst,
00:01:40läuft deine Next-App auf Node.
00:01:42Das bedeutet, dass Nodes Runtime dein JavaScript ausführt.
00:01:45Sie verwaltet die Event Loop, Datei-IO, alles.
00:01:49Und sie verbindet deinen JavaScript-Code mit dem Betriebssystem.
00:01:53Das macht Sinn,
00:01:54denn Node war die Standard-Runtime für etwa die letzten 15 Jahre.
00:01:59Es ist bewährt,
00:02:00es ist zuverlässig,
00:02:01aber 2025 ist es auch ein bisschen zum Bottleneck geworden.
00:02:06Versteht mich nicht falsch, Node ist fantastisch.
00:02:09Es ermöglichte uns, JavaScript auf dem Server zu starten.
00:02:13Davor,
00:02:14bevor Node 2009 eingeführt wurde,
00:02:16war JavaScript wirklich nur für den Browser.
00:02:20Node änderte das,
00:02:20indem es uns eine Runtime mit einer JavaScript-Engine,
00:02:23einer Event Loop,
00:02:24asynchronem IO und APIs gab,
00:02:26um all die Dinge zu tun,
00:02:27die Browser nicht können.
00:02:29Wie zum Beispiel Dateien von der Festplatte lesen,
00:02:32Speicher,
00:02:32all solche Sachen.
00:02:33Unter der Haube verwendet Node die V8 JavaScript-Engine.
00:02:37Das ist Googles schnelle Chrome-Engine,
00:02:39die großartig ist für lange laufende Aufgaben,
00:02:42wie ein Tab in deinem Chrome-Browser.
00:02:44Aber natürlich ist V8 nur eine Engine.
00:02:46Sie kann nur JavaScript ausführen.
00:02:49Sie kann keine Dateien öffnen,
00:02:51TCP-Verbindungen aufbauen,
00:02:53und all solche Sachen.
00:02:54Deshalb kommen Nodes eingebaute APIs ins Spiel.
00:02:57Wie FS, HTTP, NET und so weiter.
00:03:01Diese APIs sind irgendwie die Brücke zwischen unserem JavaScript-Code und dem Betriebssystem.
00:03:07Und diese APIs selbst verlassen sich auf eine C-Bibliothek namens libuv.
00:03:13Dies wurde nicht speziell für JavaScript entwickelt.
00:03:16Es ist eher eine allgemeine Abstraktion,
00:03:19die Node nutzt,
00:03:20um Dinge wie Datei-IO,
00:03:21Networking und so weiter über alle möglichen verschiedenen Betriebssysteme hinweg zu bewerkstelligen.
00:03:27Wenn wir also in unserem JavaScript-Code etwas wie fs.read file aufrufen,
00:03:31fragen wir den Computer wirklich nur,
00:03:33wie: Ich möchte diese Datei von der Festplatte lesen.
00:03:36Aber bevor wir dort ankommen,
00:03:38muss es zuerst durch V8 gehen,
00:03:40oder von JavaScript-Code zu V8.
00:03:42Dann übergibt es an die Node C++-Bindung.
00:03:46Diese ruft dann libuv auf,
00:03:48und das erwähnt nicht mal die Thread-Arbeit und all den Overhead.
00:03:52Und nur dann macht libuv den System Call zu unserem Kernel,
00:03:55um diese Datei tatsächlich von der Festplatte zu holen.
00:03:58Und während all das passiert,
00:04:00haben wir die Event Loop,
00:04:01die libuv benutzt,
00:04:02damit der Rest unseres JavaScript-Codes weiterhin ausgeführt werden kann und so weiter.
00:04:06Und dieses Modell funktioniert in Ordnung.
00:04:08Wir nutzen immer noch Node, aber es ist nicht optimal.
00:04:13Also zurück zu 2009,
00:04:14nochmal,
00:04:14als Node eingeführt wurde,
00:04:16sah unsere Hardware sehr unterschiedlich aus.
00:04:19Server hatten vielleicht vier Kerne,
00:04:22begrenzten Speicher,
00:04:23und Speicher war ziemlich langsam.
00:04:25Threads waren auch teuer,
00:04:27also eine neue Thread für jede Verbindung zu erstellen skalierte einfach nicht gut.
00:04:32Deshalb war Nodes Modell großartig für diese Ära,
00:04:34denn wir konnten einen Thread benutzen,
00:04:36um tausende Verbindungen wirklich effizient zu handhaben.
00:04:40Aber spulen wir zu 2025 vor,
00:04:41unsere Hardware sieht sehr unterschiedlich aus.
00:04:44Wir haben jetzt hunderte von CPU-Kernen,
00:04:46Terabytes an Speicher,
00:04:48und Speicherung ist etwa 50 Mal schneller.
00:04:51Aber wir benutzen immer noch Nodes Modell von 2009.
00:04:55Es drückt immer noch alles durch dieselbe Event Loop.
00:04:59Und nochmal, das ist in Ordnung.
00:05:00Wie,
00:05:01Nodes Architektur ist in Ordnung,
00:05:03wenn Server für Tage laufen.
00:05:04Aber in modernen Zeiten haben wir oft Serverless-Funktionen oder wir haben Dev-Server.
00:05:09All diese eher kurzen Burst-Skripte,
00:05:12die schnell starten und für eine viel kürzere Zeit laufen müssen.
00:05:16Also in diesen Umgebungen ist jede Millisekunde beim Start und jede Datenschicht wichtig,
00:05:22denn sie tragen alle zur Latenz bei.
00:05:24Jetzt nochmal,
00:05:26wenn du deine Next-App startest,
00:05:30läufst du sie auf Node.
00:05:34Das bedeutet,
00:05:34dass alles,
00:05:35was deine App tut,
00:05:36also wie Seiten rendern,
00:05:37Assets servieren,
00:05:38Responses streamen,
00:05:39alles geht durch all diese Schichten,
00:05:41die wir gerade gesehen haben.
00:05:43Also von JavaScript zu V8 zu Node, all solche Sachen.
00:05:46Und Next hat eine unglaubliche Arbeit geleistet,
00:05:50jedes bisschen Performance herauszupressen,
00:05:53obwohl die Node-Runtime immer noch bestimmte Dinge blockiert.
00:05:57Denn am Ende des Tages laufen all diese Verbesserungen immer noch auf Node.
00:06:01Also wenn du einen Dev-Server startest oder Dateien neu erstellst,
00:06:05Hot-Reloading,
00:06:06triffst du immer noch auf diese Runtime-Grenzen.
00:06:09Also wenn wir wirklich schneller werden wollen,
00:06:11müssen wir über das Framework hinausschauen.
00:06:13Wir müssen tiefer gehen.
00:06:15Wir müssen die Runtime selbst überdenken.
00:06:18Und genau da kommt BUN ins Spiel.
00:06:20BUN ist nicht einfach eine weitere Schicht auf top von Node.
00:06:24Es ist eine brandneue Runtime,
00:06:26komplett von Grund auf für die Hardware gebaut,
00:06:30die wir tatsächlich 2025 haben.
00:06:33Also statt in C++ auf top von LibUV geschrieben zu sein,
00:06:37wie bei Node,
00:06:38wird BUN in Zig gebaut.
00:06:40Und das ist eine moderne Systemsprache,
00:06:43die viel näher am Metall läuft.
00:06:45Für die JavaScript-Engine verwendet BUN Apples wirklich schnelle JavaScript Core-Engine.
00:06:51Und diese startet wirklich schnell,
00:06:53hauptsächlich weil sie einige der Initialisierungsoptimierungen aufschieben kann,
00:06:58die Engines wie V8 machen.
00:06:59Und sie läuft auch einfach wirklich schnell,
00:07:02was wiederum perfekt ist für die modernen Aufgaben,
00:07:04die wir heutzutage mit Dev-Servern,
00:07:06Serverless-Umgebungen und diesen kürzeren Build-Skripten verwenden.
00:07:10Die Core-Runtime selbst wird in Zig geschrieben.
00:07:13Also die BUN-APIs und alle Teile,
00:07:15die asynchrones IO handhaben.
00:07:17Also wo Node LibUV für alle diese asynchronen Operationen verwendet,
00:07:22also wie Dateien lesen,
00:07:24Netzwerkanfragen und so weiter,
00:07:26kann BUN diese als direkte System Calls zum Betriebssystem implementieren,
00:07:31weil es in Zig geschrieben ist.
00:07:33Jetzt für Netzwerkanfragen verwenden wir useSockets,
00:07:36also ist es ein bisschen anders.
00:07:37Aber wir entfernen so viele Abstraktionsschichten,
00:07:41indem wir Zig statt LibUV verwenden.
00:07:44Wenn du jetzt eine Datei mit der BUN-Runtime lesen möchtest,
00:07:47geht es natürlich immer noch von deinem JavaScript-Code.
00:07:49Es geht jetzt zu der JSC-Engine zu Zig,
00:07:52die dann den direkten System Call machen kann.
00:07:55Also nochmal,
00:07:56weniger Schichten zwischen unserem JavaScript-Code und dem eigentlichen Betriebssystem.
00:08:01Und das Ergebnis ist,
00:08:03dass alles so viel schneller anfühlt,
00:08:05vom Start bis zum Dateizugriff,
00:08:07HTTP-Servern und so weiter.
00:08:09Aber BUN geht nicht nur um Performance.
00:08:12Wir wollen auch 100% Node-kompatibel sein.
00:08:15Also wir wollen sicherstellen,
00:08:16dass all von Nodes eigenen APIs funktionieren.
00:08:19Aber es wird auch mit tonnenweise zusätzlichen eingebauten APIs ausgeliefert,
00:08:23wie S3,
00:08:24SQL oder Squeel,
00:08:25wie auch immer man es sagen möchte.
00:08:27Redis, Hashing, eine Shell, so viele Dinge.
00:08:30Und wenn ihr andere Programmiersprachen wie Go oder Python verwendet habt,
00:08:35ist dieser Art von Batteries-Included-Ansatz dir sehr vertraut.
00:08:39Aber als JavaScript-Entwickler haben wir uns einfach daran gewöhnt,
00:08:42Abhängigkeiten für ziemlich alles zu installieren.
00:08:45Ich verwende Passwort-Hashing in fast all meinen Apps.
00:08:48Aber ich muss trotzdem jedes Mal eine Abhängigkeit installieren,
00:08:51wenn ich sie verwende.
00:08:52BUN ändert das.
00:08:54Das Zeug,
00:08:54das man ständig benutzt,
00:08:56ist einfach direkt in die Runtime eingebaut.
00:08:59Es ist einfach auf dem Global verfügbar.
00:09:01Und nochmal,
00:09:02das sind nicht einfach wie oberflächliche Wrapper auf einem NPM-Paket.
00:09:06Sie sind wirklich in Zig eingebaut.
00:09:08Also sind sie für Performance für die moderne Hardware optimiert.
00:09:12Zum Beispiel hat BUN einen eingebauten SQL-Client.
00:09:16Also kannst du direkt zu Postgres,
00:09:19MySQL und SQLite verbinden mit einer einzigen API.
00:09:23Du musst keine zusätzlichen Abhängigkeiten installieren.
00:09:26Und nochmal,
00:09:27das ist nicht einfach nur ein NPM-Paket aufrufen.
00:09:30Es ist wirklich BUN, das direkt mit dem System spricht.
00:09:35Und es ist nicht nur Komfort,
00:09:36dass wir diese eingebaut haben.
00:09:38BUNs Optionen sind normalerweise auch viel schneller als die Node- und NPM-Alternativen.
00:09:44Zum Beispiel,
00:09:45BUN.SQL ist bis zu 11-mal schneller als MySQL 2 auf Node,
00:09:50was wirklich gut ist.
00:09:51Oder du kannst BUNs S3-Clients verwenden.
00:09:54Und das funktioniert out of the box mit jedem S3-kompatiblen Speicher.
00:09:58Also Amazon S3,
00:09:59Super Base Storage,
00:10:01Cloudflare R2,
00:10:02ihr kennt das.
00:10:03Und nochmal, auch diese API ist unglaublich schnell.
00:10:06Also hier können wir sehen,
00:10:08dass es bis zu sechs Mal schneller ist als AWS S3 SDK auf Node.
00:10:12Jetzt kannst du natürlich auch immer noch deine normalen Abhängigkeiten mit der BUN-Runtime verwenden.
00:10:17Du musst diese eingebauten APIs nicht verwenden.
00:10:20Aber sie reduzieren deine Bundle-Größe erheblich,
00:10:22denn wir fügen nicht länger diese Abhängigkeiten hinzu.
00:10:25Und es hilft mit NPM-Sicherheitslücken,
00:10:28die wir letzten Monat gesehen haben,
00:10:30denn du musst sie nicht installieren.
00:10:32Es gibt noch tonnenweise mehr APIs.
00:10:33Ich empfehle sehr,
00:10:35dass du auch die Dokumentation überprüfst.
00:10:37Aber BUN kommt mit viel mehr als nur einer Runtime.
00:10:40Es wird auch mit einem wirklich schnellen Package Manager ausgeliefert,
00:10:45der bis zu 17-mal schneller als YARN ist,
00:10:47sieben Mal schneller als NPM und vier Mal schneller als PNPM.
00:10:51Und das Gute daran ist,
00:10:52du musst die BUN-Runtime nicht verwenden,
00:10:54um BUN Install zu verwenden.
00:10:55Und das ist einfach -- du kannst BUN Install mit Node verwenden.
00:10:58Es wird einfach funktionieren.
00:10:59Also musst du nichts an deinem Projekt ändern.
00:11:03Es hat auch einen wirklich schnellen eingebauten Bundler und Transpiler.
00:11:06Also kannst du deine Dateien sofort servieren und bauen.
00:11:09Du brauchst also kein Webpack,
00:11:10kein ESBuild,
00:11:11keine extra Einrichtung.
00:11:12Und das Schöne daran ist,
00:11:14es unterstützt auch TypeScript und JSX direkt aus der Box.
00:11:18Es hat auch einen wirklich schnellen Test-Runner,
00:11:21der bis zu 14-mal schneller als Vitest und 23-mal schneller als Jest ist,
00:11:24wenn wir etwa 1.000 React-Tests SSR'd.
00:11:26Also nochmal, du bekommst wirklich schnelle Tests.
00:11:29Du musst nichts installieren.
00:11:31Also das klingt alles großartig,
00:11:33aber wie können wir die BUN-Runtime verwenden?
00:11:35Und mit Next, ehrlich gesagt, ist es wirklich einfach.
00:11:38Nach der Installation von BUN musst du einfach nur deinen Start-Befehl oder deinen Dev-Befehl aktualisieren und bun run --bun hinzufügen.
00:11:45Das ist alles.
00:11:46Du führst jetzt die BUN-Runtime aus.
00:11:48Jetzt wunderst du dich vielleicht, warum ich --bun brauche?
00:11:51Wie, ich sage bereits bun run.
00:11:54Das ist,
00:11:54nochmal,
00:11:55weil BUN wirklich Node-Kompatibilität schätzt.
00:11:57Also wenn wir einfach bun run next dev verwenden,
00:12:01wird BUN erkennen,
00:12:03dass das Next CLI diesen Node-Shebang verwendet.
00:12:07Und in diesem Fall wird BUN wie OK,
00:12:08ich verstehe,
00:12:09dass ich Node verwenden muss.
00:12:11Also wird es einfach zurück zu Node zurückfallen,
00:12:14obwohl wir bun run sagten.
00:12:15Aber mit dem --bun Flag erzwingen wir,
00:12:17dass es den Shebang überspringt und sagen,
00:12:19OK,
00:12:20wir verwenden einfach die bun Runtime.
00:12:21Also nur als irgendwie eine extra Erklärung.
00:12:25Also jetzt mit diesem Befehl startest du deinen Next Dev-Server.
00:12:29Der Bundler selbst ist immer noch Next.
00:12:31Also das ist immer noch, weißt du, Turbo Pack.
00:12:33Ich denke,
00:12:33Web Pack,
00:12:34Turbo Pack,
00:12:34jetzt ist es das Standard-Setting.
00:12:35Aber jetzt ist die Runtime darunter von all dem,
00:12:38also das Ding,
00:12:39das dein JavaScript ausführt,
00:12:40Dateien liest,
00:12:41Responses serviert und so weiter,
00:12:43das ist alles bun.
00:12:44Und weil bun darauf ausgelegt ist,
00:12:46Node-kompatibel zu sein,
00:12:47solltest du nichts an deinem Code ändern müssen.
00:12:50Oder deine Pakete oder deine Middleware.
00:12:51Alles sollte immer noch funktionieren.
00:12:53Wenn nicht, wird das auch als Bug in bun angesehen.
00:12:57Es sollte 100% Node-kompatibel sein.
00:12:59Also wenn du das versuchst und auf Probleme stößt,
00:13:01gib uns Bescheid.
00:13:02Aber du solltest nichts neu schreiben müssen.
00:13:05Und jetzt,
00:13:06da deine App auf bun läuft,
00:13:07hast du Zugriff auf all von buns eingebauten APIs.
00:13:10Zum Beispiel können wir einfach den S3-Client verwenden,
00:13:12richtig,
00:13:13in wie einer Server-Funktion,
00:13:14in React Server für Komponente und so weiter.
00:13:16Also müssen wir keine Abhängigkeiten installieren.
00:13:18Also nur um zu vergleichen,
00:13:20wie es normalerweise mit Node aussehen würde,
00:13:22kannst du sehen,
00:13:23dass wir mit bun viel weniger Code haben.
00:13:25Wir haben weniger Abhängigkeiten.
00:13:27Und es ist sofort kompatibel mit all den anderen S3-Anbietern.
00:13:32Also wenn du von Amazon S3 zu wie Cloudflare R2,
00:13:35Super Base Storage,
00:13:36all diesen anderen Anbietern wechseln möchtest,
00:13:39ist das sehr einfach.
00:13:40Oder ein eher kompletteres,
00:13:42wir können S3,
00:13:43die bun Shell und SQL direkt in einer React Server-Komponente verwenden.
00:13:47Also zuerst fragen wir die Datenbank mit SQL ab,
00:13:50um einen Blog-Post zu holen,
00:13:51generieren eine presign S3 URL für das Bild,
00:13:54verwenden die bun Shell,
00:13:55um die Wörter zu zählen.
00:13:57Nochmal,
00:13:57es gibt keine extra wie API-Ebene oder Drittanbieter-Tools,
00:14:01die bun aufruft.
00:14:02Bun handhabet die Runtime,
00:14:04die Datenbankverbindungen und die Shell alle nativ in SIG,
00:14:08so nah am Metall.
00:14:10Und nochmal, natürlich nicht einfach S3 SQL.
00:14:12Wir bekommen Zugriff auf all von buns APIs,
00:14:15indem wir einfach bun run --bun vor next dev hinzufügen.
00:14:20Aber natürlich könntest du jetzt denken,
00:14:22OK,
00:14:23ich verwende kein Postgres.
00:14:24Ich verwende kein S3.
00:14:25Ich verwende keine verrückten Abhängigkeiten,
00:14:27also warum sollte ich es interessieren?
00:14:28Das Ding,
00:14:29das mich vor dem Beitritt zu bun interessierte,
00:14:31war ehrlich gesagt einfach die unglaubliche DX.
00:14:34Du kannst einfach irgendeine JS,
00:14:36TS,
00:14:37TSX,
00:14:37JSX,
00:14:38es spielt keine Rolle,
00:14:39Datei ohne irgendwelche Konfiguration ausführen.
00:14:41Es funktioniert einfach.
00:14:41Du musst nicht über TSNode,
00:14:43Babel,
00:14:44SWC und so weiter nachdenken.
00:14:46Also selbst wenn du Next nicht verwendest,
00:14:49selbst wenn du nur entwickelst,
00:14:50du willst ein schnelles Build-Skript,
00:14:52verwende einfach bun run,
00:14:54versuche es einfach,
00:14:55es macht dein Leben so viel besser,
00:14:57denn du brauchst keine Konfiguration.
00:14:59Bun wird auch mit bun x geliefert.
00:15:01Und das ist buns Art von Äquivalent zu NPX.
00:15:04Nochmal, du musst nichts ändern.
00:15:06Du musst die bun Runtime nicht verwenden.
00:15:08Du kannst einfach NPX mit bun x ersetzen.
00:15:11Und du siehst sofortige Start-Verbesserungen.
00:15:13Zum Beispiel ist die Verwendung von bun x create next step etwa fünf Mal schneller als NPX create next step.
00:15:20Und nochmal,
00:15:21du musst die bun Runtime für das nicht verwenden.
00:15:23Es ist einfach viel schneller.
00:15:25Aber natürlich gibt es auch bun install,
00:15:27was nochmal,
00:15:28die Runtime nicht erfordert,
00:15:29dass du sie wechselst.
00:15:31Es macht deine Installationen einfach so viel schneller,
00:15:34auch auf grundlegenden Next-Projekten.
00:15:36Jetzt ist bun lokal auszuführen natürlich eine Sache.
00:15:39Aber wie stellen wir Apps bereit, die auf bun laufen?
00:15:42Denn das ist natürlich eine ganz neue Runtime.
00:15:46Jetzt kannst du bereits Next.js auf bun auf mehreren Plattformen wie Render,
00:15:51Railway oder Container deine App mit Docker verwenden.
00:15:54Aber wir sind alle Next.js-Entwickler.
00:15:56Im Idealfall möchten wir auch zu Vercel bereitstellen können.
00:16:00Also natürlich haben wir Guillermo getweetet und baten ihn höflich um native bun-Unterstützung auf Vercel.
00:16:07Und wir bekamen schnell eine ziemlich vielversprechende Antwort.
00:16:10Und dann ein paar Wochen später,
00:16:12wurde bun-Unterstützung zumindest intern erreicht.
00:16:15Also bin ich sehr aufgeregt,
00:16:17dass native bun-Unterstützung sehr bald zu Vercel kommt.
00:16:20Und das bedeutet, dass du werden können -- [APPLAUS]
00:16:25Applaus geht an die großartigen Ingenieure bei Vercel,
00:16:28die das möglich gemacht haben.
00:16:29Aber das ist sehr aufregend,
00:16:31denn das bedeutet,
00:16:32dass wir jetzt bun Apps genauso einfach wie jedes andere Next-Projekt auf Vercel ausführen können.
00:16:37Also auch nur ein echtes Welt-Beispiel.
00:16:39Ich bin mir nicht sicher,
00:16:39ob du es auf dem Bildschirm sehen kannst.
00:16:41Aber wenn man eine HONO API mit bun ausführt,
00:16:43sahen wir bereits einen 30%-Rückgang oder einen CPU-Abfall durch die bloße Ausführung von bun auf Vercel.
00:16:49Das ist natürlich ein anderes Framework.
00:16:50Das ist HONO API.
00:16:52Aber es sind dieselben Runtime-Vorteile,
00:16:53die du bekommst,
00:16:54wenn dies wie eine Server-Funktion,
00:16:56RSC und so weiter gewesen wäre.
00:16:57Weil bun viel an CPU- und Speichernutzung spart.
00:17:02Jetzt müssen wir natürlich nicht auf native bun-Unterstützung warten,
00:17:04um es in unseren Apps zu verwenden.
00:17:06Der einfachste Weg ist irgendwie,
00:17:08es zu verwenden oder es schrittweise zu übernehmen.
00:17:11Also zuerst empfehle ich,
00:17:12einfach zu bun install zu wechseln.
00:17:14Ändert nichts in deiner Codebasis.
00:17:16Dies verwendet einfach buns wirklich schnellen Package Manager.
00:17:19Auch,
00:17:19wenn du interessiert daran bist zu wissen,
00:17:21warum bun install so viel schneller ist,
00:17:22habe ich vor nicht allzu lange Zeit einen Artikel darüber geschrieben.
00:17:24Ich empfehle dir sehr, ihn dir anzuschauen.
00:17:26Es erklärt einfach -- weißt du,
00:17:27wir überspringen nicht nur Schritte.
00:17:29Wir machen was auch immer.
00:17:29Es erklärt irgendwie die Systemtechnik dahinter,
00:17:33die es so viel schneller macht.
00:17:35Jetzt nach der Verwendung von bun install,
00:17:37dann versuche die bun Runtime zu verwenden.
00:17:39Du kannst es einfach lokal mit bun run --bun verwenden.
00:17:42Teste deine App.
00:17:42Sehe, ob alles funktioniert.
00:17:44Es sollte.
00:17:45Wenn nicht, gib uns Bescheid.
00:17:47Und dann am Ende kannst du schrittweise zu buns nativen APIs wechseln,
00:17:52wo es Sinn macht.
00:17:53Du kannst natürlich immer noch diese NPM-Abhängigkeiten mischen und zusammenpassen.
00:17:57Aber das Beste daran ist auch,
00:17:59dass jeder Schritt hier reversibel ist.
00:18:00Also wenn du eine von buns nativen APIs verwendet und es hat nicht funktioniert,
00:18:04kannst du immer einfach zurück zu Node wechseln.
00:18:06Aber es ist definitiv einen Blick wert.
00:18:08Jetzt bevor ich diesen Talk beende,
00:18:10möchte ich dem erstaunlichen Team von Ingenieuren bei bun einen großen Dank aussprechen.
00:18:17Die meisten Menschen kennen vielleicht Jared,
00:18:19aber es gibt ein ganzes Team hinter bun,
00:18:21das jeden Tag so hart arbeitet,
00:18:23um bun noch schneller,
00:18:24stabiler und so viel spaßiger zu machen.
00:18:27Sie drängen wirklich die Grenzen von dem,
00:18:30was mit JavaScript möglich ist.
00:18:32Also nächst,
00:18:33redefiniert,
00:18:34wie wir für das Web bauen,
00:18:35aber bun redefiniert,
00:18:37was es antreibt.
00:18:38Danke dir sehr,
00:18:38dass du zu meinem Talk gekommen bist,
00:18:40und ich bin so aufgeregt zu sehen,
00:18:42was du mit bun und Next bauen wirst.

Key Takeaway

Bun ist eine moderne JavaScript-Runtime, die Next.js-Anwendungen durch direktere Systemaufrufe, integrierte High-Performance-APIs und reduzierte Abstraktionsschichten erheblich schneller macht.

Highlights

Bun ist eine völlig neue JavaScript-Runtime, die in Zig statt C++ geschrieben ist und Apple's JavaScriptCore-Engine anstelle von V8 nutzt

Bun bietet integrierte APIs für häufig verwendete Funktionalitäten wie SQL-Datenbankverbindungen, S3-Speicher, Passwort-Hashing und Shell-Befehle, ohne zusätzliche Abhängigkeiten zu benötigen

Die Bun-Runtime ist bis zu 11x schneller bei SQL-Operationen und 6x schneller bei S3-Operationen im Vergleich zu Node.js-Alternativen

Bun kann einfach mit Next.js integriert werden, indem man den Befehl 'bun run --bun' vor 'next dev' hinzufügt, ohne den Anwendungscode ändern zu müssen

Der Bun Package Manager ist 17x schneller als Yarn, 7x schneller als npm und 4x schneller als pnpm

Native Bun-Unterstützung kommt in Kürze zu Vercel, was eine 30%ige Reduktion der CPU-Nutzung bei Server-Funktionen demonstriert

Node.js wurde 2009 für Hardwarekonfigurationen entwickelt, die heute obsolet sind, während Bun für moderne Hardware mit Hunderten von CPU-Kernen und Terabytes an Speicher optimiert ist

Timeline

Einführung und Hintergrund von Lydia

Lydia stellt sich als Head of Propaganda bei Bun vor und erklärt ihren Hintergrund als Vercel-Mitarbeiterin, wo sie Next-Entwicklern half, schnellere Anwendungen zu bauen. Sie macht deutlich, dass sie heute zeigen wird, wie Next.js Framework Performance mit Buns Runtime Performance kombiniert werden kann, um noch bessere Ergebnisse zu erzielen. Der Talk konzentriert sich darauf, wie die Zusammenbringung dieser beiden Technologien eine neue Leistungsebene ermöglicht. Dies ist der Kontext für die folgenden Inhalte zur Optimierung von Web-Anwendungen.

Next.js Framework-Optimierungen und deren Grenzen

Lydia erläutert, wie Next.js die Web-Performance durch intelligentes Bundling mit Webpack und TurboPack, Bild- und Schriftoptimierung, Server-Side Rendering, Static Rendering, ISR und React Server Components revolutioniert hat. Sie betont, dass diese Optimierungen zwar große Fortschritte gebracht haben, aber nur bis zu einem gewissen Punkt gehen können, da sie nicht auf die Runtime-Ebene einwirken können. Das Framework kann das JavaScript nur so schnell ausführen, wie die zugrunde liegende Node.js-Runtime es erlaubt, was die fundamentale Grenze darstellt. Dieser Punkt ist entscheidend, da er erklärt, warum eine neue Runtime notwendig ist, um weitere Performance-Gewinne zu erzielen.

Verständnis von Node.js Architektur und ihren Einschränkungen

Lydia erklärt die Architektur von Node.js im Detail: Es verwendet Googles V8-Engine für JavaScript-Ausführung und verlässt sich auf die libuv-Bibliothek für asynchrones IO und Systemaufrufe. Sie beschreibt den Overhead-Pfad: JavaScript-Code geht zu V8, dann zu Node C++-Bindungen, dann zu libuv, mit Threadarbeit und Abstraktion, bevor ein eigentlicher Systemaufruf zum Kernel erfolgt. Lydia erklärt, dass dieses Modell 2009 für Hardware mit wenigen CPU-Kernen und langlebigen Prozessen optimal war, aber heute mit moderner Hardware mit Hunderten von Kernen und kurzlebigen Prozessen wie Dev-Servern und Serverless-Funktionen nicht ideal ist. Dies zeigt, warum jede Millisekunde beim Start und bei der Datenschicht in modernen Umgebungen entscheidend ist.

Einführung in Bun und seine Runtime-Architektur

Lydia stellt Bun als brandneue, von Grund auf entwickelte Runtime vor, die in Zig statt C++ geschrieben ist und Apples schnelle JavaScriptCore-Engine (JSC) anstelle von V8 nutzt. Sie erklärt, dass JSC schneller startet, weil es einige Initialisierungsoptimierungen aufschiebt, und für kurzlebige Aufgaben optimiert ist. Die Bun-Core-Runtime wird ebenfalls in Zig geschrieben, was es ermöglicht, asynchrone Operationen direkt als Systemaufrufe zum Betriebssystem zu implementieren, statt über libuv-Abstraktionen zu gehen. Dies reduziert die Abstraktionsschichten zwischen JavaScript-Code und dem Betriebssystem erheblich, wodurch Datenzugriff, HTTP-Server und andere Operationen deutlich schneller werden.

Buns integrierte APIs und Performance-Vorteile

Lydia betont, dass Bun nicht nur performant ist, sondern auch hundertprozentig Node-kompatibel sein soll und zusätzlich viele integrierte APIs wie S3, SQL, Redis, Hashing und Shell-Befehle mitbringt, die direkt in Zig implementiert sind. Sie erklärt, dass Buns SQL-Client bis zu 11x schneller als mysql2 auf Node ist und der S3-Client bis zu 6x schneller als das AWS S3 SDK. Diese APIs reduzieren nicht nur die Bundle-Größe durch fehlende Abhängigkeiten, sondern bieten auch Sicherheitsvorteile, da man NPM-Pakete mit bekannten Sicherheitslücken nicht installieren muss. Das Batteries-Included-Modell ist vertraut für Entwickler in Sprachen wie Go oder Python, wird aber für JavaScript-Entwickler durch Bun eingeführt.

Bun Ökosystem: Package Manager, Bundler und Test Runner

Neben der Runtime bringt Bun auch einen extrem schnellen Package Manager mit, der 17x schneller als Yarn, 7x schneller als npm und 4x schneller als pnpm ist, und für Node-Projekte einfach als Ersatz für npm install verwendet werden kann. Lydia erwähnt auch Buns schnellen eingebauten Bundler und Transpiler, die TypeScript und JSX direkt unterstützen, ohne zusätzliche Werkzeuge wie Webpack oder Babel zu benötigen. Der Bun-Test-Runner ist 14x schneller als Vitest und 23x schneller als Jest bei etwa 1.000 React-Tests, was erhebliche Zeitersparnisse bei der Entwicklung bedeutet. All diese Werkzeuge zusammen bilden ein vollständiges Ökosystem, das die Entwicklungserfahrung dramatisch verbessert.

Integration von Bun mit Next.js und Code-Beispiele

Lydia demonstriert, wie einfach die Integration von Bun mit Next.js ist: Man muss nur 'bun run --bun' vor dem Start-Befehl hinzufügen, ohne Code zu ändern. Sie erklärt, warum das --bun Flag notwendig ist, da Bun Node-Kompatibilität schätzt und sonst den Node-Shebang erkennen würde. Mit Bun läuft der Bundler immer noch auf Next.js (Turbopack), aber die Runtime darunter ist Bun. Sie zeigt praktische Beispiele: einen S3-Client in einer Server-Funktion ohne zusätzliche Abhängigkeiten und ein komplexeres Beispiel, das SQL, S3 und Bun Shell direkt in einer React Server-Komponente kombiniert. Diese Beispiele zeigen, wie native Bun-APIs nahtlos in Next.js integriert werden können, ohne Abstraktionsebenen oder externe Tools zu benötigen.

Entwickler-Erfahrung und Tools wie 'bun x' und 'bun install'

Lydia hebt die verbesserte Developer Experience mit Bun hervor: Man kann jede JS-, TS-, JSX- oder TSX-Datei ohne Konfiguration ausführen, ohne über ts-node, Babel oder SWC nachdenken zu müssen. Sie erwähnt 'bun x' als Bun-Äquivalent zu npx, das 5x schneller ist als 'npx create-next-app'. 'bun install' beschleunigt Paket-Installationen erheblich, selbst bei grundlegenden Next.js-Projekten, ohne dass man die Bun Runtime aktivieren muss. Diese Tools sind sofort nützlich, da sie keine Umstellung erfordern und sofortige Verbesserungen bringen. Die Einfachheit und Schnelligkeit machen Bun attraktiv, selbst für Entwickler, die nicht die komplette Bun-Runtime verwenden möchten.

Deployment auf Vercel und reale Performance-Ergebnisse

Lydia erklärt, dass Bun auf mehreren Plattformen wie Render, Railway und Docker bereits deployt werden kann, und dann eine aufregendere Nachricht mitteilt: Native Bun-Unterstützung kommt bald zu Vercel. Sie erwähnt, dass das Team bei Vercel bereits intern Bun-Unterstützung erreicht hat. Ein reales Beispiel zeigt eine 30%ige Reduktion der CPU-Nutzung beim Betrieb einer HONO API auf Vercel mit Bun. Dies demonstriert, dass die Runtime-Optimierungen direkt zu geringerer Ressourcennutzung führen, was Kosten senkt und die Leistung verbessert. Dies ist besonders wichtig für Produktionsumgebungen, wo jeder Prozentsatz an CPU- und Speichereinsparung wirtschaftliche Auswirkungen hat.

Schrittweise Adoption und reversible Migration zu Bun

Lydia schlägt eine schrittweise Migrationsstrategie vor, um das Risiko zu minimieren: Zuerst zu 'bun install' wechseln (nur Paketmanager, keine Codeänderungen), dann die Bun Runtime lokal mit 'bun run --bun' testen, und schließlich schrittweise zu nativen Bun-APIs migrieren, wo es Sinn macht. Sie betont, dass alle Schritte reversibel sind, so dass man jederzeit zu Node.js zurückkehren kann, wenn Probleme auftreten. Dies senkt die Eintrittshürde und das Risiko erheblich, da man Bun in kleinen, überprüfbaren Schritten übernehmen kann. Sie schließt mit einem großen Dank an das Bun-Team, das kontinuierlich die Grenzen dessen vorantreibt, was mit JavaScript möglich ist.

Community Posts

View all posts