homeoffice.studio Integrated Development

You’re going to need an Integrated Development Environment (IDE). You can buy one or you can build one. You’ll probably end up using one or two of your favorites. Just like everything else, it’s a lot easier to buy a ready made IDE.

Building your own IDE allows you to build it the way you want it. Be the engineer, the artist, the creator of your own high performance Integrated Development Environment. You’ll learn a lot about how it works in the process of building it.

Your IDEs are your primary tools for designing and developing Linux and KDE and applications to run on KDE Linux or any other operating system. Get started using the tools as soon as possible.

Have fun. Practice using them and then find the source code for one of your applications, clone it into your local development environment and open it up in one of your IDEs. Remember to back everything you work on up, so if you break something, you can restore it to some previous set up.

KDevelop

KDevelop is the IDE developed by KDE. Use “sudo apt install kdevelop” in your Konsole to install KDevelop, or “sudo pkcon install kdevelop” if your are using KDE Neon. Then use Discover to install the PHP and Python plugins for KDevelop, which will make it into a web development IDE, as well as a Linux application and user interface IDE.

To get the KDE source code installed on my computer, I used the command sequence:

$ mkdir -p ~/kde/src

then cd into ~/kde/src and

$ git clone https://anongit.kde.org/kdesrc-build.git  
$ kdesrc-build
$ ./kdesrc-build --initial-setup

This installed everything in my .bashrc file. I copied this

119 # Adding the kdesrc-build directory to the path
120 export PATH="$HOME/kde/src/kdesrc-build:$PATH"
121 
122 # Creating alias for running software built with kdesrc-build
123 kdesrc-run ()
124 {
125   source "$HOME/kde/build/$1/prefix.sh" && "$HOME/kde/usr/bin/$1"
126 }

into my .zshrc file. Then, I installed Qt and now, hopefully, I have a pretty decent Qt/KDE development environment set up on this Kubuntu 19.10. We’ll see.

Make sure you do your homework. I’m just sharing my notes here. I went to the Get Involved KDE Wiki and followed their instructions.

Qt

Qt is a cross platform, UI framework for developers using C++ or QML. Qt Creator is the Qt IDE and QML is a declarative language, like CSS and Javascript.

Qt, Qt Quick and the supporting tools are open source tools, which can be used under the LGPL v2.1 license or a commercial license.

Qt was invented by Haavard Nord and Eirik Chambe-Eng in Trondheim, Norway, in 1990. The first public release was published in 1995 by the Trolltech company and in 1996, the European Space Agency became their first big customer.

Qt is the framework and QML is the language that KDE is made with. Qt Designer and Qt Creator are IDEs specifically designed for editing KDE and other Qt and QML software. You can use them to design and build user interfaces for your desktop, your mobile phone and even embedded devices, like home security systems, automobile dashboards and things like that.

I’ll probably be focusing on web development, so I wont have much to say about this, yet. I just wanted you to be aware of these tools, in case you are interested in developing applications using Qt, QML and C++. It can be a very powerful addition to your local development environment toolkit.

Learn how Linux works and how KDE works. Linux is written in C. KDE is written in C++, QML and JavaScript. I’ll continue to investigate this piece of the puzzle. So far, I’ve learned that you use Qt Creator to build your business logic with C++ and your User Interfaces with QML and JavaScript.

While Qt Creator is a very specialized IDE for working with C++, QML and Javascript. KDevelop is a much more general purpose and versatile, fully featured IDE. Use it to work with C, C++, Python, QML/JavaScript and PHP projects. And work on improving these tools. Use Kdevelop to improve Kdevelop and Qt Creator.

Go to official_releases/qt/ and find out what the latest release is and replace the version number in this installation process. Go to Install_Qt_5_on_Ubuntu and follow the directions to get Qt installed.

I’m pretty sure that the $5000, Qt software development framework, along with a fully loaded Qt Creator, is far more advanced than the free and open source KDevelop. You can also get a free version of Qt Creator.

