Archive for the ‘Relativity’ Category

# Release Timeline for 2010

by marc hoffman, June 2nd, 2010, Categories: .NET, Cocoa, Delphi, ROFX, Relativity, RemObjects

With the major release of Delphi Prism out of the way now, it probably is time to talk a bit about our remaining timeline for releases this year. I realize we haven’t updated our official ROadmap since the beginning of the year, and hopefully, this post will make up for that until we get a chance to do that.

The last release of ROFX, our suite of library products including RemObjects SDK, Data Abstract, and more, was in early March and the teams have been busy since, working on good stuff on all fronts.

Because we have several “big” features in the works for the next releases, we have decided to vary slightly from our usual quarterly release cycle this year by “merging” the May and August releases into one single release that will hit sometime in July, instead. This will give us slightly longer development cycles, both for this next release, and also for the (regular, as scheduled) November release later this year. This in turn allows us to tackle more big features in a single go.

Among the new features you will see this Summer (most of which we have already talked about or hinted at) are modelling support via Relativity Server and a full-blown Server Explorer and Schema Modeler for the Mac (in DA/OSX), new Server and Client side business rules scripting in both DA/.NET and Relativity, and a brand new New Project wizard system in DA/.NET that will make it way easier to start new projects, or add a new client project to an existing solution. And these are just the big ones.

For the Winter release (in November), we’ll expand the scripting support to the other two platforms (Client and Server for Delphi/Windows, and  Client for Mac OS X), and also bring you a new Schema Modeler for Windows. The current Scheme Modeler has gotten long in the tooth and we’ve been meaning to thoroughly revamp it, for a long time. The new SM will be driven by some of the experiences we collected implementing the Mac version, but also by years of working with the current Schema Modeler and learning its limitations and issues. We’ll also bring the new template system to Delphi, as well.

Betas

Starting a couple weeks from now (probably once I’m back from WWDC), we’ll start up a more regular beta cycle again, with (mostly) weekly beta builds of RO/DA for all three platforms, all the way thru to the July release, and beyond. Many of the new features (especially DASM/Mac, and the Scripting) will be fully functional by then, and we’ll be looking forward to your feedback.

Remember that beta access is available for all customers with an active subscription. Simply point your browser to beta.remobjects.com, which will take you to the beta section on our new portal site. After logging in, you will see a list of all the products you have with an active beta program, and a list of their beta downloads (if any – we don’t always have a current beta, especially not shortly after a “release” release). The usual caveats for using beta builds of course apply.

by marc hoffman, June 2nd, 2010

Posted in .NET, Cocoa, Delphi, ROFX, Relativity, RemObjects | 4 Comments »

# Join us at Data Rage 2

by Sebastian, May 15th, 2010, Categories: .NET, Cocoa, Delphi, Mac, Relativity, RemObjects, Tools, Visual Studio, Windows, Xcode

RemObjects will present Data Abstract in a vendor showcase session at the Embarcadero DataRage 2 online conference, that will take place May 25-27, 2010.

Currently our session “n-Tier in a Box: Data Abstract in Action” is scheduled on Thursday, May 27th from 06:00 to 06:45 PDT.

In this session you will see how easy it is to create a Data Abstract server in Delphi, access that from a Delphi Client and we additionally show you how to create a Relativity-hosted DA server, access this via REST from a browser and at the same time from a native Mac application written with DA/OS X.

I like to invite you to the online conference and I’m excited to see (well, rather read or hear ;-) ) you at Data Rage 2.

by Sebastian, May 15th, 2010

Posted in .NET, Cocoa, Delphi, Mac, Relativity, RemObjects, Tools, Visual Studio, Windows, Xcode | No Comments »

# DA/.NET Client-Side Scripting

by Carlo Kok, April 19th, 2010, Categories: .NET, Linux, Mono, ROFX, Relativity

We just finished our dataset scripting support for Data Abstract for .NET. DA now lets you define scripts on the server side (inside the schema), that the client will download and hook up to the events of the dataset. Scripting is supported for both the server and the client, and uses the RemObjects Script engine, which provides the ECMAScript (a.k.a. JavaScript) syntax.

An example, take this script for a “Customers” table:

function beforePost(row) {
  if (row["Discount"] > 50) 
    fail('Discount has to be less than 50');
  if (row["Discount"] < 0) 
    fail('Discount cannot be negative');
}
function onNewRow(row) {
  row["Discount"] = 20;
}

