Avatar of marc

by marc

Announcing Oxygene 6.1

September 9, 2013 in .NET, Cocoa, Java, Oxygene

We’re thrilled to announce the immediate availability of Oxygene 6.1, the next feature release for Oxygene after the introduction of Oxygene for Cocoa earlier this year.

Like most of our monthly updates, this “August 2013″ release contains a vast number of fixes, improvements and enhancements all across the board, and for all three platforms. It also provides a small handful of new major features that we are really excited about and think will make a great difference in your day-to-day work using Oxygene.

First off, 6.1 marks the introduction of our Refactoring engine for Oxygene. We’re starting out small, with one very useful refactoring: the ability to safely rename identifiers solution-wide. But this also lays the groundwork for more refactorings to be added in the near future.

We have also vastly expanded the Go To Definition feature of the IDE to work for external references. This makes it easier than ever to have a peak at the declaration of the classes you are using, from .NET classes such as System.String to Cocoa ones such as UITableView. Just right-click, choose Go To Definition, and Oxygene will bring up the class declaration – in full Pascal syntax, of course – ready for you to review, or to copy method headers from.

Cocoa developers will love to hear that we added even better support for Deployment Targets to the compiler, with improved weak linking, and optional warnings when your code uses classes that may not be available in the lowest deployment target SDK you selected for your project. This goes way beyond what Xcode offers, and – especially with iOS 7 coming up now – will make your life supporting apps on new and older OS versions so much easier.

Of course that’s not all. There’s also support for optional interface methods in Cocoa, unsigned integer types on Java, and much more. You can find the full list of changes on our What’s New and Change Logs pages.

How to get Oxygene 6.1

As always, Oxygene 6.1 is a free update to all active subscribers, and can be downloaded now.

If your subscription has elapsed, now is a great time to renew to get access to the latest release, and all the good stuff we have cooking for the near future.

Oxygene for Prism Customers

Oxygene 6.1 is also the first release that is no longer available from Embarcadero under the Prism brand, and it will not accept Prism XE3.2 serial numbers. But as a reminder: we are committed to honoring SA contracts Embarcadero might have sold you with the promise of Prism coverage (i.e. before April 23) . Please email sales@remobjects.com with your SA details, and we’ll sort you out with ongoing access to Oxygene for .NET for the remainder of your SA period.

Of course, if you do not have SA, or if you want to take advantage of Oxygene on the Cocoa and Java/Android platforms as well, you can always renew or cross-grade to the full Oxygene package at any time.

More to Come

2013 has been a great year for Oxygene so far, but we’re not done yet. We’ve got more amazing things planned for the rest of the year, and beyond. So make sure to stay up to date with your subscription.

Happy coding!

marc hoffman,
Chief Architect
RemObjects Software

Avatar of marc

by marc

Embarcadero Prism to Oxygene License Migration

August 15, 2013 in non-tech, Oxygene, Prism

form Prism to Oxygene

Dear Embarcadero Prism Customers,

we want to thank you once again for choosing Oxygene for your .NET development needs in form of Embarcadero Prism.

As you might have already heard, our collaboration and reseller agreement with Embarcadero is coming to an end, and starting with our next upcoming release Oxygene for .NET will be available exclusively from us at RemObjects.

We can assure you that the product itself is alive and well, and with or without Embarcadero we are looking towards a bright future for Oxygene – on .NET and on the other platforms supported by the Oxygene language.

The end of our agreement with Embarcadero, however, means that starting with the upcoming Oxygene 6.1 release the product will stop accepting Embarcadero “Sanctuary” serial numbers, and we’ll be switching all customers over to our own unintrusive, no-nonsense licensing system.

Embarcadero Software Assurance

We do realize that many of you have purchased Software Assurance with Embarcadero in good faith that it would continue to include Prism.

Because we believe in treating our customers fairly, we have decided to fully honor any SA contracts between you and Embarcadero that have been purchased or renewed before April 22, 2013 (the date when Embarcadero announced its discontinuation of Prism) on our own dime, and you will continue to receive free updates for the remaining period of your SA from us.

In order to get you set up on our side, we kindly ask you to do two things:

  1. If you have not already done so, please make sure to register your latest XE3.2 serial numbers with us at remobjects.com/oxygene/registerserial. We will use these registrations to keep track of customers with (potentially) active SA.
  2. Please send us an email to sales@remobjects.com with details about your current SA contract, including when it was bought or renewed and when it expires. Based on this information, we’ll set you up with the appropriate Oxygene for .NET licenses in our system.

