You are browsing the archive for Delphi.

Avatar of marc

by marc

RemObjects SDK and Data Abstract for JavaScript

October 7, 2011 in .NET, Data Abstract, Delphi, JavaScript, Oxygene, Visual Studio, Xcode

Today we are shipping the first beta builds of RemObjects SDK and Data Abstract with our new JavaScript client support. This beta is available at beta.remobjects.com for all users with an active subscription, and we are planning to ship this feature officially in the upcoming Winter release next month.

This blog post aims at giving you a quick overview into what’s there and how to use it.

RemObjects SDK and Data Abstract for JavaScript is essentially the fourth client platform for RO/DA that we have implemented, and constitutes a fully native JavaScript implementation of our RO/DA client library – with everything you need to talk to RO or DA servers directly from JavaScript-based clients. The main focus right now is on web clients (i.e. clients running locally in a browser), but RODA/JS should also be usable from any other JavaScript based platform, such as Windows 8’s Metro, cough WebOS cough, and the like.

RODA/JS is not a separate product; rather, it ships in the box with all three of our existing server platforms: RODA/.NET, RODA/Delphi and Relativity Server.

In most cases, you will want to add the ability to expose a scripting client right from inside the regular RO/DA server you are building, and we have created components that make this really easy: Both RODA/.NET and RODA/Delphi have gained (TRO)JavaScriptHttpDispatcher and (TDA)JavaScriptHttpDispatcher components that you can simply drop into your project and hook up to your server channels. These components embed and automatically serve the core RODA/JS script files, and can also serve any custom files (scripts and HTML/CSS/Images) that you created to implement your JavaScript client (from a folder or from resources embedded in your server app).

With that done, you can simply point your browser to a subpath of your server’s URL, such as http://localhost:8099/js to access your web app.

TROJavaScriptHttpDispatcher in Delphi

The screenshot above shows the RO/Delphi MegaDemo, but a similar component is available for DA and on .NET, and all MegaDemos and DA Sample Servers have been extended to already expose sample JavaScript clients.

If you run the server and point your browser to it, it will look something like this (not about to win any design awards, but it works ;) ).

MegaDemo JavaScript Client in Action

What does the source look like? Aside from the HTML that defines what we see, there are three script files included:

<script type="text/javascript" src="RemObjectsSDK.js"></script>
<script type="text/javascript" src="MegaDemoLibrary_intf.js"></script>
<script type="text/javascript" src="script.js"></script>

The first is the core RO/JS library – automatically served by the JavaScriptHttpDispatcher component. The second is the Interface file for our server’s RODL – more on that below. Lastly, scripts.js contains the code we custom-wrote to implement our client. Let’s look at that in more detail:

First, we create our service and related components (I’m shortening the code a bit for the purpose of this post, if you look at the real sample, you’ll see it will optionally choose between JSON and BinMessage, etc):

var Service;
createService();
function createService() 
{
    var svcUrl = "http://" + document.location.host + "/bin";
    Service = new MegaDemoService(new RemObjects.SDK.HTTPClientChannel(svcUrl),
    new RemObjects.SDK.BinMessage());
}

Next, let’s look at how we call Sum():

function BeginSumMethod() 
{
    var A = document.getElementById("editA").value;
    var B = document.getElementById("editB").value;
    Service.Sum(A, B, 
                    function SuccessSumMethod(result) 
                    {
                        AddLineToLog('Result is ' + result);
                    },
                    function ErrorSumMethod(msg, ex) 
                    {
                        if (ex) {
                            AddLineToLog(" Error: " + ex);
                    } else {
                        AddLineToLog(msg.getErrorMessage());
                    });
}

As you see, JavaScript is big on asynchronicity. Instead of calling Sum() and getting back a value, Sum runs asynchronously, and we provide a callback that gets executed when the result was received (and a second callback that gets called for any errors or exceptions).

To generate Interface files for your custom RODLs (such as MegaDemoLibrary_intf.js in the sample above), both Service Builder (Windows) and rodl2objc (Mac) have been expanded with an extra option to generate .js files. Simply open your RODL and save the Intf.js, as you already know how to do for all the other languages we support:

rodl2code with JS

(As you can see, rodl2objc has also received a bit of an interface facelift ;) )

That’s RemObjects SDK for JavaScript, for talking to custom Web Services. Next, let’s look at Data Abstract.

Like with RO, making a DA server accessible from JavaScript is as easy as adding the dispatcher and (optionally) some custom script or HTML files. Here’s what the JavaScript sample for our PCTrade Sample Servers looks like (both for .NET and Delphi):

PCTrade Sample for JavaScript

On the left, there’s list of all the tables, dynamically created by looking at the schema; once a table is selected, it shows a grid on the right. For this sample, we’re using a jQuery grid, but there’s nothing that inherently ties Data Abstract to jQuery or any other JavaScript framework – you get access to the raw data via a table object and can work with it any way you please. Of course, we cannot only show data, but also maintain updates and apply them back to the server.

Let’s look at the code again:

<script src="RemObjectsSDK.js" type="text/javascript"></script>
<script src="DataAbstract.js" type="text/javascript"></script>
<script src="DataAbstract4_Intf.js" type="text/javascript"></script>
<script src="/js/jquery/jquery-1.4.4.js" type="text/javascript"></script>
<script src="/js/jquery/js/grid.locale-en.js" type="text/javascript"></script>
<script src="/js/jquery/js/jquery.jqGrid.min.js" type="text/javascript"></script>
<script src="DataAbstractjQGrid.js" type="text/javascript"></script>

In addition to the core three RO/DA files (all of which are served by default by Data Abstract’s version of the JavaScriptHttpDispatcher), we include a few jQuery files, as well as a DA-specific helper file for jQGrid that we provide for your convenience. Once again, using jQGrid is just an implementation choice for this sample (much like using QuantumGrid would be for a Delphi app).

Other than that, all the application-specific script in this sample is in the main HTML file.

For example, here is how we set up the RemoteDataAdapter:

var Channel = new RemObjects.SDK.HTTPClientChannel("http://" + window.location.host + "/JSON");
var Message = new RemObjects.SDK.JSONMessage();
var Service = new RemObjects.SDK.RemoteService(Channel, Message, "DASampleService");
var daService = new DataAbstractService(Service);
var loginService = new RemObjects.SDK.RemoteService(Channel, Message, "LoginService");
var rda = new RemObjects.DataAbstract.RemoteDataAdapter(Service, loginService, RemObjects.DataAbstract.Bin2DataStreamer);

And here is how we fetch data for a table (and show it using the jQGrid helper):

rda.getData(Tables[CurrentTable], function() {
                GridView = new RemObjects.DataAbstract
                    .Views.JQGridView(Tables[CurrentTable], "#list", "#pager");
            },
        function(msg, e) {
            if (e) {alert(e)}
            else alert(msg.getErrorMessage());
        });

If you’re familiar with RO and DA, you will already see that the classes are very similar to what you know. We have client channels, messages, remote services and a remote data adapter.

Relativity Server now also optionally exposes the required JavaScript files (including full Intf.js files for its admin API) as well as a JSON message. All you need to do to activate this is to check the Enable JavaScript Publishing option in Server Explorer:

Server Explorer for Mac

If the option is grayed out, your Relativity Server does not support JavaScript yet; if the option is not available, you need a newer version of Server Explorer for Mac.

A Word about Cross-Domain Data Access

You might be asking: why does the JavaScript need to be served by the RO/DA server? Can’t I just put it on my website? Technically, you could, but there’s a limitation on most browsers that – for security reasons – won’t just let JavaScript connect to different servers willy-nilly. So if you’re opening a website from http://mywebsite.com, the browser won’t let the JavaScript on that site send requests to http://database.mywebsite.com:8099 – unless at least some of the scripts originate from that server. So you can embed JavaScript code in your website and have it talk to your RO/DA server on a different domain or port, but you must at least reference the RemObjectsSDK.js and/or DataAbstract.js files from the RO/DA server to let the browser know that it’s ok to connect there.

This limitation might not apply when using JavaScript on other non-web platforms, for example on Metro (we haven’t tested that yet) or application platforms such as Titanium. It’s a limitation of what the browser lets you do, not a limitation of our client library.

Summary

Our new native JavaScript client libraries open up RO and DA servers to a wide variety of new client platforms, with rich browser-based apps only being one of many possibilities.

We have a good six weeks of beta cycle left before this feature ships, and we hope you’ll give the beta builds a try and let us know any feedback you have. Head over to beta.remobjects.com now to get started.

Enjoy!

Avatar of marc

by marc

Announcing the RemObjects Software “Fall 2011″ Releases

September 30, 2011 in .NET, Cocoa, Data Abstract, Delphi, Hydra, iOS, Mac, Oxygene, Relativity, RemObjects, Visual Studio, Windows, Xcode

Dear Users,

We are happy to announce the immediate availability of the “Fall 2011″ releases of our library products, including Data Abstract and RemObjects SDK for all three platforms, Hydra, Internet Pack, RemObjects Script and Pascal Script.

The new releases focus mainly on quality, with hundreds of fixes and small enhancements throughout the product – we have improved project templates, thoroughly reworked the samples and addressed lots and lots of outstanding issues across all platforms.

But that has not stopped us from shipping some significant new features, as well.

Full Support for Delphi XE2

The probably most significant change is full support for Embarcadero’s new Delphi XE2. XE2 brings a lot of changes to the Delphi platform, and we are fully committed to supporting Delphi developers. In the “Fall 2011″ release, RemObjects SDK and Data Abstract both add support for creating 64-bit Windows applications and creating 32-bit Mac OS X Applications, the two new platforms being supported by Delphi XE. Data Abstract features all new templates for FireMonkey and has been integrated with the new Live Bindings feature for both FireMonkey and VCL.
Hydra has also been updated with basic XE2 support (and we have exciting plans for features around FireMonkey for the next major release, more on that below).