Now any time you fill a DataTable, on a remote data adapter with the script engine property set will receive this JavaScript from the server, and assign them to the datatable:

    var lDs := new System.Data.DataTable();
    lDs.TableName := "Customers";
    RemoteDataAdapter1.Fill(lDs, WhereExpression(nil), true);
 
    var rows := lDs.Select;
 
    rows[0].BeginEdit;
    rows[0]['Discount'] := 60;
    rows[0].EndEdit; // will fail here with a ScriptingException "Discount has to be less than 50"
 
    var lNewRec := lDs.NewRow;
    // lNewRec is preinitialized with a discount of 20 here.

Unit tests for this new feature have been written and all is working nicely. Next will be the same feature for the Linq Remote (and Local) Data Adapter.

Of course, client side scripts are there only to provide immediate user feedback, not to enforce business rules. For this reason, DA will run this business rules script not only on the client, but (where applicable) also on the server. DA also provides a range of additional server-only script events that can implement more extensive business logic – something i will talk more about, soon.

by Carlo Kok, April 19th, 2010

Posted in .NET, Linux, Mono, ROFX, Relativity | 5 Comments »

# The Missing Link: Schema Modeler for Mac

by marc hoffman, April 14th, 2010, Categories: Cocoa, Mac, Platforms, ROFX, Relativity, Xcode, iOS, iPad, iPhone

In this previous post, i talked about the current state of Data Abstract for OS X, and also promised a follow-up with a roadmap of where we are going next.

Where We’re at

To recap, when Data Abstract for OS X originally shipped last winter, it was client only. Basically, you needed to have existing servers written in DA/.NET or DA/Delphi (or write new ones using those same tools). This basically made DA/OSX a solution mainly for our existing Delphi and .NET customers, allowing them to expand their current solutions with native Mac and iPhone clients

In the following Spring release last month, we added Relativity Server running on all three platforms, giving developers the option to host Data Abstract services on Mac (in addition to Linux and Windows), without needing to know .NET or Delphi (or even having those tools).

This took care of two thirds of the picture, but there is still one hole in a complete Mac solution: Schema Modeling (and Relativity Administration). While Relativity server runs on the Mac, developers are still dependent on Windows based tools both to configure and control their Relativity server, and – more importantly – design and work with their schemas.

What’s Coming Next

As hinted at before, we’re working on closing this gap, and are writing a new tool for Mac developers that provides two things. First, it builds on the functionality in Relativity Server Admin for Windows, and expands it to a new concept, to what we are calling the Server Explorer. Secondly, it will allow Schema Modeling thru Relativity server, essentially providing the full functionality of Schema Modeler for Windows.

Let’s have a quick look at both of these aspects.

Server Explorer

Server Explorer will provide a single unified place for you to keep track of and administer all your Data Abstract servers. You can see a preview of what the current beta of Server Explorer looks like, here: (note that many things may still be subject to change before this ships):

Server-Explorer-(small).png

Server Explorer will automatically find ZeroConf servers on your local network, and you can manually register servers at remote locations, using their Target URL. It can handle Relativity and custom servers alike, although it will show slightly different options and features for each.

In the screenshot you see two servers folded open – one custom server (this is our Continuous Integration system, OnyxCI), and one Relativity server.

Custom DA servers don’t provide much room for configuration, so Server Explorer restricts itself to showing a list of all services it finds, and allowing you to browse data (including running DA SQL queries, if the server supports it) and view the readonly schema. That is provided you have a login to the server that authorizes data access. In this case, you can see there’s 2 data services and four other services exposed by our server.

For Relativity servers, there’s a lot more to see. As the screenshot shows, you can dive into the different Domains configured on the server (we’re looking at one called “OneSpace” here, which is a personal project of mine). You can look at the schemas (as well as browse and query the data they expose) and connection strings, and you can of course configure the Relativity server itself, such as to create new Domains.

Where things get interesting is on the Connection and Schema nodes, both of which allow you to open dedicated editor documents for what essentially are the .daConnections and .daSchema files.

Schema Modeler

Combined, these two editors give you the same abilities you have in Schema Modeler for Windows: You can define new connections and browse the actual contents of the database they connect to. And you can visually create and edit schemas, both by manually defining data tables and other elements, or by dragging tables from a Connection to the Schema document.

Connections.png

There is two core differences between what you (may) know from Schema Modeler for Windows, and how the Mac version of Schema Modeler handles things.

For one thing, while DASM/Win combines both the Schema and the Connection list into a single document window, DASM/Mac keeps them separate. The reason is simply that a Domain has one list of connections, but might have more than one schema defined. Having both in separate windows makes it more intuitive to edit several schemas at the same time – you will have one shared Connections window, where you can edit the connections, and from which you can drag objects into any of the schemas.

