Usage scenarios
Sample scenario #1: automating repetitive tasks in a data
analysis application
The situation:
You are the developer of a rich-client business
application for analyzing sales data.
Your customer is a company that has installed your
application on the computer of several employees.
Those employees often do repetitive tasks such as
filtering the sales data, formatting it, and exporting it to
multiple formats.
The need:
Your customer would like to allow its employees to
automate those repetitive tasks.
Our proposed solution:
You embed Userware API into your software application so
that the employees of your customer can effortlessly write
macros and automate repetitive tasks concerning your
application.
Comparison to alternative solutions:
The main alternative solutions in this scenario are:
- Get a license for VSTA (Visual Studio Tools for
Applications).
Drawback: your customers are required
to install and use Visual Studio in order to write
macros for your application. This is too complicated and
time-consuming for the average end-user who simply wants
to automate his tasks.
- Get a license for embedding VBA into your
application.
Drawback: this solution is no longer
available because Microsoft no longer offers VBA for
licensing.
- Host VBScript.
Drawback: the VBScript technology is
old and extremely limited compared to .NET, both in
terms of features and performance (no graphical
interface, obsolete data types, etc.). Furthermore,
VBScript offers no built-in ways to easily share macros
among employees.
- Create your own scripting language.
Drawback: doing so requires a lot of
work. Furthermore, .NET is a widespread programming
language so your customers can easily find help if they
want to do something that is not documented.
Sample scenario #2: doing custom
developments to respond to business needs
The situation:
You are the developer of a rich-client application for
managing the supply chain.
Your customer is a company that often needs to order
materials from its suppliers. To do so, it sends electronic
orders to its suppliers. However, each supplier has its own
way to make orders: custom web services, XML documents,
etc..
Furthermore, your customer needs to keep a database with
all the materials offered by all its suppliers. To build
that database, your customer needs to retrieve the product
catalog from each supplier and merge it with the database.
However, each supplier has a different catalog with
different formatting and different tax calculation rules.
The need:
Your customer would like to be able to quickly add new
suppliers. This means being able to quickly:
- develop a component for automatically sending orders
to the new supplier that comply with the specifications
of the order system of that supplier,
- develop a component for retrieving the catalog of
the new supplier and for merging it with the local
database mentioned earlier.
Our proposed solution:
You embed Userware API into your software application so
that your customer can quickly adapt your application to fit
the needs of its business.
Some of the main benefits include:
- Develop directly from the application (like VBA)
- Test without restarting the application
- Instantly deploy throughout the company without
requiring end-users to restart the application
Comparison to alternative solutions:
The most common way to address this scenario is to use a
tool such as Visual Studio.
However, using Visual Studio has the following
drawbacks:
- the development cycle is much longer:
in fact, the developer needs to write code in Visual
Studio and relaunch the application every time that he
or she wants to test the compiled component.
If the application needs to connect to
a database or to a web service, constantly
restarting the application is particularly
time-consuming.
Userware API allows testing the component without
restarting the application.
- the deployment is more complicated:
in fact, the developer needs to create installation
packages, and the end-user needs to stop his application
in order to replace the old version of the component
with the newer one.
This is not required with Userware API. Deployment is
automated and does not require restarting.
- setting up the development environment takes longer:
in fact, one needs to install the development tools, set
up access to the source control, install the
prerequisites (usually in the form of external libraries
used by the application and its components), etc.
None of these steps are required with Userware API
because, after the server has been configured, accessing
the development environment is instantaneous from any
workstation where the application is installed.