5 Popular Extensions and Add-ons for JetBrains IDEs

In the fast-paced world of software development, an efficient Integrated Development Environment (IDE) is your trusty companion in the daily battle against coding challenges. For many developers, JetBrains IntelliJ IDEA stands as a formidable fortress, offering a robust platform for crafting code with finesse, thus these Extensions and Add-ons for JetBrains IDEs will come in handy

In this comprehensive guide, we’ll embark on a journey through the rich ecosystem of IntelliJ IDEA plugins. We’ll explore a handpicked selection of extensions and add-ons that cater to a wide range of programming languages and development tasks, each designed to make your daily coding grind more manageable and enjoyable.

From code analysis and version control to code generation and debugging, you’ll discover the perfect tools to suit your needs. Whether you’re a Java aficionado, Python enthusiast, JavaScript guru, or dabble in multiple languages, our guide will provide you with insights into the must-have plugins that can revolutionize your coding experience.

You can also check here for Ten IntelliJ Idea Plugins

Below we will introduce you to 5 popular plugins for IntelliJ IDEA and provide in many cases code examples to demonstrate their functionality.

1. Scala

The Scala plugin is indeed a game-changer for developers working with Scala in IntelliJ IDEA. It provides robust support for the Scala language, build tools, and test libraries, making it a go-to choice for Scala development.

This plugin offers comprehensive support for Scala syntax, build tools, and test libraries, elevating the development experience to a level similar to what Java developers enjoy with IntelliJ. While there might be some corner cases, such as handling complex implicits or Scala 3 support, the overall level of support is impressive.

What’s more, this plugin has its own dedicated blog and Twitter profile, making it easy to stay updated on the latest developments and features. In my experience, using IntelliJ IDEA with this plugin has significantly enhanced my productivity and made Scala development a breeze.

Below, I’ll elaborate on some key aspects of the Scala plugin and provide code examples where possible.

. Code Assistance:

• The Scala plugin offers intelligent code completion, highlighting, and error checking. It understands Scala’s type inference and provides context-aware suggestions.

Example:

val myList = List(1, 2, 3)
myList. // The plugin suggests methods available for List, such as 'map,' 'filter,' 'foldLeft,' etc.

2. Refactoring:

• The plugin supports various refactorings, including renaming variables and classes, extracting methods, and optimizing imports.

Example:

val oldName = "John"
val newName = "Doe"
// Using IntelliJ IDEA's refactoring features, you can easily rename 'oldName' to 'newName' throughout the codebase.

3. Code Navigation:

• Navigate through your Scala codebase effortlessly using features like “Go to Definition,” “Find Usages,” and “Navigate to Related Symbol.”

Example:

// Clicking on a method name and using "Go to Definition" takes you directly to the method's implementation or declaration.

4. sbt Integration:

• The Scala plugin seamlessly integrates with sbt, the build tool commonly used in Scala projects. It provides tools for importing sbt projects, running tasks, and managing dependencies.

Example:

// You can easily manage sbt tasks, like compiling your Scala project or running tests, directly from IntelliJ IDEA.

5. Play Framework Support:

• If you’re working with the Play Framework (a popular web application framework for Scala), the plugin offers specific support for Play projects, templates, and routes files.

Example:

// When working on a Play Framework project, the Scala plugin provides support for templates with syntax highlighting and auto-completion.

6. Worksheet Mode:

• The Scala plugin includes a “Worksheet” mode that allows you to write and execute Scala code snippets interactively, with the results displayed in a separate panel.

Example:

// In a Scala Worksheet, you can write code snippets and see the results immediately, making it ideal for experimenting and learning.

2. .env files support

IntelliJ IDEA provides support for working with .env files, which are commonly used for configuring environment variables in various applications. With this support, you can efficiently manage and edit environment variables in your projects directly from the IDE. Here’s an elaboration on how IntelliJ IDEA supports .env files and a code example:

1. Syntax Highlighting:

• IntelliJ IDEA recognizes .env files and provides syntax highlighting for them. This makes it easier to distinguish between variable names and values.

Example:

# This is a comment
DATABASE_URL=postgres://username:password@localhost:5432/mydb
SECRET_KEY=mysecretkey
DEBUG=true

2. Code Completion:

• The IDE offers code completion suggestions for variable names based on what you’ve already defined in your .env file. This helps prevent typos and ensures consistency in your environment variable names.

Example:

# Typing 'D' will prompt suggestions for existing variable names like 'DATABASE_URL' and 'DEBUG'.
D

3. Quick Documentation:

• You can quickly access documentation for environment variables by hovering over a variable name. This is particularly useful for understanding the purpose and expected values of each variable.

Example:

# Hovering over 'DATABASE_URL' displays documentation or comments associated with that variable.
DATABASE_URL=postgres://username:password@localhost:5432/mydb

4. Code Navigation:

• IntelliJ IDEA enables you to navigate to the definition or usage of environment variables within your project, making it easy to locate where a specific variable is declared or utilized.

Example:

# Right-clicking on 'SECRET_KEY' and choosing 'Find Usages' will show where this variable is used in your project.
SECRET_KEY=mysecretkey

5. Refactoring:

• You can refactor environment variables in your .env files just like you would with regular code. For example, you can rename a variable, and IntelliJ IDEA will update all references accordingly.

Example:

# Renaming 'SECRET_KEY' to 'API_KEY' will update all occurrences of 'SECRET_KEY' in the `.env` file.
SECRET_KEY=mysecretkey

6. Inspection and Error Checking:

• IntelliJ IDEA can analyze your .env files for errors, such as missing values or duplicate variable names, and provide suggestions or warnings to help you maintain a valid configuration.

Example:

# IntelliJ IDEA can detect missing values and provide a warning.
MISSING_VALUE=

7. .env File Management:

• The IDE provides tools to easily create, rename, delete, and manage .env files within your project, helping you organize your environment configurations efficiently.

Example:

• Right-click on your project directory, choose “New,” and select “File” to create a new .env file.

In summary, IntelliJ IDEA’s support for .env files simplifies the management and configuration of environment variables in your projects. This support enhances your productivity by providing code completion, navigation, refactoring, and error checking capabilities tailored specifically for environment variable files.

3. IdeaVim

IdeaVim is a plugin for JetBrains IntelliJ IDEA that brings Vim keybindings and functionality to the IntelliJ IDE environment. Vim is a highly configurable and efficient text editor known for its modal editing, keyboard-driven commands, and extensive customizability. IdeaVim allows developers who are familiar with Vim to work comfortably within IntelliJ IDEA while taking advantage of the IDE’s powerful features.

Here’s an elaboration on IdeaVim’s features and how it enhances the IntelliJ IDEA experience:

1. Vim Keybindings:
   • IdeaVim provides a wide range of Vim keybindings, allowing developers to navigate, edit, and manipulate code using familiar Vim commands. This includes modes such as Normal, Insert, Visual, and Command-line.

   Example: In Normal mode, you can use “h,” “j,” “k,” and “l” to navigate left, down, up, and right, respectively.

2. Modal Editing:
   • IdeaVim follows Vim’s modal editing paradigm, where different modes serve distinct purposes. This enables users to perform different actions without relying heavily on the mouse.

   Example: In Normal mode, you can quickly navigate and select text, while in Insert mode, you can insert or edit code.

3. Ex Commands:
   • You can use Vim’s Ex commands to execute complex operations and searches in IntelliJ IDEA.

   Example: :w to save the current file, :q to close a tab, or :find filename to search for a file.

4. Customization:
   • IdeaVim allows users to customize their Vim configuration, including defining key mappings, setting options, and adding custom commands.

   Example: You can remap keys, define custom functions, or configure Vim options to match your preferences.

5. Clipboard Integration:
   • IdeaVim integrates with the system clipboard, making it easy to copy and paste text between IntelliJ IDEA and other applications.

   Example: You can use standard Vim commands like "+y to copy text to the system clipboard.

6. Search and Replace:
   • You can perform advanced search and replace operations using Vim-like regular expressions and commands.

   Example: :s/pattern/replace/g to search and replace text globally in a file.