The second difference is more important. The current DASM/Win contains both DA/.NET and DA/Delphi server code that talks directly to the databases to retrieve metadata such as table names. If you are writing a Delphi server, it uses DA/Delphi drivers, if you are writing a .NET server or creating a schema for Relativity, it uses DA/.NET ones. This logic is embedded right into DASM/Win.

For DASM/Mac we have changed this, and have moved modeling support into the Relativity server. Relativity now exposes APIs (password protected, of course) that allow Schema Modeler to create connections for and obtain meta data from any database supported by the instance of Relativity it is talking to – over the network.

This means that you don’t need to worry about the proper drivers being installed and properly configured on your development machine, it also means that your database does not even have to be exposed to the network your development machine is on (you might have both your Relativity server and the backend database hosted somewhere on the internet, and expose only Relativity thru the firewall, for example. As long as you can talk to your Relativity server, you can work).

As a side effect, this allows Schema Modeler to be a 100% native Cocoa application and to still model and validate schemas against all the DA/.NET drivers available in Relativity.

Schema-Modeler-(small2).png

As you can see in the screenshot of the Schema document above, DASM/Mac also already exposes the new DA Scripting feature, which allows you to use JavaScript to define business rules that will run inside Relativity (but also in custom DA Servers).

The Add Event drop down provides quick access to stubs for all the available events, in this case the schema implements (well, pretends to) the beforeProcessDelta event, which gets called before any chunk of updates received from the client would be applied

When?

Work on DASM/Mac is well under way, and we’re confident it will ship with the upcoming “Summer 2010″ releases. The same is true for DA Scripting in DA/.NET and Relativity (the feature is completed as we speak).

Stay tuned to see both features in beta drops, very soon.

yours,
marc

by marc hoffman, April 14th, 2010

Posted in Cocoa, Mac, Platforms, ROFX, Relativity, Xcode, iOS, iPad, iPhone | 1 Comment »

# What’s New and Cooking…

by marc hoffman, March 6th, 2010, Categories: .NET, Delphi, Delphi Prism, Mono, ROFX, Relativity, RemObjects, Visual Studio, Xcode

The past week has been a busy one, here at RemObjects. On Tuesday, we shipped our new “Spring 2010” releases, updating our entire product suite. We also started work on three major new projects that will significantly shape Data Abstract over the coming year.

Let’s start with a quick look at the “Spring 2010” releases. On first sight, this round looks like a minor update – and in many ways it is, as a large portion of the past product cycle has been concentrating on QA and documentation (which is making great strides in the wiki, i must say – kudos to the entire team for keeping up with their documentation writing). But we also shipped a few great new features and key technologies that will play an important role moving forward.

Script

Firstly, there’s the new RemObjects Script for .NET that Carlo talked about the previous week. Right now, RemObjects Script is is shipping as a standalone library product (like its close sibling Pascal Script for Delphi, and like Internet Pack, it ships free and with complete source, and is available in our public SVN). So that alone, i believe, is pretty cool – but RemObjects Script fits into a greater plan, and that is the expansion of Business Rules Scripting in Data Abstract.

A little known and often overlooked feature we have had in Data Abstract for Delphi for a long time is the ability to define business rules inside the schema, to be run on the client. Not really meant to enforce security, but more to provide a better client experience, the idea was that constraints and business logic could be specified – using Pascal Script – right inside Schema Modeler, and clients will retrieve and run these rules automatically, and would always have the latest set of rules, without needing to update the client .exe.

RemObjects Script is an essential piece in our plan to take this to the next level, and we are currently working on full Business Rules Scripting support, both client and server side, and for all three editions of Data Abstract. The idea is that right inside Schema Modeler, you will be able to specify JavaScript based rules that can run either on the client (be it .NET, Delphi or OS X), the server, or both.

Server side rules can be used for the actual enforcement of rules, making it possible to replace a lot (if not all) of the code that currently makes up a common DA server. Client (and shared) rules can complement these to enhance the local editing experience, by “enforcing” adherence to rules while editing data, without requiring a roundtrip to the server for final validation.

This DA Scripting feature is in the works now, and will ship for the various editions over the remaining course of the year, starting with Data Abstract for .NET in May.

Relativity

Next up, we shipped the first release of Relativity. Relativity is our new standalone Data Abstract application server, replacing the aging (and Delphi based) DAServer.

The idea behind Relativity is that the vast majority of Data Abstract servers don’t really need much custom code (beyond business rules), yet the common Data Abstract approach today is to create a custom server .exe that needs to be built, deployed and maintained. With Relativity, this can now be a thing of the past, and you can deploy Data Abstract services in a ready-made server application, simply by uploading the appropriate .daSchema file.

