Several months ago, I promised to write about the IBM Rational Jazz platform and IBM Rational Team Concert. As you may have noticed, I have not yet write about them, but in my defense I can say that I have not had much time to devote to this nor other posts in this blog. As I mentioned in some others posts, lately I have been leading a major renovation of our entire suite of custom development tools, and these last 3 months I have been fairly busy managing all this change. Taking advantage of Easter holidays, I finally found the right time to get to write about the Jazz platform.

But before proceeding, a disclaimer. What I am going to write about Jazz is just a personal opinion, may or may not be wise, may or may not have something to do with reality, but I want to make clear that this is an entirely personal opinion, and do not mean any endorsement from my current employer.

The Eclipse vision

To describe the Jazz platform, I think we should go back to the past, because in my opinion, Jazz is trying to evolve the vision/mission/wildest dream that Lee Nackman had in 1998: to create a single technology platform on which to build the various IBM’s application development tools. The objectives Lee had at that time were:

1. to solve one of the most customer complaints: instead of having tools with their own “personality”, customers demanded a common look and feel;
2. to be able to integrate different tools, especially from IBM, but also from external ISV in order to complement IBM’s product line;
3. all reducing the development costs, as at that time each IBM tooling group used its own specific platform.

With the help from the autonomous OTI subsidiary (acquired by IBM in 1996), and overcoming an enormous amount of skepticism within IBM, Lee and his team delivered a technology platform that became what today is known as the Eclipse platform. Looking at the success of this platform, especially in terms of IBM adoption across the different brands and tools, it seems that the main objectives were reached. Not to mention also that open sourcing the platform and several projects (as the JDT), they killed lots of competitors, shrinking the Java tools market, and created a great ecosystem around it.

The Eclipse vision revisited

But the knowledge and tool set that IBM acquired when they bought Rational Software in 2002, mixed with a retrospective analysis they did based on the experience they gained in the Eclipse development, helped them to figure out which were the new challenges for the software delivery process. I’ll try to summarize, IMHO, some of the improvements they realize:

• When IBM built Eclipse, their focus was on the developer productivity. But the software development process usually involves some more skills, specialists, roles, levels, … and they need to work together, they need to share information, and when all members of the team work in a geographically dispersed manner, the conflicts inevitably appears. So there is a need to involve all the team in all the phases of the software lifecycle regardless of their location and role, and instead of improving the productivity of the developer, we need tools to improve the productivity of the entire team, and directly or indirectly, the productivity of the whole organization.
• When talking about covering the overall development cycle, we usually find that we need several tools, and sometimes these tools are outside of the scope of Eclipse. And we also find that there are lots of barriers to share resources between these heterogeneous tools, as they use private vocabularies, formats and stores. So the integration between these external tools are usually built on bridges, and lots of times, highly cobbled (so they require updates with every interface change). There is a need to raise the level of integration. We need to be able to integrate and share cross-repository information using open interfaces and a loosely coupled approach.
• When thinking about non coding activities, we realize that not each role or tool needs a heavy desktop client. There are some situations where a web UI (or another type of client) is more suitable. Despite some incubators (e4 Bespin or Eclifox), Eclipse nowadays only supports its desktop client. It’s true that using Equinox and its underlying OSGi services, you can deploy Eclipse plugins into the server-side, but there isn’t any “standard” way to share user interfaces or a framework for the web UI. Which will be the problem? the same Lee discovered in 1998: tools with their own “personality”, tools without a common behavior.
• Process, process and process. How much we love them and how much we hate them also? Why is so hard to try to follow a process? Why the only Eclipse tools available (RMC or EPF) only try to author and then publish a static document? Why tools doesn’t live the process?
• Creating a new Eclipse environment with all of the required plugins, configuring the project, setting-up the build process and all the other little pieces that come into play to give code life could be a mess for a new team member. This kind of manual tasks are tedious and error-prone, and they are perceived by developers as a waste time. So it is not strange that tools like Maven had a great adoption.

