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.