In the realms of professional craftsmanship, the quality of the tools can have a dramatic impact on the quality of the output — whether it be analog, such as a woodworker creating a cabinet, or digital, such as a software developer creating a computer program. Yet this is not the only reason why programmers tend to be particularly choosy and even fiercely loyal regarding the tools of their trade, because software development may be the only field in which its practitioners build their own tools and thus understand better than anyone else the desired capabilities with which those tools could be imbued.
As a result, hundreds of competing source code editors and integrated development environments (IDEs) have been created and refined during the past several decades. The initial products available were line editors whose sole input device was the keyboard of a terminal connected to a mainframe computer, and whose sole output device was a line printer — no screen and no mouse! Eventually those were supplanted by full-screen editors — such as vi and Emacs — that displayed multiple lines of text on a monospace terminal, and were more geared toward computer programming than were the first generation of editors. With the increasing availability of personal computers and language compilers, dedicated programmer's editors — such as Brief, Multi-Edit, jEdit, and UltraEdit — steadily gained valuable features, including language-sensitive syntax highlighting, code folding, search-and-replace using regular expressions, macro languages, and project file management.
The most powerful programming applications eventually incorporated more advanced features, many of which were previously handled by separate dedicated applications. These features include: debugging source code interactively, generating unit test code, checking files in and out of version control utilities, customizing the editor's user interface, recording and running macros to automate tasks, and using FTP to upload and download source code files and other website resources. One such development environment is Komodo IDE, which I will examine here.
ActiveState and Komodo IDE
Computer programmers who use open-source languages such as PHP, Python, and Perl have likely heard of ActiveState, a Canadian company which has been creating and selling software development products since 1997, according to Wikipedia. The company is well known in the open-source community for their cross-platform language distributions, now named ActivePerl, ActivePython, and ActiveTcl. In addition, they recently released ActiveGo (currently in beta) and plan to release distributions for Ruby, Lua, and Node.js
Their flagship programming platform, Komodo IDE, was first released three years later, according to Wikipedia. The latest version, as of this writing, is 10.2.1, a copy of which was kindly provided for review by ActiveState. The software can run natively on Microsoft Windows 7 and later versions, Mac OS X 10.9 and later, and officially six of the most popular Linux distributions and probably most if not all of the major ones.
In terms of financial costs, Komodo IDE Personal, at $147, is available for students, freelancers, and other individuals who would not be compensated for their purchase. Professional developers can get a single-seat license for $295 or $394, depending on whether they want upgrades and support. For teams of five or more developers, five licenses can be had for $1675. Anyone interested in a site license to support 20 or more developers, should contact ActiveState. Teachers may qualify for a single or group license at no charge.
ActiveState makes freely available an open-source editor, known simply as Komodo Edit, which is quite usable for text editing but does not include any of the more advanced IDE capabilities.
In this review, I will be using the Microsoft Windows version of Komodo IDE, on a Windows 10 machine. In this case, the installation requires 276 MB of space on the hard drive. If you were to perform the installation process, then you should see six pop-up windows in succession (whose screenshots will not be shown here), which allow you to customize the content and location of your installation. Specifically, on the "Custom Setup" window, within the parent grouping "Desktop Integration", there are three optional features: "Desktop Shortcut", as the name implies, simply adds a shortcut to your desktop. Similarly, "Quick Launch Shortcut" adds one to your taskbar. "Register as Default" specifies that the Komodo IDE instance you are installing will have higher precedence over any other installations of the software — presumably earlier versions. That same window indicates that the default installation directory is C:\Program Files (x86)\ActiveState Komodo IDE 10\. (This naturally will be different for people installing on a Mac OS X or Linux platform.) It can be changed to any alternate destination if its drive has sufficient free disk space.
On the last window, if you finish the installation process with the "Open User Guide" option selected, then the online manual will be opened in a new browser window. Overall the process is similar to that of any other modern software application, and you will likely find that it goes smoothly.
Once Komodo IDE is installed, launching the program for the first time will result in six additional pop-up windows. On the "Appearance" and "Integration" window, you can specify the color scheme from one of 17 possible options (the "Default" scheme uses various dark background colors). In the "Integration" section, you can specify one of nine options for the key bindings, with support for seven other popular editors / IDEs: Atom, Eclipse, Emacs, IntelliJ, Sublime, VScode, and Vi. It is not immediately obvious what the difference is between the two options "Default" and "Legacy" (the old Default) nor that between the two options "Vi" and "_vi". The window also designates which web browser will be used by Komodo IDE for opening web pages.
On the next window, you can change the indentation from the default option of four spaces. Also, you can specify five options related to the automation of editing, such as triggering snippets and code completions, ending delimiters and tags, and wrapping a selection with a typed delimiter. Throughout this review, I will stick with all the default values.
When the initial launch sequence ends, you should see the Komodo IDE main window, whose interface is likely quite different from the appearance and layout of most if not all the other applications you are accustomed to within your given operating system's environment — enough so that it might initially seem a bit cluttered and confusing. This is partly because the traditional menu bar is initially collapsed into a three-line menu (a.k.a. the hamburger or drawer menu) in the upper right of the toolbar — or more correctly, the horizontal bar which is located beneath the menu bar and which contains what the documentation refers to as "toolbars", each consisting of a set of buttons with related functionality. Being able to easily hide the menu bar is a welcome feature — and possibly inspired by mobile apps — as it frees up needed space that would otherwise be occupied by an entire menu bar that may get little use once you begin editing files.
In terms of appearance alone, the default styling is a flat design that incorporates shades of black, gray, blue, and white. As a result, it has a clean look that does not appear to use any of the icons, controls, and other elements that are provided by the given operating system's UI libraries for developers to use. One could argue that this not only gives the product a much more consistent appearance over all of the OS platforms that it supports, but it probably also reduces the burden of ActiveState's design and support work specific to a particular platform. Any user who wishes to alter the appearance to more closely match the native standards of a particular operating system, can do so using the options at Edit > Preferences > Appearance > Platform Integration.
The toolbar, at least the left portion of it, is by default reminiscent of that of a web browser, with buttons for moving forward and backward. To the right of those are three buttons for common file-related tasks. The central portion of the toolbar is dominated by a field labeled "Go to Anything", which allows you to search, from a single field, through all of your code bookmarks, the Komodo IDE commands and menu items, the API documentation, your currently open files, installable packages, shell commands, your toolbox items (such as snippets and macros), and the files and sections defined within any project. The buttons to the right of that field can be used for managing macros, controlling the display of the three side and bottom panes (which contain various widgets), and other functionality. The toolbar can be customized, such that the default buttons can be disabled or enabled as desired, and new buttons can be added to it.
All professional-grade IDEs allow extensive customization of the appearance and functionality of those products, and Komodo IDE is no exception. The preferences window (accessible by Edit > Preferences) has no fewer than 29 categories: Appearance, Code Intelligence, Color Scheme, Commando, Debugger, Editor, Environment, File Associations, File Opening, File Saving, Find, Formatters, HTTP Inspector, Interactive Shell, Internationalization, Key Bindings, Language Help, Languages, Mapped URIs, Notifications, Places, Printing, Servers, Shared Support, Source Code Control, Syntax & Spell Checking, Web & Browser, Workspace, and Windows Integration. To quickly limit the list to those matching a search phrase of one or more keywords, you can type it into the search field above the list of category names.
One glaring omission is a feature offered by most if not all major word processors, spreadsheet programs, and other editors: the ability to specify a default directory to begin at when opening an existing file. But in Komodo IDE there is none, and when you begin a new session, Files > Open invariably begins looking in the samples directory (created by the installation process) or, for Windows users, your Documents directory, even though it is quite unlikely that your files are stored in either location. For any fresh session, the process should instead default to whatever value you set in a new field in Preferences > File Opening.
Overall, the level of customizability provided within Komodo IDE can be quite helpful. For instance, the text used within the program, such as for the built-in help information and on the menu labels, starts off rather small — enough that it might prove annoying to users with vision difficulties. Fortunately, you can change the font face and size, separately for the user interface and the text displayed in the editor. The allowed values are determined by the chosen color scheme, whose preferences section is like a style editor unto itself, with options to set such style choices as the foreground and background colors, as well as bolding and italicizing, for every conceivable element shown in the Editor Pane, including function names, identifiers, and 50 others. You can even create a new custom color scheme if you are not happy with any of the 17 prebuilt ones.
In my opinion, there are some noticeable blemishes in the layout and menu design of the Komodo IDE interface. For instance, one of the first oddities a new user will notice is a group of nine buttons near the center of the New Tab pane. All of these are redundant, and duplicate commands accessible from the main menu — and thus they are a waste of space and seem like an attempt to fill up the empty area of that pane. I suspect most developers would prefer more of a "blank canvas" when starting fresh.
Similarly, in the lower right corner are two buttons, labeled "Troubleshooting" and "Report a Bug". The "Troubleshooting" button activates a menu whose ten links largely duplicate those of the Help > Troubleshooting menu accessed from the three-line menu at the top. The two sets of links should have been combined into one and centralized in the main menu. In addition, the button wastes screen space. The same criticisms can be leveled at the "Report a Bug" button, but even more so: That button is redundant because it duplicates the functionality of the Help > Troubleshooting > "Report a Bug" menu item, and it too wastes space as it is merely a link to the GitHub web page for Komodo IDE and Komodo Edit issues. The prominent visibility of that button has (according to the ActiveState team) increased the number of bug reports submitted by users, but that same benefit might be achieved by telling every new user about the "Report a Bug" menu item. The reminder could be included in the initial screens seen by users when they first begin running Komodo IDE. As an alternative or as a complement, the information could be presented as a usage tip (one of many), since so many computer users are accustomed to countless programs popping up a brief but informative tip each time they launch a given program. At the very least, there should be a setting in the user preferences to hide both of those buttons.
The View > Tabs & Sidebars menu does not currently give any indication as to which of the 15 tools listed on it are visible after any menu item is activated. This hampers the new user in learning as quickly as possible these parts of the interface, such as how the names on that menu correspond to the icons at the tops of the left and right panes, especially as those icons can get a bit lost in the plethora of toolbar icons above and the tool-specific icons below. The menu could indicate the active menu items with ticked check boxes (as is done in the View > Toolbars menu) or highlighted labels.
Lastly, visual confusion can occur when the menu toolbar has been collapsed into the three-line menu icon, because then all the menus are forced into the upper right corner of the overall Komodo IDE window. Consequently, when you go two or more levels deep into the menu system, causing one menu after another to cascade out, it can be difficult to easily see where the top-positioned menu stops and the menus under it begin — and thus which of the menu labels you can choose from. An example menu sequence that illustrates this problem is Project > New From Template.
Admittedly, this is using the default styling, and it is possible that a different color scheme has distinct border coloring that would eliminate or at least greatly reduce this quandary. Alternatively, one can use the conventional menu bar.
On a positive note, the designers and developers of the Komodo IDE interface have clearly put substantial effort into making the interface quite customizable by you, and have also provided ways to maximize the available screen space for viewing source code, by repurposing the traditional title bar, by allowing full modification of the buttons and widgets in the various panes, and by providing a "Focus mode" which frees up even more space by hiding all three panes with a single mouse click and even reducing the height of the toolbar. Users will likely find the interface to be generally comprehensible and, with practice, conducive to productivity.
Komodo IDE offers a full arsenal of features one would expect in a professional-grade IDE. With regards to editing any sort of text, and not just source code, the product supports all of the standard editing functionality: Text can be selected as a stream of characters, as a block of adjacent lines, and as a column (i.e., a rectangle) of characters (illustrated in the screenshot below). There does not appear to be a way to un-select a rectangle of characters inside of a larger selected rectangle of characters (while maintaining the first selection) — like an enclosed subset — as one can with Sublime Text, but I have yet to imagine a realistic use case for such a capability.
If you then begin typing new characters, the resulting string replaces all of the selected characters.
Moreover, with the multiple carets feature, you can insert the same text in many locations that are not necessarily on top of one another (i.e., not forming a horizontal line). Specifically, multiple selections and carets (zero-length selections) can be set, and all subsequent edits and movements are applied to the caret in each selection simultaneously.
When editing source code, you can, with a single command, select the block of code associated with the current line (i.e., the line of text containing the edit cursor at that moment).
A variation on this is to select the delimited block of code, i.e., all of the code within the braces, excluding the code on the top line preceding the opening brace.
As with any editor, text can be cut and copied to the system clipboard and pasted therefrom.
Not only can you jump backward and forward through your editing changes (typically referred to as "undo" and "redo"), but you can also jump backward through earlier cursor positions within open files, referred to within Komodo IDE as the editing history — which at the very least can save you time when you open a file worked on in the past and your edit cursor is automatically positioned where you had last left it, so you can immediately resume your earlier work.
The ability to search for a static string or pattern of characters is crucial for any software development tool, and thus Komodo IDE allows you to search for text in the current file, all open files, or all files located within any given directory structure — and optionally replace some or all of them with new text. You can use regular expressions to find patterns of characters and, for each instance, replace the string with any combination of characters, even dynamically specified substrings of the original text.
It all seems to work well, with the only apparent exception that the "Replace" button not only replaces the currently found instance of the search string, but also then automatically jumps ahead to the next instance of the string, if any, even though you did not request for Komodo IDE to perform another find operation. (Thus the button's label is misleading and should instead read "Replace & Find", as it does in jEdit.) This behavior is alright in the scenario when you know that there is only one instance of the search string — in which case it would not make sense to use the full find/replace dialog, but instead just do a quick find (the Fast Find feature) and then change the text manually. But more often than not, there are multiple instances of the search string within the file or you do not know how many there are. When using a regex pattern, you typically would like to verify that the replacement was done correctly — not in the sense that Komodo IDE might have interpreted the pattern incorrectly, but rather that you may have entered one that does not do exactly what you hope it will (we've all been there!). If the next instance of the search string is more than a full screen of text below the prior one, then the result of the prior replacement is no longer immediately visible, and you may not discover that there was a problem with it. A diligent individual is thereby forced to backtrack to the prior replacement — perhaps by changing the search string (to match the replacement value) and then searching backwards, which adds an extraneous entry to the "Find" field. All of these problems would be avoidable if the dialog had a new button that would perform a replace operation and then stay put, so you can see the replacement before optionally searching for the next instance, or if the dialog displayed a preview of the replacement about to be made, before you hit the "Replace" button.
During an incremental search, as you types characters into the search field, all of those instances that match within the Editor Pane are highlighted.
Source code can be indented and properly formatted automatically as you type or later, and the settings for all of that can be customized. You are notified visually of any syntax errors, and can jump from one to another.
Auto-completion is a handy capability that can save time by automatically popping up a list of possible completions of whatever string of text you are currently typing, based upon the source code language — for instance, object methods in Python and PHP, and submodule names in Perl. Also, when you begin entering parameters to a function or method, Komodo IDE will pop up a reminder (a "calltip") listing the names and datatypes that the function or method is expecting to be passed.
The names of classes and methods can act like hyperlinks to their definitions, which can speed the process of checking their nature before using them. Similarly, any HTTP(S) or FTP URL can be clicked to go straight to that page in the default browser.
You can also collapse a block of indented code under whatever line of code above it has a higher block level (i.e., is less indented) — usually referred to as "code folding". This is useful for getting a better sense of the higher level structure of a program or a portion thereof.
The same sort of purpose is provided by the (optional) "minimap", which is located on the right side of the Editor Pane and can give you a high level view of all the code, with the portion of the code visible within the Editor Pane shaded.
Most programmers would agree that one of their favorite features of any IDE is the ability to step through source code, one line at a time, essentially watching the program in action as it creates variables and objects, sets their values, and produces output. It certainly beats littering one's code with "print" statements! For instance, a PHP coder can execute and debug a script running on the command line or in a web server, either locally or remotely.
Komodo IDE provides full debugging for Perl, Python, PHP, Ruby, Tcl, Node.js, and Chrome (browser) — once you have properly configured the program so it can find and work with the language interpreter for the given source code (instructions for how to do so are found in the online tutorials). Breakpoints and bookmarks can be set and used within the source code. As one would expect, Komodo IDE can present within its own window any web page produced by the code being executed.
Not only can Komodo IDE read — and in turn, debug — files located on remote servers, but it allows you to edit them as well, once you have supplied the needed information for the program to log into a particular web hosting account.
Often referred to as "workplaces" in other IDEs, projects in Komodo IDE allow related files to be organized as a whole. Each project can have individual preferences, such as the top-level directory, file extensions to be ignored, settings for debugging sessions, special editor settings, user environment variables (of the operating system), character encodings, and the date-time format. Initially, there is a prebuilt project associated with the tutorials, containing source code files in various languages, which you can explore and execute, knowing that they are confirmed to work within Komodo IDE.
New files can be created based on pre-defined templates that contain default content according to the particular file types. Komodo IDE boasts several other file-related capabilities. For instance, it has built-in support for color-coded file differencing, which includes the ability to easily jump forward and backward from one difference to another. This can be especially helpful when comparing source code that has been forked into two or more different versions that are largely the same but contain critical changes among them. This IDE integrates with source code control (SCC) repositories for CVS, Git, and others.
Most if not all of the functionality provided within Komodo IDE can be accomplished either by choosing menu items or entering their corresponding command shortcuts on the keyboard. The assignment of the key sequences to their corresponding commands is often referred to as "key bindings", and they are fully customizable by you. This can be especially helpful if you have already memorized a set of keystrokes that were learned when using a different editor or IDE in the past. For programmers working in a Windows environment, there is no need to fear that any custom key binding preferences are saved in the Registry and thus will be nearly impossible to back up and later restore if needed or to quickly customize a new installation of Komodo IDE. The product saves all preferences in a text file.
The features mentioned above encompass only a small subset of the multitude offered by Komodo IDE and discussed in their documentation, yet at least these are most of the critical ones which the majority of programmers would consider a bare minimum for any IDE worthy enough to invest time in trying out and perhaps even more time in mastering.
Just as with learning a computer language (or any human language, for that matter), thoroughly learning a sophisticated code editor or IDE is best accomplished through practice — and the greater the immersion, the better. However, reading instructional materials and working through integrated exercises can be quite helpful as well. In the case of Komodo IDE, those materials comprise an online manual, some tutorials, and conversations within a forum.
The online manual is divided into three major sections: "General Use", "Base Editor", and "Advanced Topics". Not only does the website provide the usual search capability, but in the left pane, which contains a table of contents, a "Quick filter" field automatically hides the links whose titles do not contain whatever text is typed into that field — thereby allowing you to quickly focus on those subsections that match your interest.
The first section provides information on general usage of the product. It explains how to install and launch Komodo IDE on Windows, Mac OS X, and Linux platforms — using the GUI installer or the command line. It contains an overview of the elements that compose the editor's workspace (menus, toolbars, widgets, panes, sidebars, and tabs), as well as limited information about the included sample project files. The subsection dedicated to tutorials primarily focuses on how you can create or modify your own tutorial, using YAML markup.
The basic editor functionality is explicated in the second section, and covers a wide range of topics: hyperlinks (to three types of strings in the code), user preferences (typically referred to as "settings"), key bindings (typically referred to as "shortcuts"), projects, file manipulation, finding and replacing text, the Places panel, the Open Files pane, the Commando (the universal search field mentioned above), abbreviations, userscripts (typically referred to as "macros"), snippets, URL shortcuts, tab stops, templates, custom toolbars and menus, code intelligence, refactoring, and more.
The third section explores advanced subjects, including collaboration with other developers through Komodo IDE, publishing code, the Database Explorer, code profiling, the debugger, build tools, and many others.
The main problem with the online documentation is that much of it appears to be out of date or, in a few places, unfinished (at least, as of this writing). There are features mentioned that have since been removed or transformed significantly. For many of the commands and their corresponding elements on the screen, the description of where to find that particular menu item or the appearance of its toolbar icons, do not match what one sees in the program. For example, in the case of the Project sidebar, a menu item mentioned in the manual (View > Tabs & Sidebars > Places) is missing. Most glaringly, the entire "Database Explorer Sidebar" section consists only of the text "The Database Explorer shows…" — and that's it! The Status Bar, which is supposedly beneath the Bottom Pane, is not to be found as described and pictured. Moreover, on many of the tutorial pages, some or all of the embedded images are missing or look nothing like the current ones in the software.
As noted earlier, the installation comes with a sample project, comprising several programs in Perl, PHP, Python, Ruby, and Tcl. These are a convenient way to quickly try some of the functionality for viewing and testing code.
There appears to be two sets of tutorials: One set, noted above and accessed by Help > Tutorials, consists of links to eight sections of the online manual, mostly devoted to programming languages supported by Komodo IDE. Another set, found within the right pane in the "Tutorials" section of the Toolbox tool, is built into the Komodo software and thus can be perused even when you may not have Internet access (perish the thought!). This second set includes the "Getting Started" tutorial, which is the one that, by default, begins immediately after launching Komodo IDE for the first time.
ActiveState maintains some online forums, containing several hundred posts so far, organized into eight categories: Announcements, Discussions, Feature Ideas, Customization, How To, Tutorials, Support, and Report a Bug. That last one is simply a link to the GitHub page where users can report issues. By far the two most active categories are Support, where people can get help with specific problems they are encountering, and How To, where people can learn how to use features within Komodo IDE. Another source of support is the Mozilla IRC channel #komodo, which is active from 9 am to 6 pm, Pacific Time. In my (limited) experience, the ActiveState developers are responsive to new issues and feature requests when they are submitted.
Aside from some visual oddities and rather rusty online documentation, Komodo IDE is a powerful, attractive, and well-supported platform for editing and debugging source code in all the major open-source computer languages and on all the popular operating platforms.
If you are a computer programmer or a website or app developer, and you are not entirely delighted with your current toolset, then you definitely should take a close look at Komodo IDE, which combines all of the editing capabilities one takes for granted, excellent code and debugging tools, and a range of other features that could make it the ideal replacement for whatever tool you are currently using.