The OpenSplice Blog

News for the Santa Clara (CA) OMG Meeting

2010-12-07T13:40:00.000-08:00

This OMG meeting we should finally be voting on the the C++ and Java API an also run an interoperability demo with a few other DDS vendors. In a few minutes I'll be presenting the slides on the latest version of the submission and then hopefully move to discussing the submission with the Architectural Board and eventually vote for adoption on Thursday -- I'll post any relevant update.

During this meeting we'll also be running another interoperability demo. We did some some testing last night and everything is working just fine. The demo is planned for Wednesday the 8th of December during the DDS PSIG meeting.

A+

My take on the new DDS C++ PSM

2010-08-10T02:09:00.001-07:00

It has been a while since we've started the standardization of a new C++ API for DDS (namely the ISO C++ PSM for DDS). Now we are getting close, on principle the standard should be voted during the September meeting, yet there are still a few points to resolve among submitters. If I look back at the IDL-derived C++ API and what will be the new, SimD-inspired, API I believe the result is great. In this and subsequent post, I'll share with you an outlook of what our current proposal for the final C++ API standard looks like. Your comments will be useful as they might be able to still influence how the API will look like.

To start with, let's take a look at a simple writer:

int main(int, char**) {
int domainId = 0;

try {
  // Create Domain + Topic + Pub
  dds::domain::DomainParticipant dp(domainID);
  dds::topic::Topic<MiB> topic("MessageInABottle", dp);
  dds::pub::Publisher pub(dp);

  // Create DataWriter
  dds::pub::DataWriter<MiB> dw(pub);

  // Write Sample
  MiB sample(1, "Hello");

  // You can write like this...
  dw.write(sample);

  // ...and like this (and there is more...)
  dw << sample;
}
catch (const dds::core::Exception& e) {
  std::cout << e << std::endl;
}

return 0;
}

Now we can look at a more "complex" example in which we set custom QoS on the Publisher and DataWriter:

int main(int, char**) {
 int domainId = 0;

 try {

   // Create Domain + Topic + Pub
   dds::domain::DomainParticipant dp(domainID);

   dds::topic::Topic<MiB> topic("MessageInABottle", dp);

   // Publisher
   dds::qos::PublisherQos pubQos;
   dds::qos::Partition partition("TheCoolAPI");
   pubQos << partition;

   dds::pub::Publisher pub(pubQos, dp);

   // Subscriber
   dds::qos::SubscriberQos subQos;
   subQos << partition;
   dds::sub::Subscriber sub(subQos, dp);

   dds::qos::DataWriterQos dwQos;
   dwQos << Reliable() << TransientDurability();

   dds::pub::DataWriter<MiB> dw(topic, dwQos, pub);
   MiB mib;
   mib.msg() = "ciao";

   // You can write like this...
   dw.write(mib);

   // ...and like this (and there is more...)
   dw << mib;

 }
 catch (const dds::core::Exception& e) {
   std::cout << e << std::endl;
 }

 return 0;
}

That's it for this post. I'll let you know digest the code and perhaps give some comments on how you like it. Next will be a post showing the reader side.

A+

SimD v0.8 now available

2010-06-18T07:49:00.001-07:00

I've released SimD v0.8 a few minutes ago. This new version includes a few extensions to the read API, now supporting iterators as well as std::vector and a refactored signal/slot API. Linux and Windows versions are available for download

Designing Distributed Systems with SCALA and DDS

2010-06-15T12:34:00.000-07:00

In the past few months I've been experimenting with Scala a relatively new programming language targeting the JVM (and .NET). Differently from some of the latest programming languages targeting the JVM such as Groovy or Clojure, Scala is statically typed and features a very powerful type system with sophisticated type inference -- meaning that the compiler will infer types for you whenever possible thus limiting the need for typing them explicitly.

Scala provides a well balanced blend of imperative and functional programming mechanism which, I have to admit, seem to always give you the right tool to address a programming challenge in the most elegant manner.

Another very interesting aspect of the language, especially for those that have to deal with large systems, is that it has been designed ground up to be scalable, meaning that Scala supports equally well the development of small applications as well as big systems and system of systems.

Last but not the least, Scala is fully interoperable with Java, meaning that you can reuse Java Classes in Scala applications and viceversa. In summary, if you are a Java programmer, I think, you should definitively take a look at Scala and seriously consider moving to it.

Performance... Right, you might be wondering about Scala's overhead. In my experience in using Scala for distributed applications I've not seen any difference w.r.t. Java. This is consistent with what reported by other Scala users -- Scala matches Java in terms of performance.

Assuming that now you are agreeing that Scala is a great language for developing your next application, and be aware that companies like Twitter, SIEMENS, SONY and many others have taken that route, let's explore why Scala and DDS is a great combination.

Building Distributed Systems in Scala with OpenSplice DDS

View more presentations from Angelo Corsaro.

There are several reasons why the combination of Scala and DDS is very natural, so let's explore two of those. First, DDS, differently from many other Pub/Sub technologies allows you to preserve the user-defined-types end-to-end. What do I mean with this? If you think about an application in abstract terms, you can think of it as a computation applying operators (or operations) on types. Some of these types might be native to your programming environment, such as Int, String, List, etc., other might be user-defined such as FinancialInstrument, RadarTrack, FlightDataPlan, etc. Programming languages usually give you abstraction to build user defined types and operate over them. DDS, provides you abstractions to distributed user defined types, without loosing type information, across applications in a distributed system. This means, that your application does not have to deal problem of representing user-defined-types into some other type that can be handled by the distribution technology (e.g. a specific JMS Message, or a sequence of bytes) . Applications using DDS always and only deal with user-defined-types. This has some important implications in terms of simplicity, code clarity, efficiency and safety.

As a result when combining Scala and DDS you have a statically typed programming language and distributed middleware that allow you to preserve your type invariants end-to-end.

At this point some people will raise the issue that types get you into troubles when you are trying to extend your system. This is true for inflexible type systems, however both Scala and DDS (with the newly adopted specification on Extensible and Dynamic Topic Types) provide you with structural type system that while preserving all the good properties of a sound type system nicely support type extensibility and evolution.

The second reason why I think that Scala and DDS are a very good combination is that it provides an actor model for building concurrent and distributed applications. The actor model matches very nicely with DDS and provides you an elegant and effective abstraction for building distributed systems.

There are several other reasons that I could list for choosing Scala and DDS for distributed applications. One of the other may is the native support for dependency injection supported by Scala, the other will probably be explored in some future post.

A+

Living in a world of self-proclaimed world leaders

2010-06-10T12:37:00.000-07:00

It's some time I don't post on this blog, not so much because I've not had much to say. Anyway, here we are, although it is 21h38 Paris time, I am just done with my second Webcast on "Building Distributed Systems in Scala with OpenSplice DDS" (see http://bit.ly/9A8ew1) and I've not yet had dinner -- I just saw something that is way to funny and could not resist sharing my thoughts.

Well, don't know how you take "self-proclamation" but personally I find it funny not to say a bit ridiculous. People or companies coming up and saying "I am the world best whatever", or "I am the world leader in whatever" just sounds funny to me. Maybe this is cultural, as in my country we believe that it is up to the others to establish if you are the best. As such, the only one who takes the liberty of "self-proclamating" himself (or I should say itself) as the best is Silvio Berlusconi... He, believe it or not, "self-proclaimed" himself the best Prime Minister of the Italian history... I hope that Alcide De Gasperi did not hear him :-)

Anyway, I saw that the habit and attitude toward of "self-proclamation" is spreading (perhaps it is infectious) and after becoming insensitive to those who proclaim themselves as "DDS World Leader" now I saw those who just decided to self-graduate into "Small Footprint DDS world leader".

Don't worry, I am not envy of all these world leaders that seem to appear like mushrooms, and don't worry we won't self-proclaim ourself into anything. Yet, I wonder how these people score in Geography. I start to suspect that their view of the world might be slightly skewed or constrained to a small fraction for the entire globe.

A+!

OpenSpice DDS v5.2

2010-04-28T23:27:00.001-07:00

Click to Play

OpenSplice DDS v5.1 introduces a new set of features that further its applicability to Ultra-Large Scales Systems, Dependable Systems and Resource Constrained Systems. This presentation provides an overview of the new key features included in v5.1

DDS Interoperability Demonstrated

2009-07-15T04:45:00.001-07:00

Yesterday afternoon, precisely at 15.30 US ET time the interoperability between different DDS vendors was once again demonstrated. Thanks to a very successful demonstration, OpenSplice DDS is now the first and only Open Source DDS implementation providing interoperability!

A set of slides describing the scenarios that were demonstrated is available at http://bit.ly/OuNag .

Ciao!

The DDS Interoperability Demo - Reloaded

2009-07-15T04:42:00.000-07:00

