How did NINJA-ID start?

NINJA-IDE was born from a few e-mails sent to PyAr, mails which topic was quite frequent on the mailing list: "Which is a good IDE for Python?", "Why isn't there a Python IDE that has this or that feature?" and the responses to those e-mails were always more or less the same as the available IDEs were, in general, not designed for Python just provided the option to integrate it through a plugin so you would end up using a heavy IDE designed for something else where Python support was minimal, or very oriented to a specific framework or not free. So, motivated by the challenge it represented and some interesting ideas laid out in the mailing list we decided to start this project with a single focus: "what features should a good IDE have for a Python programmer?".

With that we started developing NINJA-IDE, its name being a recursive acronym: "Ninja Is Not Just Another IDE". The IDE has been developed for only 7 months now but, thanks to the willpower and programming hours devoted to it, we already have a version 1.1 of it with a lot of functionality. Since its first week of development, NINJA-IDE is used to develop NINJA-IDE helping us find bugs, enhance the application's usability and usefulness through our own experience and continuous use of the tool.

The project is developed under the free GPL3 license and its code can be obtained at http://ninja-ide.googlecode.com

Some of the IDE's current features are:

• Common IDE features for file management, tabs, automatic indentation, editing zoom, etc.
• Being written in Python and PyQt, it is multi-platform and it has been tested in Linux, Mac OSX and Windows systems
• Syntax highlighting for a variety of languages (though centered in Python, syntax highlighting is provided for a variety of other languages for all programmers' benefit)
• Ability to use a Python console within the same IDE
• Integrated project management functionality, recognizing python projects and allowing for the creation of new files and folders within the IDE, automatic "__init__" file creation with the module's information, etc.
• Interface's panels layout is fully and easily customizable, adapting to the user's preferences
• It allows for more than one editor to be visible at the same time, either horizontally or vertically
• Extensible through plugins (which can be created using a NINJA-IDE plugin more easily)
• IDE session support, recovers opened files and projects when the IDE was closed upon opening a new instance
• Auto-complete support (specific to the object being accessed)
• Update notifications
• Lots more!

Who is behind NINJA-IDE?

NINJA-IDE was developed by Santiago Moreno and Diego Sarmentero originally, a week after the beginning of the project they were already developing in it. Thanks to PyAr's mailing lists, blogs, etc. in a very short time the project's publicity made it possible to receive user's bug reports, suggestions on NINJA's mailing list and even code contributions from users and collaborators, some of which became NINJA-IDE committers (like Martín Alderete and Matías Herranz) and others contributors (like Juan Carlos Ojeda and Cesar Vargas).

This strong collaboration and participation we receive allows NINJA-IDE to grow larger and larger every day, making it better and implementing features that its users need. At the same time, comments from NINJA-IDE users motivate us to keep working hard on this tool that we hope it makes it even easier to develop Python applications.

You can get in touch with the project members in multiple ways:

• NINJA-IDE's mailing list: http://groups.google.com/group/ninja-ide
• NINJA-IDE's development mailing list: http://groups.google.com/group/ninja-ide-dev
• NINJA-IDE's IRC channel: http://ninja-ide.org/support.html
• Bug reports: http://code.google.com/p/ninja-ide/issues/list
• NINJA-IDE's Twitter account: http://twitter.com/ninja_ide

We, as NINJA-IDE's developers, are very happy today due to achieving the 3rd place as "Best Free Software" and the 1st place as "Free Software that needs donations the most" (award received as the project with greatest growth expectations) within the contest of *`Portal Programas <http://www.portalprogramas.com/software-libre/premios/software-libre-donaciones>`_*, just a few months after starting. At the same time, we are now part of Qt Ambassador's Showcase of Featured Projects.

How do we decide what features to add?

At the beginning of the project we thought of a structure that would allow it to grow and incorporate functionality over time with two main factors as a guide: the code editor and project management. The application was built from the start over these two fundamental pillars, making a good foundation on which to add new features later.

The project went through different stages, starting with a good editor with syntax highlighting, a project and file management next and, later on, features like plugins, autocomplete, session management, etc.

A lot of time Python is seen as the language with most difficulty to provide information about the code that is being written as object inference is not possible while programming due to dynamic typing, etc. In some cases it is indeed the case that explicit typing would allow for simpler and more detailed analysis, but it is also true that there are a lot of tools and libraries for Python nowadays that help avoid the taboo that is an IDE that can provide real assistance over the code that is being generated. That is why NINJA-IDE tries to provide Python programmers with the same functionality and aides that Java or .NET programmers get on their most popular IDEs. Taking the results and experiences from other language's IDEs, it is our intention to get a Python-centered IDE that satisfies its users.

The mailing list is normally used for the process of suggesting, choosing and incorporating new features into NINJA-IDE, making it a collective decision of all the project's active members. The result is detailed and public information about the feature's objective, the appropriate time to incorporate it and lots of other details. Lots of times these features are motivated by an interesting capability of another IDE, an idea of some of the members or a suggestion from the user's group. This way anyone, be it a user or developer, can express what it wants from NINJA-IDE and we can all decide if it is to be added to the project or would better be implemented as a plugin, at the same time it shows what ideas are being worked on and who are taking control of them to keep the group synchronized.

What do we expect from NINJA-IDE?

NINJA-IDE was born to satisfy what we consider an important need that we saw that other IDEs' approach were not covering. Our intention with this project was to build an IDE focused on Python application development but never forget the need to keep a user community that would allow us to enhance the tool's usability. Nowadays we are very happy to have a NINJA-IDE community as the user's experiences, suggestions and knowledge base it makes development faster and more comprehensive, taking care of details that would be otherwise overlooked.

Future plans

We are now at version 1.1 of NINJA-IDE, codename 'Kunai'. This first version has all the features previously mentioned, providing developers with a practical and robust IDE. Needless to say, as with any project, enhancement and new features to implement will appear.

Some of the features that are planned to be added in NINJA-IDE version 2.0, that we have just began developing, are:

• New extensible and dynamic architecture
• Visual debugger
• Visual browser of a project's modules and classes (based on BlueJ)
• Support for version control tools
• Collaborative edition of a document
• Integrated Qt interface designer
• Code finder
• Virtualenv support
• More refactoring features
• Versioning plugins
• Support for frameworks like
  • Django
  • Google App Engine
• And this is just the beginning!

Release notes for current versions can be found at: http://code.google.com/p/ninja-ide/wiki/ReleaseNotes And a full listing of features proposed for version 2.0 at: http://code.google.com/p/ninja-ide/wiki/Brainstorming_version2

What tools does NINJA-IDE use?

The IDE is developed using PyQt libraries for all GUI work and some functionality. Qt allowed for a solid and highly-customizable interface, making it possible to extend each element as needed to modify its behaviour and adapt it to the IDE's needs.

For syntax highlighting, NINJA-IDE uses its own system based on Qt features that is easily extensible just with a simple JSON file describing the language to add. This methods has several performance benefits, but there is support for Pygments to allow for syntax highlighting that are not included or recognized by this internal system. NINJA-IDE 2.0 is planned to include support for all languages supported by Pygments not only for the speed benefits but also to avoid depending on this external library.

Features like autocomplete, refactoring and those that involve the code itself are based on Rope, a great library and very complete for these kind of situations. Rope allows a Python IDE to have features from IDEs for statically-typed languages.

Code checking using the Pep8 library is also supported nowadays precisely to provide information about how the code adheres to PEP 8 norms.

NINJA-IDE extensibility

NINJA-IDE has a very complete plugin system that allows features to be added just as if they had been native to the IDE. Writing a plugin is very simple and there is even a NINJA-IDE plugin to write NINJA-IDE plugins (recursion anyone?). This "plugin-writing" plugin allows you to choose the portions of the IDE the new plugin will interact with and automatically creates the needed project structure as well, the plugin description file that NINJA-IDE uses as well as the base class for the plugin with the methods that one needs to implement. At the same time, once we are done writing the plugin, it provides functionality to package it so that it can be distributed.

There are 3 NINJA-IDE plugins available at the time:

• Pastebin: sends code to pastebin.con and gets the resulting link back to be able to share the code
• PluginProject: the plugin creator plugin we just talked about
• ClassCompleter: autocompletes some structures while you are writing Python code. For example: creates class constructors automatically making the appropriate calls to parent classes, etc.

For more information about how to develop a plugin for NINJA-IDE you can read the following wiki article: http://code.google.com/p/ninja-ide/wiki/CrearPlugins