Data Abstract Improvements

  • Data Abstract for .NET has been improved with support for additional DA LINQ and DA SQL constructs, such as GROUP BY support and aggregate functions.

  • DA SQL queries are now able to return updateable data tables without the client knowing the involved table name(s) beforehand – a change that has let us implement full data editing support in Server Explorer for Mac.

  • Relativity Server has been enhanced to provide a self-hosted copy of our “PCTrade Sample” Domain, and all samples have been updated to optionally talk to Relativity Server instead of the standalone sample servers provided with each platform.

  • Data Abstract for Xcode has gained support for Cached Calculated Fields, a feature driven by our own needs using DA in internal applications here at RemObjects, that can provide a significantly performance boost to your apps.

  • Data Abstract (and RemObjects SDK) for Xcode have also been made fully compatible with the new Automated Reference Counting (ARC) feature that is coming to Objective-C with Xcode 4.2.

  • Server Explorer for Mac has also made great strides since first hitting the App Store in May and is turning into a versatile tool for Relativity and DB admins independently of Data Abstract. Server Explorer is available as part of Data Abstract for Xcode, and also standalone on the Mac App Store for users of DA/.NET and DA/Delphi and non-DA OData developers.

What’s Next?

As mentioned above, the “Fall 2011″ mainly focuses on quality improvements and minor features, but that does not mean our teams have been sitting still where major new features are concerned.

  • Work is almost completed on our native JavaScript clients for RemObjects SDK and Data Abstract, and initial feedback is that it will be “impressive”. We are planning to have a beta with JavaScript available to all active customers within the next couple of weeks and ship the final JavaScript support in the “Winter 2011″ release. RODA/JS will be available as part of all three of our server platforms: RODA/.NET, RODA/Delphi and Relativity Server, at no extra charge.

  • We’ve also been working hard on script debugging support for Data Abstract and Relativity Server, and the next release of Server Explorer will include a full graphical remote script debugger to help you write and debug JavaScript Business Rules in Relativity Server.

  • Since we introduced Server Explorer for the Mac, the tool has become a core part of how we work with Data Abstract and Relativity Servers, and the DA/.NET team is working on bringing the same experience to Windows, replacing the aging Schema Modeler with our all new Server Explorer for Windows. We have set no deadlines for DASM7/Win as we want the tool to be as good as we can make it, but we expect to have a usable pre-release to show before the end of the year.

  • On the Hydra front, our next “Winter 2011″ release will be a major one, with Hydra 4 introducing two new visual plugin platforms to the mix: FireMonkey and Silverlight. With that, Hydra 4 will let you use VCL, FireMonkey, WinForms, WPF and Silverlight within a single app.

Remember that as always, these and other future enhancements will ship at no extra charge to customers with an active product subscription, and pre-release beta and gamma builds will be available to all active customers, as well.

So whether you’re excited about XE2 support and the other features and enhancements we ship this week or just want to get ready for the good stuff that’s still to come later this year – make sure your subscription is up to date so you don’t miss out!

Get it Now!

As always, the new products are available to licensed users on our Customer Portal; Free 30-day Trial versions are also available on our Trial Downloads page.

To purchase or to renew your existing subscription, visit our secure online shop at remobjects.com/shop.

Also remember that you can expand your platforms at any time, simply by renewing to the new platform combo. For example, if you currently own Data Abstract for .NET, add DA/Xcode to the mix and start developing iPhone and iPad apps, simply by renewing “Data Abstract for .NET and Xcode”.

Yours,
marc

Avatar of marc

by marc

Thoughts on Windows 8 and “Metro”

September 17, 2011 in .NET, Data Abstract, Delphi, Elements, non-tech, Oxygene, Platforms, RemObjects, Visual Studio, Windows

I just got back home from 360iDev in Denver, one of the best third party conferences on iOS development.

In parallel, another big conference has been going on in Anaheim, introducing big and significant changes to a completely different platform. I’m talking of course about //build/. As you probably heard, if you’re not living under a rock, Microsoft announced both Windows 8 and – more interesting to us as developers – Visual Studio 11, and has made preview releases of both products available, as well.

The good (and unexpected) news is that all the doomsaying about .NET has proven to be false; if anything, Windows 8 strengthens .NET as one of three ways to build high quality apps for its new Metro application platform. It does so by essentially making .NET, C++ and HTML5+JavaScript equivalent tools that can use the same APIs to create apps. Given the choice of those three, what would you choose? Clearly, .NET is the winner here.