In a few hours we are going to demonstrate interoperability between different DDS implementations, namely PrismTech's OpenSplice DDS, RTI's DDS, and TwinOaks CoreDX.

This time I'll be demonstrating the interoperability of OpenSplice DDS Community Edition, namely the Open Source version of OpenSplice DDS.

More later.

Ciao!

The DDS Interoperability Demo - Reloaded

2009-07-14T07:17:00.000-07:00

In a few hours we are going to demonstrate interoperability between different DDS implementations, namely PrismTech's OpenSplice DDS, RTI's DDS, and TwinOaks CoreDX.

This time I'll be demonstrating the interoperability of OpenSplice DDS Community Edition, namely the Open Source version of OpenSplice DDS.

More later.

Ciao!

The OMG Real-Time Workshop

2009-07-12T07:57:00.000-07:00

Following a tradition established over the course of many years, the OMG Real-Time Workshop goes live again tomorrow. The 2009 edition (see http://bit.ly/vcGCd), is strongly centered around DDS, showing how this technology is really picking and quickly walking the path toward becoming the next big thing.

The first day of the Workshop, Monday the 13th, will be full dedicated to Tutorial and will features:

OMG DDS Tutorial (full day)
UML Profile for DDS Tutorial (Half Day)
UML profile for Modeling and Analysis of Real-time and Embedded systems (Half Day)

I'll be giving the DDS Tutorial along with Gerardo Pardo and the UML for DDS Tutorial with Sam Mancarella.

The second and third day of the Workshop, namely Tue 14th and Wed 15th, will be dedicated to paper presentations and the DDS Interoperability Demonstration.

If you want to see the full list of papers check out http://bit.ly/vcGCd I'll try to write up the most interesting things that will be happening.

Ciao!

Back from India

2009-06-22T09:26:00.001-07:00

I spent the whole past week in India across Delhi and Banagalore giving several OpenSplice DDS presentations. I've always been extremely fascinated by India, when I was a kid it was for me the land of mystery, the land in which people could do amazing things; while growing as a teenager I was fascinated by philosophy at the foundation of Hinduism and Buddhism--yet, for one reason or another, I had not yet been in India. This first visit in India was fantastic from all perspective. From a technical perspective OpenSplice DDS presentations were very well attended by an extremely bright audience, which was also one of the most lively and inquisitive I've encountered in years. From a human perspective the experience was very enriching as I had a chance to live and breath the peacefulness and loyalty irradiating from most of the people I met. Thus, once again I'd like to thank all the people that took the time to come and listen to my presentations, that showed me around, and helped me in understanding more about this very fascinating country.

Namaskar,

@ngelo

OpenSplice DDS

2009-05-14T02:58:00.001-07:00

Click to Play

OpenSplice DDS Open Source Teaser.

OpenSplice DDS v4.1 Open Source - What's coming up?

2009-05-12T09:58:00.000-07:00

Although I am sure that the Open Source release of OpenSplice DDS was noticed by most of you I am equally sure that many of you are wondering what is going to come next. I've discussed the content of the upcoming "source-drops" in my latest webcast, but perhaps it is worth sharing it on the blog as well.

Before going into the details of what will be available next and when it will be available, it might be worth to spend a few words on the version numbering scheme we are using for the OpenSplice DDS Community edition. The version numbering will be pretty straightforward and will be made of MAJOR.MINOR.YYMMDD where MAJOR is the major version, MINOR (always>0) is the minor version and YYMMDD is the date for the beta incremental release.

Thus as an example the current version is v4.1 is the first v4 major release (notice that MINOR is never 0). The next release will be as follows:

v4.1.090526

DDSI/RTPS [beta]
Visual Configuration Tool
mmstat (shared memory tool)
Support for Windows
Support for Visual Studio Express 2005

v4.1.090626

Unicast Communication for OpenSplice DDS Native Networking
C# API [beta]
Linux 64bit support

v4.1.09.07.31

C# API

Thus as you can see there are a lot of goodies coming up in the next few months.

Cheers,

@ngelo

The UML Profile for DDS goes Live!

2009-03-19T15:27:00.001-07:00

This week, after circa 6 month from when the OMG recommended the UML Profile for DDS (UML4DDS), Sparx has made available a full implementation of this profile. This is a great news for all DDS users; now they have access to a great and affordable tool which will allow them to completely model DDS applications in UML. What I believe users will find fantastic is how the UML4DDS and the Sparx EA Tool make it very natural to work with the DLRL layer of DDS (see previous posts on DLRL and Hibernate). Many users, by seeing the UML4DDS will eventually realize that DLRL is the most natural way of using DDS from Object Oriented Languages, and certainly the most natural way of modeling DDS applications in UML.

DDS Interoperability Demo at the DC OMG Meeting

2009-03-19T02:31:00.000-07:00

The next 25th of March, at the Washington DC OMG Meeting, PrismTech, RTI, and TwinOaks, will demonstrate on-the-wire interoperability between their DDS implementations. This is an important step toward proving that OMG DDS compliant implementations can interoperate and yet exchange real-time data without loosing performance or QoS and without introducing single point of failures.
This capability is quite distinct especially when compared with other technologies such as JMS for which on-the-wire interoperability is not an option and for which interoperability has to be achieved by means of bridges that along with introducing performance overhead also introduce single point of failures--often not acceptable in business- and mission-critical applications.

BTW, at the upcoming OMG Meeting there will be also some interesting discussions around the C++ PSM for DDS and the Extensible and Dynamic Topic Types, thus one reason more to be there.

Cheers,
@ngelo

The Standard C++ PSM for DDS on SourceForge

2009-02-17T17:26:00.000-08:00

Hello,

I've recently started CZed a SourceForge project that will provide the reference Standard C++ PSM for DDS. The project page is available here, while the Subversion repository can be navigated from here. The current version of the API is not complete but the bulk of it is in place.

The main idea behind CZed is to have a working C++ PSM before the actual recommendation of the standard takes place. This will ensure that as many people as possible will have experimented the API and feed back comments thus increasing the likelihood that the API is very successful. Thus, take a look at the API and drop me questions, comments, or ideas.

Cheers,
@ngelo

Choosing OpenSplice DDS

2009-02-05T13:15:00.000-08:00

Yesterday I gave a webcast, now available here, which first goes through the strategic, technical, and financial reasons for moving to OpenSplice DDS, and then shows some migration use cases as well as migration tactics.
Strategic vs Tactical Perspective
One of the key point I made in the first part of the webcast was trying to ensure that people look at Open Source in from a strategic as opposed to tactical perspective. In essence, now that OpenSplice DDS is Open Source many people will just see it as a cost effective manner of procuring the best DDS implementation available on the market. This perspective, although correct, is tactical and misses the strategic implication of Open Source, which if properly exploited are those that will bring the highest benefits.

An example, Open Source is a key element in enabling and catalyzing lead-user innovation; some visionary companies in domains characterized by lead-users innovations, such as Aerospace and Defense, have already realized and mastered the strategic relevance of Open Source. Other company are starting to understand its potential and are quickly embracing the new way.

Embracing OpenSplice DDS
The second part of the webcast, focused on showing some use cases motivating a move to OpenSplice DDS. For instance, I showed how OpenSplice DDS can be used to scale-out a data tier by either completely replacing a DBMS, or by offloading or fully federating the DBMS. I also showed how OpenSplice DDS can be used to replace another DDS implementation of yet another pub/sub technology.

From DDS-XYZ to OpenSplice DDS
Finally, one of the topic covered on the webcast was how to actually port applications developed on a DDS-XYZ to OpenSplice DDS. As explained in the webcast this is typically just an exercise of finding and removing calls to proprietary API that might be required by DDS-XYZ. Indeed, as shown by the example below, OpenSplice DDS does not require the use of any custom API for configuring transport or anything else. Configuration completely taken care by external tools. Below is an example that shows the code necessary to write a publisher for a TempSensor Topic.

// -- IDL --
module demo {
module tc {

struct TempSensor {
long tID;
float temp;
float humidity;
};
#pragma keylist TempSensor tID
};
};

// -- Publisher Implementation --

package demo.tc;

import DDS.*;

public class TempSensorApp {

static final String PARTITION = "SensorData";

public static void main(String[] args) {

if (args.length <> ");
System.exit(-1);
}

int tid = Integer.parseInt(args[0]);
int samples = Integer.parseInt(args[1]);

DomainParticipantFactory dpf =
DomainParticipantFactory.get_instance();

/**
* Create Domain Participant
**/
DomainParticipant part =
dpf.create_participant(null,
PARTICIPANT_QOS_DEFAULT.value,
null,
ANY_STATUS.value);

/**
* Regiter Type Support for TempSensor
**/
TempSensorTypeSupport tempSensorTS = new TempSensorTypeSupport();
String tempSensorTN = tempSensorTS.get_type_name();
tempSensorTS.register_type(part, tempSensorTN);

/**
* Create the TempSensor Topic
**/
TopicQosHolder topicQoS = new TopicQosHolder();
part.get_default_topic_qos(topicQoS);
Topic tempSensorTopic = part.create_topic("Demo_TempSensor",
tempSensorTN,
topicQoS.value,
null,
ANY_STATUS.value);

/**
* Create a Publisher
**/
PublisherQosHolder pubQoS = new PublisherQosHolder();
part.get_default_publisher_qos(pubQoS);
pubQoS.value.partition.name = new String[1];
pubQoS.value.partition.name[0] = PARTITION;

Publisher pub =
part.create_publisher(pubQoS.value, null, ANY_STATUS.value);

/**
* Create a Writer
**/
DataWriter writer =
pub.create_datawriter(tempSensorTopic,
DATAWRITER_QOS_USE_TOPIC_QOS.value,
null,
ANY_STATUS.value);

TempSensorDataWriter tempWriter =
TempSensorDataWriterHelper.narrow(writer);

/**
* Register Instance
**/
TempSensor temp = new TempSensor();
temp.tID = tid;

long handle = tempWriter.register_instance(temp);

/**
* Write Sample
**/
temp.temp = 12.1F;
temp.humidity = 0.45F;

for (int i = 0; i <> Temperature = " + temp.temp
+ " - Humidity = " + temp.humidity);

try {
Thread.sleep(1000);
}
catch (InterruptedException e) { }
temp.temp += 0.1;
temp.humidity += 0.01;
}

/**
* Cleanup
**/
tempWriter.dispose(temp, handle);
tempWriter.unregister_instance(temp, handle);

pub.delete_datawriter(tempWriter);

part.delete_publisher(pub);

dpf.delete_participant(part);
}
}

