A language and compiler is only half the story for being productive and creating great apps and solutions. Oxygene rounds off the development experience with a strong development environment built on the Microsoft Visual Studio 2012 IDE.
For developers who already have a copy of Visual Studio 2012 Professional or higher installed (for example for use with C# of Visual Basic.NET), Oxygene seamlessly integrates itself with the existing development environment, so that you can use the Oxygene Language next to C# and Visual Basic.
For developers starting out fresh, Oxygene comes with its own version of the Visual Studio 2012, dedicated exclusively to Oxygene development for .NET and Java.
Working together, the just released Visual Studio 2012 environment and Oxygene's advanced IDE features take developer productivity to the next level.
Starting a new development project can be a big step, and Oxygene provides a wide range of project templates to help you get off the ground with basic application skeletons for just about any scenario imaginable, including Windows applications, Services, Command line tools, Web sites and mobile apps for Android or Windows Phone.
Simply Choose File|New Project, select the kind of application you want to start with, and you're off.
The templates span all sorts of projects you might want to create, from Windows apps using WPF, WinForms or the new WinRT, over services/daemons and web sites to mobile projects for Windows Phone 7, and Android.
One of the most important areas of an IDE is the code editor, and Oxygene builds on Visual Studio's already great code editing experience and takes it to the next level.
The Visual Studio code editor is build on WPF — that's an implementation detail, for sure, but it enables Oxygene to provide a wealth of great graphical features that go beyond displaying mere text:
Especially helpful when working with code shared between projects or platforms, the Project Switcher UI gives you an indicator of the project and platform the current source file belongs to, right inside the editor. What's more, if the same code file is shared between several projects, you can switch context within a single click — syntax coloring for IFDEFs, Code Completion and all the IDE smarts will automatically adjust.
A lot of development time is spent navigating around code. Following call trails, skipping through the ancestry of a class, and the like. Every time you navigate around the code, Oxygene will drop small Navigation Markers, like breadcrumbs, that you can follow along with a single command to get back where you came from, without ever getting lost in your codebase.
And of course the code editor provides all the essentials that you need for writing code productively. A powerful Code Completion engine gives you access to all identifiers or keywords valid at the current code location — including smart features such as showing you types from un-referenced namespaces and automatically inserting the namespace name for you, or "Wizard" code completions that can insert entire blocks of code, such as anonymous method declarations or inline interfaces, for you.
Class Completion lets you keep your "interface" and "implementation" section in sync with one click, or automatically define fields, local variables or even methods based on the identifier under your cursor with a single keystroke.
Oxygene has a state of the art compiler that is not only written completely in managed code; since the 5.0 release, the compiler is also written in 100% Oxygene and compiles itself.
Because the compiler is 100% managed, you can run the command line compiler almost anywhere where .NET and Mono can run — including in your ASP.NET websites, and on Linux and Mac OS X.
But the real power of the modern Oxygene compiler comes out when used inside the IDE, where several of its special and more advanced non-language features come to shine:
Oxygene's "Inline Errors" feature directly and visually connects your code with the errors and warnings it may generate — may they be few and far between.
Problems will be highlighted right inside the code editor, with red (error) yellow (warning) and green (hint) markers that show you the exact location of the issue and a short and precise description. Oftentimes, errors are linked with helpful secondary error locations (such as the original occurrence of a duplicate identifier), and Error Ranges are drawn to help you figure out which part of, say, a complex arithmetic expression is causing the problem.
Oftentimes, code problems have a clear and obvious fix — a missing semicolon, a misspelled identifier, a type from a namespace that is not in the uses clause.
When that is the case, Oxygene's Inline Errors shows an additional "magic wand" icon, and clicking the error message will bring up a Fix-It panel that lets you easily fix the issue with a single click — without having to touch the code yourself.
What's more, the Oxygene IDE can offer to fix code problems automatically for you as you hit compile, if they are safe to fix. This is incredibly helpful when used in combination with Oxygene's optional "Warn on Case Mismatch" option that helps code look clean. Oxygene itself is of course a case insensitive language — but this option and Auto-Fix-It work together to keep your code looking good.
New in Oxygene 5.2, the IDE can now go a step further and let you "ignore" any code errors that the compiler knows how to fix. This way, when you make a quick code change and press "Start" just to see you mistyped a name or missed a semicolon, your app will still compile and run. The code error will still be there, and you will want to go in and fix it eventually, but at least you did not waste precious time in your debug/change/debug-again cycle.
Also new in Oxygene 5.2, we have integrated deep code analysis into the IDE. Based on the open-source Gendarme engine, Oxygene will analyze your .NET and Mono executables after they have been built, and report on a wide range of "code smells" and common coding problems that can't be found by a regular compiler.
You can control the level of analysis via project options — maybe starting out with a light check for serious problems, and later expanding to cover more and smaller issues.
Gendarme integration also makes use of Oxygene's Inline Error reporting, so you will see its warnings right inside the code editor, marking the relevant lines of code blue. Clicking Gendarme warnings also provides the option to fix problems for you (where available), or to ignore specific warnings, should you ever see false positives.
One you've written your code and compiled it, the next step usually is to test and debug your project.
Visual Studio of course comes with a state of the art debugger for .NET (and unmanaged) code, and Oxygene can take full advantage of that debugger "for free", and builds on top of it by providing deep integration of the Oxygene language for evaluating expressions in watches, hovering over constructs in your code to inspect them, etc.
For debugging Java-based projects, we have gone a step further, and integrated a full Java and Android debugging experience with the Visual Studio debugging system, especially for Oxygene. This allows you to test your Java applications and as your Android apps both in the local emulator and on the device, seamlessly from inside the IDE, using the same UI paradigms that you may already know from the .NET debugger. To the causal observer it will seem that nothing special is going on here, but in fact a completely unique debug engine, provided by Oxygene, is used in the background to make this possible.
Regardless of the platform, Oxygene will not only let you debug your own code, but — provided source code and debug symbols are available — will also let you step thru code from C# or Java libraries you might be using.
The Visual Studio 2012 IDE, and Oxygene's extended support build on top of it, provides a plethora of other features — some big, some really small — that make your life developing code easier.
In combination with the great Oxygene Language, Oxygene will make you more productive than ever.