For well-known reasons, many people are talking about home-made IDEs these days, and some members of the deepin community will ask: does deepin have its own IDE?

When the netizens are discussing, a post appeared on the deepin community forum soon, the content is about the use of deepin-IDE manual, this post immediately blew up a lot of partners who are diligently moving bricks and mortar. Of course, there will also be people who follow the current affairs of the soul to ask a question:

"Is it related to VS Code?"

In order to eliminate your doubts, this article provides a formal answer, and also introduces deepin's own IDE in the meantime.

Why make your own IDE

From an operating system perspective, to build a thriving ecosystem, a rich and complete base software system is required. Development libraries, package formats, development tools, and developer support are a gradual process of improvement and development.

Development Library

In terms of development libraries, deepin OS has its own DTK (Development ToolKit), which has 4 core modules, 220+ classes, 2300+ function interfaces, 11 auxiliary function modules, and 10+ extension interface modules, which can meet the development needs of daily graphic applications, business applications, and customized system applications. The deepin operating system At present, more than 40 native applications such as browser, music, email, etc. developed by deepin OS are all developed with DTK.
- DTK：https://github.com/linuxdeepin/dtk

Packet Formats

The package format is derived from Linux package managers, such as apt, up2date, yum, portage, pacman, and so on. The diversity of package managers brings more choices to users, but the disadvantage is also very obvious: their packages are not interoperable. deepin operating system, in order to solve the problem of "one package for multiple uses", launched the "Linglong" package management program, which completely solves the problem of upgrading between system and application, application and application. In order to solve the problem of "one package for many uses", deepin OS has launched the "Linglong" package management program, which completely solves the compatibility problems caused by upgrading between the system and applications, and between applications.

- Linglong：https://github.com/linuxdeepin/linglong

- "Linglong" Packing Store：https://store.linglong.dev/

Development Tools

At the level of development tools, there are countless mature IDEs, such as VSCode, Visual Studio, QtCreator, etc. These mature IDEs have some common features, such as good scalability, beautiful interface and strong usability, and most importantly, their corresponding ecosystems are very complete. The most important thing is that the corresponding ecosystem has been very well developed. However, the pain point is that we don't have any self-developed IDE tools yet. Self-developed IDE is a very important part of the ecological construction, but also the developer's ecosystem.

First of all, self-developed IDE can provide DTK, a variety of open interface development support, developers can be based on the development library to develop applications corresponding to business functions. Secondly, in order to use "Linglong" such a good thing, self-developed IDE can provide "Linglong" packaging format by default, which can cover the whole Linux ecosystem in one package. Finally, in order to facilitate developers' communication and enhance community activity, self-developed IDEs can integrate developer platforms, so that developers can gather together to exchange development experience. From this point of view, self-developed IDEs are a must!

According to the deepin team's style of doing what they say they will do, after years of research and development, deepin-IDE has broken out of its shell, and its ultimate goal is to integrate the above dispersed contents to form a highly unified, open and free, resource-rich eco-construction tool.
Current status of deepin-IDE

deepin-IDE didn't come out of nowhere, it has been developed internally for many years, why has it been so quiet? Why has it been silent? Because during this period of time, it has been continuously improving its features and overcoming some technical problems, but it has not yet reached a very perfect point. At the same time, because the designers are not involved, so the entire interface by the R & D staff "native" design, very stylish (plain) (plain), as for how good it looks, the end of the article has a preview of the function of the map, we look at it again.

First, let's take a look at the overall architecture of deepin-IDE:

Architecture

The overall use of modular framework-based development, support for C / C + +, Java, Python and other programming languages, each development language is accessed in the form of plug-ins. Modular design can, on the one hand, shorten the product development and manufacturing cycle, increase product series, improve product quality, and quickly respond to market changes; on the other hand, it can also reduce or eliminate the adverse impact on the environment, and facilitate the reuse, upgrading, maintenance and independent uninstallation.

Its overall structural design is shown in the figure below:


As shown in the figure above, the modules with colors are all related to specific languages. The corresponding communication middleware uses LSP (Language Server Protocol), which can be used to realize syntax highlighting, symbol tree, syntax tree and other functions based on the protocol; the debugging-related modules use DAP (Debug Adapter Protocol), which can be used to realize common debugging functions such as startup, run, breakpoint hit, single-step jump in, single-step jump out, etc. of the debugged program based on the protocol. DAP (Debug Adapter Protocol) is used for debugging, based on which common debugging functions such as startup, run, breakpoint hit, single-step jump in, single-step jump out, and so on, can be realized for the debugged program. Through the intermediate protocol adaptation, decoupling the language business functions and the actual functionality of the provider's dependence, so that the language extension becomes feasible.