So in my opinion, and as I told previously, the Jazz platform is the evolution of the original Eclipse vision, keeping in mind the above and some more other concerns, with an special focus on teams and collaboration. But its aim is not to replace Eclipse, they are distinct platforms with different goals, although Jazz seems to be the perfect complement to Eclipse. This new vision is well summarized at the About Jazz page:

Our goal is to provide a frictionless work environment that helps teams collaborate, innovate, and create great software. To that end, we are focusing on driving fundamental improvements in team collaboration, automation, and reporting across the software lifecycle.

The Jazz Platform

When trying to describe what compose the Jazz platform, albeit IBM have split the original Jazz project in several projects at the jazz.net site, I still have some problems trying to draw the line between the platform and the applications, to see which components are part of the Jazz platform and which are part of the different products based on it. So I will try to use the below picture, that I have borrowed from the IBM Rational guys, in order to clarify my ideas:

To enable a seamless and higher level of integration between tools, IBM has defined a reference architecture, API specifications, and a set of common services and tool building blocks, that together are called the Jazz Integration Architecture (JIA). At the center of this integration architecture we found the Jazz Team Server (that may consist of one or more physical servers that act together as a single logical server), which provides foundational services (RESTful web services) to enable groups of tools to work together. Let’s summarize each of these foundational services:

• Presentation: in a multi-tool integration scenario we usually found lots of linked resources that may not be familiar to a particular client tool or this tool may not be able to provide a user interface for theses resources. The services provided by the presentation foundational services enables a client tool to find and invoke a suitable user interface for any resource URL in order to present the relevant data. There are also two main components (I believe, but I am not sure, they belong to the presentation services) that allow tools developers to implement specific user interfaces: the web dashboards component, that provides the infrastructure and UI for creating and presenting dashboards in a web browser, and the web UI component, that provides a framework for rich web user interfaces (based on the Dojo toolkit).
• Process enactment: these are the services that allows to define and implement a wide range of processes. It is focused on agile processes, but it can also be used in highly-structured processes, as it provides the essential components of a development work flow, such as operations, roles, permissions, preconditions or follow-up actions. By default, it is packaged with several process, as Scrum, OpenUp or the Eclipse Way (PDF), and it has an editor to be able to modify the process configuration. Each time you create a project you must assign a process, but you can have several projects and each project can follow a different process. It governs all activities, artifacts, artifact relationships, and operations that are pursued within the context of the process area, and it works in a seamless and unobtrusive way, as it manifests itself through artifacts types, operations manipulating the artifacts, and artifact change events.
• Administration, users, projects, teams: For dealing with users, projects, security, and licenses, each server hosts a set of core administration services. For example, these services can provide a common user identity in order to support authentication (establishes user identity) and authorization (a particular operation can be performed) based on the team membership or role in a project.
• Collaboration: Collaboration between the team members of a project can be performed in real-time, but also asynchronously (especially important for teams working across time zones). It also occurs at different contexts: around tools, process, tasks or data elements. The collaboration services in the Jazz platform supports and enables some of these core functions, for example, instant messaging, sending email and SMS, maintaining subscriptions, etc. It is something like a mix of the Eclipse ECF and Corona projects (and I wonder why they did not use these projects).
• Storage, data warehouse and search: You may have noticed that I have deliberately grouped 3 core foundation services in only one. The reason is because the Jazz repository model is composed by three logical DB in one, working together in order to provide the above 3 services. I am going to use another “stolen” picture to describe it:
  
  
  • Instead of having a fixed schema (that make integration hard) or a very generic schema (that makes writing tools tough), the Jazz repository allows tools to store their data their way. So content resources are created in a particular representation by the client, and can only be retrieved in that representation. The server doesn’t know enough about the content to transform it into an alternate representation. The storage services provides a completely RESTful framework for CRUD operations on resources stored in the Jazz private DB.
  • For every resource stored in the private DB, there are a set of “indexed properties” that are stored automatically in another DB using RDF. The indexing process is able to extract RDF triples from some resource representations and able to extract text streams from some resource representations as well. This process extracts asynchronously each tool’s data into searchable indexes, consolidates them, and provides centralized query services for searching across the consolidated index. In this way, the search foundation services are able to provide common queries, both structured queries (based on SPARQL) and full text search (based on Apache Lucene).
  • And finally, we find the data warehouse DB, a periodically snapshot of all the information, used for public reporting. The data warehouse services relies on the Eclipse BIRT project for its reporting system.