Open the applications and click on Help. Read the documentation to get started learning how to use these tools. There is no such thing as a self taught computer programmer, you’re either going to have to go to school, or you’re going to have to read a lot and watch a lot of videos. Self discipline is an important facet of self determination, which is a normal and necessary quality of human consciousness.

Read the manual by typing, “man [whatever application you want to read about]”, (without the quotes or brackets) in your terminal. The installed manuals cover Linux, the help directories cover the applications you are running on Linux. Or whatever operating system you are running them on.

I’ve got Qt Creator, Kdevelop, Geany and CodeLite installed on this machine. There are many other programs that accomplish a variety of other tasks. There are also a lot of other options you can choose to use. These are the IDEs I’ve installed on this computer. I’ve also got Vim installed and configured as a text editor and IDE.

My home made IDE, using Alacritty, Zsh, Tmux, Vim and Vifm setup on this new KDE Neon system is my favorite IDE.

Integrated Development Environment

Jetbrains has a very large selection of excellent text editors and IDEs. They’re probably some of the best in the world. They’re definitely some of the most popular. Microsoft’s Visual Studio Code is another very excellent and popular option. Atom and Sublime Text are also great options that are not quite so famous. There are many others, more than I can mention.

Microsoft’s open source Visual Studio Code, is probably aimed at Jetbrains commercial IDEs. Jetbrains leases a variety of high performance IDEs for a small fee. Microsoft gives VSCode away for free. Once they put Jetbrains out of business, they’ll probably start charging people for using VSCode.

Start using Krita and Karbon, along with Qt Designer, Qt Creator and KDevelop, to design and build your applications. Keep working on building and fine tuning your local development environment. Improve your KDE tools by using KDevelop and kdesrc-build, or clone the KDE Git repository that you want to work on and stage your improvements to the repository using SSH. Use C++ for your business logic and QML for your user interfaces.

GTK

GTK is a whole nother set of libraries and tools for building your desktop. You can mix Qt and GTK. The QT and GTK applications all play with each other. You can put GTK applications on a KDE desktop and Qt applications on Gnome. I always have a mixture of GTK and Qt applications.

I’ve switched to Gnome-shell desktop to get away from KDE Plasma’s GUIs and learn how to use my command-line tools. I also want to try System76’s Pop-OS! I like the idea of computers manufactured with Linux installed by default.

I’ve had Pop-OS! installed for about a month now and I’ve already got Alacritty, Zsh, Tmux, Vim and Vifm setup and configured as a very high performance IDE.

Htop, Zsh and Vifm on Alacritty and Tmux

I’ve got some work to do, to learn how to use it properly. I’ve already accomplished one minor project, getting The HomoSpeis Hypothesis posted into this website, to get some muscle memory built into my subconscious mind.

I’ve also got Geany installed, in case I ever need a graphical IDE for anything. Geany seems to be a light weight IDE, without a lot of bloat. I probably wont be using it a lot, because I will be using my home made Alacritty, Zsh, Tmux, Vim and Vifm setup.

Spend the time to get these tools installed and configured and learn how to use them to communicate with your hardware and with the global cloud of artificial intelligence. Imagine you are playing the piano. Be an artist.

Neovim

Setting Neovim up as an Integrated Development Environment (IDE) involves several steps that transform it from a simple text editor into a powerful development tool.

Neovim can be installed on various operating systems. For Unix-like systems, you can use package managers like apt for Ubuntu (sudo apt install neovim), brew for macOS (brew install neovim), or compile from source.

Neovim looks for a configuration file in ~/.config/nvim/. You can use either init.vim for Vimscript or init.lua for Lua (which is recommended for newer setups due to better performance and structure).

init.vim: vim

set number set tabstop=4 set shiftwidth=4 set expandtab

init.lua: lua