7. Plugins and Extensions:
   • IdeaVim is extensible and supports various Vim plugins, enhancing its capabilities even further.

   Example: You can install Vim plugins for specific programming languages, version control systems, or project management tools.

8. Incremental Search:
   • IdeaVim provides incremental search functionality similar to Vim, enabling developers to quickly find text within a file.

   Example: Press / to initiate a search, and as you type, the plugin highlights matching text.

9. IntelliJ IDEA Integration:
   • IdeaVim works seamlessly with IntelliJ IDEA’s features, allowing you to switch between Vim-style editing and standard IDE functionality.

   Example: You can use Vim keybindings for code navigation and editing, then seamlessly switch to the IDE’s refactorings and inspections.

10. Documentation and Community:
    • IdeaVim has a dedicated community, documentation, and active development. Users can find resources and support online to help them configure and optimize their Vim experience within IntelliJ IDEA.

Example: You can refer to the documentation or online forums for solutions to common questions or issues.

IdeaVim is a valuable plugin for developers who appreciate Vim’s productivity and editing capabilities but also want to take advantage of IntelliJ IDEA’s extensive features and ecosystem. It allows for a smooth transition between Vim and the IntelliJ IDEA environment, offering the best of both worlds for coding efficiency and convenience.

4. Key Promoter X

Key Promoter X is a popular IntelliJ IDEA plugin that helps developers become more proficient with the IDE by reminding them of keyboard shortcuts when they perform actions using the mouse. This plugin encourages users to adopt keyboard shortcuts, which can significantly improve coding efficiency and streamline the development workflow. Here are some key features and details about Key Promoter X:

1. Keyboard Shortcut Reminders:
   • Description: Key Promoter X monitors your interactions with the IDE and provides pop-up notifications whenever you perform an action using the mouse for which a keyboard shortcut exists. These notifications remind you of the corresponding shortcut key, encouraging you to use it in the future.
   • Usage Example: Let’s say you frequently use the mouse to execute a code formatting action. With Key Promoter X installed, it will display a notification indicating the keyboard shortcut (e.g., Ctrl + Alt + L for formatting code in IntelliJ IDEA). This serves as a gentle nudge to use shortcuts instead of mouse clicks.
2. Customizable Prompts:
   • Description: The plugin allows you to customize the notifications to fit your preferences. You can adjust the delay before a reminder is shown, specify which actions trigger reminders, and even disable notifications for specific actions if desired.
   • Usage Example: If you prefer to see reminders after a longer delay or only for specific actions, you can configure these settings in the Key Promoter X preferences to match your workflow.
3. Detailed Statistics:
   • Description: Key Promoter X keeps track of your mouse actions and provides statistics on how often you use keyboard shortcuts versus mouse clicks. These statistics can help you identify opportunities for improvement and measure your progress in adopting shortcuts.
   • Usage Example: You can review the statistics to see which actions you frequently perform using the mouse and then make a conscious effort to switch to keyboard shortcuts for those actions to improve your efficiency.
4. Support for Various IDEs:
   • Description: While Key Promoter X is commonly associated with IntelliJ IDEA, it is available for multiple JetBrains IDEs, including Android Studio, PyCharm, WebStorm, and more. This means you can enjoy its benefits across various development environments.
   • Usage Example: Whether you’re working on a Java project in IntelliJ IDEA or a web development project in WebStorm, you can use Key Promoter X to help you learn and use keyboard shortcuts consistently.
5. Community and Open Source:
   • Description: Key Promoter X is an open-source project with an active community of users and contributors. This means that the plugin is continuously updated and improved, and you can find support and discussions in online forums and communities.

Key Promoter X is a valuable tool for developers looking to boost their productivity by incorporating keyboard shortcuts into their daily workflow. By gently reminding you to use shortcuts, it can help you become a more efficient and proficient user of your JetBrains IDE.

4. .ignore

In the world of software development, version control systems like Git, Mercurial, and even older ones like SVN are ubiquitous tools that help us manage and collaborate on code. However, not everything in our projects should be shared with the world. Sometimes, our software requires extensive configurations that we’d prefer to keep private.

