Original motivation for TaskAdapter software
Microsoft Project software (MSP) is a powerful project planning tool often used for initial project planning or status reporting. Those companies that use Microsoft Project typically also use an interactive task management system like Atlassian JIRA, Redmine, Trello and such.
The challenge with a static Microsoft Project plan file is that once it is created, it is too tedious to keep up-to-date. Many managers use Microsoft Project in the beginning of a project to roughly estimate required resources and completion date, but when the project actually starts, the plan quickly becomes out of date and useless.
This was the original motivation for TaskAdapter project: the author was working as a technical project manager at a Silicon Valley IT company and he needed to provide an estimate about the current project completion date.
While a popular “divide and conquer” principle works for basic estimates, once your project gets into hundreds of moving parts with dozens of developers and multiple dependencies between what part of the project is blocking what other part, it is nearly impossible to collect that information from your task management system.
Generation 1 (2011): a Visual Basic script for Microsoft Project and Redmine
After a sizeable estimation process for all important tasks and dependencies between them, a Visual Basic script
was created to export tasks from the task management system (Redmine at the time) to a Microsoft Project file.
This allowed to get a ballpark estimate given all the tasks laying on the critical path of the project.
While not perfect (you cannot realistically plan big projects with high accuracy), this at least gave a rough estimate which lead to some decisions on the project scope.
Generation 2 (2012): A downloadable app for several systems and two-way sync
This Visual Basic script was later rewritten to be a Java-based desktop application built on top of Eclipse RCP
platform. It supported some other task management systems as well as two-way integration: not only it could
export tasks from Redmine and others into a Microsoft Project file, but it could load an MSP file and save back to
Redmine or what-have-you.
While supporting only a limited set of fields, this application was the first version that was uploaded for general public on http://www.taskadapter.com. Surprisingly, it found its users!
A part of this app was split into a separate open-source project called Redmine Java API:
https://github.com/taskadapter/redmine-java-api
It has been adopted by hundreds of projects, including Netbeans IDE and such.
The new app architecture included:
- Core module for task transformations.
- General API for various connectors (JIRA, Redmine, GitHub, etc) to describe their unique features and fields.
- Connectors themselves (each system was represented by a connector module).
- User Interface API for editors configuring connectors (each connector like JIRA needed some unique UI elements).
- Basic web application with user management, integration configs management, licensing, etc.
- Licensing module
- Packaging module that included all of the above.
The app was still implemented in Java.
Generation 2.x (2012-2016): support for more systems, minor updates, maintenance mode
The desktop application (generation 2) was doing a good job for manual export and did not require a lot of work except for general bug-fixing or releasing minor updates for ever-changing systems. Let’s just say that some task management systems are better than others in keeping their remote APIs backward compatible.
Another thing we always took time to address is properly supporting our users.
A typical bug or support report submitted by email is
usually addressed within couple days.
Maybe a SaaS? Nope!
While “Software as a Service” was all the rage in the Silicon Valley in 20xx, we rejected this approach after a brief consideration. Here is a detailed analysis why this app will NOT be a “SaaS”.
Generation 3 (2017): A downloadable app with web-based interface, any-to-any fields mapping and automated sync
Gradually, a common use-case was revealed: many companies had more than one task management system.
They would have something like Atlassian JIRA used by their software engineers and some other system like Redmine
or Basecamp used by their contractors or support people.
While theoretically it was possible to keep those systems in sync manually, people understandably valued their time
more than that. So the most commonly requested feature at the time became automated sync: configure integration
between two systems once, set some schedule and let it periodically run.
While it was technically possible to put this automated mode into the desktop version of the application, another approach was chosen: split TaskAdapter desktop application into two: TaskAdapter “server process” and “web application”. This became TaskAdapter version 3. See release notes for TaskAdapter version 3.0.0
This version was reusing the transformation core
When you download a TaskAdapter 3.x distributive, you are getting both TaskAdapter “server process” module and its web-based application that accesses the “server module” that can run on your local computer or on your server.
This also allowed natural support for more than 1 user accessing the same TaskAdapter installation on a shared server.
This version reused most of the modules/code from the desktop application, while replacing the “User Interface” module.
We started gradually replacing parts of the old Java code with Scala language where it was useful.
All new code was written only in Scala. This gave a significant productivity boost.
Generation 3.x (2017 - now): support for more systems - Trello and beyond
Trello is a simple task management system with absolutely brilliant web-based user interface.
Atlassian (the same company that owns JIRA) acquired Trello to expand its marker share. JIRA and Trello are in different
weight categories and solve very different problems.
See this excellent article about Trello.
Support for Trello required some changes in its Java library, so we eventually took over the official Trello Java API git repository in 2018 - https://github.com/taskadapter/trello-java-wrapper.
This sums up TaskAdapter application history so far!
Feel free to reach out to us with your suggestions or comments! We are always happy to help.