Because of the unique capability, which could not be found elsewhere: enrichment of the existing web sites and portals with a rich consumer-facing functionality provided in form of Interactive Web Services.

Symula SOA technology is based on logical meta modeling of visual objects (taken from the real world of application problems) while binding objects to Web Services - either pre-existing or generated on demand. Any traditional agile programming techniques are uncomparable with this must-have intuitive modeling and declarative programming technology. It immensely boosts achieving comprehensive software functionality will be published and consumed as Web Services.

   The idea was in the air since the late 1990s: "Instead of writing applications for a particular operating system, write them to a Web browser. Then people could work whenever and wherever they had a Web browser".
   We, in Symula consistently considered this as vital, nevertheless substantial technical hardness to achieve such Modus Operandi. Instead of going on several "quasi-browser" compromises, we concentrated our best efforts on true rich client, which has to be operable "purely from within the browser".
   Thence, today we are ready to answer upcoming market demand: synthesizing the best of a desktop environment with the best of the web. Symula value proposition is enabling technology for the interactive presentation layer above underlying Web Services.

The fundamentals of our rich client are fairly simple.

1. Though we do have well-working and matured Java-based client, it couldn't be considered as appropriate. If a technology can not serve B2C, it could not claim being web-enable. And Java-based client paradigm simply is not for consumers - to install 14 megabyte of JRE (Java Run-time) just because some web shop requires Java? Means - a consumer WILL NOT BUY in this web shop. How many Java-driven shops did you meet on the web? Right. Nobody wants to lose customers.
   
2. Regarding other installable proprietary plug-ins: if general public does not ready to install Java, it would not be realistic to hope for the readiness to install any proprietary plug-in.
   
3. Rich Internet Application (RIA) driven by Flash seems better alternative. However, Flash-driven apps are usually very "heavy". Even though Flash plug-in is widely pre-installed, application loading takes quite a long time. Besides, Flash Action Script is yet waiting for many essential controls, it is still much for a "cool" multimedia effects rather than for business application logic and workflow.

To briefly re-cap the essentials of the rich client according to our vision:

1. "runnable" on-demand from within web browser
2. 100% suitable for a home user - not just for a business user (it should be the same client for B2C and for B2B / B2P)
3. real-time responsive on every change: either in data or in user action, when yet fairly "lightweight" (all right in terms of loading time)

   Old folks are absolutely right (as usual!) - if it was a source code generated from the logical meta model, it would be indeed disservice.
    What Symula generates is not a source code, but a document, or a collection of documents. Documents, which serve actually as containers of meta data, are well readable and self described. XML is used as the standard data representation format. The component is a container for an XML document representing data for the application. Data binding is easy and standard-based: you use the datapath attribute to bind components to tags in XML documents. The syntax used in the datapath attribute to point to a specific tag or tag attribute follows the standard XPath notation. So, data binding is declarative and doesn't require script, this ensures consistency between model and implementation.

   Symula  model-driven service framework (MDSF) establishes true loosely coupled service oriented architecture (SOA). Its platform independent model (PIM) is purely logical reflecting the concept of services - the real world business process participants and activities such as customer, order, item, payment, delivery terms etc. Focusing on business requirements rather than technical infrastructure specifics, everything is done at a level of abstraction that corresponds to determinable business objects and functions, their relationships and dependencies. Since the model is purely logical, application and infrastructure are loosely coupled and the isolation of the functionality from the implementation specifics is hermetic.
   Symula insures decisive implementation transparency and decoupling. Different implementations may be switched, or an older implementation upgraded, with no impact on the consumer of the software services. Thereby Symula presents genuine service-oriented programming model separating the communications, messaging and data infrastructures from business functionality of application services.

   Prototyping enables developers to relatively quickly prove or disprove a concept. Prototyping also allows business people to adjust their project requirements and their expectations from the desired Web Services.
   However, modeling tools which provide just a "band-in-a-box" prototype is indeed much less wholesome. The question is, what can developers do further with the prototype, which was obtained from the modeling tool? Whether true development shall re-start from the beginning since the prototyping effort has firmed up the functional requirements? If the model is built as an "all or nothing", means: the prototype could not be enriched with more complex business logic than that, which can be modeled visually, such prototype would indeed be no more than a "nice toy". Rather, with Symula, developing the application can be a simple matter of finalizing an operational prototype.
   Symula provides so powerful visual data modeling capabilities for queries, updates, reporting and analysis functionality, that hardcoding for data-centric business logic is actually needed very seldom. Along this, the framework provides open API to embed process-centric business logic. Besides embedding of a hard-coded (in C, Java, C# or VB) Web Service calls into an application, Symula takes advantage of JavaScript as its native embedded scripting language. This allows to define the highly more flexible "wiring" between Web Services in a way that is interpreted and executed at runtime.
   Developers gain speed because they do not need to compile and link JavaScript; they can simply write business rules and then -execute immediately. Moreover, the large JavaScript developer community provides a solid base of shared knowledge and support (books, websites, user groups, and other resources).

Such a SOA application as you plan to develop must :

• be reliable, scalable - to support growing and changing number of clients and client requests, and robust - that is proven to work under changing loads; up to supporting millions of requests a day
• perform in a reliable and consistent manner and not consume unnecessary system resources
  

and (last but not least)

• trippingly provide users with indispensable business data via continuous event-driven workflow which is based on immediate responses, smooth transitions between states and displays based on the essential application patterns: field validation, data formatting, sorting, filtering etc.

   Lets drill into a real world example: Travelocity®, a Sabre Holdings™ company that "pioneered the online travel space and continues to be the most popular travel service on the Web, giving consumers access to hundreds of airlines, thousands of hotels and cruise, last-minute and vacations packages, and best-in-class car rental companies...".  
   Lets calculate the time which shall take to providing users with business data in the conventional form of the "data-stuffed" HTML pages which Travelocity is using. User's request for flights, for example from New York to Los Angeles, will bring 37 flights. The server side processing time shall be calculated as a cumulative times required for the following operations:

1. request for retrieving data from a data source (a database or other "backyard" data repository)
2. retrieval a static template (no matter written in JSP, ASP or PHP)
3. matching dynamic data within the template and generating resulting HTML.

   And finally, when calculating the total time taken data to come to a user, we shall count also

   4.  traffic time, while the resulting flights schedule HTML  in the case of Travelocity's "weights" about 166 KBytes.

   Comparing this with "Flights booking" task driven by Symula SOA application, the first operation - "request to a data source" - would take pretty much the same time as was taken in Travelocity. Further, since neither "retrieval a static template" nor "matching dynamic data" would be needed, the time taken for the second and the third operations is actually equal to zero.
   In contrast to Travelocity HTMLs causing repetitive back-and-forth transfer of about 166 KBytes each time when a client performs requests looking for flights, Symula RIA form is transferred only once, then  - upon each client request - the data transfer takes only 3-5 Kbytes!
   There are two ways how Travelocity (and others) can leverage scalability and performance of their mission-critical and heavy loaded SOA applications. The first (which is most common) is a escalation, means - making a system data processing faster, enabling simultaneous carrying of more concurrent connections. However, after programmers efforts of code optimizing are already exhausted, the only remaining remedy is to strengthen "heavy metal": stronger servers, broader bandwidth, more servers, more bandwidth...
   The second way to better scalability and performance is elimination, means freeing systems from unnecessary or wrong encumbrances. Instead of intolerable hardware purchases, taking application software to the next architectural level would substantially improves overall performance and scalability insuring indisputable return of investment.

   The central component of Symula One is Data Manager service. It is a place where persistent data objects "live". The objects conform to certain life cycle. They are created, retrieved, updated and destroyed.
   Before, during and after these actions the Data Manager emits events (for example: beforeUpdate, insteadOfUpdate, afterUpdate). These events allow application developer to customize the behavior of the objects. This task can be accomplished by applying JavaScript custom event handlers to the data object.
   The example bellow (script fragment) is taken from the on-line auction application. This code is associated with the application object "Bid". When new Bid object is created, all clients participating in the auction are notified:

 function afterInsert
    (connection, datasource, dataset, result){
     // notify all interested parties that
     // auction has another winner
     publishWinnerMessage( dataset );
     return result;
 }
 
 function publishWinnerMessage( dataset )
 {
     // set the command
     var msg = { $$cmd: $C.CMD_WINNERS_UPDATE};
     
     // fill the message with data
     var keys = dataset.keys();
 
     while (keys.hasNextElement()) {
         var key = keys.nextElement();
         var value = dataset.get(key);        
         msg[key] = value;
     } 
 
     // send the message to subscribers
     publishMessage(msg);
 }

Symula ONE is the tool of choice to develop custom Web Services - in particular, consumer oriented. It allows to model what context sensitive data sets and operations available on them should be exposed via Web Services.
   Symula ONE allows to define business rules which express the behavioral aspects, such as validations, conditional data processing, complex calculations, notifications. Based on modeled business scenario, it generates WSDL definitions (including XML schemas of the documents to be transmitted), then - just created Web Services can be instantly deployed and invoked immediately.
Now lets imagine the following  business scenario.
   The "Musicians Paradise" shop is a conventional store selling musical instruments. They also have a Web Site hosting standard  Web catalog, allowing consumers to place orders. Recognizing the limitations of their currently exploited web site, the management team decided:

1. To establish affiliation program to enabling partners orders placement from within their web sites via Web Services
2. To introduce on-line auctions creating more attractive channel to sell the gear.

   A system architect, Toni Smartini, was invited to design a solution while the company's PR writer, Johnnie Hardworker, was instructed to write and publish appropriate announce about on the  web site.
   Setting-up Symula ONE framework, Toni invoked database investigator and built the object model. Based on that model he visually combined logical views consisting of the business objects such as: Order, Item, Customer, Payment Type, Payment Details, Shipping Terms and Billing Address.
   Meantime, Johnnie launched his favorite HTML content editor starting to prepare the press release.
   Using Symula ONE WS-Factory Toni generated a custom Web Service - including creation of mate data describing data set, WSDL definition of the service, and XML schema of the documents to be accepted and sent in return by the service. This way he allowed affiliation partners to arrange on-line orders placement from within several partners' web sites. The next step was to add some validations to the order placement process, like customer credit cards checks, price validation, and inventory checks. With a couple of mouse clicks the Web Service just created was deployed. The architect then prepared some test cases and run them through the web service -  all seemed working fine.
    For the on-line auctions Toni prepared some more on-line "views" for services enabling bidding on specific items. Once again, he generated the web services, and visualized them with the help of Symula ONE Factory of forms which were seemed like these.

    The last thing to mention: all that process took about five working hours. Toni went satisfied for his lunch, while Johnnie right finished running a spell checker over his almost completed article text. He was still towards formatting and applying company's corporate look & feel cascaded style sheets...

Symula ONE allows host sites to embrace functionality of the services without installing any new software. Consumers remains in the host site when using the enriched functionality, which is integrated dynamically.
Actually, nothing should be changed at the existing web site - just to add the following lines anywhere in your HTML/JSP/PHP/ASP/ASP.NET pages to activate the RIA client:

 <script type="text/javascript" 
         src="/symula/all206oc.js"></script>
 <noscript>
 Your warning message here...
 </noscript>
 
 <script type="text/javascript">
 var startFormName = 
  "xml://APPLICATIONS/BIDDING/XmlForms/AUCTION_BANNER.xml";
 var configurationURI = "/symula/symula.properties.jsp";
 
 function runStartupForm() {
   configure(configurationURI);
   openProgram(startFormName );
 }
 
 // register window.onload event handler
 core.addEventListener(window, "load", runStartupForm);
 </script>

Yes, Symula Server can serve multiple virtual hosts. All customers are assigned unique identifiers (CustomerID). The customers should add the following lines anywhere in their HTML/JSP/PHP/ASP/ASP.NET pages:

 <script type="text/javascript"
      src="http://symula.yourdomain.com/symula/all206oc.js">
   </script>
 <noscript>
 Your warning message here...
 </noscript>
 
 <script type="text/javascript">
 var startFormName =
  "xml://APPLICATIONS/BIDDING/XmlForms/AUCTION_BANNER.xml";
 var configurationURI = 
    "http://symula.yourdomain.com/symula/props.jsp"+
    "?CID=${ClientId}";
 
 function runStartupForm() {
   configure(configurationURI);
   openProgram(startFormName );
 }
 
 // register window.onload event handler
 core.addEventListener(window, "load", runStartupForm);
 </script>

   With Symula ONE, it becomes possible to offer your products and services to consumers via right sites with massive visitors traffic. As it was already discussed, technically to incorporate your auctions is now so easy like to put there your ads. But now you establish a complete business process  - your really selling web counter - everywhere you merely could put a banner.