Sharing Slides

2009-02-02T12:30:00.000-08:00

Hello All,

I've just signed up with slideshare.com and from now on most of the slides on DDS or OpenSplice DDS will be available here . For the time being I've uploaded the presentation that explains the vision behind the Open Source launch of OpenSplice DDS, and which also covers the new product structure.

Below is also a neat widget that can be used to check out the various slides I'll be uploading.

Ciao,
@ngelo

| Get your Presentation Pack

OpenSplice DDS goes Open Source

2009-01-13T13:23:00.000-08:00

PrismTech announced today the release of OpenSplice DDS as Open Source Software. OpenSplice DDS is a full implementation of the OMG DDS Standard, providing support for both the DCPS and DLRL layers. PrismTech will be sharing his visions and answering questions during an online webcast organized for the 14th of January 2009. Registration for the webcast is free and available here.

OpenSplice DDS Podcasts on YouTube

2008-10-22T15:32:00.000-07:00

I've started to post a series of podcast covering OpenSplice DDS on YouTube. The Porcast Channel is http://www.youtube.com/user/OpenSpliceDDS, here I'll post at least one recording per week covering one specific aspect of OpenSplice DDS. There are a few Podcast already avaiable, and why not starting with the first one?

Cheers,
@ngelo

Extensible and Dynamic Topic Types for DDS

