The InterSystems Atelier IDE is an Eclipse plug-in which puts the power of the Eclipse development environment into the hands of InterSystems developers. If you have experience with InterSystems technology, this shift to an Eclipse-based IDE represents a significant change from the development model you are familiar with.
The following list summarizes changes you need to be aware of:
You are working on your local client machine.
Prior to the introduction of the Atelier IDE, you edited code in Studio, which wrote to a namespace defined in a database on a server. You edited, compiled, ran, and debugged the application entirely on the server. If you wanted to store source code in files on the client system, you had to export the files from the server in XML format.
Atelier stores code in the Client file system, and also writes it to a namespace on the server, where it is still compiled, run, and debugged. Atelier manages the synchronization of the client and server versions.
You need to decide about version control.
Before Atelier, managing source code with a version control system (VCS) required that you convert the code from the representation in the server database to XML files stored on disk. Because version control was server based, source control hooks had to be defined by your team. ISC offered predefined helper classes to integrate with the file system and the Perforce VCS. Users needed to write their own source control integration helpers based on the documented API to connect to VCS that ISC did not support.
In Atelier, source control integration is done on the client as is standard practice in the industry. Atelier can take advantage of the numerous version control plug-ins available for Eclipse. These plug-ins are supported and maintained by the teams that create the VCS. Your development team does not have to maintain VCS tools. Atelier does provide support for the legacy version control hooks, but InterSystems strongly recommends converting to a client-side, Eclipse-based version control if at all possible.
You also need to decide about source code format.
Atelier writes source files to disk using a new format called Universal Definition Language (UDL). It is essentially the human-readable format that the Studio editor used to present source to users. The advantages of this format include that it is accessible to any tool that views or edits text and that it preserves any code formatting added during editing. It contains only the source code, and does not include XML tags that can complicate analysis of differences between file versions.
In addition, the Atelier editors read and write files in the legacy XML format. This is useful if you have a substantial body of existing code, which cannot easily be converted from XML to UDL format. You need to decide what part of your existing code base you want to keep in XML and what you want to convert to UDL. InterSystems strongly recommends converting as much code as possible, and using the UDL format for any new projects you create going forward.
A project can contain files in both XML and UDL format, and the Atelier editor handles each type correctly. While it is technically possible to maintain a single class in both UDL and XML formats, this practice is not recommended.
Projects are essential.
All source files and other resources you work with in Atelier must be in a project on the client. You create a project with the New Atelier Project wizard. You can also add projects by importing from your VCS, and configuring the project for Atelier. Consult the documentation for your VCS for more information.
The way you add files to a project is related to the decisions you have made regarding source code format. If you are starting a new development project using the UDL format, create files with the Atelier new file wizards. Right-click in the Atelier Explorer view and select New from the context menu. Select the file type from the submenu. Atelier saves the file in the project in UDL format, as well as synchronizing it with the server.
If you are converting an existing code base to UDL, you have the following options:
You may need to keep some of your code base in XML. Possible reasons for this choice include to avoid losing revision history, or because your build process depends on files in XML format. In this situation, you can simply add XML files to the project by copying them into the project directory in the file system, or by adding a project from version control that contains XML files.The Atelier editor opens the XML files, displays them for editing in UDL format, and writes them to disk as XML.
Atelier manages multi-developer servers.
Most developers work in an environment using version control to manage source files on their client machine. However, there are situations in InterSystems development that require multiple developers to work on the same server and namespace. Because Studio established a persistent connection to the database, it could lock files for editing in a process, preventing interference from other developers. Atelier uses a RESTful API to interact with the server, so a persistent lock on source code on the server is not possible.
Rather than locking files on the server, Atelier uses versioning to detect conflicts. When a user opens a document, Atelier verifies the version. When Atelier writes that file to the server, it checks whether the file on the server has changed since it was opened. If the server version is out of sync, Atelier presents the user with a dialog where they can choose between the new client version or the server version. This is the default behavior. There is an option in the Atelier preferences that lets the client always override the server. The code on the client in Atelier is never replaced by changes made on the server without the Atelier users knowledge and consent.
Developers often rely on a number of the key bindings that are standard in Studio. Eclipse also has standard key bindings, and many are different from those used by Studio. Atelier does not modify Eclipse key bindings to support conventions used by other development tools. You can see the current Eclipse key bindings by selecting Help > Key Assist... from the main menu. You can customize key bindings using Window > Preferences > General > Keys.
You may find the following topics useful in making the transition from Studio to Atelier:
Basic UI Concepts
UI Differences Between Mac and Windows
Using the Atelier Welcome System
Navigating the Atelier Workbench
Rearranging the Atelier Workbench
Working with Atelier
Atelier Equivalents for Studio Actions
Studio Extensions in Atelier
New Atelier Project
Legacy CDL Support
Select a Class File Template
New Empty Class
Select a Routine File Template
New Routine File
New CSP File
New Business Operation Class
New Business Service Class
Import files to XML
Export files to XML