If you have active Software Assurance for RAD Studio XE3 or Prism XE3, and you have not received an XE3.2 serial number, please reach out to your contacts at Embarcadero (and feel free to include sales@remobjects.com in CC for your communication, so we can also follow up on our end) to ask them for your XE3.2 key.

We do apologize that we need to ask you for these manual steps, but unfortunately we receive no information or details about Prism users and their SA contracts from Embarcadero, so the only way we have to move you into our system you is by you contacting us.

Renewals, and/or moving to the full Oxygene Package

If you do not have Software Assurance, or your SA ends before August 23, 2013, we have attractive renewal options explicitly for Prism customers that will let you upgrade/renew to our full Oxygene package — with Oxygene for Cocoa, Oxygene for Java and of course Oxygene for .NET..

We have emailed everyone who registered their Prism serial number with us with the details for this today.

If you have not registered your serial yet, but are going to do so, we will email you once we received your registration. If you have any questions, or for some reason cannot register your serial number (maybe because you’re on Prism XE or later, which we don’t accept serials for), please just email sales@remobjects.com with your details, and we will sort you out as best as we can.

Exciting Things Ahead

We’re very excited about the things we have planned for Oxygene (and Hydrogene) moving forward. The imminent 6.1 release contains some very cool features that many of you have been asking for, including initial support for Refactoring (that we’ll build upon further going forward) and other IDE and language enhancements. And we have more exciting and more groundbreaking things planned for the rest of the year and for 2014.

We hope that you will continue to put your faith in us and in Oxygene, even without Embarcadero. Prism, and the Oxygene Language, always have been 100% driven by us at RemObjects, and it will keep getting better and better.

We’re looking forward to having you along for the ride as we move ahead further.

Yours,

marc hoffman
Chief Software Architect
RemObjects Software

Avatar of marc

by marc

Android and “True Native” Compilers

August 12, 2013 in Android, Cooper, Oxygene

Here’s what Google has to say about using their NDK:

The NDK is a toolset that allows you to implement parts of your app using native-code languages such as C and C++. For certain types of apps, this can be helpful so you can reuse existing code libraries written in these languages, but most apps do not need the Android NDK.

Before downloading the NDK, you should understand that the NDK will not benefit most apps. As a developer, you need to balance its benefits against its drawbacks. Notably, using native code on Android generally does not result in a noticable [sic] performance improvement, but it always increases your app complexity. In general, you should only use the NDK if it is essential to your app—never because you simply prefer to program in C/C++ [or Pascal].

Typical good candidates for the NDK are self-contained, CPU-intensive operations that don’t allocate much memory, such as signal processing, physics simulation, and so on. When examining whether or not you should develop in native code, think about your requirements and see if the Android framework APIs provide the functionality that you need.

At RemObjects, our philosophy has always been to support developers using the official tool chains and frameworks that are recommended by the platform vendor (especially now that in the 21st century these APIs have become so good, object-oriented and easy to work with, out of the box) – whether with our Oxygene compiler or our Data Abstract and RemObjects SDK library products, both of which support Android at the proper and recommended level: Dalvik.

Avatar of marc

by marc

Duck Typing in Action

July 31, 2013 in .NET, Cocoa, Cooper, Nougat, Oxygene

I came across a really awesome use of Duck Typing yesterday, and i wanted to share this with you, since i think Duck Typing is one of those features in Oxygene that are incredibly powerful, but underrated – probably even unknown to many users.

This is actual code that is live on our website, and it’s driving the downloads lists for licensed products and betas.

Both download pages are driven by the same .ascx, which runs a query to get the products a user has access to, and then compares it to the available downloads (passed in as aFiles), to determine what files to show. The code looks something like this:

method DynamicDownloadList.PrintProductFiles(aFiles: sequence of BetaFile; aBeta: Boolean);
begin
  if aBeta then begin
 
    var lProducts := from p in DataAccess.Linq.GetTable<ByUser_BetaProducts>(...) 
                       order by p.DisplayOrder;
    // loop and print out files
 
  end                                    
  else begin
 
    var lProducts := from p in DataAccess.Linq.GetTable<ByUser_LicensedProducts>(...) 
                       order by p.DisplayOrder;     
    // loop and print out files
 
  end;                                    
 