In order to further improve the scalability, the front-end and back-end are implemented as plug-ins.

In the front-end, the extension of a new language is realized by accessing a new language plug-in, which is used to implement language-related and special business logic without writing the full amount of code, thus reducing the code burden of the language plug-in.

On the back-end, a language service provider can be accessed more easily through the plug-in approach.

Based on the above description, the language-related top-level data flow diagram is drawn as follows:


Features

deepin-IDE contains IDE common features such as intelligent editor, highly scalable command system, project management, build management system, plug-in system, etc. In addition, it also supports a variety of compatible protocols, a variety of development languages, code versioning integration, and low overhead real-time performance analysis tools. Overall, the IDE common features are in the table

  • VersioningSupport mainstream version control systems Git, SVN.

  • Protocol Support

  • Language SupportSupport for C++, C, java, python, javascript five categories of commonly used editing languages, support for commonly used build tools CMake, Maven, Ninja, Gradle and so on.

In addition to the above common features, deepin-IDE also includes some unique features, such as reverse debugging, code migration and so on.

  • Reverse Debugging

This function further improves the debugging efficiency and development capability of the application by means of process execution history playback, event classification management, timeline management and other means.

  • Code Migration

The code migration analysis subsystem is a highlight of deepin-IDE, which can assist developers in migrating Linux applications from x86 platforms to domestic processor architectures such as Longxin and Fetion, and domestic operating systems such as Unicom UOS, etc. The function can automatically analyze the content of the code that needs to be modified and give guidance on the code migration, which can reduce the difficulty of the migration and enhance the efficiency of the migration.

Functional Interface Preview

  • Language Support

  • code migration

  • debug mode

  • reverse engineering

  • version management

Who is using deepin-IDE

deepin-IDE has been lightly used in some of the deepin applications, some of which are listed below:

1、Deep drawing board application (deepin-draw)

The repository address: https://github.com/linuxdeepin/deepin-draw

2、Deep viewer application (deepin-image-viewer)

Warehouse address: https://github.com/linuxdeepin/deepin-image-viewer

3、Depth album application (deepin-album)

Warehouse address: https://github.com/linuxdeepin/deepin-album

  • Development of drawing board applications

  • Development of drawing applications

  • Development of photo album applications

How deepin-IDE will develop in the future

IDE is a very ambitious topic, deepin-IDE is just starting out compared to other mature IDEs, there are still a lot of things that need to be improved:

  • Hire a designer
  • Improvement of the plug-in system
  • Low-code programming support
  • support for one-click software packaging: deb, Linglong packaging
  • Support for package signing, on the application store
  • AI function access
  • Integration of DTK and other development kits, access to plug-in templates such as text management, desktop, taskbar and so on.
  • Developer platform access

deepin-IDE There are still some known problems to be solved:

  • Too many file descriptors cause crashes
  • Some translations are missing.
  • The bottom interactive area does not support multiple pages for the time being.
  • Symbol tree parsing accuracy is not high

Is deepin-IDE open source?

deepin-IDE inherits deepin's technical gene of "focusing on self-research and contributing to open source", with more than 140,000 lines of self-research code.

Of course, the rapid development of this product is standing on the shoulders of the "open source" giant, in order to avoid duplication of the wheel, using some open source terminal components, functional components, here is a list of open source products drawn from the open source results, thanks to the open source community!

Code public address, welcome to actively participate in the development of deepin-IDE:

Repository address:

Download link:

That being said, it's a good time to answer the question from the community member at the beginning of this article:

"Is it related to VS Code?"

Our answer is:

DEEPIN-IDE is purely and simply self-developed!

deepin-IDE is rooted in the open source community, it relies on open source components such as scintilla, and itself is open source under the GPLv3 license, so of course it has to contribute to open source. Like other basic software, IDEs take years to build and improve, for example, VSCode has been in development for eight years now, so developing an IDE is really difficult.

Although the road is far, the journey will be accomplished. Though it is difficult, it will be accomplished if we do it. We also welcome open source enthusiasts to participate and help it continue to grow!

Leave a Reply