Programming

In this Thread: people telling you how IDEs suck then proceed telling you how to turn their terminal based text editor into an IDE

For my money: yes, you should use an IDE or something like one, but not because you're "missing out" - rather, because a plain text editor will limit your progress.

There are (still!) people around who think it's some sort of badge of honour to only use text editors, but in reality, this means they miss the syntax errors and typoes that we all make because we are human, and end up wasting hours looking for them when an IDE would let them see them.

You wouldn't turn up at a cookery school saying "I'm still a beginner, so I'm only going to use this pair of scissors" - specialised knives and utensils are part of the chef's toolkit, and becoming a better chef is just as much about learning to use them effectively as it is about memorising recipes. It's the same with programming.

It’s worth figuring out an IDE “lite” like vscode to see how you go. It’s pretty lightweight and easy to spinup compared to something like IntelliJ

I use vim, and I can safely say, it was worth bothering to learn it and set it up, ESPECIALLY if you make a career out of it, and one time I had a friend who didn't use an IDE and I showed him how much easier it was to do certain things on vim and he felt very very stupid for using notepad.

If you try out an IDE don't feel obligated to have to use every feature of it just to justify using it. Just use it much like your text editor to start with and learn the extra features you go.

Interesting question. Personally, I started with a text editor transitioned to vim, then to VSCode and now I've settled on a customised neovim install.

I'm a believer of PDE, that is personal development environment. It's a concept one of the Devs of Neovim TJDeVries talks about.

In essence it's the idea of building your development environment how you want it. Personally, Neovim allows me to do this. For example, I have a VSCode style debugger, incredibly fast searching with ripgrep, vim keyboard shortcuts and uses the same language servers as jetbrains products.

Here's a link to his full conversation on the topic: https://youtu.be/QMVIJhC9Veg

Stay awesome!

There's a lot of value in using an IDE, from just general formatting stuff to being able to tell what class functions do without having to dig into the class itself. Not to mention autocomplete.

There's lots of free solutions out there now, so if you're curious I'd give it a shot. I think you'll find once you start using one it'll be hard to go back to just a plain text editor.

I like vs code a lot, if you're looking for specific recommendations. It's lightweight and can be upgraded to do pretty much anything via extensions.

I usually use a text editor in day to day, but when I say text editor, I mean something a little more full featured like emacs or sometimes vim. It's quite valuable to have something that can integrate easily with a debugger and has navigation + completion features if you want to go the text editor route. I hadn't heard of geany before, but it looks like it can do at least that much.

I started as a sysadmin in 1995 and started programming not long after that. I spent most my time in a shell and vim, started writing python all in vim. Then I took on a project that was a graphical application for windows and OS X. It was a rewrite of a windows visual basic app that we did not have the source for, so now good opportunity to write a multi platform application.

I wrote that program in python/pyQt3. Started on linux (which it also ran on) decided to look at IDE's to help with pyQt I found Eric3. It made writing the first app and many after a lot easier.

So moved on from there a few years later and I use Jetbrains Pycharm commercial if I am writing anything bigger then a quick script I will do it in Pycharm.

Some of the things I like in Pycharm.

• really good vim emulation
• the linter finds code problems very well
• completion is great
• debugger is fantastic I rarely use a print to debug but it still happens
• Increase's productivity, hard to see at first.

I strongly recommend looking at IDE's start with Kdev and see where it goes also try the trial version of Jetbrains Clion. https://www.jetbrains.com/clion/

It feels like a lot of extra work to learn an IDE but it pays in productivity. Watch some videos on Clion.

As hiajen said, most IDE’s simply aren’t as useful for lower-level languages like C++. And while communist suggested vim, I would say that something along the lines of helix-editor would be a bit more user-friendly, and just as extensible :)

The line between IDE and text editor is kinda blurry nowadays anyway. I don't know that much about Geany, but many of the text editors I've used were basically full IDEs, except that the IDE features were opt-in.