XAML, integral part of both WPF and Silverlight in the past, has been promoted to the default UI paradigm for “modern apps”; it is interesting to see that (a) Microsoft is dropping the WPF nomenclature and talking about XAML itself and (b) making XAML UI also accessible to non-managed development using C++. The new UI layer that lets you build Metro apps is backed by WinRT, a managed class library (and subset of the full .NET framework), and together Metro and WinRT are presented as the way forward for building what Microsoft, literally, called “modern apps”. Classic Win32/Win64-based applications are still supported, but relegated to the “old” Windows desktop. It also seems (although Microsoft has not been completely precise in talking about this, so there is still some discussion and interpretation going on) that the Win32 model will not be supported at all on ARM based Windows 8 slates (i.e. not only will x86/x64-built applications not run on ARM devices, which seems obvious; no, there will most likely also not be the option to recompile classic Win32 apps for ARM. To run on ARM systems (and Microsoft is making it clear that they expect all/most tablets shipping with Windows 8 to be ARM based), the new Metro/WinRT APIs will need to be used.

It sounds like this seems to spell the end of traditional “native” Win32 development tools, at least for “modern” Windows applications.

Metro itself looks like an impressive and ambitions “reimagination” of Windows, indeed. Of course only time will tell how successful it will be and how well it will run (in my first attempts running the Windows 8 Developer Preview in VMware Fusion, it certainly feels awkward and clunky in places, and unnavigatable without touch in others), but IMHO one must applaud Microsoft for taking such a bold step.

For developers, creating apps for Metro will be a paradigm shift, much akin to targeting a completely different platform. In fact, watching the excellent Eight Traits of Great Metro Apps presentation, a lot of the purposeful “limitations” of the development remind me of iOS: the way application backgrounding is handled (your app will be killed as it gets off screen) or how Windows Push Notifications will need to be used to give the appearance of non-running applications staying live, updating their tile and providing notifications.

This goes to show, I think, how important it is to develop applications with platform-appropriate tools, not one-size-fits-all solutions. I’ve made the argument before that anyone trying to use Win32-rooted tools to create applications, say, for Mac or iOS is doomed to fail and produce sub-par results. The same, I believe, will now apply to using Win32-based tools to create Windows 8 apps: Your applications will look out of place, and/or be relegated to the legacy desktop.

In the same vain, it is great and refreshing to see Microsoft talk about and stress how important good design, a quality user experience and conformance to the Metro design paradigm is (same video). They really copied the right pages from the Apple playbook here.

So What about Our Tools?

Windows and .NET are a very important platform for us here at RemObjects, and that continues to be the case going forward. The teams here are already hard at work at providing support for VS11, WinRT and Metro, based on previous access we had to internal betas as well as of course the Developer Preview that is now available via MSDN to everyone.

Data Abstract (and RemObjects SDK) will be integrated into Visual Studio 11 soon, and will let you build Metro clients (something which is especially important since the client data access story on Metro/WinRT seems to be pretty thin, otherwise). We’re not forgetting Hydra, either.

And Oxygene will, of course, let you create Metro/WinRT applications, allowing you to build native applications with lots of shared Object Pascal code for Windows Phone 7, Android and Metro – next to, of course, regular Windows and cross-platform apps with .NET, Mono and Java.

I don’t want to promise exact timelines, but we’ll let you know more and will have beta bits for customers to play with, Real Soon™.

Exciting Times Ahead

As most of you know, I’m mostly a “Mac and iOS guy” and have not been a big fan of the Microsoft platform for a while. But what I’m seeing here looks impressive, and while I’m not contemplating to switch <g>, real competition is good for everyone, and it is great to see a new quality platform coming out of Microsoft, and I believe this will be a great opportunity (and challenge) for Windows developers. The next couple of years will be very exciting, as far as development platforms go!

marc

Avatar of marc

by marc

Gamma Builds of Data Abstract and RemObjects SDK with Delphi XE2 Support Available Now.

September 2, 2011 in Data Abstract, Delphi, Mac, short, Windows

As promised in my previous post, new gamma builds for Data Abstract and related products are available with full support for Delphi XE2, including Win64 and Mac OS X.

These are not “gamma” builds from the branch we are working on for our upcoming Fall 2011 release due later this month; these builds are feature complete and considered “stable”, but they have not yet gone thru the full range of testing that our final releases go thru, so use them at your own risk.

To get the builds, head over to beta.remobjects.com. Like all of our beta programs, these builds are available to any customer with an active subscription. Please use the private ROFX beta forum on RemObjects Connect to discuss these builds and provide feedback.

Enjoy Delphi XE2!

Avatar of marc

by marc

Delphi XE2 Support

August 30, 2011 in Data Abstract, Delphi, Hydra, Mac, Windows

I want to take a few moments to talk about support for the upcoming Delphi XE2 in our “for Delphi” products. As most of you have probably heard by now, Delphi XE2 is one of the more exciting releases for the development tool in the past years, adding a lot of new functionality. For the purpose of our products, there’s really four areas of interest that are new in XE2:

  • Platform support for 64-bit Windows
  • Platform support for 32-bit Mac OS X
  • Live Bindings
  • FireMonkey

Our products, especially Data Abstract and the underlying RemObjects SDK are mostly non-visual, so the new platform support is probably the most interesting aspect for us.

As you know, we have long supported Win64 and (to a lesser degree) Mac OS X via the open source Free Pascal compiler, so we have been in good shape for supporting these two new targets with Delphi XE as well. So it goes without saying that we’ll be fully supporting RO and DA on these three platforms, starting with the next release, both for creating clients and servers.

64-bit Windows will be a default part of new VCL-based Data Abstract projects created thru our wizards; and we will also have new templates to get going with FireMonkey-based DA clients on Windows and Mac.

Live Bindings are another interesting area for Data Abstract, as they make it a lot easier to connect visual controls to database content without relying on separate “TDB*” components, as used to be necessary. Data Abstract will include full support for Live Bindings as well.

As already mentioned above, RO/DA are pretty much non-UI libraries, so they work regardless of the actual UI layer and will function in FireMonkey and VCL applications alike. Of course we do have some visual elements in DA, such as our standard Reconcile Dialogs, and these areas have been abstracted to properly provide different versions of the dialogs for VCL vs. FireMonkey (and of course you have always been able to add your own Reconcile UI yourself, and you can still do that).

FireMonkey is a lot more interesting for Hydra, and as you might have seen in Alex’s blog post a few days back, we have been hard at work to fully integrate FireMonkey into Hydra as a UI platform equal to VCL, WinForms and WPF, so that you will be able to seamlessly mix all four of these UI technologies with the upcoming Hydra 4 release (in addition to a fifth UI platform for plugins: Silverlight). Hydra will be supported on 32-bit and 64-bit Windows.

Timelines.

The important question you have of course, is: when can you get your hand on this stuff? The answer is: ASAP.

We have been shipping beta builds with (secret) XE2 support for a while now, so people who have been participating in the field test of Delphi XE2 and installed our betas could already use RO/DA with the new technologies.

As of the day Delphi XE2 RTMs, we are planning to have a fresh beta build up that will be off our “stable” branch and can be used with XE2. This build will not contain binaries (to ship XE2 binaries, we need to integrate the final XE2 into your build system, which we cannot do until it is final ;), but it will include all the files you need to build and install the XE2 design time packages from source.

Later in September, probably somewhere in the early second half of the month, we will ship our official “Fall 2011″ releases of RO and DA, which will contain all the XE2 support outlined above, including pre-compiled binaries, and we will also have a new Trial version that supports XE2.

For Hydra, we will stay in beta a little wile longer; we expect to have a “usable beta” build with FireMonkey support for you within September.

Remember: Our betas are accessible to all customers with an active subscription, so to get going with RO/DA on Delphi XE2 right away, just head over to beta.remobjects.com. If your subscription has lapsed, there’s no time like the present to go and renew now to make sure you have access to the betas and will get the final products with XE2 support as soon as possible.

Hydra and FireMonkey – Best Friends Forever

August 18, 2011 in .NET, Delphi, Elements, Hydra, Windows

As you have probably alrady heard, in the upcoming release of Delphi XE2, Embarcadero will introduce a new cross-platform GPU powered GUI framework called FireMonkey. The new framework is similar in concept to .NET’s WPF, and builds on the former VGScene/DXScene components to let you to build applications with both 2D and 3D elements, transforms and animations.

FireMonkey is not an evolution of the VCL, nor does it replace it. The VCL will still be incldued with Delphi, with FireMonkey being an alterative option for UI development. But while the VCL remains for Windows only, FireMonkey will allow you to create GUI applications for both Windows (32 and 64 bit) and Mac OS X.

Since FireMonkey is a cross-platform framework, it’s not bound to Windows and it doesn’t directly use things like the Windows message loop or handles. Being a GPU powered framework, FireMonkey uses Direct2D/Direct3D or OpenGL to render GUI, meaning that by default, FireMonkey and the VCL will not get along well, and you won’t be able to, say, add a FireMonkey control to a VCL application or vice versa, or even share FireMonkey and VCL forms within the same application. Which is a shame, really, if you have an exisiting Delphi app that you want to extend with some nice FireMonkey graphics, for example.

Enter Hydra

Traditionally, Hydra has served the purpose of letting you mix Delphi VCL applications with UI (and non-UI) written .NET (using either WinForms or WPF).

So will Hydra support FireMonkey, as well? Yes it will. The Hydra team is currently working on providing full support for FireMonkey plugins on both .NET and Delphi hosts. With this new feature in Hydra, you will be able to use both visual and non-visual plugins built with FireMonkey in the same way you can currently use VCL or .NET plugins.

To show you a few examples:

FireMonkey in the Delphi VCL

Hydra will provide the ability to host FireMonkey plugins inside the VCL:


FireMonkey in the VCL

FireMonkey in .NET WinForms

The following screenshot shows a FireMonkey plugin running embedded in a WinForms-based .NET application:


FireMonkey in WinForms

WPF in FireMonkey

Or you can even show a WPF plugin within a FireMonkey host application:


WPF in FireMonkey

Of course, these are just three examples, all the other obvious combinations will work as well (FireMonkey in a WPF app, VCL or WinForms in a FireMonkey app).

Find out More

FireMonkey support in Hydra will ship soon™ after Delphi XE2 is generally available, and will be a free update to any customer with an active Hydra subscription. (Current Hydra users will also be able to access beta builds with FireMonkey support when XE2 is out.)

Find out more about Hydra at remobjects.com/hydra.

Avatar of Alex

by Alex

Changes in the Data Abstract Samples Suite

August 17, 2011 in .NET, Data Abstract, Delphi, iOS, Mac, Windows, Xcode

Before the next upcoming release, I would like to highlight several changes concerning our Data Abstract samples suite.

Provided sample domain with the Relativity Server:

With the next release, we will provide Relativity Server with a new sample domain named PCTrade Sample that will contain a single schema called PCTrade. This schema will use the PCTrade for SQLite connection. The default login and password for this domain are Data and Relativity, respectively.

With this sample domain, Relativity Server can now be used as the server part for most of our DA samples in addition to the existing DASampleServer.

For the Xcode samples, you can easily choose the server you want to connect to:

For the .NET & Delphi samples you will need to set the flag value to True in the sample code as shown in the picture below:

Please note that several .NET samples, like Business Processor Sample and Refresh Update Data Sample, do not support working with Relativity since they depend on server logic implementation.

New Login service for the DASample server:

From the beginning, our samples had a virtual login implementation used only for the identification of clients and their platforms. For the next release, we have added a new secure DataService and LoginService to the DASample server. In order to maintain compatibility, we left the existing DASampleService unsecure. So if you try to build a client using that service, you will not need a login. But we added the new DataService on the top of the DASampleService, and made it secure. Thus, if you request that service, you need to login first.

The New Project Wizard for DA/Delphi

June 28, 2011 in Data Abstract, Delphi, Windows

Today, I want to show you the new Template Wizard in Data Abstract for Delphi.

Notice the VCL Application icon under the Data Abstract project type. This will launch the new Template Wizard. The template wizard includes a number of new options that were previously not available.

RemObjects Data Abstract for Delphi Template Wizard

The first project type creates a Client for Relativity server. If you are not familiar with Relativity server, it is a pre-built, reusable server recently introduced with Data Abstract. It serves as your middle-tier, making data publishing easy, so you can focus on your client application development.

If you have an existing custom Data Abstract server, you will want to choose the second option to create a new client. This is great when you want to add a new, different client to your existing architecture, if you are connecting to a server created by someone else, or with a different edition of Data Abstract.
Both of these two options obtain the schema information from the middle-tier instead of the database.

The third option is similar to the old wizard. It will create a new custom server and client at the same time. You just have to specify a connection to a database and the schema will be built based on that database, and then your client and server are built based on that schema.

This last option is an interesting twist on a Data Abstract application. Instead of having a separate middle-tier, it creates a single monolithic client that contains the schema and database connectivity. This effectively creates a Client/Server application, but lets you take advantage of the powerful and familiar features of Data Abstract, including schemas.

Let me show you how to create a client for Relativity server. If your Relativity server is running on your local network, the wizard can discover it via ZeroConf. If your server is not on the local network, just specify the Relativity URL. If you are using AES encryption, you also have to specify the password.

Now select the domain. Each domain is an individual Data Abstract server instance within the single Relativity server. If the domain you want is not already defined, you can click the Start Admin Tool to launch the Data Abstract Administration tool and define the domains and schemas you want.

You also need to provide the username and password necessary for connecting to the domain, because all the schema information is obtained via the connection to the Relativity server. This is great if you are connecting to a server that is hosted elsewhere and you wouldn’t otherwise have access to the database. The default Relativity data username & password is Data & Relativity.

Select Relativity Domain

Once you connect to the domain, the wizard enumerates the schemas and tables. Any tables selected will have strongly typed Data Tables created in the client application.

Relativity select Schema and Tables

You can change your Data Streamer for Data Transfer. It is recommended that you stick with the Bin2DataStreamer though.

Data-transfer-options

Finally, give your project a name and optionally specify a different location for the project.

Project name and path

When the wizard finishes, the project will open in Delphi ready for you to finish your application. The operation of the other wizards is pretty similar. I encourage you to download the latest update of Data Abstract for Delphi and try them out.

If you would like to see the Relativity client completed, check out the full video on the Data Abstract channel in RemObjects TV or watch it on YouTube.

Avatar of marc

by marc

Spring 2011

March 28, 2011 in .NET, Cocoa, Data Abstract, Delphi, Elements, iOS, Mac, Oxygene, Relativity, RemObjects, Visual Studio, Xcode

It’s the time of the year again: i am very happy to announce the immediate availability of the “Spring 2011″ releases of out entire product suite. Point your browsers to portal.remobjects.com (licensed users) or remobjects.com/trials and remobjects.com/free for free products and trial downloads. Let’s have a look at what’s new:

Data Abstract

We’ve added Business Rules Scripting support in Data Abstract for Delphi, bringing it on par with it’s .NET sibling. Scripting in Delphi is based on ActiveScript/JScript and scripts and the DA scripting API are fully compatible between the two editions; you can have a Delphi client receive client-side scripts from a .NET server and they will run just as they would on a .NET client. We’e also made vast improvements to Business Rules Scripting support in Data Abstract for .NET and it’s now using our completely redesigned RemObjects Script 2.0 (more on that below).

New Schema Modeler and Server Explorer for Mac has left the Tech Preview stage, and has been greatly improved since the Winter 2010 release. It also has much improved support for editing and validating scripts you’re writing for your Relativity Server.

Mobile platform support in Data Abstract for .NET has been extended; we’ve added full DA LINQ support for Mono Touch, and now also support MonoDroid (aka Android for Mono) and Windows Phone 7. This means that (if you don’t want to go native with Data Abstract for Xcode or “Black Lodge”, you now create applications for all three major smartphone platforms in .NET, and potentially share a lot of code between them (although we’d hope you will use MVC to capsulate your UI and create a proper platform-specific UI to make your app great on each platform).

As a minor news item, support for our cross-platform Briefcase Files has now been extended to Data Abstract for Delphi and is now available in all three editions!

RemObjects SDK

As part of DA, RemObjects SDK for .NET has of course also been extended to support Windows Phone 7 and Android; Internet Pack is also supported on Android now (but not on Windows Phone 7, which – like Silverlight in general – does not support network access beyond the APIs provided by the platform.

The TCP ClientChannel has been ported over to RemObjects SDK for Xcode, and we’ve added a new feature we call URL Schemes that allows you to let the framework to automatically pick the right channel and message type based on a full URL (such as tcp://examle.com:8089/soap). This feature debuts in Ro/Xcode but will make its way onto the other RO platforms as well, eventually.

We’ve also added HTTP-level gzip compression in RemObjects SDK for Delphi (which allows you to save bandwidth with non-RO SOAP clients, mainly), and made the AES Encryption Envelope available support for Silverlight in RemObjects SDK for .NET.

RemObjects Script

As mentioned before, RemObjects Script 2.0 as been completely redesigned to no longer depends in the Microsoft Dynamic Language Runtime and run much faster than version 1,0 in most scenarios. It and passes 100% of all tests in the standard EC5 EcmaScript test suite, and we are working on testing it with other common JavaScriopt test suits such as Sputnik, to ensure top script compatibility. The product is now licensed under the BSD license and fully open source; in addition to a packaged installer on our Free Downloads page, you can also access the code from the Git repository on code.remobjects.com

Hydra

Action support in Hydra has been extended to fully support actions and action updates (such as enabling and disabling) across platform boundaries. So a Delphi host application can now incorporate actions driven by a .NET plugin, or vice versa.

Delphi Prism

The official RTM announcement and availability for Delphi Prism will come from our friends at Embarcadero in the next few days, but as part of our RTM cycle, we have also finalized our part of a new Delphi Prism release, which will be a free mainly-bugfix release available to all users of Delphi Prism XE (even RAD Studio customers not on SA). There are a few nice features in there, though, and my favorite ones are the new visual navigation markers that highlight and keep track as you navigate through your code (and go back), as well as inline errors, which highlight places with compiler errors right inside the code editor (similar to and inspired by Xcode). The inline errors are just the tip of the iceberg for some very cool stuff we have coming in the Fall release, too.

Oxfuscator

We shipped the first standalone release of Oxfuscator just in January, so this update merely contains a handful of fixes and brings Oxfuscator in line with what ships in the new Delphi Prism XE spring update mentioned above.

 

I hope you enjoy these new releases, and let us know what you think!

yours,
marc

Avatar of marc

by marc

DSConf in Review

February 14, 2011 in .NET, Android, Cooper, Data Abstract, Delphi, Elements, Events, iOS, MonoTouch, non-tech, Oxygene, RemObjects, Visual Studio, Xcode

DSConf

It’s Monday February 14, 3AM and i’m jet-lagged and back home from Las Vegas, where our three-day Developer Solution Conference ended – what seems like a few hours ago – on Thursday.

DSConf Las Vegas was the first conference we have ever organized, and has been the first state-side events of our partners in crime, the Developer Experts.

This being our first event, and having a lot of time, resources and money invested into this over the past three or four months since we started planning, we were of course nervous about how the conference would go. Did we have the right mix of content? would our one-track, half-sessions/half-workshop approach work? would people like the event? heck, would anybody show up?

To say that we’re very happy with how the event turned out would be a tremendous understatement. interest in the conference was great, and with 40 registrations, we certainly reached our goal as far as pure numbers of attendees go. But what’s more important, people really dug the concept of DSConf and our sessions+workshops approach, and again and again attendees approached me (and my fellow staff) telling me that the conference was “exactly what [they] were looking for” or “just perfect”.

DSC 9736

DSConf was held at the MGM Grand, where we had access to three rooms, one for the main session and workshop, one for breakfast, lunch, afternoon sneaks and Embarcadero’s sponsor booth, and a third where attendees could break out to, to sit down and code, away from all the action.

DSC 9753

Day 1 started (after a brief introduction of all the staff) with an overview of the development tools, with Jim and Olaf first looking at Delphi XE and Delphi Prism XE, and Daniel then giving an introduction into Xcode and Objective-C (with a little bit too much focus on how “weird” Objective-C is, if you ask me [i love it – i don't think it's weird at all ;], but people enjoyed it and learned a lot). After lunch (a great mix of Asian food provided by the awesome MGM Grand catering staff), Daniel Wolf started his session on UX design and paper prototyping, followed by a hands-on workshop on the same topic, which everyone seemed to agree was the highlight of the day:

Paperprototyping
Photo: Jim McKeeth

We closed with a workshop for the development tools shown earlier in the day, before releasing attendees to dinner and a free Poker Training session put on by MGM staff especially for our attendees. Those not interested in poker joined us back in the conference room for some late-night coding.

Day 2 came bright and early, with the keynote from Embarcadero’s David I – giving an overview of the current Delphi XI and the plans for the future, including a demo of Delphi/x64 and some hints at what’s coming down the road with VCL+. After that, we dove into multi-tier. First Jim gave us some background on why you’d want to bother with multi-tier in the first place, then Olaf and Daniel took the down-and-dirty road of showing attendees how to do data access the old fashioned way – custom REST and JSON parsing, and all those gruesome details.

After lunch (mediterranean food, which i did not get a chance to eat but was told was excellent once again) Holger and Jim dove into Data Abstract, showing how to create clients and servers with either Delphi or Delphi Prism.

Every conference needs it’s hick-up, so the last three hours of the day saw me on stage with Holger and Daniel leading developers thru our workshop and working with Data Abstract for .NET in Delphi Prism. I’m not an on-stage kind of guy, but things went well, and Daniel clearly enjoyed telling me how to use my product on the big screen ;).

If you’ve been to conferences before, you know that usually half the audience is checking their mail or catching up on twitter while talks are going on. But – just as in the workshop the day prior &dasnh; pretty much every attendee was following along with the workshop, as we plugged thru the details of DA/.NET, DA LINQ, RemObjects SDK Roles and creating custom web service methods that performed mathematical operations only Daniel will understand. While we were on stage guiding the workshop, the rest of the team roamed the room to answer questions and assist attendees who ran into problems.

DSC 9756

After the dinner break (i went to eat an excellent Teppanyaki with the RemObjects crew and a few friends), attendees met again for an “open bar and networking” evening.

Day 3 was all about mobile development, with three sessions dedicated to iOS (iPhone and iPad), Android and Windows Phone 7, respectively. The iOS session touched briefly on MonoDevelop, but then focused on Xcode (personally my favorite way to develop for that platform); the Android session was given by our guest speaker Brian Long (who’s presentation, if i may say so, was one of the highlights of the conference), providing a great and in-depth introduction to MonoDroid (a topic unknown to myself, as well, up to that point). Last but not least, Jim introduced the attendees to Windows Phone 7 development with Silverlight.

All three sessions consisted of about two-thirds of an in-depth view at the platform and development tools themselves (with Delphi Prism being used for all three .NET based tool chains, although the principles shown would have applied just as well to C#), and one third of a look at how Data Abstract rounds those platforms off with multi-tier client functionality.

CooperSlide1

Next up came the part i was most excited about: Jim spent half an hour giving a sneak peak at a new top-secret project that has been brewing in our labs for a while now: “Cooper”. DSConf attendees were the first people outside of RemObjects to ever hear about Cooper, but now that the word is out: Cooper is a new compiler that brings the Oxygene language (that you all know an love from Delphi Prism) to the Java and Android platforms. Just like Oxygene, when first releases, aimed at bringing the “full .NET experience”to Pascal developers, Cooper does the same for Java. it links directly against the Java class libraries and generates 100% true Java (or Dalvik, Android’s variation of Java) executables, and is a “true” Next Generation Object Pascal for Java. (We’ll have a video reproducing the DSConf session up on RemObjects TV within the day, and stay tuned for more information, soon!).

CooperSlide2

“Cooper” was met with a lot of excitement from the attendees, and i believe it will be one of the most interesting products we’ll be shipping this year.

But, time to move on, and day three of DSConf ended with a set of workshops putting the knowledge from the morning to use – with the help from Daniel, Brian and Jim on stage, attendees went on to build mobile clients for the Data Abstract server created the day prior, for iOS, Android and Windows Phone 7.

 

So people showed up, all the sessions went well, but the greatest part of the conference for me has been talking to all the attendees – many of which long time customers who’s names i’ve seen again again but who i had never met, and just as many who were completely new to our products.

There’s two things attendees said to me that i will never forget. The first was a long-time customer coming up top me, telling me how long he’s been using our stuff and saying “Thanks. You guys have made me a lot of money.” That must be among my favorite customer quotes ever. The second was a guy – new to DA – who looked me up, said he’d loved what he’d seen, and asked what Data Abstract would cost. I told him, and after looking at me – flabbergasted – for several seconds, he said “That’s all? That’s per deployment, right?” Nope, i told him. That’s the flat license, per developer.

DSConf Team
Photo: Nate Woolls, TeamRO

So we’re very happy with how DSConf turned out. Tired, yes, but very happy. So happy in fact, that we’re already planning the next event. I cannot go into details yet, but stay tuned to http://dsconf.com for more information soon (and sign up to the DSConf newsletter to stay up to date).