Sure! We hope that too! Just to clarify, there is no competition at all between Koder and Genio. We are really keen to work together!
Many thanks!
It is perfectly possible to implement LSP in an editor. I think Vim and YouCompleteMe are a good proof of that.
But let’s take the following example.
Clangd needs a compilation database to compile the source files, i.e. a list of the flags to pass to clang for each file that are part of a project.
If a source file, let’s say src/project/ProjectFolder.cpp, is opened in Koder, it would not know where the compilation database is located. It may also not exist and Koder would not know how to generate it.
Also, it does not know where the root folder of the project (usually where the db is), we also need to pass that too.
We’d need to generate it outside of the editor and locate it manually, then Koder would pass it to clangd.
An IDE would know where it is and how to generate it, instead. The whole process would be much more seamless and automated.
That is exactly what I mean by “knowledge of the project”.
To summarize, you are correct. LSP can be done solely in an editor but not without manual steps to configure the environment. A thing that an IDE already does by design.
I didn’t assume there is, after all these projects have different scope. It’s just that such sharing is only possible if some care is taken to make the editor features modular and independent. (As opposed to, for example, having one big Editor class where you take everything or nothing, or copy some parts and then modify them and then it all diverges in slightly incompatible ways and you track down similar bugs independently…)
This was mainly for the broader audience, we are already on the same page @KapiX!
I personally haven’t looked at the editor thoroughly, Andrea is leading that area. My feeling is that there is work to do on the editor side to bring Genio on par with Koder which is very well engineered.
Not exactly top of mind at the moment. We really hope to get some help from other developers to adapt Debugger and get it cooperate with an IDE/editor.
It would be great to be able to step through the code and manage breakpoints within Genio.
VScode is based on Chromium,which doesn’t work on Haiku.
It’s built with web technology and wouldn’t integrate nicely with the Haiku UI,even if it worked.
It’s by no means a native application.
It’s bloated,runs slow on older machines and sends telemetry to Microsoft.
Even if it worked on Haiku,I’d rather write my code in notepad.exe than in VScode,but I really appreciate that someone tries to make coding on Haiku more fun now.(But Koder and Pe are a great improvement over notepad.exe already,that was only to show how much I like VScode)
It’s not only because I dislike Microsoft,it’s because it simply won’t work.
Again,VScode is based on Chromium,and that doesn’t work here.
It partially does within QtWebEngine,but it crashes often and nobody found out why.
Chromium offers zero upstream support for anything but Windows,Linux and MacOS,so we’d have to maintain huge patchsets permanently,just like the BSDs do.
I guess it’s even more likely to get Firefox working someday than Chromium.
And besides that,yes,I do strongly dislike VScode,because it’s not an actual application,but a webpage that brings its own rendering engine.
I have no problem with non-native ports like Qt or GTK,Haiku wouldn’t be usable without them,but webpages packaged as applications is something I really can’t stand and avoid on the BSDs,and I really don’t want to have to deal with that on Haiku.
Finally, a real IDE.
As a newcomer, I first saw Paladin and wondered if this /is/ an integrated development env.
Genio is so different and looks very promising.
Autocomplete, jump to definition are so much needed features.
I love to test and maybe contribute to it.
Thanks for this news, I tested zoom (alt-+/-/0) and the hyperlinks - function and looks good.
By investigating your git repo I can’t help but make a few comments:
The experimental/lsp_client branchy be based (rebased) up on the master branch and keep based on it. So this branch can use the lastest code and is still experimental for the lsp.
Thanks for your feedback!
Sure we need to do some housekeeping but the lsp branch needs some feature being implemented in the project-folder branch, so it’s not a big deal for now
We finally merged the project-folders branch into main and made a few other changes.
If you want to test and experiment with the new features, any feedback is welcome!
This is a list of the major changes committed so far (from commit #479adf5 ahead):
Updated to v0.2.0
Removed the old project management system (.idmpro)
Implemented the concept of Project Folder, i.e. a folder on file system.
Show in Tracker
Open Terminal pointing to the selected folder out of the source tree
“Find in files” early implementation through grep
Open files not supported by Genio (i.e. images, binary, etc.) with default application
Log class
Better and more consistent way of handling cut, copy and paste
Console I/O file matcher - File names or path can now be clicked and the file will be opened in the Editor.
Line numbers are supported that allows to click on a compile error and open the file with cursor positioned on that line
For any other minor bug fixes and improvements, please see the commit log.
There is Umbrello on HaikuDepot which has decent code generation capabilities.
Do we need to reinvent the wheel?
Genio can now open project folders out from the file system, in theory you can create your classes with Umbrello and work on the skeleton in Genio.
More to this, in theory you can now include an Umbrello model file in the project folder (and Git if you like) and double click on it directly from Genio to open Umbrello
An idea of modular program have in Paladin “IDE”. I remeber a Daiku a IDE from Japan with GUI editor, where it’s now ??? You idea is brillient but you must TEST soft for memory leaks, new funcionals as welcome!!!
It’s just that such sharing is only possible if some care is taken to make the editor features modular and independent. (As opposed to, for example, having one big Editor class where you take everything or nothing, or copy some parts and then modify them and then it all diverges in slightly incompatible ways and you track down similar bugs independently…)