Currently I use VScodium as my editor, and I've been happy with it. I hear a lot of good things about Kate too, and as a KDE user, I feel like I should try it some time. Kate to me looks like the same spirit of text editor as Geany. Maybe if you're comfortable with that style of editor, give it shot.

The 2 editors that have really been catching my eye lately have been Helix and Lapce. I think it's really cool that Helix went with a Kakoune style "selection → action" system instead of the normal vim style "action → selection". I think Lapce is trying to be a similar style of editor to Vscode, with simple IDE features by default, but then an extension sytem to expand that. Maybe an editor like that would be approachable to you. Although unlike Helix, Lapce seems to be less production ready for now, so maybe wait on that.

For now you could of course just try VScode (or VScodium if you're like me and want open-source software) since that's a popular one right now.

I don't feel like I have to make that decision anymore.

I use Vim and VSCodium, because I can enable IDE functionality gradually, and only enable what I need.

Step by step debugging is very enlightening when it comes to inspecting execution. If your current setup doesn’t include that, I’d strongly suggest to revise it.

When I first started programming I used a text editor, UltraEdit32. When I moved into .Net, I initially used Ultraedit and wrote all my own build files, but switched to using Visual Studio with all the bells and whistles. When I moved to Python/Node I adopted Vim, and these days I tend to use Doom Emacs.

There's a spectrum from visual studio or eclipse, with complex project structures, through vscode and rider which are simpler, to programmers editors like Emacs or neovim, to plain editors like nano.

I think the most important thing is that you're comfortable with your tools. I could crunch out a lot of code with Visual Studio and Resharper, but I use Emacs as an IDE, note taking tool, and email client . The familiarity makes me productive.

It is super helpful to have syntax errors or warnings highlighted when working on code, and a decent editor will make it easier to navigate code - jump to the definition of a function, find the documentation for an API call etc.

As codebases get larger, you need all the help you can get. You may also find, when you work with others, that their opinionated tooling clashes with your opinionated hand crafting.

Hm, i do thing witu c/c++ the benefits of using an IDE are not as great as for other languahes like java/python etc etc but still existant.

I wont programm java without my IDE, for c/c++ i mostly just use vim with someplugins for autocompletion. I could be a snowflake tho.

Personally, my path was from basic programming editors (Notepad++, PSPad) to IDEs (Eclipse, IntelliJ IDEA) to NeoVim which I use currently.

I started out as a self-taught web developer pretty early. I worked with basic editors back then, and it was quite enough for my high-school tinkering efforts.

I then transitioned to Java when I went to university and started my first programming job. During those days I used full-fledged IDEs, mostly IntelliJ IDEA, but played around with Eclipse as well. The biggest advantage of that was that it indexed the whole project semantically, allowing me to use project-wide auto-completion and to navigate between source files quickly. Also, Java's build processes can get quite convoluted, which the IDE pretty successfully hid from me, which in hindsight is not a good thing.

As I am quite curious about the internals of everything, I started doing C - mainly for assignments at the university. Initially, I used CLion for everything, as it's basically just IntelliJ for C, but as I grew more and more frustrated with my Java job (both in terms of using Java itself, and in terms of company culture and stuff), I started looking for C jobs. Around that time, I incidentally started messing around with Vim and NeoVim, building out my config, finding Language Servers for languages etc. I fell in love. I love the versatility of using discrete tools for things, without them being bound to a big IDE. I love how everything is fast. I love how I can swap things out easily. The only thing I'm missing at the moment is a good GUI debugger for C - currently making due with terminal-based GDB. BUT I have recently started playing around with making a custom GDB GUI, which might potentially be accepted as a project at my current job, so I'm hopeful about that part as well.

Anyway, if I were to work with Java or C#, I would still probably use an IDE - the languages are not really suited for writing with just an editor. But C, C++ and many other (saner, hehe) languages - I can imagine I will be using NeoVim or something similar for a very long time into the future.

Some IDE's really speed up development, yes. They provide tools for running tests, automatically do formatting and make it very easy to navigate around the code. For me, that last point is the main reason to use an IDE, it is so much faster to just click on a function and go to the file where that function is implemented. IDE's can also help with setting breakpoints and using the debugger.

I'm not sure how things are for C++ though. Personally, I mostly develop with Java, Typescript (Svelte), Python and Rust. For Java, I use IntelliJ, for all others I just use VS Code.

A good IDE takes the basics and supercharges them.

Navigation along with block expand/collapse, make reading code much easier, they allow you to focus on what really matters.

Syntax highlighting, inspections, and formatting allow you to focus on what you write and not if you missed a semicolon.

Visual debugging is so much better that you just have to try it once, no debate.

Run configurations, especially for tests, are a nice treat if you running multiple apps/different configurations.

While there are many benefits to using an IDE, you have to keep in mind that they are not an one for all solution. Sometimes it's better to open a terminal.

Also, they are great as long as they assist your flow and not disturb it, you will need to spend time to figure out the configuration that works for you. I have been changing IDE configurationd since 2012 when I first used eclipse.

I think there are two key aspects to IDEs:

a) the larger the codebase and the less familiar you are with it, the more of a nightmare it will be to hunt bugs or search places to insert code; this is where an IDE becomes extremely helpful by e.g. letting you search a struct across multiple modules, showing lints, compiler errors etc.

