The fields of Cancer Research and Human Genomics, while presenting some very hard and interesting problems that touch the domains of Computer Science and Software Engineering, do not always have the resources to aquire or use the latest and greatest software tools. In particular it can be really difficult to justify such expenditures.
Choosing the right tools can significantly improve developer quality of life as well as productivity. The folks at JetBrains were kind enough to support our development in these important fields, so as a thank you, we want to talk about what gets us so excited about using their tools.
IntelliJ is a very intuitive, robust, and dare I say it, enjoyable way of programming in Java. Both the Community and Ultimate version include many features that accelerate the process of developing our software. While much of the appeal of IntelliJ is, as the cliche goes, that it just works, we highlight a few life-enhancing features that our team takes advantage of or is aided by.
IntelliJ can detect copy-and-paste code that someone lazily (cough) added into the code-base and allows you to quickly navigate between duplicates.
Smart Quick Fixes
IntelliJ can highlight areas that are potentially buggy or just non-optimal. A particularly nice touch is that pressing
Alt-Enter will present a large number of context-sensitive options for fixing things. These options can range from suggesting a fix (that can be applied file or project wide), suggested improved code, annotations for hiding false positives, and configuring the check itself.
Context-sensitive Plugin Suggestion
So you’re starting a new project or reinstalling your system. You open up a new file and IntelliJ suggests useful plugins which let IntelliJ understand types of code:
It’s a small touch, but appreciated.
So you like IntelliJ but your team likes Eclipse. Or vice versa. Keep things in sync and reduce un-necessary or distracting formatting challenges by taking advantage of IntelliJ’s ability to import code formatting files from Eclipse, from CheckStyle, or from other IntelliJ installs.
While debugging, an intuitive interface allows you to quickly inspect variable values.
Note the display of variables in-line with code and displayed via tool-tips.
While most IDEs, editors, and tools usually face stiff competition or viable alternatives, few stand head and shoulders above the competition in the way PyCharm does. From writing small scripts, to command line tools, to full fledged web applications, if your weapon of choice is Python, PyCharm will empower development like no other. PyCharm is also available in both Community and Professional editions.
A lot of the features mentioned in the previous section about IntelliJ hold true for PyCharm. You can expect goodies like excellent debugging support and great plugins.
When writing Python applications it is essential to manage your dependencies in a way that isolates them from your system as well as making them reproducable. The canonical way of doing this is by creating isolated Python environments using Virtualenv.
PyCharm provides excellent support for creating, managing, and using your environments. At project creation you can choose to create a new environment or should you have an existing one already you can have PyCharm use that one. You can of course swap and create these enviroments for existing projects too.
The UI, in addition to showing your dependencies in a concise way, also displays possible updates and allows you to search for additional packages found in PyPI or any other repository you may have configured.
PEP8 and Style
PyCharm will continuously monitor your code style to make sure it adheres to the PEP8 style guide for Python. You can of course configure additional style rules and enforments, such as when to line break around parentheses and braces for example.
The framework support provided by PyCharm, in particular web frameworks, is simply best in class. If you are looking to creating a Django webapp serving Jinja2 templates or a small Flask app with a React SPA for a front-end, PyCharm is your one stop shop for everything. Need to access a MySQL instance or manage a docker deployment? PyCharm will still have you covered.
A special mention is needed for the support provided for Django projects. Just to quickly list a few of the benefits:
- Project structure awareness
- Code Completion for tags, templates, and views
- Django documentation
- Comprehension of routing and settings specific to Django
- Template comprehension and debugging
- manage.py integration
To be perfectly honest, I do not want think about working on large Django projects without PyCharm.
DataGrip styles itself as a database IDE. Some might raise an eyebrow to the term “Database IDE” but I assure you it is an accurate description. In addition to being able to view tables, sort through data and query, it really does provide an excellent development experience for the writing and testing of complex queries.
One tool to rule them all
Some readers might be all too familiar with the experience of having multiple database tools, one for each particular flavor that they happen to work with. I too used to be like you. Having to work with several microservices of varying maturity, some running with H2 or sqlite in development, others in prod with MySQL or PostgreSQL, it quickly becomes annoying to have to jump between multiple tools.
DataGrip allows us to use a single tool to view, debug, and run queries on all the varying systems that we are responsible for, unifying and simplifying the configuration I need to manage.
Write, Execute, Explain
Depending on the complexity of queries you intend to write, and the tools at hand, it can be cumbersome to write multi-select multi-join queries without having to test and retest different components in isolation of the main query.
DataGrip gives you a truly interactive environment from which you can write your queries, with autocompletion based on both your SQL dialect and structure of your database. One very cool feature is that you can test nested queries in isolation with just the tap of a hotkey (
cmd-enter on a mac).
In addition to just executing you can also obtain an explain view of your query, allowing you to identify any spots for effeciency gains.
It should also go without saying that all the code warnings and suggestions you may be familiar with in the other JetBrains tools are also present.
It’s always both interesting and a good exercise to see the tools and techniques that others use as well as well as reflecting on whether or not there are better methods of accompishing the same tasks. Hopefully this article provides a few data points in this regard and makes a convincing case as to why we feel that the tools discussed here improve developer quality of life.