end;

The code that i’ve abbreviated behind the “//loop and print out files” comment was actually just 5 lines, but it was mostly identical for both beta and final downloads. I still had to duplicate it, because the two LINQ queries, of course, returned sequences of different types. Which is kind of a bummer, if you think about it – these are two queries (actually, Data Tables defined in the DA server that apply quite a bit of complex logic) that return the same kind of data, but due to the way LINQ works, because they are different tables, the resulting objects are of different classes.

So even though both ByUser_BetaProducts and ByUser_LicensedProducts contain fields like ProductID, Name, ImageName, and so on, it’s not really easy to write code that can be shared and work against either version. (To boot, these classes are auto-generated by LINQ, so it’s not like i can just add a common interface to the ancestry list, either.)

Yesterday i set out to expand the logic for the download display a bit (in particular to improve how the unified “Oxygene” download shows for people who own all three platforms), and i found the duplicate code turning too complex to stay duplicated. Sometime it’s fine to copy/paste 3-5 simple lines of code into two places, but this was getting more sophisticated than i liked sharing and maintaining in two places.

Duck Typing to the rescue!

So what i needed to do was write code that could work on two classes that have no common ancestor and no shared interface, but look “similar”. Exactly what Duck Typing was made for!

First, i went ahead and declared the following interface:

type
  IByUserProducts = public soft interface 
    property ProductID: System.Guid read;
    property Name: System.String read;
    property ImageName: System.String read;
    property OptionalMessage: System.String read;
    property DateExpires: nullable System.DateTime read;
  end;

that defined all the members from the query i needed access to.

Next, i adjusted the LINQ code just ever so slightly:

method DynamicDownloadList.PrintProductFiles(aFiles: sequence of BetaFile; aBeta: Boolean);
begin
  if aBeta then begin
 
    var lProducts := from p in DataAccess.Linq.GetTable<ByUser_BetaProducts>(...) 
                       order by p.DisplayOrder 
                       select duck<IByUserProducts>(p, DuckTypingMode.Weak);
    // loop and print out files
 
  end                                    
  else begin
 
    var lProducts := from p in DataAccess.Linq.GetTable<ByUser_LicensedProducts>(...) 
                       order by p.DisplayOrder 
                       select duck<IByUserProducts>(p);
    // loop and print out files
 
  end;                                    
 
end;

The only thing i changed is that at the end of the from clauses i added an extra select operator to change what the LINQ query returns: duck-typing the specialized class returned from DA into the custom IByUserProducts interface i declared.

Now, instead of returning sequences of ByUser_BetaProducts and ByUser_LicensedProducts respectively, both queries return the same type: a sequence of IByUserProducts.

This, in turn, means that i could take all the code from “// loop and print out files” and move it into a separate function, called from both branches.

Presto: shared code!

DuckTypingMode.Weak

If you’re eagle-eyed, you might have noticed that i’m passing DuckTypingMode.Weak to the duck() function in the first branch, but not the second. What does that do?

Simply put, i lied when said that the two queries returned the exact same set of fields. In fact, the query for release products returns a few extra fields, including the expiration date (which i need to gray out newer downloads if a subscription expired – in contrast to beta downloads, where the whole product just disappears).

DuckTypingMode.Weak allows the duck typing to IByUserProducts to succeed, even though the underlying class does in fact not fully qualify for the interface, because it’s missing the DateExpires property. Oxygene will instead inject a stub that will throw an exception if DateExpires were to be called.

But that’s fine. All i need to do in my now shared code is check the aBeta flag, and make sure i don’t actually call DateExpires when i know it’s not there, and i’m all good!

Summary

To summarize, Duck Typing is an awesome way in Oxygene to let you write code against classes that have the same (or similar) API, but don’t have a common ancestry or shared interfaces.

Of course, if you have full control over the class hierarchy yourself, the easiest (and cleanest way) to achieve this is to just define an interface and have the classes implement it. But sometimes, as in this example, the actual classes are out of your hand. Duck Typing lets you get around this nicely and safely.

Soft Interfaces

You might have noticed that i used the soft keyword when defining the interface, above. This was actually not fully necessary, as the duck() function will work with any kind of interface.

Soft interfaces approach duck typing from the opposite end: by defining the interface as “soft”, i don’t actually need the duck() call, as soft interfaces carry with them the information that they may automatically be duck-typed too, with a simple cast. As such, a simple select p as IByUserProducts would do to convert the types.

However, soft interfaces use the default (static) duck-typing mode by default, not the weak duck-typing. So this approach would have worked for the Beta branch of my code, which is why i chose to explicitly call duck() in both cases, for clarity. (Yes, i could/should drop the unnecessary soft keyword then, but i left it in to have an excuse to talk about it here ;).

You can read more about Duck Typing and Soft Interfaces on our wiki.

Avatar of marc

by marc

Announcing the Oxygene 6 “July 2013″ Update

July 30, 2013 in .NET, Cocoa, Cooper, iOS, Java, Nougat, Oxygene, Platforms, Prism, Visual Studio, Windows


Oxygene "July 2013"

We’re thrilled to inform you that the “July 2013″ update for Oxygene 6 is available now.

The team has been incredibly hard at work since we shipped Oxygene 6 in May, both on this update and on the next feature release coming up in August, and the “July 2013″ update brings with it a good ~140 fixes and improvements across all three editions and across the entire toolchain, from compiler to IDE.

Even though we consider this update a “bug-fix release”, we could not stop ourselves from including two major compiler/language enhancements, as well: On the Java/Android side, the Oxygene language has gained full support for unsigned integer types — a feature not available in the Java language and not officially supported by the Java Runtime, we know that a lot of you who use Oxygene on Java have been looking forward to this. On the Cocoa side, the compiler has been updated with support for Oxygene’s trademark Future Types (one of my favorite features), based on GCD under the hood.

With these two changes, we’re taking another big step towards bringing the Oxygene language closer together on all three platforms.

What’s Next?

We’ve also been busy at work for the upcoming 6.1 release (for which alpha/beta builds have been available for a while now) and beyond. Check out my blog post for more details and some hints at what is coming up. We’re very excited.

Prism

Embarcadero Prism customers, please note that the “July 2013″ release will be the last update made available to you under the Prism brand, and the last release to accept Embarcadero serial numbers.

Please make sure that you have your Prism XE3.2 serial number registered with us, so that we know about you and can contact you about moving forward. As mentioned in the past, we will honor existing SA agreements you may have with Embarcadero beyond July – but we can only do that if we know who you are ;).

As always, if you have any questions or concerns at all, please contact us at sales@remobjects.com.

Yours,
marc hoffman
Chief Architect

Avatar of marc

by marc

2013.2 and Beyond

July 17, 2013 in Data Abstract, non-tech, Oxygene, RemObjects

Hi, everyone.

As we go into the second half of 2013, i wanted to talk a bit more about our plans moving forward, what we have been working on and what we are working on and planning for the foreseeable future.

Oxygene

I can’t believe it’s only been a little over a month since we released Oxygene 6 and Nougat, and so far the feedback we’ve been getting has been just incredible. I am really thrilled to see so many of you diving into Mac and (more so, unsurprisingly) iOS development with Oxygene. Cocoa is a great and exciting platform to be working on, and that will only become more so with the upcoming releases of the groundbreaking new iOS 7, and with OS X Mavericks (both of which i know lots of you have already been using the betas of with Oxygene successfully).

We’re not sitting on our laurels, but moving ahead full steam with development of Oxygene and related technologies, and we have a lot of cool things coming up this and next year.

For starters, we’ve been working on an incremental “July” update for Oxygene 6 to address some bugs and add some minor enhancements here and there. “Gammas” for this release have been out for a while, and we are very close to finalizing the update (think a week or so). July, versioned as 6.0.51 will be a free update for all active subscribers and all Prism XE3.2 users (Embarcadero might have abandoned you on the roadside like a toy they have lost interest in, but we’re not giving up on you!).

Hot on the heels of that will be our August release. Versioned as Oxygene 6.1, this will be a significant update release for Oxygene with a handful of really cool big features and featurettes that i, personally, am very excited about. Of course there is full support for the new Visual Studio 2013 that Microsoft recently announced. There’ll also be ASP.NET MVC 4/4.5 support, and some really cool IDE workflow enhancements, some of which we have been working on for a long while in the background. The first “alpha” of Oxygene 6.1 is available for active subscribers now.

(Do note that as of Oxygene 6.1, the product will no longer be accepting Embarcadero Prism serial numbers, as our collaboration period with the great people at Embarcadero has come to an end for good by the time 6.1 ships. If you are a Prism customer with Software Assurance beyond August 2013, please make sure to contact us, we will take care of you.)

Beyond 6.1, i just want to name-drop a few projects/technologies that we are working on, without going into much (or any, really) detail on them, yet.

There’s “Hydrogene” coming up, which we’ve been dropping a few hints about here and there for a while now. Hydrogene is an exciting new sister product for Oxygene that we think will really be a game-changer. We’ll be rolling out Hydrogene to select beta testers soon, and the plan is to ship the “1.0″ product with the Winter (November) release cycle of Oxygene. This is not a promise for a timeline, though, and we won’t ship (or formally announce) Hydrogene until it is ready.

2014 will be a very exciting year for Oxygene and Hydrogene, and we have three related projects that will bring everything together in ways you cannot even imagine yet:

Fire” started as a personal side-project of mine that runs orthogonal to Oxygene (and Hydrogene), and has recently been ‘promoted’ to something we’re officially pursuing as a company project (and which has made great strides since). If and when it ships, hopefully sometime in 2014, it will become a regular part of the Oxygene and Hydrogene products.

There’s also “Marzipan” and “Infrared” (who comes up with these code names, right?), two amazing under-the-hood compiler-level technologies that Carlo’s team has been working on. Thinking about the possibilities with these two techs makes me dizzy, trust me.

Data Abstract and RemObjects SDK

Over on the DA side, we also have big things in the works. We’ve been thinking a lot about the future direction for Data Abstract over the past year or so, and last month we made the decision to stop and switch gears a bit in how we develop and ship DA (and RO). The quarterly releases we have been doing are great for getting new features out on a regular basis, but they also make it harder for the team to sit back and focus on the bigger picture, and on more fundamental changes.

So we’ve decided to take a bit of a break. A break, that is, from shipping significant releases every quarter. As of right now, we’ll be focusing the majority of our R&D effort on the major “next generation” version of RO/DA, which we plan to ship sometime in the first half of 2014.

The umbrella code name for this project is “DA8“, but this is more than just another major version number increase. We are taking a step back and really rethinking DA, and (re-)designing a DA “for the next ten years” (to borrow a phrase). A lot has changed (and is changing) in our industry since we first came up with DA in 2003, and we have a lot of ideas and plans for what we want to do, to not only make DA stay relevant in the changing market, but to make sure that DA remains the leading and best infrastructure for your data access and server development.

Some of these plans are very concrete, some of them are still very vague and in flux. Some of these changes and features we will start talking about (or even have alpha/beta bits of) very soon, while others will remain under wraps a while longer. Some of these will ship with the first DA8 “1.0″ release in early 2014, while others will be longer-out. Once again, we’re starting on a new DA for a new decade of technology.

Of course active subscribers will stay in the loop on DA8 as it develops. We will have a regular stream of pre-release builds for you to let you get an early start on some of the new technologies and changes as they emerge.

We’re also keeping the current “7.0″ code base active in a branch, and we most likely will keep shipping (very light-weight) quarterly updates for August, November and/or February, to fix crucial bugs or support new platform versions — such as Visual Studio 2013 (which we already have a Gamma of RO/DA out for), Xcode 5/iOS 7/Mavericks, or Delphi XE5.

Summary

As you can see, whether you’re using Oxygene or Data Abstract and the SDK (or both!), we have a lot of cool things planned for you for the next twelve months and beyond. Here at RemObjects, we are very excited about all of these projects, and we can hardly wait to show and tell you more.

Yours,

marc hoffman
Chief Architect

Avatar of Anton

by Anton

NetworkServer – an easily configurable RemObjects SDK server component

July 16, 2013 in .NET, Data Abstract

Introduction

In the previous article I’ve described how to create a RemObjects SDK server and set up the needed server components and tie them together.

The main purpose of the RemObjects SDK and Data Abstract frameworks is to simplify the development of distributed applications, yet some of the tasks needed to create a server application are the same for each server (f.e. server startup code, network component with server channel, messages, session manager etc).

Last year we introduced the ApplicationServer helper class (a unified base class for RemObjects SDK-based servers), so you can concentrate on the server’s business logic, not on writing the same (most of the time) server application startup code with all these checks like “are other instances of the server already running”, “do we need to start as a Windows Service” etc.

Now it is the time to make one more step forward and take a look at another core server application part that is again implemented in the same way as most of the server applications – the network connectivity part.

Network connectivity components include the server channel, one or more server messages, the session manager, event sinks, the event queue manager, the ZeroConf support component, etc. It is sometimes boring and error-prone to properly set them all up manually, and f.e. changing the server channel type can be a lot harder than it ought to be.

So we decided to implement and implemented a feature called ‘Server Reconfiguration System’. In short, this new feature allows to set the server connectivity parameters via its configuration file:

<?xml version="1.0"?>
<configuration>
  <configSections>
    <section name="ServerConfiguration" type="RemObjects.SDK.Server.Configuration.ServerConfigurationSection,RemObjects.SDK.Server" />
  </configSections>
  <ServerConfiguration>
    <ServerChannel type="superhttp" port="8101" enableZeroConf="true" />
    <ServerMessages>
      <ServerMessage type="bin" />
      <ServerMessage type="soap" />
    </ServerMessages>
    <SessionManager type="Memory" />
  </ServerConfiguration>
</configuration>

So there is no need anymore to rebuild the server application to change the Server Channel port, its type (i.e. protocol), or even to change the session storage from memory to Olympia Server.
And for sure, the generated components can be accessed via code and customized as needed.

Let's take a look at this new feature in action. As the only difference is how the server network connectivity is configured in step 7, please refer to the RemObjects SDK Beginners Guide for steps 1 - 6.

Server Application

7. Open the code-behind file for the main form (remember that our server app is intentionally primitive, so no properly layered architecture or 'Run As Windows Service' support is available here) and add the following private field:

private RemObjects.SDK.Server.INetworkServer server;

Also modify the form constructor:

public Form1()
{
    InitializeComponent();

    this.server = new RemObjects.SDK.Server.NetworkServer();
    this.server.LoadDefaultConfiguration();
    this.server.Start();
}

Now we have to provide the license information for the server components. To do this, add a file named licenses.licx to the server application project and set its Build Action to Embedded Resource. This file should contain the following text:

RemObjects.SDK.Server.IpTcpServerChannel, RemObjects.SDK.Server
RemObjects.SDK.Server.IpSuperHttpServerChannel, RemObjects.SDK.Server
RemObjects.SDK.Server.IpHttpServerChannel, RemObjects.SDK.Server
RemObjects.SDK.Server.NamedPipeServerChannel, RemObjects.SDK.Server
RemObjects.SDK.Server.LocalServerChannel, RemObjects.SDK.Server
RemObjects.SDK.Server.HttpSysServerChannel, RemObjects.SDK.Server
RemObjects.SDK.Server.HttpSysSuperHttpServerChannel, RemObjects.SDK.Server
RemObjects.SDK.Server.SuperTcpServerChannel, RemObjects.SDK.Server
RemObjects.SDK.Server.EventSinkManager, RemObjects.SDK.Server
RemObjects.SDK.Server.MasterServerSessionManager, RemObjects.SDK.Server
RemObjects.SDK.Server.MemoryMessageQueueManager, RemObjects.SDK.Server
RemObjects.SDK.Server.MemorySessionManager, RemObjects.SDK.Server
RemObjects.SDK.Server.OlympiaMessageQueueManager, RemObjects.SDK.Server
RemObjects.SDK.Server.OlympiaServerSessionManager, RemObjects.SDK.Server

At build time the license compiler will embed the needed license information into the server application based on the class names provided in this file.

The server application can now be started. It will use the default settings (i.e. the Http Server Channel will be listening on port 8099 and Binary Message will be used to communicate with the client applications).

8. Add the Application Configuration File item to the server app project and add the following settings:

<?xml version="1.0"?>
<configuration>
  <configSections>
    <section name="ServerConfiguration" type="RemObjects.SDK.Server.Configuration.ServerConfigurationSection,RemObjects.SDK.Server" />
  </configSections>
  <ServerConfiguration>
    <ServerChannel type="superhttp" port="8101" enableZeroConf="true" />
    <ServerMessages>
      <ServerMessage type="bin" />
      <ServerMessage type="soap" />
    </ServerMessages>
    <SessionManager type="Memory" />
  </ServerConfiguration>
</configuration>

Note: To ensure that the .NET application config file handlers will be able to properly load custom config sections, set the Copy Local property of all referenced RemObjects SDK assemblies to true.

After restart the server application will expose its services via the SuperHttp Server Channel listening on port 8101. And this without a single code line changed.

Now it is possible to change the Server Channel protocol (HTTP, SuperHTTP, TCP, SuperTCP), the port it is listening to and other options without the need to rebuild the server application.

