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, Cocoa and Java.
Working together, the 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 and Mac applications, Services, Command line tools, Web sites and mobile apps for iOS, 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, and of course iOS.
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. (Read more)
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.
Fix-It and Auto-Fix-It
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.
Treat Fixable Errors as Warnings
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 Win32/Win64) 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 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.
The same is true for testing your Cocoa applications. We have built a full-fledged native debugger for Mac and iOS into Visual Studio, based on the powerful LLDB debugger back-end that also drives debugging in Apple's Xcode. You can launch your Cocoa application straight onto your Mac, your iOS device or the iOS Simulator, and get the full debugging experience you expect – stepping through code, evaluating fields and variables, catching exceptions.
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 through code from C#, Java or Objective-C libraries you might be using.
Full Tool Chain Integration for Cocoa and Android
Oxygene provides sophisticated tool chain integration to let you go from your code to a finished, deployable application, all from within the IDE when you press "Build".
The new CrossBox menu (and the corresponding CrossBox server application on Mac) lets you manage what external devices you build for – whether your Mac, iOS devices, Android phones, or the iOS Simulator or Android Emulator. Simply pick your target, hit "Build" and/or "Start", and off you go.
For the Cocoa platform, the CrossBox menu is driven by connections to a small helper server, CrossBox itself, that runs on your Mac(s). This connection lets the IDE take care of all the build and deloyment tasks necessary – some of which need to happen on a Mac. You do not need to worry about packaging your executable into an .app bundle, code signing it or creating the finished .IPA file for submission to the Apple App Stores – Oxygene does all of this for you, from the comfort of your IDE. The same goes for deploying apps to your devices for testing or debugging. Connect your iPhone, select it from the CrossBox menu, and your app will get deployed and start on the device. (Read more)
The IDE also manages your developer certificates and profisioning profiles (required by Apple for on-device deployment) for you, automatically connecting with your Mac to obtain the necessary information as needed. All you need to do is pick the right certificate and profile you want to use.
For Android, the CrossBox menu gives you access to the Android devices atached to your local PC or VM, as well as any Emulators you have set up. As on Cocoa, debugging on your Android device is as simple as selecting it from the list and hitting "Start"
Start with Instruments
Instruments is a powerful profiling and debugging tool provided by Apple as part of it's Xcode toolchest. Oxygene provides full support for Instruments for Cocoa apps, integrated right into the Viual Studio. Need to debug a performance problem in your app, or want to examine your applications memory footprint? Just press "Start with Instruments", and the application will launch on your Mac or iOS device, connected to Instruments and ready to be profiled. (Read more)
And there's more
The Visual Studio 2012 IDE, and Oxygene's extended support built on top of it, provides a wide range 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.