DEV Community: Ganesh Samarthyam

Why You Should Use IntelliJ IDEA!

Ganesh Samarthyam — Sat, 12 Sep 2020 07:32:07 +0000

An Uncomfortable Confession!

I’ll start with a confession – I was a Vim (text editor) lover and disliked IDEs. As a power-user I loved the power & magic that powerful text editors like Vim and did not like the IDEs that made developers lazy!

Perhaps that started with the buggy and pathetic Turbo C/C++ IDEs in the college days. I was surprised how most of my classmates were using them and (god-forbid!) even loved it. What bothered me was they didn’t even know how to invoke it from command-line (forget about using the powerful command-line options we can pass to control it). That’s how I also started using command-line tools and loved the power & magic of Unix command-line.

20 years fast-forward, and I can see how much I have missed the power of developer friendly IDEs. Of course, I am talking about ergonomic IDEs like IntelliJ IDEA. The main reason where the power of text editors stop is that they are generic (max they understand is syntax highlighting, code completion, etc.) – not language-specific capabilities and in-depth ones that require deep understanding of language and semantics (like the deep static analysis and refactoring transformations that IDEs do).

In this blog post, I am going to cover five reasons why you should consider using IntelliJ IDEA.

It’s not either powerful text editor or IDE – it’s BOTH!

What I found interesting is we can have the power of text editors plus the power of IDEs. And IDEs can be super high-quality (and not like those buggy Borland/Turbo C/C++ IDEs). For example, I can use IdeaVim as a plugin and have the comfort of using my short keys. At the same time, I can do things like Alt + Enter and invoke powerful and convenient quick fixes, transformations and refactorings!

IntelliJ IDEA = Productivity

What I love about IntelliJ is its keyboard shortcuts and features that boost our productivity. My five most favorite shortcuts (in Mac): quick-fixes (Alt + Enter), refactoring (Ctrl + T), search everywhere (Shift + Shift aka double Shift), generate code (Cmd + N), insert live template (Cmd + J). This is just a sampling of what you can do with this powerful editor. You can do many things “auto”-magically - automatically find potential bugs, fix them, transform code, generate code, reformat & rearrange, improve, …

Polyglot Language Support

IntelliJ IDEA is synonymous with Java – but it is not the only language it supports: It has superb support for programming in Kotlin, Scala and Groovy. Wait, not just that, it also supports JavaScript, TypeScript, and SQL! This is possible mainly because of the rich plugins it supports.

Rich Set of Built-in Tools

Want to dig deeper and debug or performance tune applications? Decompiler, disassembler, and profilers are integrated. Want to pull changes or commit changes all from without leaving your IDE? Version control is integrated and supports Git, SVN and Mercurial. Using Spring, Java EE, Micronaut, Quarkus, Helidon? That’s tiny list, please add more including Grails, Play2 & Hibernate. Using SQL? Got you covered with the power of DataGrip integrated.

Cloud, Mobile and Web Development

IntelliJ IDEA is not just for developing desktop applications. You can use it for cloud (esp. with Azure and AWS plugins), mobile (with support for React Native, Cordova, and Ionic frameworks) and web development (supports JavaScript, TypeScript, HTML and CSS, Node.js, Angular), ...

IntelliJ IDEA is for Learners, Professionals, and Students

Community Edition

This is the free and open source version, and yes it can be used for commercial development. It has all the important features required for regular development including code completion, static analysis and auto/quick-fixes, refactorings, and more. It also has support for multiple languages, mobile development (on Android), version control integration, profiling, and more.

Ultimate Edition

The main reason for switching to Ultimate Edition is development for web and enterprise environment. It has powerful support for developing in different languages (through plugins for PHP, Go, SQL, Web – JavaScript and TypeScript), support for frameworks (Spring, Hibernate, React, Angular, Node, …), build tools (npm, grunt, gulp, …) and more. There is a 30 day free trial for you to give it a try. Interested in purchasing licenses/renewing for yourself or your company? Contact reachus@codeops.tech (CodeOps is an Authorized Reseller of JetBrains Tools for India & US).

Edu Version

If you are a student, you can use the IntelliJ DEA Edu version (free). What I love about Edu is the helpful learning support provided for learning both Java in the form of assignments, programming tests – all that help learn programming in a fun and interactive way.

Give it a try now!

If you are a LOTR (Lord Of The Rings) fan, you’ll relate to “one ring to rule them all” for IDE – and yes, “72% of Java developers choose IntelliJ IDEA”! No matter if you develop occasionally in Java (Community), professional developer using the IDE most of the day (Ultimate), or learning Java (Edu) – you can use IntelliJ IDEA. Give it a try and have fun coding! Download here.

Auto-Refactoring Code Smells in C#.NET with Rider

Ganesh Samarthyam — Fri, 24 Jul 2020 13:57:31 +0000

It is quite common to see bad and smelly code. Refactoring is all about clean code: identifying the bad smells in code and transforming the code to make it better.

In this article, we discuss how to automate most of the refactoring tasks. For illustration we are using Rider (Rich IDE from JetBrains). Identifying smells and refactoring is made incredibly easy because most of it is automatic with Rider! Just point and click/select options to see the magic unfold!

Rider often identifies / indicates bad smells in code.
To refactor, you need to select appropriate refactoring action from one of:

“Refactor” menu option
“Refactor This” option with Shift + Cmd + R
Clicking the Yellow bulb
Invoke "Context action" with Alt + Enter

Let's jump in with smells examples and how to refactor them.

Extract from Large Methods to Smaller Helper Methods

Large methods are one of the biggest enemies of readability. It is easy to end-up with excessively long methods with 100s of lines of code.

A rule of thumb is that the entire method code should be visible within your screen (and reducing the font size of zooming out is not the right fix :-p)

Methods should read like steps. So, extract code segments into separate private helper methods. Tip: Look out for new lines - they indicate logical breaks in the method and they blocks separated by newlines belong in separate methods!

Add Parameter Validation Code Automatically

Applications can easily break with missing validation checks. Examples: null checks and check if collection is empty.

Code defensively and add these validation code automatically. Just point on the parameter and click the hammer icon and add the checks! Or on the parameter press Alt + Enter to add these checks - just like magic!

Extract Variables From 'Magic Strings'

You can refactor ‘Magic Strings’ with named variables or constants.

"Magic strings" are hardcoded strings in the programs. Though its extremely convenient to just embed the required strings in the program, it is a bad practice & a smell. Refactor them to named constants or variables. If needed extract them into resource files for internationalization. It’s easy to extract variable or inline variable with just context actions

Extract Classes from Method(s)

When you have large static methods in a class, it is often an indication that the method belongs to a class on its own. For example, consider a large method in a class named AirQualityReporter named ReadXLS - that reads pollution readings from an Excel file.

Reading a XLS file should be handled by a separate abstraction. So the smell is "missing abstraction" and the refactoring is "extract class".

This short video shows how. Note that the extracted class XLSReport need further refactoring since its a large method with more than one responsibilities. Of course, that's the topic of another video :-)

Constructor to Factory Method

To control object creation, we need to use factory methods.

In many contexts, we want to control object creation. For example, reuse objects instead of creating them again and again (as in Flyweight pattern) or restrict the number of objects created (as in Singleton). With a publicly available constructor, that becomes not possible. Invoke refactor this by adding a factory method and make the constructor protected in a click or two!

Refactor "Data Clumps" and "Long Parameters" With "Transform Parameter"

Large parameters and data clumps are common smells in large codebases. Rule of thumb - if >4 parameters, consider refactoring.

'Data clumps' refer to related parameters that are always passed and used together - that indicates they belong in a separate data class.

With “Transform Parameters” refactoring, extracting data clumps to data classes is as easy as blinking the eye!

Converting Interface to Abstract Class (and vice versa)

‪Think about UI widets. The base type Widet doesn't exist in the real-world and it abstracts various concrete widgets such as TextWidget, ScrollBar, Grid etc. So the base type Widget is best expressed as an abstract class.‬

‪Consider 'Scrollable' - not all UI Widgets are scrollable. And Scrollable doesn't have concrete behavior - it just provides methods such as ScrollUp and ScrollDown. So its best expressed as an interface.‬

