Fleet
More Than a Code Editor
Ein Blick in den Maschinenraum von Fleet, Teil 1 – Architekturübersicht
Wir haben kürzlich ein neues Produkt vorgestellt, an dem wir seit einiger Zeit arbeiten: Fleet, eine JetBrains-IDE der neuen Generation. Fleet befindet sich derzeit in der geschlossenen Preview und wir erhalten großartige Rückmeldungen von unseren Early Adoptern, die uns helfen, das Produkt zu verbessern und für eine öffentliche Preview im Lauf des Jahres 2022 vorzubereiten.
In der Zwischenzeit möchten wir gerne etwas mehr darüber erzählen, wie Fleet unter der Haube aufgebaut ist. In einer Reihe von Blogbeiträgen werden wir die verschiedenen Aspekte von Fleet im Detail beleuchten, von der Architekturübersicht bis hin zu Einzelheiten wie State-Management, Parser, Protokolle, Erweiterbarkeit und sogar die Entstehung des Logos. Wir wünschen Ihnen viel Spaß bei diesem Rundgang im Maschinenraum!
Wie ist Fleet aufgebaut?
Als wir Fleet zum ersten Mal vorgestellt hatten, fanden auf Twitter interessante Diskussionen über die verwendeten Technologien statt. Einige tippten auf JavaScript und Electron. Andere hofften, dass dies nicht stimmte. Manche waren froh, dass es nicht „altbackenes Java“ war. Es ist wirklich erstaunlich, wie viele Schlüsse ausschließlich auf der Grundlage von Screenshots gezogen werden können.
Die Wahrheit ist, dass Fleet auf einer zuverlässigen, leistungsstarken und wunderbaren Plattform basiert: JVM. Ja. JVM. Warum? Weil die JVM trotz einiger anderslautender Meinungen eine sehr performante Plattform ist. Hinzu kommt die Plattformunabhängigkeit, die uns die Unterstützung mehrerer Betriebssysteme erleichtert.
Allerdings ist die JVM nicht ausschließlich ein Host für die Programmiersprache Java. Es zwingt Sie auch keiner dazu, Swing als UI-Bibliothek zu verwenden (mehr über die UI und die Verwendung von Skia in Fleet folgt in einem der nächsten Beiträge). In Wirklichkeit können wir in der JVM eine Vielzahl von Sprachen verwenden – zum Beispiel Kotlin. Und genau damit haben wir Fleet entwickelt – mit der Programmiersprache Kotlin.
Als waschechte polyglotte IDE ist Fleet allerdings selbst auch polyglott. Ganz richtig – ein kleiner Teil von Fleet, insbesondere der Fleet System Daemon, ist in Rust geschrieben!
Die Architektur von Fleet
Nachdem wir nun wissen, in welcher Sprache Fleet entwickelt wurde, wollen wir uns der Architektur zuwenden. Fleet besteht aus den folgenden Komponenten:
Gehen wir nun im Einzelnen auf diese Komponenten ein, um ihre Aufgaben besser zu verstehen.
Frontend
Es ist zwar ein naheliegender Gedanke, dass das Frontend der Benutzeroberfläche entspricht – aber in Wirklichkeit handelt es sich um mehr. Neben der Benutzeroberfläche bietet das Frontend verschiedene weitere Funktionen:
- Datei-Parsing
- Syntaxhervorhebung und grundlegende Code-Completion
- Editor-Funktionalität
Fleet wird standardmäßig im Editormodus gestartet. In diesem Modus können Sie grundlegende Completion- und Navigationsfunktionen sowie weitere Features nutzen, die Sie von einem leistungsstarken Editor erwarten können. All dies wird vom Fleet-Frontend bereitgestellt.
Arbeitsbereich
Wie der Name schon sagt, ist der Arbeitsbereich der Ort, an dem Abläufe im Zusammenhang mit der Arbeitssitzung gehandhabt werden. Dazu gehören Aspekte wie das State-Management. Diese Funktionalität kann entweder im Fleet-Prozess oder als separater Prozess ausgeführt werden, je nachdem, ob sie lokal auf dem Computer ausgeführt wird oder nicht. Dadurch besteht die Möglichkeit, einen Arbeitsbereich auf einem Remote-Server auszuführen.
Smart-Modus und Backend
Wie bereits erwähnt kann Fleet als einfacher Editor ausgeführt werden. Wenn jedoch erweiterte Funktionen wie intelligente Code-Completion, erweiterte Navigation, Refactorings und Inspektionen benötigt werden, ist der Smart-Modus gefragt.
Der Smart-Modus kann auf eine Vielzahl von Optionen zurückgreifen, darunter die reguläre IntelliJ-IDEA-Codeengine, spezielle Analysemodule oder sogar Sprachserver (ob LSP-basiert oder nicht).
Fleet System Daemon (FSD)
Diese in Rust geschriebene Komponente ist verantwortlich für Build-Aktionen, das Ausführen von Code und von Terminalbefehlen sowie weitere Aktionen innerhalb der Umgebung, in der Fleet ausgeführt wird.
All diese Komponenten bilden zusammen eine verteilte und skalierbare Lösung. In separaten Beiträgen werden wir die Technologien, die diesen Komponenten zugrunde liegen, und die Protokolle, über die sie kommunizieren, im Detail beleuchten.
Im nächsten Beitrag sehen wir uns das State-Management an, um zu erfahren, mit welchen Methoden die Konsistenz zwischen all diesen Services sichergestellt wird.
Bleiben Sie also dran!
Autor des Original-Blogposts:
Discover more
Fleet의 내부 구조, 파트 I – 아키텍처 개요
JetBrains의 차세대 IDE인 Fleet이 최근 공개되었습니다. 현재 비공개 테스트 버전을 진행 중이며 초기 사용자로부터 수많은 피드백을 받으며 제품을 개선하고 2022년 중에 테스트 버전을 출시하기 위해 노력하고 있습니다.
Fleet이 공개되기를 기다리는 동안 Fleet이 내부적으로 어떻게 빌드되었는지에 대해 조금 이야기하고 싶습니다. 일련의 블로그 게시물에서 최상위 아키텍처 뷰를 비롯해 상태 관리, 파서, 프로토콜, 확장성 및 로고 디자인에 대한 핵심 세부 사항에 이르기까지 Fleet의 모든 측면에 대해 더 깊이 파고들 것입니다. 갑판 아래에서 이 크루즈를 즐기시기 바랍니다!
Fleet은 무엇을 사용하여 빌드되었을까요?
Fleet이 처음 발표되었을 때, Fleet이 무엇을 사용하여 빌드되었는지에 대한 흥미로운 대화가 Twitter에서 오고 갔습니다. 몇몇 사람들은 JavaScript와 Electron이 사용되었다고 생각했습니다. 그렇지 않기를 바란 사람도 있었습니다. 어떤 사람들은 “투박하고 낡은 Java”가 아닌 것에 만족했습니다. 스크린샷만으로 이렇게 많은 내용을 추론할 수 있다니 매우 놀랍습니다!
사실 Fleet은 JVM이라는 안정적이고 성능이 뛰어난 훌륭한 플랫폼을 기반으로 빌드되었습니다. 예. 바로 모두가 아는 그 JVM입니다. JVM을 선택한 이유는 무엇일까요? 그 이유는 일부 속설에도 불구하고 JVM은 실제로 매우 성능이 뛰어난 플랫폼이기 때문입니다. 또한 크로스 플랫폼이므로 더 쉽게 여러 운영 체제를 지원할 수 있습니다.
JVM은 Java 언어 전용 호스트가 아니며 UI 라이브러리로 Swing을 사용할 필요도 없습니다(UI 및 Fleet이 Skia를 사용하는 방법에 관해서는 이후 게시물에서 자세히 설명). 실제로 JVM에서는 Kotlin과 같은 다양한 언어를 사용할 수 있습니다. 그리고 Fleet은 바로 이 Kotlin으로 빌드되었습니다.
그러나 Fleet이 진정한 다중 언어를 지원하는 IDE인 만큼 Fleet 자체도 다중 언어로 만들어졌습니다. 맞습니다. Fleet의 작은 부분, 특히 Fleet System Daemon은 Rust로 만들어졌습니다!
Fleet 아키텍처
이제 Fleet이 무엇으로 빌드되었는지 알았으므로 아키텍처에 대한 간략한 개요를 살펴보겠습니다. Fleet은 다음의 구성 요소로 구성됩니다.
지금부터 이 구성 요소를 각각 자세히 살펴보고 그 역할을 알아봅시다.
프런트엔드
프런트엔드가 단지 사용자 인터페이스일 뿐이라고 생각하기 쉽지만 실제 역할은 그 이상입니다. 프런트엔드는 UI일 뿐만 아니라 다음과 같은 기능을 제공합니다.
- 파일 분석
- 구문 강조 표시 및 기본 코드 완성
- 에디터 기능
Fleet은 기본적으로 에디터 모드에서 시작되며 기본 코드 완성 및 탐색은 물론 모든 강력한 에디터에서 기대할 수 있는 기능을 제공합니다. 이 모든 것이 Fleet의 프런트엔드에서 제공됩니다.
작업공간
이름에서 알 수 있듯이 작업공간은 작업 세션과 관련된 작업을 처리하는 곳입니다. 상태 관리와 같은 측면은 작업 공간에서 취급합니다. 이 기능은 시스템에서 로컬인지 여부에 따라 Fleet과 함께 프로세스에서 실행되거나 별도의 프로세스로 실행될 수 있습니다. 따라서 작업공간은 원격 서버에서 실행될 수도 있습니다.
스마트 모드 및 백엔드
위에서 언급했듯이 Fleet은 에디터로 실행될 수 있습니다. 하지만 다른 기능 중에서도 스마트 코드 완성, 고급 탐색, 리팩터링 및 검사와 같은 고급 기능이 필요한 경우 스마트 모드를 사용하면 됩니다.
이 스마트 모드에서는 기본 IntelliJ IDEA 코드 처리 엔진, 사용자 지정 분석기 또는 언어 서버(LSP 기반 여부에 관계없이)를 포함한 다양한 옵션이 지원됩니다.
Fleet System Daemon(FSD)
Rust로 작성된 이 구성 요소는 Fleet이 실행되는 환경에서 빌드 작업, 코드 실행, 터미널 명령어 실행 및 기타 작업을 담당합니다.
이러한 모든 구성 요소가 함께 모여서 확장 가능한 분산형 솔루션을 제공합니다. 이후 게시물에서 이러한 각각의 구성 요소를 만드는 데 사용된 기술과 구성 요소 간의 통신에 사용된 프로토콜에 대해서 더 자세히 알아보겠습니다.
다음 게시물에서는 상태 관리에 대해 살펴보고 이 모든 서비스에서 일관성을 유지하는 방식을 설명합니다.
다음 블로그 게시물도 기대해 주세요!
게시물 원문 작성자
Discover more
Fleet Below Deck, Part I – Architecture Overview
This is a multipart series on building Fleet, a next generation IDE by JetBrains.
- Part I – Architecture Overview
- Part II – Breaking Down the Editor
- Part III – State Management
- Part IV – Distributed Transactions
- Part V – The Story of Code Completion
- Part VI – UI with Noria
We recently announced a new product which we have been working on named Fleet, a new generation IDE by JetBrains. The product is currently in closed preview and we’re receiving great feedback from early adopters, helping us improve it and get it ready for a public preview sometime in 2022.
In the meantime, and until we’re ready for public access, we’d like to talk to you a bit about how Fleet is built under the covers. In a series of blog posts we’re going to dive deeper into every aspect of Fleet, from the top level architectural view, to nitty gritty details of state management, parsers, protocols, extensibility, and even the logo design. We hope you enjoy this cruise from below deck!
What is Fleet built with?
When we first announced Fleet, some interesting conversations took place on Twitter in regards to what it was built with. Some thought it was JavaScript and Electron. Others were hoping it wasn’t. Some were happy it wasn’t “clunky old Java”. It’s actually amazing how much folks can deduce about something based exclusively on screenshots!
The truth is Fleet is built on a reliable, performant and wonderful platform called the JVM. Yes. The JVM. Why? Because despite some popular belief, the JVM is actually a very performant platform. Additionally, it’s cross-platform, which makes things easier when it comes to supporting multiple operating systems.
The JVM however is not a host to the Java language exclusively, nor are you required to use Swing as the UI library (more on the UI and how Fleet uses Skia in a later post). In fact on the JVM you can use a variety of languages such as Kotlin. This is precisely what we have built Fleet with – Kotlin.
However, as a true polyglot IDE, Fleet itself is also polyglot. That’s right, a small part of Fleet, in particular the Fleet System Daemon, is built in Rust!
Fleet Architecture
Now that we know what is used to build Fleet, let’s take a look at a brief overview of the architecture. Fleet consists of the following components:
Let’s break down each of these components to better understand what they do.
Frontend
While it may be tempting to assume that the Frontend is the User Interface, it is actually more. It is not only the UI but also provides functionality such as
- File parsing
- Syntax highlighting and basic completion
- Editor functionality
Fleet is launched by default in editor mode where you can get basic completion and navigation, as well as functionality you’ve come to expect from any powerful editor. All this is provided by Fleet’s frontend.
Workspace
As its name suggests, the workspace is where things related to the work session are handled. Aspects such as state management are handled by the workspace. This functionality can be run either in process with Fleet or as a separate process, depending on whether it is local to the machine or not, thus allowing for the possibility of a workspace running on a remote server.
Smart Mode and the backend
As mentioned above, Fleet can be run as an editor. However, if more advanced features such as smart code completion, advanced navigation, refactorings, and inspections amongst other features are required, that’s where the smart mode kicks in.
This smart mode can be powered by a variety of options, including the default IntelliJ IDEA code-processing engine, custom analyzers, or even language servers (whether these are based on LSP or not).
Fleet System Daemon (FSD)
This component, which is written in Rust, is responsible for build actions, running code, executing terminal commands, as well as other actions in the environment in which Fleet runs.
All of these components come together to provide a solution that is distributed and scalable. In later posts we’ll dive deeper into the technologies used for building each of these components and the protocols used to communicate between them.
In the next post we’ll take a look at state management and see how we make sure there is consistency across all these services.
Stay tuned!
Discover more
Fleet 后台探秘，第一部分 – 架构概述
我们最近宣布了一款一直在开发的新产品，这款产品的名称为 Fleet，是由 JetBrains 打造的新一代 IDE。 该产品目前处于封闭预览阶段，我们收到了来自尝鲜者的大量反馈，帮助我们改进产品并为在 2022 年的公开预览做好准备。
同时，在我们准备好供公众访问之前，我们想与您谈谈 Fleet 是如何在后台构建的。 在一系列的博文中，我们将深入探讨 Fleet 的各个方面，从顶层的架构视图，到状态管理、解析器、协议、可扩展性，甚至是徽标设计等小细节。 我们希望您喜欢了解这次后台探秘！
Fleet 是用什么技术构建的？
当我们第一次宣布 Fleet 时，Twitter 上发生了一些有趣的对话，讨论它是用什么技术构建的。 一些人认为是用 JavaScript 和 Electron， 其他人则希望不是。 有些人对没有使用“笨重老式的 Java”感到非常高兴。 令人惊讶的是，人们可以仅根据屏幕截图推断出多少！
事实是，Fleet 是在可靠、高性能、美妙的 JVM 平台上构建的。 是。 JVM。 为什么？ 因为与流行的看法相反，JVM 实际上是一个性能非常高的平台。 此外，它是跨平台的，在支持多个操作系统时使事情变得更容易。
然而，JVM 并不是专门为 Java 语言提供的主机，也不要求您使用 Swing 作为 UI 库（关于 UI 和 Fleet 如何使用 Skia 的更多内容请见后续博文）。 事实上，您可以在 JVM 上使用各种语言，例如 Kotlin。 这正是我们构建 Fleet 所用的语言 – Kotlin。
然而，作为一个真正的多语言 IDE，Fleet 本身也是多语言的。 没错，Fleet 的一小部分，尤其是 Fleet System Daemon，是用 Rust 构建的！
Fleet 架构
我们现在已经知道 Fleet 是用什么技术来构建的，让我们来看看架构的简要概述。 Fleet 由以下组件构成：
让我们将这些组件逐一分解，以更好地理解它们的作用。
前端
虽然我们可能会认为前端就是用户界面，但实际上它的作用更大。 它不仅是用户界面，而且还提供以下功能：
- 文件解析
- 语法高亮显示和基本补全
- 编辑器功能
Fleet 默认在编辑器模式下启动，您可以在这里获得基本补全和导航，以及您期望从任何强大的编辑器获得的功能。 所有这些功能都是由 Fleet 的前端提供的。
工作区
顾名思义，工作区是处理工作会话相关事务的地方。 诸如状态管理等方面都由工作区来处理。 这个功能可以在 Fleet 的进程中运行，也可以作为单独的进程运行（具体取决于它是否在计算机的本地），因此，允许工作区在远程服务器上运行。
智能模式和后端
如上所述，Fleet 可以作为一个编辑器运行。 但是，如果需要更高级的功能，例如智能代码补全、高级导航、重构和检查等其他功能，那么智能模式就可以发挥作用。
这种智能模式可以由各种选项提供支持，包括默认的 IntelliJ IDEA 代码处理引擎、自定义分析器，甚至是语言服务器（无论这些是否基于 LSP）。
Fleet System Daemon (FSD)
这个组件是用 Rust 编写的，负责构建操作、运行代码、执行终端命令，以及 Fleet 运行环境中的其他操作。所有这些组件一起提供了一个分布式和可扩展的解决方案。 在后续博文中，我们将深入探讨用于构建这些组件的技术，以及用于它们之间通信的协议。
在下一篇博文中，我们将查看状态管理，看看我们如何确保所有这些服务之间的一致性。
敬请关注！
英文博文原作者：