2008-05-30T16:17:00.000-07:00

here The OMG DDS standard has been designed to effectively support statically defined data models. This assumption ensures that topics data types are known at compile time, that every member of the DDS global data space agrees precisely on the same topic-type association, and that extensions are captured by either DLRL classes inheritance, or by DCPS IS-A relations. Although this model allows for good properties such as static type checking and very efficient, low-overhead, implementation of the standard it also suffers a few drawbacks. Namely, it is hard to cope with data models evolving over time unless all the elements of the system are upgraded consistently. It is also complex to deal with dynamically defined topics, although in some case this is achievable by means of proprietary APIs.

These limitation are currently being addressed in the scope of the OMG RFP mars/2008-05-03, which is looking to extend the DDS standard with the following features:

• Extensible Topic Type System. This will define an abstract type system for DDS Topics Type, that shall provide built-in support for extensibility, as well as support for complex types such as object maps, and sparse data.

• Dynamic DDS API. A Dynamic DDS API, to be used as an alternative to existing API, that shall allow to define, read, take, access, and write, Topics whose types are not know at compile time.

• Data Encapsulation Format. New data encapsulation format, or extend existing, so to efficiently support extensible and dynamic types.

The RFP is available here.

Cheers,

@angelo

Webcasts: System Wide Interoperability for Next-Generation Air Navigation Systems - May 21st, 2008

