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're working on your local client machine:
Prior to the introduction of the Atelier IDE, developers edited code in Studio, which wrote to a server database where the code was stored in a namespace defined on the server. The application was edited, compiled, run, and debugged all on the server. If developers wanted to store source code in files on their client system, the files had to be exported from the server in XML format.
Atelier stores code in the Client file system, and also writes it to 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 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 for viewing or editing 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 using the UDL format for any new projects you create going forward.
You also 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 no longer has 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.
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 a project from your VCS. Consult the documentation for your VCS for more information.
You can add files to a project in several ways:
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.
You may find the following topics useful in making the transition from Studio to Atelier:
Developers may rely on a number of the key bindings that are standard in Studio. Eclipse also has a number of 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.
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
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