Anyway, the Jazz platform is still in its early stages, and it is constantly evolving to meet additional challenges. What I have summarized previously is what it is know as the Jazz Platform 0.6, but a new version is expected to be delivered on June with a new name, the Jazz Foundation. So if you are interested in more deep details about the above or new services that are going to be delivered, I recommend that you go through the development team wiki (registration required).

The killer-application

There is also an interesting parallelism between how Eclipse and Jazz has been developed. In order to convince other IBM’s development tools product managers to adopt the Eclipse platform, Lee and his team decided to build a Java IDE. There were two reasons behind that decision: 1) to provide a real example (a killer-application) of a tool developed on the platform, proving in that way its benefits; 2) to help the Eclipse development team to better understand the needs of future consumers of the platform and to discover areas that required further development. This strategy was a success and the Eclipse platform and the Java IDE were quickly adopted inside IBM.

The Jazz project seems to use the same kind of strategy. They are developing a real tool using the Jazz platform. This killer-application is called Rational Team Concert and as far as I know it is also rapidly adopted inside IBM. I hope to write about this product in the near future.

Adoption

Looking at the jazz.net site the increasing number of IBM tools that are adopting the Jazz platform, I have no doubt that it will be another success in terms of IBM adoption. But …

• Will it be a success outside IBM as was the Eclipse platform? IBM has not contributed the Jazz platform to the open source world (in terms of a free software license), and nor it is licensing it in any way (as far as I know). The only way to get this platform is licensing some of the Jazz based products. I am sure they are going to attract some more new customers looking for a complete lifecycle solution, but I believe it will not be a great success as Eclipse was. Anyway, I think the current goal for the Jazz platform is different from the Eclipse platform goal.
• Are ISVs going to adopt this platform for their own products? There are the usual business partners that are complementing/extending the IBM’s Jazz based products with some new features, but it does not seem that they are going to adopt the Jazz platform for their own products. And it does not seem that IBM is trying to convince them to adopt the platform, as they did with Eclipse, or licensing it on an OEMs basis.
• Will this platform attract external developers? IBM is not encouraging them to contribute in terms of code (the rights of what you contribute are transfered to IBM). They are only encouraging people to influence the direction of products through direct, early, and continuous conversations at the jazz.net website. So it will be very strange to see any non-customer developer.

So in terms of external adoption/extension, it seems that IBM is focusing only in the interface as a way to integrate non-IBM tools, encouraging developers, customers and ISVs to participate in the development of the Open Services for Lifecycle Collaboration initiative, something like an open standards consortium.

Conclusion

Starting looking at the original Eclipse vision and how IBM revisited it after the Rational Software acquisition and the Eclipse success, I have attempted in this post to describe what it is the Jazz platform. I am sure some of you have realized that some of the improvements that I have described previously can be easily or are already implemented through Eclipse plugins, but I think these are the minor ones. There are three main conceptual differences between Eclipse and Jazz:

• a server centric approach instead of a local workbench in order to leverage the team concept;
• a persistent storage using a federated cross-linked repository to store resources;
• a seamless integration between tools using standard loosely coupled open interfaces and web protocols.

And in my opinion, these conceptual differences can only be implemented through the creation of a new platform. Instead of solving some particular problems in an isolated way, Jazz is trying to attack the essence of the software development process. Does it means that we must convert to a new religion, drop the Eclipse platform and adopt the Jazz platform? No, Jazz is not going to replace Eclipse. There will be a strong relationship between the Jazz and Eclipse environments, yet the
two are distinct and can run independently. Jazz is going to complement Eclipse in some particular scenarios:

Eclipse for Individuals, Jazz for Teams

We have also seen that IBM’s decision is not to open source this new platform, but to create a community around the jazz.net and OSLC websites. However, it will need to attract a broad and active participation from a wide external community in order to be a great success outside IBM, as it was Eclipse, something that I believe it is not a current IBM goal.

What will happen in the future? Sincerely, I don’t know, time will decide. From my particular point of view, this new vision match up what we have been doing for a long time and that has lead us to extend the Eclipse platform in order to create a custom collaborative tool set. So, as we are already an IBM Rational customer and we have licensed some of the Jazz products, I will be very happy if we can integrate, in an easy way, our custom tools with the IBM Rational tool set.

If you reached this point, please, participate in the conversation

Before concluding this long post, I would like to ask you:

• To the IBM/Rational guys: As I assume that I could make mistakes (history, goals, …) , if you want to add or point out something wrong, please write me, better as a comment in this post although I will also accept private emails, and I will correct it.
• To the non IBM/Rational guys:
  • How much of you have heard about Jazz? How much of you have experimented with it? Which is your (technological) opinion?
  • Must IBM open source the Jazz platform? Do you think it will be interesting and wide adopted? Why?

Additional information

PS: One of the latest tasks Lee Nackman did before his retirement at IBM, was to help spur the development of the Jazz platform.

PS: Most of the people actually involved in the development of the Jazz project were part of the Eclipse platform development team, so it is not strange to see that they are applying the same strategy, but also adopting the best practices they learned during the Eclipse development process.

PS: There is an excellent case study on IBM’s strategy and process for creating Eclipse at the Harvard Business School. It’s a worth read.

PS: Another interesting read is a paper on Collaborative Development Environments (PDF) by Grady Booch and Alan W. Brown, which seems to be the “spark” that started the new vision.

Well, I just finished the work I have been involved during the last month. The task consisted mainly to assemble a RFP document to renew all of our modeling and automatic code generation toolset. Next Monday, we will introduce to some selected providers which are the project objectives and which are the requirements.

Advancing some details, I will tell you that in a first stage we will start designing and developing an infrastructure where all the development tools will rely on. We will also ask to design and develop a tool to model the business logic flow and to automatically generate the code that will execute on a IMS/PL/I/DB2 mainframe environment under a property framework (we call this framework “Application Services Integration”).

The architecture of this framework could be compared to a service oriented architecture (SOA), thought in this case services are coupled, mainly because performance (we have constant peaks of 1.500 tx/s and one requirement is that the response time must be lower than 1 second).

This RFP is our second attempt to renew our development toolset. First attempt, developed under something similar to the MDA paradigm (or should I say DSL as we didn’t use UML?) and based on Eclipse PDE framework plus a metamodel that relies on a central repository database, was a complete failure. I will explain the reasons (a forensic analysis) in another post, although it’s about performance and scalability in a geographically disperse environment.

Why I’m telling you this? Well, because I want to share with you similar experiences. Unfortunately, this kind of experiences are usually hidden “behind the firewall”, and, in my opinion, it’s positive to share these details with others as we can learn about success and failures (as my manager usually says to me, “you always must assume that the rest of the people are cleverer than you”).

I was evaluating some enterprise data modelling tools when I realized that one of them, the new version 7.01 of Rational Data Architect (RDA), now supports MySQL. Simultaneous, I was working on a personal project trying to analyse the WordPress database, that relies on MySQL, in order to understand how does it works. So I decided to combine both projects and try to reverse engineer the MySQL WordPress database with RDA to obtain the WordPress data model.

Based on this experience, I wrote a short tutorial for beginners that explains how you can reverse engineer a MySQL database with RDA. I didn’t intend to cover all aspects of the product, that is the job of the reference manuals. And if you want to go deeper in the Rational Data Architect functionalities, at the bottom of this article you can also find some references.

So, here it is the tutorial as well as my conclusion. Hope you find it useful.

Prerequisites

1. A WordPress installation configured and running (so I assume that you have also a MySQL instance running). In this tutorial we are going to use a wordpress 2.07 database and MySQL 5.0 (despite RDA only supports up to version 4.1).
2. Rational Data Architect V7.01. If you don’t have a license and you are just evaluating the product, you can download a trial. RDA can be installed on top of an existing Eclipse 3.2 environment or will install its own Eclipse 3.2 instance.
3. A MySQL jdbc driver. You can use the official MySQL Connector/J.

Creating a new data design project

A data design project is primarily used to store modelling objects, including logical and physical data models, DDL scripts, mapping models, and more. To create a data design project:

1. On the main menu bar, select File > New > Project. Or, you could right-click in any blank space in the Package Explorer (if you are using the RDA plugin on Eclipse) or in the Data Project Explorer (if you are using RDA with the Eclipse bundled on it) and select New > Project. The New Project wizard opens.
2. Select Data Design Project, under the Data folder.
3. Name the Project WordPress and select Finish.

Creating a new physical data model:

A physical data model (PDM) is a database-specific model that represents relational data objects, such as tables, columns, primary and foreign keys. A PDM can be used to generate DDL statements that can then be deployed to a database server.

You can use the New Physical Data Model wizard to create a physical data model:

1. Select File > New > Physical Data Model from the main menu file. The New Physical Data Model wizard opens.
2. On the first page of the wizard, change the file name of the model to WordPress PDM, the selected database to MySQL, the selected version to 4.1, and check the Create from reverse engineering check box. Then select Next.


3. On the second page, note the Create a new connection is checked. Leave that as it is and select Next.
4. On the third panel, specify:
• Database: The name of the WordPress database, in this case wordpress
• JDBC driver class: com.mysql.jdbc.Driver
• Class location: Browse to the location of the MySQL jdbc driver file mysql-connector-java-5.0.4-bin.jar
• Connection url: jdbc:mysql://host:port/, where host is the name of the system where MySQL is installed, in this case localhost, and port is the database server port that the MySQL instance is using to listen to communications from remote clients, in this case 3306
• User and Password: type your user ID and password


5. Select Test Connection and if the connection is successful then select Next.
6. On the fourth panel, select the wordpress schema to reverse engineer and then select Next.
7. On the fifth, select the database elements to reverse engineer and then select Next.
8. On the sixth panel, check the Generate Overview diagram option and then select Next.
9. Select Finish.

The PDM is created and displayed in the Data Models folder under the WordPress data design project (this model has a .dbm extension to represent physical data model).

If you expand WordPress PDM.dbm and wordpress schema, you will see the database elements we have reverse engineer. Double-click the wordpress diagram, in the Diagrams folder under the wordpress schema, to see the new generated diagram. In the properties tab, you can change the elements that must appear in the diagram.

Creating the foreign key relationships

As wordpress database doesn’t use foreign keys, we must create them manually in order to see relationships between tables. To create a foreign key relationship from a parent table to a child parent table in a physical data model diagram:

1. Select a type of relationship in the palette.
2. Select the parent table that has the primary key
3. Drag to the child table. Depending on the type of relationship you are creating, a pop up window might open asking you to specify relationship options.

Be aware that the key from the parent table is migrated to the child table. As wordpress doesn’t use a similar name on the child table, we must delete this new field at the child table and assign manually the relation between the primary key at the parent table and the foreign key at the child table.

1. In the Data Project Explorer view, select the WordPress PDM model and then the wordpress schema.
2. Select the child table to modify.
3. Select the Foreign key relation to modify.
4. Select Details under the Properties tab.
5. Select the appropriate column in the child table.
6. Delete the generated column in the child table.

So in order to establish all relations, we must create manually the following relationships:

• wp_linkcategories[cat_id] -> wp_links[link_category]
• wp_categories[cat_ID] -> wp_post2cat[category_id]
• wp_categories[cat_ID] -> wp_categories[category_parent]
• wp_posts[ID] -> wp_post2cat[post_id]
• wp_posts[ID] -> wp_comments[comment_post_ID]
• wp_posts[ID] -> wp_posts[post_parent]
• wp_posts[ID] -> wp_postmeta[post_id]
• wp_comments[comment_ID] -> wp_comments[comment_parent]
• wp_users[ID] -> wp_links[link_owner]
• wp_users[ID] -> wp_posts[post_author]
• wp_users[ID] -> wp_comments[user_id]
• wp_users[ID] -> wp_usermeta[user_id]

And you will get this final diagram:

You can also define the referential integrity constrains, but this is not the object of this tutorial.

Publishing the data model

Finally, you can publish the data model outside of the modelling tool, as an HTML page or as a PDF file. To create a PDF report:

1. In the Data Project Explorer view, select the WordPress PDM model to on which to create a report.
2. On the main menu bar, select Data > Publish > Report.
3. In the Generate Report window, select the Diagram Report for Physical Data Model. Each row contains information on the type of file to be generated, the name of the report, and a description.
4. Type an output file name in the Select the file name for the generated report field.
5. Select OK to publish the model report.

Summary

In this tutorial you learned how to create a new physical data model and reverse engineer an existing MySQL database. You created a foreign key relationship from a parent table to a child parent table, and you modified the columns involved in the relationship. Finally, you published the data model outside of the modelling tool, as a PDF file.

My opinion

Rational Data Architect supports lots of relational data sources (Cloudscape, DB2 Universal Database (UDB), DB2 UDB iSeries, DB2 UDB zSeries, Derby, Informix, MySql, Oracle, Microsoft® SQL Server and Sybase), and that it’s great.

You can work in the Logical model or in the Physical model separately, and you have the ability to transform a Logical model to a Physical model or vice versa. This sounds good, as you can differentiate roles but reusing the previous work: analysts designs the application, the logical model, and developers could implement the physical model based on the target DBMS reusing the work done by the analyst. The only problem is that both models are not synchronized, so if the analyst changes an entity in the logical model, it is not propagated to the physical model, and this could be a mess.

It’s very easy to reverse engineer a database, as I have show you in this tutorial. The biggest concern about obtaining a data model through reverse engineering is discovering relationships. This is a hard work, as many apps database designs doesn’t use foreign keys (as WordPress) and they don’t tend to normalize column names. RDA has a discover function that can help you find the matching elements automatically so that you don’t have to specify them manually. I need to check deeper this functionality, but I don’t have a hope that it will succeed completely, as there are lots of relations that rely on the code, not in the database.

It will be very useful that when you create a new relation between two entities/tables, you could also specify the child column. In the tutorial example, I had to delete the new field created automatically at the child table and to assign manually the relation between the primary key at the parent table and the foreign key at the child table. In my opinion, this steps can be avoided if you let specify which is the target child column.

RDA can be installed on top of an existing Eclipse 3.2 environment or will install its own Eclipse 3.2 instance. I didn’t find any list of plug-in dependencies in the installation guide, so I tried to install RDA on top of my existing Eclipse 3.2 (Birt, CDT, DTP, PHP, TPTP and WTP). The plug-in worked fine, except some few functionalities as the report generation and the XML Schema Validator. This is a problem that I have had with lots of Eclipse plug-ins. If you don’t want to deal with plug-in dependencies problems, my recommendation is to install RDA with its own Eclipse instance.

I have also found some bugs:

• You can not specify a precision for the BIGINT numerical type, despite you can specify it in MySQL.
• RDA doesn’t support the MySQL ENUM type. Enum is not a SQL standard (you must create a separate table that maps different values or use a check restriction), but if the RDA brochure says it supports MySQL then it must support the ENUM type.
• With the previous problem in the physical model, RDA doesn’t generate DDL, despite there isn’t any error in the Problems tabs and no message appeared in the Generate DDL wizard. This problem drives me crazy, until I found the problem. It will be very useful to have a validation utility.

Despite these bugs, Rational Data Architect made a very good impression on me.

References

• “Use Rational Data Architect to define and enforce data object naming standards” (developerWorks, Jan. 2007) examines the features of IBM Rational Data Architect that enable users to define and implement object naming standards, and then demonstrates with a real-world example.
• RDA skills series at developerWorks:
• “Rational Data Architect skills series, Part 3: Discover schema relationships with Rational Data Architect” (developerWorks, Dec. 2006) describes how to create schema mappings semi-automatically.
• “Rational Data Architect skills series, Part 2: Generate SQL/XML queries with Rational Data Architect” (developerWorks, Sep. 2006) describes how to transform data from relational data sources into XML format.
• “Rational Data Architect skills series, Part 1: Access and integrate enterprise metadata with Rational Data Architect” (developerWorks, Jul. 2006) describes how to create a unified view across heterogeneous data sources.

Trying to determinate the best way to implement Continuous integration at our shop, and specifically, which information we must generate after nightly builds, I’ve discovered QALab, an opensource project that “collects and consolidates data from several QA tools and keeps track of them overtime, allowing developers, architects and project managers alike to be presented with a trend of the QA statistics of their project”

It collects data from the following tools:

• Checkstyle: code style validation and design checks. QALab keeps track of number of violations per file and overall.
• PMD: Code checks (possible bugs, dead code, sub-optimal code, etc). QALab keeps track of number of violations per file and overall.
• PMD CPD: Duplicate code (always a bad idea) detection. QALab keeps track of number of the overall number of duplicated lines.
• FindBugs: fantastic tool to detect potential bugs (really!). QALab keeps track of number of violations per file and overall.
• Cobertura: Coverage tool. QALab keeps track of percentage of branch and line coverage.
• Simian: excellent duplicate code detection (non-open source). QALab keeps track of number of the overall number of duplicated lines.

(Via The Server Side)

Borland Software announced that it will spin its developer tools group off into a wholly owned subsidiary known as CodeGear, a new organization that will be 100% dedicated to the developer tools market. The reason is they did not believe any of the prospective suitors would be able to “reflect the core value of the asset.”

Borland has produced great tools. Hope this new company will continue the saga.

(Via eWeek)

Just discovered an opensource MDA code generator tool from Obeo called Acceleo.

Features includes integration within Eclipse, native use of EMF, development environment (template editor with syntax highlighting, reflective editor, real time error detection, …), the ability to target any technology as it is based on the use of templates, and compatibility with XMI/UML 2.0 or 1.4, so you could integrate it with Rational Software Modeler, Poseidon or Topcased among others.

In the documentation page, you will find a quickstart guide if you want to catch up with it.

(Via Software architecture and design thoughts)

I have enjoyed reading the “Object Oriented CASE Tools: Lost Opportunities and Future Directions” article at developer.*

I have spent more than 15 years designing and developing in-house case tools for our legacy systems (more than 1.000 developers). I have implemented almost all of the “Traditional CASE tools” features described in the article, and they have proved that they are necessary to archive a very productive development environment.

Now, we are focusing our efforts on distributed systems, and specifically, in OO environments. We have a current discussion about which is the best strategy towards our toolset in these environments. On one side, there is the opinion that we must use OO COTS tools; and on the other side, that we must developed our own tools following the guidelines of the traditional case tools. The absence of some of the features stated in the article is inclining the balance towards the second option (the traditional one). Some features, as the central repository relying on databases, are essentials in environments focused in the reusability of the artifacts, and with OO COTS tools you can’t implement them, with or without “frameworks”. They seem designed for individual developers or small teams and not for a big enterprise.

Urbancode has announced the release of AnthillPro 3, a build management and application lifecycle automation server.

Supporting a distributed server/agent architecture, AnthillPro3 allows for distributed and multi-platform builds, automated unit, functional, and performance tests, as well as deployments to multiple environments. An embedded workflow engine provides the ability to define consistent and automated processes that integrate with existing Change Management Systems as CVS, ClearCase, Harvest, PVCS, Perforce, Starteam, Subversion and VSS. Roles based security guarantees separation of responsibility and together with guaranteed traceability and built-in audit reports provides a compliance solution out of the box.

Usage scenarios includes Automated Build, Multi-platform Build, Continuous Integration, Distributed Performance Tests, Dependency Management or Promotion and Deployment through QA, UAT, and PROD.

(Via TheServerSide)