GoLand is an IDE that helps you read, write, and edit Go code - the popular programming language designed by Google. Continuous error detection helps fix errors quickly with suggestions from the IDE's intelligent, quick fixes feature. Refactoring is just one-undo-step away as it can be done safely in an instant when using GoLand.
It’s great for beginners and experts alike because no matter your experience, there’s always something that you could use some help with.
GoLand lets you easily navigate your code through instant switching. You can jump between types and examine them in a group based on the usage type that they are part of. GoLands tools help you increase productivity by running tests without additional plugins and debugging your applications within the GoLand IDE.
The IDE directly supports Git, GitHub, and Mercurial, while plugins are required to support Perforce and other version control software.
GoLand is a true IDE in that it supports core Go development, JavaScript, NodeJS, SQL Databases, and others. These abilities enable GoLand to work on modern web applications, DevOps, or any other tasks.
Finally, GoLand's has over 1000 plugins that you can use to enhance the IDE further.
EduTools
If you're learning to code, one of the main challenges you'll have is finding the right educational materials. This is simply because there’s so much information out there.
The EduTools plugin aims to solve this problem and it lets you learn programming languages like Kotlin, Java, Python, JavaScript, Go, and C++. It does this by giving you coding tasks and verification tests in your IntelliJ IDE. In this way, you’ll get to build your knowledge and get instant feedback on the code you've written.
It goes further than this, though. It's also the perfect tool for educators who want to teach students to code. Here, they'll be able to create their own interactive courses with integrated tests.
Node.js
In recent years, Node.js has become increasingly popular as a backend framework for both web and mobile application development. So, it’s quite possible that, at some stage, you’ll need to write some Node.js code if you haven’t already.
If this is the case, the Node.js plugin is definitely worth considering as it provides support for Node.js projects in your IntelliJ-based IDE. As such, you’ll be able to run Node.js applications from your IDE and debug them by using the built-in visual debugging tool.
You’ll also be able to profile Node.js application from your IDE, create new Express projects from the Welcome Screen, and, with the Node.js remote interpreters plugin, run and debug Node.js applications in remote environments.
Duckly
We couldn't create a list of plugins without mentioning ours. Duckly is here to make pair programming a breeze.
Duckly is a video chat tool built for developers with direct integration to the IDE so you can talk, share your code in real-time, and easily collaborate with your team. It enables remote developers to work as if they were side by side.
This plugin proves itself necessary by the day. With remote work becoming the norm throughout companies due to COVID-19, the ability to pair-program is interrupted by bad WiFi signals or background noise. Duckly provides the solution to that by allowing you and your team to share the same view while coding. Duckly is great for pair programming, code reviews, debugging sessions, and much more.
Protocol Buffers
Because protocol buffers provide a faster and more efficient way to serialize data compared to other formats like JSON and XML, you’ll probably, at some stage or another, work with them. This is even more so when you’re working with modern server architectures where vast amounts of data are transferred constantly.
When you do need to work with protocol buffers, it might be a good idea to consider the Protocol Buffers plugin. It provides editor support in IntelliJ-based IDEs. So, it offers syntax highlighting, semantic analysis, references and navigation, quick documentation, autocompletion, brace matching, and more.
Presentation Assistant
Pair programming is not only an excellent way to increase the quality of code and the efficiency of your team but also a great tool when educating new developers. A problem that often occurs when pair programming is when a developer uses keyboard shortcuts the other developer doesn't know. This is especially the case when teaching someone to code.
The Presentation Assistant plugin solves this problem by showing the name and the shortcut of any action you invoke while coding. In this way, your coding partner, whether experienced or inexperienced, knows exactly what you're doing. Because of this, it's the ideal tool when live coding in front of an audience, screencasting, and when teaching.
Quokka
When was the last time you wrote a bunch of code only to find out that it doesn't work when you're done? To solve this problem, you’ll often switch to online REPL tools to test a specific block of code. This takes time and makes you less productive.
The Quokka plugin solves this problem and makes it easier to prototype and test JavaScript code in your IntelliJ IDE. It's as simple as opening a new Quokka file and then start experimenting. Because you're able to do it in your IDE, you don't need to learn any new tools just to test an idea and you can focus on writing code.
Zero Width Characters Locator
The problem with zero width characters is that they can cause havoc with your code. The bigger problem with them is that they’re invisible. So, two pieces of code might look identical, but one could contain zero width characters. This makes them extremely hard to find and debug.
Instead of spending hours to find zero width characters, rather use the Zero Width Characters Locator plugin. It adds an inspection tool to IntelliJ that makes it easier to find zero width characters. Ultimately, this plugin could end up saving you a lot of time and headaches.
Lines Sorter
Different developers have different preferences on how they like their code to be arranged. For instance, some don’t care much about the order of lines while others prefer to have it in a specific order, often alphabetically.
If you’re one of the last mentioned, then the Lines Sorter plugin is definitely for you. It adds a Sort Lines action in IntelliJ’s edit menu. So, you can just select the lines you want to sort, click on Sort Lines, and the lines of code will be sorted alphabetically.
ESLint
Let's face it, bugs can be frustrating to find and solve. It's even more difficult for new developers working on a codebase for the first time. So, you’ll want to eliminate and avoid programming errors as far as possible.
The ESLint plugin helps you do this. It quickly analyzes your code to find programming errors, stylistic errors, and bugs. And when you find these errors and bugs easier, you'll be able to rectify them quickly and easily. Another bonus is that the plugin can fix many errors it finds automatically.
Also, you’re able to write your own rules that will work alongside the plugin’s built-in rules. Ultimately, you can customize the plugin based on your team's needs and you'll ensure that your code is always free of errors.
Tabnine AI Code Completion
Still on the topic of saving time, one of the pain points of a developer is usually writing every single simple function or line every time. This issue is solved with Tabnine AI Code Completion!
Tabnine is an AI-powered code completion extension to help you code. It is powered by machine learning models trained on lines from trusted Open Source code on GitHub. This plugin works in various IDEs and different languages, including JavaScript, Python, Java, TypeScript, Rust, Swift, and more.
You can see two gifs of code with and without Tabnine to see the difference this plugin brings. It predicts what you will potentially create according to your object or function. Now, instead of having to type console.log("hello world"), you can just start typing, and Tabnine will finish the job for you.
Rainbow Brackets
Let's face it, when coding, you'll deal with brackets upon brackets and even more brackets from round ones, to square ones and squiggly ones. Obviously, this can become complicated when trying to figure out which bracket closes which block of code.
Luckily, the Rainbow Brackets plugin solves this problem. By showing bracket pairs in specific colors, it makes it easier for you to see where a code block starts and where it ends. This eliminates confusion and allows you to save time when writing code.
VSCode Keymap
So, you’re thinking of switching from Visual Studio Code to an IntelliJ based IDE? Maybe you’ve made the switch already. The problem is that, when switching, you’ve got to learn a new set of keyboard shortcuts to not only find your way around the IDE but also to be productive when writing code.
Luckily, there is a solution. The VSCode Keymap plugin lets you use the VSCode keymap in all IntelliJ-based IDEs. In this way, you can still use the keyboard shortcuts you know and love and you won’t lose anything when it comes to productivity. In simple terms, it let’s you switch from VSCode quickly and effortlessly.
Multirun
When developing an application, you’ll often need to test different configurations. This will, generally, require you to run the application in a specific configuration, change the configuration, and then run the application again. This, in turn, takes a lot of time and effort.
To save time, the Multirun plugin allows you to run multiple configurations at once. With it, you’re able to group multiple run configurations and run them with the click of a button. This makes it easier to run batches of tests and configurations or to start multiple servers and web applications.
.env Files Support
.env files are extremely important to control the environment your application will be running in. In other words, they allow you to configure the environment for different stages of your application development process whether it's for staging, production, or your local environment. By configuring these files correctly, you'll ensure that your application runs as it should.
The .env Files Support plugin adds support for editing .env files to all IntelliJ-based IDEs. As such, it offers syntax highlighting, autocompletion of environment variables in .env files, Dockerfiles, and docker-compose.yml files, and the ability to go to specific declarations in your files through keyboard shortcuts.
PowerShell
When writing applications, you’ll often need to execute scripts. In Linux, this is generally not a problem as you have access to the terminal through IntelliJ. The problem is, running PowerShell scripts on Windows in the IDE is challenging and you’ll often be required to copy and paste code to the PowerShell window.
That is, until now. The PowerShell plugin gives IntelliJ PowerShell language support. As a result, you’ll have features like syntax highlighting, IntelliSense, code snippets, code formatting, script execution, and more.
Save Actions
It often happens, especially with larger projects or larger development teams, that you end up with a messy code base with differing styles, indentations, and the like. This not only makes it difficult for new developers to start working on the project but also makes the project more challenging to maintain.
The Save Actions plugin solves this problem. With it, you'll be able to set configurable save actions that will be applied every time files are saved. So, every time a developer saves their work, you’ll be able to reformat, rearrange, compile or optimize your code.
This allows you to enforce a code style and code rules which makes your code cleaner, more uniform and easier to maintain.
Grazie
It’s a fact, when we write, we make spelling and grammar mistakes. So, it’s understandable why productivity software and word processors come with spell and grammar checking capabilities built-in. But why can’t you have this functionality in your IDE?
In fact, you can. The Grazie plugin provides intelligent spell and grammar checking functionality. Using the LanguageTool proofreading engine, it supports over 15 languages including English, Chinese, German, and more. It also recognizes natural language constructs in programming languages, markup languages, comments, and commit messages.
GitToolBox
By now you know that, as a developer, you'll not only spend a lot of time in your IDE but you’ll also spend a lot of time using git. As a result, it's vital that you have an IDE with excellent git integration get allows you to perform your git actions from within your development environment.
Fortunately, JetBrains’s range of IDEs features some of the best git integrations on the market. With the GitToolBox plugin, you’ll be able to extend the features these IDEs already offer. Its features include enhanced status display, auto fetch at fixed intervals, inline blame annotation, commit dialog completion, behind notifications, and more.
Terraform and HCL
Hashicorp’s Terraform is a powerful infrastructureas code tool that makes it easy to manage cloud services. As such, it allows you to write infrastructure as code in configuration files that determine the configuration of cloud services. To do this, however, you’ll need to use HashiCorp Configuration Language (HCL) and HashiCorp Interpolation Language.
But where do you start? Fortunately, the Terraform and HCL plugin add support for these languages and the Terraform framework in IntelliJ-based IDEs. So, it offers features like autocompletion, rename refactoring, syntax highlighting, code formatting, inspections, and more.
These features allow you to get up to speed quickly and efficiently.
Database Navigator
As a software developer, you’ll work with databases often. You’ll typically do this by using the specific database’s console or shell through the terminal or desktop application.
The Database Navigator plugin aims to make this easier. It adds extensive database management, development, and maintenance capabilities to IntelliJ and other IntelliJ-based IDEs.
As such, it provides both SQL and PL/SQL editors, advanced database connection management capabilities, script execution support, database objects browsing, advanced navigation functionality, and more. Moreover, it supports most of the databases you’ll often work with including, MySQL, SQLite, PostgreSQL, and others.
CamelCase
This is often one of the biggest disagreements between developers - what case should code be written in. Well, it depends on the specific language’s specifications and its naming conventions. Sometimes languages even require the use of different cases, so you’ll need to understand the difference and how to use them.
No matter the language or your preference, another important thing is that you apply your naming conventions consistently in your codebase. The CamelCase plugin ensures consistency by allowing you to switch easily between kebab-case, snake_case, PascalCase, camelCase, and more.
Makefile Language
The make utility can be extremely helpful when you want to run or update tasks when certain files are updated. When using it, you’ll typically use Makefile that defines the set of actions or tasks that need to be executed. Like writing code, you’ll need the right tool that allows you to ensure the quality of your makefiles.
The Makefile Language plugin adds extensive makefile language support to IntelliJ-based IDEs. It offers features like syntax highlighting, keyword and target name completion, rules, variables, and conditionals folding, quick documentation for comments, makefile run configurations, context and gutter actions, and more.