vim.opt.number = true vim.opt.tabstop = 4 vim.opt.shiftwidth = 4 vim.opt.expandtab = true

Choose a Plugin Manager: Popular choices include:

vim-plug for Vimscript.
packer.nvim or lazy.nvim for Lua, which are more modern and flexible.

Installation and Usage:

Add the following script to your init.lua or a separate file that’s sourced in your init.lua. This script checks if lazy.nvim is already installed, and if not, it clones the repository:

lua

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", -- Use the stable release
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

If you’re using LazyVim, which is built on top of lazy.nvim, you’ll follow similar steps but might clone a starter repo:

— Example for LazyVim setup

lua

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  { "LazyVim/LazyVim", import = "lazyvim.plugins" },
  { import = "plugins" },
})

Here, require(“lazy”).setup() initializes lazy.nvim with the plugins defined in your plugins folder or directly in the setup function.

lazy.nvim automatically installs plugins if they’re not present when Neovim starts. Plugins are loaded lazily based on conditions like event-driven loading (e.g., on certain file types, commands or key mappings). Dependency loading where plugins load only when their dependencies are needed.

Lazyvim provides a user interface (:Lazy) for managing plugins, showing updates and controlling plugin states. Reduces startup time by loading plugins only when necessary rather than at startup. It uses bytecode compilation and caching for Lua modules. Many operations, like fetching or updating plugins, are done asynchronously to keep Neovim responsive.

Plugins are configured through a Lua table syntax, which is more intuitive than traditional Vimscript. Each plugin can have options like config, keys, cmd, ft (filetype), etc., to control when and how it loads. You can split plugin configurations into separate files for better organization, typically under a lua/plugins/ directory.

Lazyvim can check for plugin updates and apply them. Manages dependencies between plugins to ensure correct loading order. Uses lazy-lock.json to manage plugin versions, ensuring consistency across different machines or when sharing configurations.

Since Neovim now fully supports Lua, lazy.nvim leverages this for better performance and easier configuration. To use lazy.nvim, after installation, you would define your plugins in Lua, set up your configurations and then use Neovim as usual, with the added benefits of efficient plugin management and performance optimizations.

Core Plugins for an IDE include a Language Server Protocol (LSP) to integrate with language servers for code completion, linting and more using nvim-lspconfig. Use treesitter for advanced syntax highlighting and parsing.

Plugins like nvim-cmp offer advanced autocompletion features. Use nvim-tree.lua or nerdtree for file management within Neovim. lualine.nvim makes a customizable status line. gitsigns.nvim or vim-fugitive for Git operations.

Set up custom key mappings for your workflow, e.g.,: lua

vim.api.nvim_set_keymap('n', '<leader>ff', '<cmd>Telescope find_files<cr>', {noremap = true, silent = true})

Install and configure a color scheme that suits your preference.

Use vim-terminal.nvim or Neovim’s built-in terminal for running commands directly from Neovim. Integrate with debugging tools like nvim-dap for a seamless debugging experience.

Neovim’s plugin system allows you to add functionalities modularly, tailoring the editor to your specific needs. Neovim runs many operations asynchronously, providing a smoother experience, especially with large files or complex plugins. With Lua, configuration and plugin development become more intuitive, reducing the barrier for custom solutions.

By following these steps, you can transform Neovim into a full-fledged IDE, with capabilities comparable to or even surpassing many traditional IDEs, all while maintaining the flexibility and efficiency of Vim. Remember, the setup process is iterative; you’ll likely refine your configuration over time as you discover new plugins or better workflow practices.

Sources

https://wiki.qt.io/Qt_History 
https://timeline.kde.org/ 
https://community.kde.org/Get_Involved/ 
http://download.qt.io/official_releases/qt/ 
https://wiki.qt.io/Install_Qt_5_on_Ubuntu
grok

KDevelop

Qt

Integrated Development Environment

GTK

Neovim

Installation and Usage:

Sources

Share this:

Like this: