About the components
The PureWeb APIs enable you to develop powerful, resource-intensive visualization software that require server-grade hardware, while ensuring that end users can enjoy this experience on their personal devices.
A deployed solution has three main components:
- the application that you want to make available remotely (the "service"),
- the front-end interface that resides on end-user devices (the "client").
a web server allowing the service and the client to communicate remotely with each other (the "PureWeb server").
This section begins with a brief discussion about what's involved in implementing the service and the client, and describes the role of the PureWeb server.
The service is the component that handles all the heavy computation, data processing and image rendering.
You can use PureWeb to modernize existing software, or to develop a new solution from the ground up. If you have existing software, then this will be your PureWeb service and you're all set! Jump ahead to the section about the client.
If, on the other hand, you are using PureWeb to build something new, here are a few things to keep in mind as you begin your PureWeb journey:
- The first step is to lay the foundation for the service. All you need to get started is some basic logic. For example, if you want to display 2D or 3D graphics on the remote clients, you could begin by writing the image rendering code for a single graphic.
- You develop this logic as you would any other software, using one of the supported programming languages (C++, .Net or Java) and the tools that you are already familiar with, such as Microsoft Visual Studio or Eclipse. You don't need the PureWeb APIs for this step.
- It's not necessary to spend a lot of time on the service before you can start integrating the PureWeb APIs. Like any other development project, the process is iterative. For instance, once your service can render an image, you can start on the client and use the APIs to display the rendered graphic, then return to the service to add new functionality, go back to the client to create an interface element that accesses this feature, and so on.
In a deployed solution, the service will run on server-grade hardware as powerful as necessary, on-premise or in the cloud.
The user interface for your service application will be the front-end client on users' devices, as described next.
The client is a thin interface that resides on personal devices such as phones, tablets and laptops. Regardless of whether you are using PureWeb with existing software or plan to develop the core logic as you go, you will need to create a client for your users.
The client is very lightweight. You are essentially just designing the look and feel of the user interface elements, and so creating it is not as onerous as you might think. And since the service handles all the image rendering and keeps the source data in its original location, your clients can be used to securely interact with hardware-intensive applications, even across low-bandwidth networks.
All you need to get started on the client really is just a stub, maybe one or two buttons so that you have something to connect to the service. You don't need to spend a lot of time on the client before you can start integrating the PureWeb APIs. Like any other development project, creating the client will be an iterative process.
You design the client the same way you do the service: using the native building blocks of the platform that you are targeting (HTML5, or a native iOS or Android app), using standard tools such as Xcode for iOS or your favorite text editor for HTML5. This gives you complete control and flexibility on the design, and your end users will appreciate the usability of working with an interface that feels natural to them.
The client does not need to expose all the functionality of the service application; you can develop it so that it includes only the features that your users actually need when they are on the go.
It's also important to note that you can create multiple clients for the same service. This allows you to support a broader range of platforms (a browser-based HTML5 client and a native iOS app, for instance) and different workflows (casual vs expert users for example).
The PureWeb server is the solution's middle tier. It is responsible for managing sessions and coordinating connections. It also provides an interface for system administration and configuration. You can use it to set up authentication and security, view logs, and change default values for many properties such as timeouts, ports and log retention period.
The server is implemented as a Java Spring Web Application, using the Apache Tomcat 7.0 web container (tomcat.apache.org).
To allow your application to communicate with the PureWeb server, you write service-side and client-side code (one or two lines) to establish the initial connection, then you configure the PureWeb server to run your application as a plug-in. This is described in the First steps topic.
The next section, About the APIs, provides a high-level overview of how you add PureWeb into the mix, to enable the service and the client to interact remotely with each other.