Relativity is based on Data Abstract for .NET, but it ships with all three editions of Data Abstract. This means it gives Delphi developers the chance to use .NET drivers and the advanced server-side functionality such as DA SQL, without needing to purchase (or learn to work with) DA/.NET. It also allows Mac and iPhone developers to create and host servers (since we don’t ship a server library in DA/OSX).

And of course Relativity will also take full advantage of DA Scripting, starting in May.

More Stuff

In addition to these to “big ones”, we’ve also shipped a range of smaller new features and enhancements.

Internet Pack for .NET has been extended with a native client implementation for LDAP, which Carlo also blogged about before. We use LDAP a great deal internally, and this new client class makes it easy to build LDAP authentication into your RO/DA servers (or any other applications, of course). In fact, Relativity ships with a default LDAP Login Provider that is based on this implementation.

Data Abstract for .NET now provides the ability to expose data via the REST protocol, which makes it very easy to access data from non-DA client applications, for example from client-side AJAX based web sites. REST is one of many features we have added over the past year or so to enable better accessibility from web clients (another notable one is support for JSON messaging in RemObjects SDK), and we’ll be blogging and writing more abut this.

Our Xcode integration has been extended by new project templates that really make it easy to get going with Data Abstract or RemObjects SDK for the Mac or iPhone. These templates were created based on a lot of custom code i had written while implementing our internal Bugs 7 client, and they should provide a great starting point.

Screenshot 1 - Templates.png

(One of the next items on my list is a post that will look at these in more detail).

 

Visual Studio 2010The last important change i want to highlight is that the entire range of products for .NET is now compatible and integrates with the new Visual Studio 2010 (based on the current Release candidate, although we expect no problems between now and the final release of vs2010 in April).

What’s Next

Ok, so i mentioned work on three new major features has started this week, as well. What are those? The first one, of course, is the new DA Scripting support i mentioned above.

The second new feature is one that we have been planning for a while but are finally getting around to for this time, and that is a brand new “New Project” template architecture for both Delphi and .NET. The current templates are pretty server-focused, and don’t make it very easy to create different client types. Our new templates will be focused around ann the various client applications you might want to create (WinForms, WPF, Gtk#, Silverlight, Monobjc, ASP.NET, VCL, UCL, and so on), combined with a great integrated wizard that will allow you to either create a new server project to match, or connect your client to an existing (custom or Relativity) server.

The third new feature, which i am most excited about, is to round of our Mac development story to allow for pure Mac development of DA applications. We have the library to build great clients on Mac, iPhone and iPad. We now have Relativity to host DA services on a variety of server platforms. What’s missing, and what we’re working hard on for the May release, is the tool chain in the middle – a Schema Modeler for Mac that will enable developers to design and test their schemas, for Relativity deployment, right in their Mac.

 

Stay tuned for a lot more talk about all three of these topics, over the next three months. In the mean time, go and check out our “Spring 2010” releases, available now!

 

marc

by marc hoffman, March 6th, 2010

Posted in .NET, Delphi, Delphi Prism, Mono, ROFX, Relativity, RemObjects, Visual Studio, Xcode | 4 Comments »

# Everything is Relative

by marc hoffman, February 3rd, 2010, Categories: .NET, Cocoa, Delphi, Linux, Mac, ROFX, Relativity, Visual Studio, Windows, Xcode

Today i want to talk a bit about “Relativity”, a new feature we’re shipping with Data Abstract this month (and which is actually available as “tech preview”in the current Winter 2009 releases).

“Relativity” is, simply put, a standalone server application that can be used to host Data Abstract schemas and serve data. In essence, it provides the complete Data Abstract middle tier, in a precompiled box and ready run. This offers several benefits, not the least of which are:

  1. No need to build your own. Relativity provides all the power and abstraction of a true Data Abstract middle tier server, without you actually having to create, build, and deploy your own executable. This allows you to concentrate on the client development. It also is really handy for prototyping, if you just want to have database server to talk to, without much work, even if you plan to eventually implementing your own custom server.
  2. Build on Data Abstract for .NET. .NET is platform with the most advanced version of DA – it supports our powerful DA SQL execution engine, and other features not available on all platforms. “Relativity” is being made available to all users of Data Abstract, so whether you’re a developer using .NET, Delphi, or Xcode, you can now write clients against Relativity that take full advantage of these features.

But let’s go and take a more detailed technical look at Relativity.

Relativity is a server application, so it does not provide any user interface. You can deploy a Relativity server in several ways, including:

  • Running it as a regular user application, on Windows.
  • Installing it as a Windows service.
  • Running it as a Unix daemon with the mono-service2 tool, on Mac and Linux.
  • Running it as a menubar item, on Mac.

Regardless of how you deploy and run it, Relativity will start making it’s Data Abstract services available on (by default) port 7099. But of course before it can start serving actual data, it will need to be configured with what data to serve. That is done thru the Relativity Server Admin tool, which is currently available for Windows (but versions for both Mac and iPhone are in the works).

When you first start it, the Admin tool will look something like this:

Screen shot 2010-02-03 at 2.24.03 PM.png

On the left hand side, you will see a tree view with all known instances of “Relativity” servers. This includes any servers (local or remote) that you connected to in the past, as well as any servers discovered on the local network using ROZeroConf.

Select any of the servers (here, “VEMMY” is the one instance running in my Windows VM), to connect and get more options.

Screen shot 2010-02-03 at 2.30.01 PM.png

The first two nodes allow you to configure how this “Relativity” server is accessed. This includes options such as what ports to listen on, what RemObjects SDK channels and messages to use, etc. Here you have the full choice of all the options provided by RO, you can choose the familiar HTTP, TCP, Super HTTP or other channels, BinMessage, SOAP Message, and so on.

Where it gets more interesting is the third node – Domains. This is where you configure the meat of the services Relativity is providing.

Each Domain corresponds to what typically would be a separate Data Abstract middle tier server. Domains are completely abstracted from one another and Relativity allows you to host as many separate domains as needed. With that, a single Relativity server can replace multiple DA servers, be it for related to completely independent applications or projects.

As you can see, i have three domains set up in my server, one for “BC7″, our new bug tracking system (using a PostgreSQL database running on our Xserve build server), one for “RemObjectsCom”, the database that drives our website (Microsoft SQL Server, running on the Windows server that hosts our website), and finally “OneSpace”, the database for a personal iPad project i am working on.

As we drill into a specific domain, you start seeing more things that will be familiar to you as a Data Abstract developer. Each domain can contain one or more Schemas – which correspond directly to .daSchema files or TDASchema components as you know them. You can manage schemas right there in the Admin tool, or directly launch Schema Modeler to edit the schema in question:

Screen shot 2010-02-03 at 2.39.38 PM.png

The domain also maintains a list of Connections to back-end databases available to it’s schemas. Once again, this directly corresponds to the .daConnections file or TDAConnectionManager component. Since Relativity is based on DA/.NET, these connections are based on the available DA/.NET drivers – regardless of whether your regular development platform is .NET, Delphi or Cocoa.

Another interesting part is the Login node. Relativity provides several options for handling authentication from client applications for data access (something you would normally need to manually implement, in a standalone DA server): in addition to relying on a static list of allowed username/password combinations, you can also choose to use a data table or command defined in one of the domain’s schemas to verify users (as i do in the example shown below) or query an external LDAP server for login.

The LDAP option is very handy if you are running a variety of services – some using Relativity, and some not – that you want to share user data among. We recently switched to LDAP for all our employee resources, and it has made administration so much easier.

The LDAP support in Relativity is based on a new 100% managed LDAP client implementation we’ve added to Internet Pack for this upcoming release. Carlo will blog more about this, soon.

Screen shot 2010-02-03 at 3.05.53 PM.png

The Login Provider architecture is extensible, so you can implement your own providers, for example if you need to do user authentication with a different method.

Client Access

Once you have Relativity set up to serve your data, your client application(s) can access it like any other Data Abstract server.

The only slight difference is that, since a Relativity server can host more than one domain, you need to tell the server which domain to access, by simply passing an additional Domain parameter as your login string, as in 

User=foo;Password=bar;Domain=DomainName

You will also want to select which Schema to query. in regular DA applications, each schema usually has its own DataService, so keeping in line with that, Relativity allows you to append a schema name to the ServiceName property of your Remote Service. Instead of using DataService, simply use DataService.DomainName. (Alternatively, you can also pass a Schema to LoginEx).

In Closing…

So, this has been a brief introduction to Relativity – i hope you found it useful.

We think of Relativity as a strategic piece of Data Abstract, and it will play an increasing part in what we do for DA. We have lots of things planned for the future that will make Relativity even more powerful, such as our upcoming JavaScript Business Rules Scripting based on Carlo’s RemObjects Script for .NET.

You can try out the tech preview of Relativity now, and the official release will be part of what we ship at the end of this month. I’m looking forward to your thoughts and feedback!

marc

by marc hoffman, February 3rd, 2010

Posted in .NET, Cocoa, Delphi, Linux, Mac, ROFX, Relativity, Visual Studio, Windows, Xcode | 8 Comments »