‪If you have created an abstract class instead of an interface (and vice versa), you can do it automatically in Rider (Rich IDE for .NET). Just point at the abstract class or interface and press Shift + Cmd + R and you can change its form from one to another. ‬

Smells and Refactorings Covered

This is a small article and we have just scratching the surface! Just as a quick summary, here is the list of smells and refactorings we have covered so far:

“Large Methods” => Extract “Helper Methods”
“Unchecked Methods” => Add Parameter Validation to Methods
“Magic Strings” => Extract constants / variables
“Large static methods” => Extract class
Unconstrained constructors => Factory Method
“Data Clumps” & “Long Parameter Lists” => Extract data classes
Inappropriate abstract class => Transform to interface

Summary & Key Takeaways

Refactoring is all about repeatedly improving the existing code. When we get some code working and leave it there, it will be certainly be smelly. However, if we revisit the code and improve it, the code quality improves dramatically.

Fortunately, such improvement can be done sort of "auto-magically" with the powerful IDEs like Rider. For example, consider renaming a variable/method/class/etc. Renaming manually is prone to errors and time consuming. And its so easy to rename with Rider - just point on the name and press Alt + Enter => "Refactor This" => "Rename" and boom, the refactoring is done!

Also, there is no need to remember “too many” shortcuts!

Select “Refactor” menu option
Invoke “Refactor This” with Shift + Cmd + R
Get “Context Actions” with Alt + Enter

Hope you explore powerful refactoring features of Rider & ReSharper and make your code clean and higher quality.

Python Comprehensions & Generators Made Easy (PyCharm)

Ganesh Samarthyam — Sat, 11 Jul 2020 06:53:02 +0000

One of the features I love is Live Templates in PyCharm: With it, you can code super fast! They are incredibly useful for speeding up common tasks such as looping over (or generating from) a collection object.

In this brief blog, show how to use them in PyCharm (works for both Community or Professional editions)

Python Comprehensions & Generators 101

Comprehensions and generators can help write concise yet expressive code. Consider this loop:

small_words = []
for word in quip.split(" "):
    if(len(word.upper()) <= 4):
        small_words.append(word.upper())
print(small_words)

This is quite verbose.

Here is how it could be expressed with a list comprehension - which is quite readable as well:

small_words = [word.upper() for word in quip.split(" ") if len(word) <= 4]
print(small_words)

Here are the parts of the comprehension:

That's easy and nice, isn't it!

Live Templates in PyCharm

You can use Live Templates - the template code segments that you can fill - in PyCharm.

Here is the list of live templates. You can access it as PyCharm -> Preferences -> Editor -> Live Templates.

Getting Started - Easy and Simple Live Templates

The live templates main, iter and itere are easy and simple ones to get started with.

In live action in this YouTube Video.

It's repetition made easy!

Templates for List, Set, and Dictionary Comprehensions

This is where the fun begins - let it be list, set or dictionaries, comprehensions are easy with PyCharm. Just start typing comp which stands for 'comprehension'. For list comprehension, type l, so it's compl. For adding an if condition, add an i, so it becomes compli'. Nothingcompli`cated!

So goes comps, compsi, compd and compdi for set and dictionary comprehensions with optional if conditions.

List comprehension

That's how you process lists!

Set comprehension

That's how you deal with sets!

Dictionary comprehension

That's how you deal with dictionaries!

Generator comprehension

Generators create a sequence - we iterate over them one at a time. If you try to print a generator you'll get a generator object (not its content printed!). For example, if small_words is a generator, then print(small_words) will print cryptic reading one like - <generator object <genexpr> at 0x102c1b7c8>. So convert to list, for example, before printing, like print(list(small_words)).

Here is an example.

That's how you deal with generators!

Live Templates to Remember

main - main check
iter / itere - for loop
compl / compli - list comprehension
comps / compsi - set comprehension
compd / compdi - dictionary comprehension
compg / compgi - generators

Have fun playing around with comprehensions and generators in PyCharm. Check out for ~1 min PyCharm Tips & Tricks here.

Have fun coding!