b) IDEs are only as helpful if they can be configured with your codebase, and sadly there are probably numerous codebases that won't play nice and let you crate a working config

I think you should give (mostly) everything a fair try. At least anything that's "different" than what you're used to. As a programmer, you should always be striving to improve your workflow. The ideal workflow is different for everyone. The standard text editing experience with a mouse / using control arrow keys etc to navigate is fine and familiar. But you should really at least experiment with modal editing like vim or kakoune. Beyond just the way you type text, the way you interact with the editor (and by extension the project you're working on as a whole) is important to consider too. Make files are a great way to simplify those complex commands you run, but there may be a way to achieve those actions in the editor you're using. Compilation, testing, and running code is just one thing. But what about something like git? Magit on emacs is an example of an extremely well thought out integration of git into an editor. Autocompletion is a whole other story, but you can get that in mostly any kind of editor with LSP integration.

Anyways the point I'm trying to make is that you should never be stagnant in how you program (editor) and what you program (language, paradigm, domain, etc).

Only time you should be stagnant is once you've at least considered the other options and you know what works for you. :)

I've been doing development in many languages over the years, including C++, Java, Python, and Go. i do everything from the command line: tmux for multi-tasking, vim for editing, the specific compiler and other language tools, makefiles, grep, etc. I am plenty productive, and I find the speed and generality of the tools I use make up for the features an IDE might have out-of-the-box and that I have to either take a couple more steps to accomplish or write some kind of script to help with. Basically "the command line is my IDE". Also nice to not be dependent upon a windowing/desktop environment to get stuff done. Nice and portable and lightweight on dependencies.

You may actually miss out when using an IDE. Driving without training wheels is more fun :)

I've used IDEs (Netbeans, Intellij) in the beginning but then started migrating away. They where just too heavy for me. Also, often IDEs do lots of stuff in the background such that you easily don't understand fully what is going on. Now I settled using the 'helix' text editor. It provides some IDE-like features like integration with language-servers, syntax highlighting, code completion, file navigation, code navigation, symbol search. But there are no dozens of buttons for triggering compilation etc. You do all this on a separate terminal.

Quite handy for such setups are tiling window-managers like i3. They allow you to easily fit the editor and terminals on the screen. This way you also don't need the build-in terminal of an IDE.

There are "simple text editors" with IDE like features also, like neovim configured with LSP, Helix aso. And for languages that will infer types, it is really nice to have the editor show the types as inlay hints.