In these scenarios, the need to ‘hide’ certain files from others, ensuring they don’t end up in remote repositories or get included in Docker containers, is entirely reasonable.

Most of these version control systems offer their own type of ignore files, like .gitignore or .dockerignore. However, their default support for IDEs often falls somewhere in between adequate and subpar—it just exists.

This is where the .ignore plugin comes into play. Its mission is to make our lives easier when dealing with these ignore files. It provides helpful features such as syntax highlighting and rule inspection. Additionally, the plugin can visually mark excluded files right in your IDE’s project view, based on the rules configured in a specific .*ignore file.

Beyond offering solid support for .gitignore and .dockerignore files, it doesn’t stop there. It also covers various other file types, like .npmignore or .helmignore. In fact, the list of supported files is extensive and available on the plugin’s homepage.

Here’s an elaboration on how .ignore files work:

1. Purpose of .ignore Files:

• .ignore files are used to tell version control systems which files or directories to exclude when tracking changes in a project.

2. Common Usage:

• Developers commonly use .gitignore files in Git repositories to specify files or directories that should not be committed to the repository.

3. Patterns and Rules:

• .ignore files contain patterns and rules that describe which files or directories to ignore.
• Patterns can include wildcard characters, such as * (matches any number of characters) and ? (matches a single character).
• Rules can specify individual files, entire directories, or patterns to match multiple files.

Example of a Simple .gitignore File:

# Ignore compiled files
*.class
*.jar

# Ignore build output directories
/target/
/out/

# Ignore logs and temporary files
*.log
*.tmp

# Ignore IDE-specific files
.idea/
.vscode/

In this example, the .gitignore file specifies that files with .class and .jar extensions should be ignored, as well as directories named target and out. It also excludes log files, temporary files, and directories associated with IDEs like IntelliJ IDEA (.idea) and Visual Studio Code (.vscode).

4. Comments:

• Comments in .ignore files are preceded by the # symbol and are used to provide explanations or context for the rules.

5. Global and Local .ignore Files:

• In addition to project-specific .ignore files, you can also have a global .gitignore file that applies to all your Git repositories. This is useful for ignoring files or patterns that are common across multiple projects.

6. Version Control System Support:

• While .gitignore is specific to Git, other version control systems like Mercurial use similar files (e.g., .hgignore), and the concept is the same: specifying files to ignore.

7. Customization:

• .ignore files can be customized based on the requirements of your project. You can specify rules to ignore files generated during compilation, build output, log files, or any other files that should not be included in the version control system.

8. Importance of .ignore Files:

• Properly configured .ignore files are crucial for maintaining a clean and efficient version control system. Ignoring unnecessary files and directories helps reduce repository size, prevents unintentional commits of sensitive data, and ensures that only relevant project files are tracked.

9. Ignoring Files After Commits:

• If you’ve already committed files that should be ignored, you can remove them from version control while keeping them in your local working directory. This is done using the git rm --cached command for Git repositories.

Example:

# Remove a file from version control but keep it locally
git rm --cached filename

Note: The exact filename and patterns in .ignore files can vary depending on your project and the tools you’re using. Be sure to tailor your .ignore files to suit your specific needs and development environment.

5. Kuburnetes

Kubernetes, often abbreviated as K8s, is a powerful open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. Originally developed by Google and now maintained by the Cloud Native Computing Foundation (CNCF), Kubernetes has become the industry standard for container orchestration and has gained widespread adoption among developers and DevOps teams.

Here’s a simplified tabular overview of some key aspects of Kubernetes:

Summary

These extensions offer features like version control integration, code quality analysis, and enhanced coding assistance. Some notable ones include the Git Integration plugin for seamless Git support, the Code Inspections and Linters for code analysis, and the Key Promoter X for encouraging keyboard shortcuts usage. Additionally, IDEs like IntelliJ IDEA often have dedicated extensions for specific technologies, such as the Scala plugin for Scala developers. These extensions contribute to a more efficient and tailored development experience within JetBrains IDEs.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.