2008-05-20T06:37:00.000-07:00

Air Navigation Systems are increasingly being challenged by significant increases in traffic volume, which are projected to double by 2025. These systems also demand seamless information sharing to enable new operational requirements, such as ubiquitous and real-time access to flight data information and improved gate-to-gate services. Several programs in Europe and USA, such as the CoFlight European Flight Data Processor (eFDP), ICOG, SWIM, SESAR, and NEXT-GEN, are investigating how these challenges can be addressed from a technological and operational perspective. The OMG Data Distribution Service (DDS)—already embraced by programs such as CoFlight and ICOG-2—is emerging as a key standard technology for enabling system-wide interoperability since it can ensure the performance, availability, and determinism required by Air Navigation Systems. The webcasts will (1) explain what is motivating the swift adoption of DDS in next-generation Air Navigation Systems and (2) provide concrete examples of using OpenSplice DDS to solve challenging Air Navigation Scenarios.

I am running this webcast tomorrow, hope to see you there!

Cheers,

@ngelo

What is DDS?

2008-05-12T03:01:00.000-07:00

In short, the Data-Distribution Service for Real-Time Systems (DDS), is QoS-enabled data-centric (topic-based) publish subscribe middleware. In order to understand what this means, let's try to explain every relevant bit of the above definition

Publish/Subscribe (P/S): P/S is a communication paradigm under which different parties, namely publishers and subscribers, can asynchronously and anonymously exchange information based on their interest. Under this communication paradigm Publishers produce data, while Subscribers consume the portion of data they are interested in. The interest is usually captured under the form of a subscription, and depending on how subscriptions are expressed we usually distinguish between Topic-based P/S, Content-based P/S, Subject-based P/S, etc. In Topic-based P/S, subscription are expressed by means of topics, which usually are identified by means of unique names and an associated (dynamic) type. On the other hand, in Content-based P/S subscriptions are defined by a matching-expression which identifies the property of produced data that are of interest for a subscriber.

Data-Centric: DDS is Data-Centric in the sense that it makes it possible to organize its Topics in a relational model, thus providing support for identity and relations. As such, for each Topic can be defined one or more primary keys, and one or more foreign keys representing respectively the instance and the relationships with other Topics. In a sense, a DDS Topic can be thought as specifying a database table, where the Topic key(s) uniquely identify a row, and the topic attribute define the table columns. In DDS jargon a database row is called a Topic Instance, while the stream of update to a specific Topic Instance are called Topic Sample.

In DDS subscription are referred to a Topic, to a content-filtered Topic or a MultiTopic. A Topic subscription is pretty straightforward as express the interest to receive all the instance for a specific topic. A content-based Topic subscription allows to subscribe to a Topic but to receive only the samples the match the provided SQL92 filter. Finally, a multi-topic subscription provides a mean to subscribe to the JOIN of two or more Topics.

Since DDS supports relational data-modeling, it should not come at surprise that it also provides an Object/Relational Mapping (ORM), which in this context is called Data Local Reconstruction Layer(DLRL). But to avoid overloading you with information I'll explore this in another post, for the time being it is good to know that such a feature is available!

QoS-Enabled: DDS provides an extremely rich set of Quality of Service Policies that allow to control the most important non-functional properties of the Topics, as well as of the entities that generate and consume them. As an example, it is possible to control the timeliness properties, such as, deadline, time-based-filter, and latency-budget, it is possible to control the importance of data, is durability, etc.

I believe this is enough information for the time being. I'll provide more detailed explanation in later posts, but this should (hopefully) give a first idea of what DDS is capable of. Before I forget, some useful resources on the DDS can be found at:

- DDS Standard Portal
- DDS Forum

There are also a few intro paper that have been written by various folks, one of the latest it this.

@ngelo

Why a DDS Blog?

2008-05-12T02:54:00.000-07:00

It is now a few months that I was feeling the urge to start a blog on this extra cool new standard called "The Real-Time Data Distributions Service for Real-Time Systems", or DDS for short. I've been involved with DDS for the past few years, have had a chance to exploit it in rather challenging applications. There are a few goal I had in mind when creating this blog, and these were roughly (1) share what I've learned in applying DDS in mission- and business-critical distributes systems, (2) help in understanding what lays under the DDS iceberg tip, and (3) give heads-up on what's coming-up in the next standard revisions.

@ngelo