A full list of available options will be provided in the corresponding Wiki article.

Conclusion

The introduction of the NetworkServer class and the corresponding infrastructure allows to easily create highly configurable RemObjects SDK server applications.

Avatar of Anton

by Anton

RO/DA for Visual Studio 2013 is here

July 4, 2013 in .NET, Data Abstract, Visual Studio

The Red Queen once said, “Now, here, you see, it takes all the running you can do, to keep in the same place. If you want to get somewhere else, you must run at least twice as fast as that!“.

Several days ago Microsoft released a preview of the Visual Studio’s next version – Visual Studio 2013 Preview (it can be downloaded from the official Visual Studio site). So Data Abstract for .NET and RemObjects SDK for .NET (as well as the other Visual-Studio-based editions) were updated to support the new Visual Studio version, and I can gladly report that New Project Wizard, DA LINQ Wizard and other IDE integration stuff “just works” in the new IDE.

Visual Studio 2013

To let you get started with Visual Studio 2013 yourself, we have made a new Gamma release available on beta.remobjects.com. Note even though this version is technically a pre-release, it is identical to the May 2013 release except for the added VS2013 support, and should be very stable and production safe. We will release a ‘real’ Beta soon with other bug fixes and improvements (and marc lets me know that an Oxygene 6.1 beta with VS2013 support is imminent, as well).

Anton,
Team Lead, DA/.NET

Avatar of marc

by marc

Introducing the RemObjects “Beta” app for iOS and Android

June 26, 2013 in Android, Build System, Data Abstract, iOS, Oxygene, Uncategorized

We’re constantly trying to optimize the workflow for publishing and announcing beta releases. Oxygene has been on a weekly beta cycle for a long while now and we’re trying to get RO/DA onto a more regular (maybe bi-weekly-ish) cycle as well (i’ll be writing more about our upcoming plans for RO/DA over the next year or so, soon), and we want to make the process of publishing new beta builds easy for us, and the process of being notified about new beta builds easy for you.

As part of this, two changes have been made recently.

Firstly, if you have installed any beta build of a product post our May 2013 releases, our Everwood Update Check will now notify you not only of new release versions, but also of new beta builds being available – making it very likely you’ll be find out about new builds within 24 hours of actively using a beta product.

But we wanted to do more, and so we’ve started developing an app to keep the hard-core beta users amongst you even closer in the loop: Welcome to the “Beta” app.

“Beta” is a small app, available for iOS and Android on the respective app stores. The iOS version has been available for a couple of weeks now (i got it approved shortly before WWDC), and the Android version is live as of now. What does “Beta” do? Two things, really.

The most important thing, it will receive and show to you Push Notifications when new beta (or release) builds for your products are available. Are you anxiously awaiting the next Oxygene beta drop each friday afternoon? Your iPhone or your Android will now let you know!

So “Beta” will be useful even if you never ever run the app again, after the first time.

But you can also go into “Beta” at any time, to see the list of current beta and release products available to you, including a shiny “NEW” badge on builds shipped within the past two days. Over time, we might expand beta to show more info (such as to let you know whether a new build is covered by your current subscription or not, look at change logs, and more).

What does “Beta” look like? Here’s the iOS version:

(including a sneak peak at what it will look like on iOS 7), and here’s the Android version:

So where to get the app? You can get “Beta” on the iOS App Store and the Google Play store, respectively. In addition, we’ve also made full source for the app available on GitHub; of course it is written in 100% Oxygene, the client apps and the Push server.



Avatar of marc

by marc

Hear me talk about WWDC and Oxygene for Cocoa on iDeveloper Live

June 20, 2013 in Uncategorized

I had the honor and privilege to be invited onto the iDeveloper Live podcast on Tuesday, mainly to talk about Oxygene, but Scotty and i also reminisced about WWDC, which took place the week prior, and we spend the first 15 or so minutes talking about iOS 7, OS X Mavericks and – most importantly, of course – the new Mac Pro that we’re both very excited about, before we dived into the core topic: Oxygene.

If you missed listening to the stream live on Tuesday, the episode is up now, so you can download it, stream it in your browser, or of course subscribe to the entire podcast in iTunes.

I love the iDeveloper Live podcast, and its’s been great to be on it again. Make sure to also check out the other episodes, as well as the podcast sponsor, Invasive Code.