1 2 3 Previous Next

Developer Community

243 posts

Previous blogs

Widget Extensions Introduction

Widget Extensions Click Event


This blog we will take a quick look at making a new Date Picker Widget


I'm not going to worry about styles just the basics of getting the widget defined and able to place in the Composer canvas.

As in previous blogs we have to decide on a name, we will use DatePicker

Because we don't want to write all of the logic that has been written many times will use a jquery datepicker https://jqueryui.com/datepicker/ which has a lot options.


The simple syntax is $(#myDate).datepicker() which will do most of the work.

The $ is the jquery reference an the  #myDate is the id where the datapicker will render and the datepicker is the function worker.


Before we get into the renderHtml I realize I need to quickly talk about the widgetProperties function in the ide.js. This where we set what properties can be defined and whether they are dynamic. For example the thought it useful to have a Title , Date and some simple css style configurable options. Inside the widgetProprties we have properties section (json) and the basic  pattern is


  • baseType
  • defaultValue
  • isBindingTarget

Setting the isBindTarget to true allows for dynamic setting in the composer.



Below is the complete definition for the widgetProperties





Next we set up the design time (ide)  renderhtml



And finally we define the  runtime renderHtml which looks like this




Deploy it and you have a basic Data Picker.





There is more work to do on this to provide better styling but  its a start!

Put together a quick example mashup in support of a couple of analytics projects to demonstrate use of the new TWX Analytics 8.1 APIs within TWX mashup builder. The intention here is for use in POCs to provide a quick way of demonstrating customer-facing analytics outputs along with the more detailed view available in Analytics Builder.

Required pre-requisites are:

  • ThingWorx 8.1 + Analytics Extensions
  • ThingWorx Analytics Server 8.1
  • Carousel TWX UI widget (attached) imported into TWX
  • Data set(s) loaded with signals / profiles generated.


The demo can be installed by importing the attached entities file into TWX composer then launching the mashup 'EMEA.Analytics.CustomerInsightMashUp'.


A quick run through of the functionality ...


On launching the mashup, data sets and models are displayed for selection on the left hand-side.


On selecting dataset and model, signals are presented in two tabs - first an overview of all signals. The list on the left can be expanded by changing the value for 'Top <n> Contributing Features'.



On selecting a signal from the list, the 'Selected Signal Details' tab displays additional charting for value ranges, average goal etc. The number of 'bins' to display can be edited.



Similarly, profiles can be viewed from the 'Profiles' tab - each profile can be selected by dragging the upper carousel.




This is all done using the Analytics 8.1 "Things" in TWX along with an additional custom Thing with some scripted services (EMEA.Analytics.Helper).

Thanks to Arian Van Huelsen & Tanveer Saifee at PTC for their support; all comments / feedback welcome.

As many already know, ThingWorx versions 8.0+ now support both Apache Tomcat versions 8.0.44+ and versions of 8.5.13+. For this reason, many will want to consider using the latest Apache version for their ThingWorx instance, even despite the fact that the installation documentation does not seem to provide examples for the 8.5.x versions. This is because much of the configuration between the two versions remains the same.


One may question these similarities when looking at the updated documentation from Apache on configuring SSL Connector ports. It would seem like some of the more traditional elements are now unusable, since they are marked for deprecation (including keystoreFile, keystorePass, and clientAuth). However, for now, these elements are still usable because Tomcat will convert whatever is provided in the Connector tag to the brand new SSLHostConfig tag (used primarily by Tomcat going forward). Apache has noted that these configuration options will continue to be usable throughout the next few major versions of Tomcat. PTC is already working on documentation which helps utilize the new configuration options in the future, but it won't be available for some time. In the meantime, for step-by-step instructions and further reading, see our Knowledgebase Article using self-signed certs (this article uses a CA).


Happy developing!



In this blog post, we will discuss how to Start and Stop ThingWorx Analytics, as well as some other useful triaging/troubleshooting commands. This applies to all flavors of the native Linux installation of the Application.


In order to perform these steps, you will have to have sudo or ROOT access on the host machine; as you will have to execute a shell script and be able to view the outputs.


The example screenshots below were taken on a virtual CentOS 7 Server with a GUI as ROOT user.


Checking ThingWorx Analytics Server Application Status

1. Change directory to the installation destination of the ThingWorx Analytics (TWA) Application.

    1. In the screenshot below, the application is installed to the /opt/ThingWorxAnalyticsServer directory


2. In the install directory, there are a series of folders and files. You can use the ls command to see a list of files and folders in the installation directory.

    a. You will need to go navigate one more level down into the ./ThingWorxAnalyticsServer/bin directory by using command cd ./bin

    b. As you can see above, we used the pwd command to verify that we are in the correct directory.


3. In the ./ThingWorxAnalyticsServer/bin directory, there should be three shell files: configure-apirouter.sh, configure-user.sh, and twas.sh

    a. To run a status check of the application, use the command ./twas.sh status

          i. This will provide a list of outputs, and a few warning messages. This is normal, see screenshot below: 

    b. You will have a series of services, which will have a green active (running) or red not active (stopped).

          i. List of services:

      • twas-results-ms.service - ThingWorx Analytics - Results Microservice
      • twas-data-ms.service - ThingWorx Analytics - Data Microservice
      • twas-analytics-ms.service - ThingWorx Analytics - Analytics Microservice
      • twas-profiling-ms.service - ThingWorx Analytics - Profiling Microservice
      • twas-clustering-ms.service - ThingWorx Analytics - Clustering Microservice
      • twas-prediction-ms.service - ThingWorx Analytics - PredictionMicroservice
      • twas-training-ms.service - ThingWorx Analytics - Training Microservice
      • twas-validation-ms.service - ThingWorx Analytics - Validation Microservice
      • twas-apirouter.service - ThingWorx Analytics - API Router
      • twas-edge-ms.service - ThingWorx Analytics - Edge Microservice


Starting and Stopping ThingWorx Analytics


If you encounter any errors or stopped services in the above, a good solution would be to restart the TWA Server application.


There are two methods to restart the application, one being the restart command, the other would be using the stop and start commands.


Method 1 - Restart Command:


1. In the same ./ThingWorxAnalyticsServer/bin directory, run the following command: ./twas.sh restart

    a. The output of a successful restart will look like the following:

2. The restart should only take a few seconds to complete


Method 2 - Stop / Start Commands:


1. In the same ./ThingWorxAnalyticsServer/bin directory, run the following command: ./twas.sh stop

2. After the application stops, run the following command: ./twas.sh start


Note: You can confirm the status of the TWA Server application by following the steps in the "Checking ThingWorx Analytics Server Application Status" section above.

In a previous blog I provided a quick Widget Extensions Introduction

The idea is not to have too much information just enough to get you going and maybe ask more questions.


The simple Hello World example just displayed some text based on a configurable property called Salutation. Now I would like to make the text change based on a a user click.

Previously we looked at renderHtml now we need to do introduce another function call widgetEvents in the ide.js and the  fireUpdatedEvent in the runtime.js files.


Below shows the implementation for the widgetEvents  function which basically adds the Updated event in the Composer

Composer view from the

Next in the runtime we have to add a handler that handles the click event

From there we can then wire up the click to a service called  RandomMessage which returns a random message from an array of messages



Below shows the service



After clicking you get a random message (well not that random!)


Mapping previous versions of ThingWorx Analytics API to ThingWorx Analytics 8.1 Services

Since ThingWorx Analytics 8.1, the classic server monolith has been replaced by a series of independent microservices. This new structure groups services around specific elements of functionality (data, training, results). Thus the use of the previous API commands to access ThingWorx Analytics functions has been replaced by the use of ThingWorx Services. Those Services exist within specific Microservice Things accessible in the ThingWorx Platform 8.1.

The table below shows a mapping of the most common previous API commands from version 8.0 and previous versions to the version 8.1 related services. The table below does not contain an exhaustive listing either of API commands nor of Services.

The API commands used below are samples which might require further information like headers and Body once used. These are used in the table below for reference purposes.


Previous API Command Purpose

Sample Syntax

TWA 8.1 Service

Analytics Thing related to Service

Service description


Version Info

GET: http://<IP Address>:8080/1.0/about/versioninfo


This service is available in each Mircorservice Thing inheriting from Analytics Server

Returns the internal

version number for a

specific microservice.

The first two digits =

ThingWorx Core

  • version. The next three

digits = version of the

  1. microservice.


Registering new Dataset

POST: http://<IP Address>:8080/1.0/datasets/


Data Microservice

Creates the dataset uploads the data along with its metadata and

optimizes it

  1. automatically.


Checking Dataset Status

GET: http://<IP Address>:8080/1.0/datasets/<DataSet Name>


Data Microservice

This old functionality is replaced by a Service that lists all the created Datasets


Creating Metadata

POST: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/configuration


Data Microservice

(Check line 2 for further information)


Checking Dataset Configuration

GET: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/configuration


Data Microservice

Retrieves the metadata

from a dataset.


Loading Dataset CSV

POST: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/data


Data Microservice

(Check line 2 for further information)


Checking Job Status

GET: http://<IP Address>:8080/1.0/status/<Job ID>


Available in all created Microservices inheriting from AnalyticsJob Server

Retrieves the status of a

specific job


Signals Job

POST: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/signals


Signals Microservice

Create a job to identify signals


Signal Results Job

GET: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/signals/<Job ID>/results




Retrieve a result of a Signals job


Profile Job

POST: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/profiles




Creates a job to generate

  1. profiles.


Profile Result Job

GET: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/profiles/<Job ID>/results




Retrieve the results of a

profiles job.


Train Model Job

POST: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/prediction




Create a prediction

model job.


Train Model Result Job

GET: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/prediction/<Job ID>/results




Only retrieves the

PMML model. But if a

holdout for validation

was specified in the

CreateJob, a validation

job is auto-created and

  1. runs.


Scoring Job

POST: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/predictive_scores




Submit Predictive Scoring Job


Scoring Job Result

GET: http://<IP Address>:8080/1.0/datasets/<DataSet Name>/predictive_scores/<Job ID>/results




Retrieve results from prediction scoring jobs




Thingworx extensions are a great place to explore UI ideas and get that special feature you want.


Here is a quick primer on Widgets (Note: there is comprehensive documentation here which explores the complete development process ).The intention is not to explain every detail but just the most important points to get you started. I will explore more in additional posts. I also like images rather than lost of words to read. I have attached the simple Hello Word example as a start point and  I'm using Visual Code as my editor of choice.

The attached zip when unzipped will contain a folder called ui and metadata xml file. Within the ui folder there needs to be a folder that has the same name as the widget name. In this case its helloworld.


Metadata file - The 3 callouts are the most import.

  • Package version: is the current version and each time a change is made the value needs to be updated.
  • name: a unique name used through out the widget definition
  • UIResources: The source locations for the widget definition.

The UIResources files are used to define the widget in the ide (Composer) and runtime (Mashup). These 2 environments ide and runtime have matching pairs of css (cascading style sheets)  and a js (javascript) files.

The js files are where most of the work is done. There a number of functions used inside the javascript file but just to get things going we will focus on the renderHtml function. This is the function that will generate the HTML to be inserted in the widget location.



In this very simple case the renderHtml in the runtime is the same as in the ide

renderHtml (helloWorld.runtime.js)


Hopefully you can see that the HTML is pretty easy just some div and span tags with some code to get the Property called Salutation.


So we have the very basics and we are not worried to much about all the other things not mentioned. So to get the simple extension into Thingworx we use the Import -> Extensions menu option.

The UI and metadata.xml file needs to be zipped up (as per attachment).  Below is a animated gif that shows how to import and use the widget


Very Quick Steps to import and use in mashup.


The next blog will explore functions and allow a user to click the label and display a random message. This will show how to use events


Widget Extensions Click Event

Starting in ThingWorx 8.0, Application keys are now encrypted and stored in the database. The Key used to encrypt the Application key id value is stored in /ThingworxStorage/Keystore.jks and the password for the keystore is stored in /ThingworxPlatform/keystore-password. These files are created automatically by ThingWorx and unique to that instance.


ThingWorx 8.1

In addition to the handling application key decryption, the Instance device ID is also stored in keystore.jks. To properly configure an HA landscape using ThingWorx 8.1, consider either;

  1. In a dark Site scenario, copying the license_capability_response.bin from the primary lead server to the ThingworxPlatform folder of all slave instances
  2. In a connected scenario, removing or renaming the existing capability response on the slave servers after replacing the keystore.jks and password-keystore to automatically retrieve a new capability response based on the encrypted device ID


Failure to do so will result in a Host ID mismatch error

[message: Trusted storage hostid does not match system hostid.]

ThingWorx 7.4ThingWorx 8.0ThingWorx 8.1
Installation Guide
Installation GuideInstallation Guide

In the Java Options field, add the following to the end of the options field:

-Dserver -Dd64



-Djava.library.path=<path to Tomcat>\webapps\Thingworx\WEB-INF\extensions

Place the license.bin file in your ThingworxPlatform folder

Obtain the license.bin file from the PTC Support site:

a. Log into the PTC Support site.

b. Click Manage Licenses.

c. Click PTC ThingWorx>PTC Licensing Tool.

d. Click Download.

Obtain your license Activation ID(s). Activation IDs are provided to new customers in the entitlement letter. Existing customers can visit the PTC Support site to obtain.

Rename the file to license.bin and place it in the ThingworxPlatform folder

Open the platform-settings.json file and add the following inside the "PlatformSettingsConfig":


"username”:”PTC Support site user name",

"password”:”PTC Support site password",




NOTE: You must have an Activation ID to ensure your license is current.

Multiple IDs must be separated with a comma.




Simple example for platform-settings.json:




    "PersistenceProviderPackageConfigs": {

        "PostgresPersistenceProviderPackage": {

            "ConnectionInformation": {

                "jdbcUrl": "jdbc:postgresql://localhost:5432/thingworx",

                "password": "password",

                "username": "twadmin"




    "PlatformSettingsConfig": {

       "LicensingConnectionSettings": {







Thingworx does not log the exact exceptions thrown by the Services but rather masks it  with intuitive Exceptions like "Unable to Invoke Services",

sometimes the log messages just say "null" not describing the exact origin of the "NullPointerException". Needless to explain how difficult it can get to debug.


Below is a small piece of Java code that can used in Java Extension that will help you log the Stack trace of the Exception.

public static void extractStackTrace(Exception exception, Logger _logger) {
     StackTraceElement[] elements = exception.getStackTrace();
     String log = null;
for (StackTraceElement element : elements) {
     log = (log == null) ? element.toString() : log + ";" + element.toString();

You can monitor the Exception in the Application log.


It is better if this Stack Track log can be made optional only on Debug Mode.


public static void logError(Exception exception, Logger loggerObject, String message) {
if (exception != null) {
if (isDebugMode) {
     extractStackTrace(exception, loggerObject, message);
} else {
     loggerObject.error(message + " : " + exception);
} else {


Finally there is an article which combines all of the available resources on certificate configuration to better enable developers to complete their production-worthy edge devices. Please see the official PTC documentation located here. Please feel free to comment with any questions, comments, or feedback on this! Happy developing!


Starting from 8.1, licenses are instance specific - linking a platform identifier (aka Device ID) to an entitled item of an customer order (aka Activation ID)

  • The Instance ID (aka Device ID) is tied to a ThingWorx platform instance - it is generated during the web app deployment.
  • The Activation ID is available on the entitlement letter and / or from the License Management Web Tools on the PTC eSupport portal
  • The license must also match the version of the platform


License deployment outline (see ThingWorx 8.1 Licensing for details)


  • Administrator retrieves the Activation ID(s) - either from the entitlement letter and / or the License Management Web Tools - ThingWorx > Manage ThingWorx 8.1 and Navigate 8.1
  • Administrator configures platform-settings.json with user name, password (PTC eSupport credentials), and Activation ID(s)
  • Administrator deploys / starts the ThingWorx Platform (Thingworx.war)
  • ThingWorx platform generates the instance ID (Device ID)
  • If connection to PTC, for license retrieval, works (aka connected scenario) :
    • ThingWorx calls out to PTC License server with credentials, Device ID and Activation ID(s)
    • If successful, it will automatically :
      • Link the Device ID and Activation ID(s)
      • Generate the license file
      • Download as license_capability_response.bin into ThingworxPlatform folder
    • If it fails, see disconnected scenario.
  • If connection to PTC, for license retrieval, fails (aka disconnected scenario) :
    • ThingWorx starts in limited mode. Administrators can log in but cannot save entities
    • LicenseRequestFile.txt is generated in ThingworxPlatform folder. It contains information (Device ID) used for manual, self service mapping via the License Management Web Tools
    • Administrator rename license file to license_capability_response.bin and copy into ThingworxPlatform folder


IMPORTANT -  Which Activation ID(s) to pick ?


  • As a rule of thumb, when setting up a new instance, you shall pick all the Activation IDs attached to a single Order (SON / Sales Order Number) with quantity 1 (may vary)
  • This is straightforward if you have the entitlement letter handy :

  • Otherwise in the License Management Web Tool - ThingWorx > Manage ThingWorx 8.1 and Navigate 8.1, it is possible to filter the Activation IDs by Order.
    The SON is called Entitlement ID in the web tool :

IMPORTANT -  Limited mode


  • In limited mode, it is not possible to save licensed entities (mashups, users, things, ...)
    • CS271552 - NullPointerException in logs and Composer hangs when saving entities in ThingWorx 8.1


IMPORTANT - Connected mode (8.1.0)


  • Only the first Activation IDs specified in platform-settings.json is use while fetching the capability response (license file). - Solved in 8.1.1
    • CS274132 - Multiple license Activation IDs in platform-settings.json are not used in 8.1.0


[Solved : 05-Nov-2017] - Self serve license generation (disconnected scenario) - CS271748

The following Expert Session videos are now available for viewing within the ThingWorx Community:

ThingWorx expert sessions.png

ThingWorx Analytics Installation - This Expert Session will walk you through the complete installation of ThingWorx Analytics from the Prerequisites to Confirming the Installation is successful and all steps in between. The first half of the video gives a breakdown of the components and the process of the installation with the second half being an actual Demo of the Installation.


ThingWorx Analytics API Overview - This Expert Session is designed to help beginners get up and running with ThingWorx Analytics. It covers basic concepts like: What are APIs, how to configure the metadata file, and a live Demo that shows you how to interact and use ThingWorx Analytics in real time. This Expert Session would also be useful for experienced users who need a refresher course.

Decision Tree, ThingWorx Analytics Builder - This Expert Session reviews the concept of “Decision Trees” and the functionality that is available in ThingWorx Analytics Builder. First, you will learn how to create and upload a dataset in ThingWorx Analytics Builder.  After that, it shows you how to train a model and score on the model that was just generated. It then goes into detail on how the prediction learner "Decision Tree" operates and classifies inputs.


Use Case Identification - This Expert Session goes over ways to identify and develop a successful use case for ThingWorx Analytics. The example use case presented here is on employee retention in a fictional company with the goal of maximizing employee retention . This presentation will provide you with all the fundamentals you need to develop your own ThingWorx Analytics use cases from the ground up.


ThingWorx Analytics Signals - This Expert Session will provide you with an in depth explanation behind how Signals are calculated in ThingWorx Analytics, what purpose they serve, and why we use them.  Some basic mathematical concepts are discussed so viewers will have a better idea of how ThingWorx Analytics operates behind the scenes.


Related Links

For more information, you can visit a new space dedicated to these helpful technical videos.


Additional Expert Sessions will be highlighted here in the ThingWorx Community every few weeks. Visit the Online Success Guide to access additional information about ThingWorx training and services.

In the last while I've seen a few things which got me thinking about how value is created or unlocked from connected data.  Multiple components are required to create, send, store and manage the data created by edge devices, doing these things enables value to be unlocked, but what does it take to unlock the value?


It was this article which first got me interested in considering this question.  In particular it was a section near the bottom of the article where the author describes a number of creative business use cases for car manufacturers which could be enabled by connected data.  If this author could come up with several creative and potentially valuable use case examples for one industry I started to wonder what other sorts of use cases could exist in other industries?  Could there be a series of use of use cases which a little variation be applied to different industries?


The second article which further sparked my interest in where the value originates from, is this one on using a cryptocurrency with IOT.  While the idea of using a blockchain like technology with IOT is intriguing, it was the second image in the article (below) which resonated with me on value.  This image is a graphical representation of the connection between the key components of a connected system and it makes it clear that each component has a critical role to play and the whole system and missing anyone of the parts and the system doesn't function.  This image make it clear that it's the "Analyze" phase which drives the action to do something, and it's taking an action which is the reason the systems reason for existing.    


Which brings me to the third and final article describing Industry 4.0.  Like the other two articles, it wasn't the main point of the article I found most interesting, rather it was the image below, and in particular the side bar 'Value Creation through' which brought me back to the question of where value comes from.  The idea that in a manufacturing setting, value can be created through product or process innovations as well as through new business models is intriguing.  I think a fourth idea missing from this list, is one were network effects from getting more and more proprietary data creating a compounding effect, like with Facebook or LinkedIn.  If there are at least four modes of value creation, maybe there others?



While these articles caused me to ask some questions, none of them really answered the question of where the value is unlocked. To answer the question I decided to restate the question to be "how is value unlocked from data" making the assumption the value is derived from the data.  This question is a little easier to address.  The best visual representation of the answer I've seen is the data value road map (below) from the Creating a Data-Driven Organization book which was released a couple of years ago.  While I think the author is probably missing at least two boxes above 'optimization' ("new business models" and "data driven network effects") I think the graphic does a good job communicating that as the value created from data increases, the complexity of the analytic task also increases; suggesting the value is unlocked by the analytics. 

For me, the value from a system of connected devices is unlocked from the "analysis" phase as seen in the first image. But in order to perform the "analysis" I think requires two things.  First asking the right high value questions of the data (product managers/beginning with the end in mind/use cases) and then using the right set of technologies to address those questions which in many instances means Artificial Intelligence of some sort.  Interestingly although artificial intelligence is required for many high value use cases, both parts of the analysis require distinctly human skills (the right use cases & controlling the technology) to create externalized intelligence and generate value.

Creating a Data-Driven Organization: Practical Advice from the Trenches 1, Carl Anderson, eBook - Amazon.com

Starting with the 8.1 release, the architecture of ThingWorx Analytics has changed from being a single sever to being split into several independent microservices.  This has been done to allow services to run concurrently. It also prevents issues with one microservice from affecting the others.


The new Analytics Server Architecture consists of a suite of 9 microservices:

  • Data
  • Clustering
  • Profiling
  • Signals
  • Training
  • Prediction
  • Validation
  • Presciptive
  • Results


All of the microservices work together to create a similar experience for users as it was in the past. The data that is uploaded and generated by the Analytics Server is stored directly in a file system, instead of a Postgres Database like it was in the past.

Closer Integration with ThingWorx

Please note that ThingWorx Foundation is required to be installed and operating before Installing Analytics.  During the install you will be asked to supply IP Address of the ThingWorx Instance that will be used for Analytics.  At this step, the AnalyticsServerThing is configured which allows the user to interact with Analytics Server through ThingWorx.  All of the configured microservices are represented as Things under the AnalyticsServerThing. This is because ThingWorx Analytics has become a native part of ThingWorx Foundation functionality and is dependent on ThingWorx for user interaction. 


Because of these changes, there is no longer a direct ThingWorx Analytics Server REST API. Support for accessing the services via REST calls is now provided through the ThingWorx Core REST API layer.  Because of this, a new URI pattern is required moving forward.

One other update from the older versions is that the requirement to use application keys and Application IDs are no longer necessary.  This should come as a welcome relief as the Application keys and IDs were the source of issues for users who may have misplaced them etc.

Less Data-Centric

In the old versions, jobs, models, signals, etc. were all tied to the dataset.  So there was no way to a model from one dataset to the other. With the new architecture, this is no longer the case you are able to move a model from one dataset to the other seamlessly.  Please note that when moving a model from one dataset to the other, it must have the same metadata between each of the datasets.  This is because a model created to increase efficiency in a factory would provide no insight on a dataset that monitors the soil moisture in a corn field.

Updates to Metadata

Although going over the exact changes to the Metadata is out of scope for this post, it is worth mentioning. For more details on the changes, please follow this link.


In conclusion, the new architecture of ThingWorx Analytics was done to increase scalability and to produce a more robust system.  The new release is much more integrated into the ThingWorx Platform to increase the ease of use from the previous releases.  It is much less data-centric than it was in the past and geared more to the solutions themselves. 

Filter Blog

By date:
By tag: