Release Notes for Deephaven version 0.15

Summer has continued to deliver features for data scientists, developers, and analysts to the deephaven-core project. Last month’s easy Python pip installation is followed by the first integration of Deephaven’s real-time widgets with Jupyter, the official release of the requested Go client, and many quality-of-life improvements.

The complete 0.15.0 release notes can be found on GitHub.

Highlights

Real-time and interactive widgets in Jupyter

Deephaven’s interactive table widget is powerful. We've written about it handling a quadrillion rows and serving as a best-of-breed pandas DataFrame viewer.

Now, you can use that same Table widget in a Jupyter Notebook.

And it displays real-time and updating data!

That's a first, right?!? We’re excited for you to use these!

So here's what you get: A rich, stateful table experience… capable of handling dynamic and real-time data... within Jupyter... with just a few lines of code:

#install and start the deephaven-core server
pip install deephaven-server

#install and use the iPython widget plugin
pip install deephaven-ipywidgets

from deephaven_server import Server
s = Server(port=8080)
s.start()

The README from the deephaven-ipywidgets GitHub project provides further instructions and context for this feature. We look forward to your feedback.

We know you want real-time plots in Jupyter, too. Those will be available to Jupyter users by the end of August.

A Golang client API

Yep. It’s a Go.

Followers of our blog may have seen our preview or announcement of a Deephaven client-API for Go developers!

You can now receive snapshots from the Deephaven server in a Go client and push static or streaming data from the client to the server.

Below is a ‘hello world’ version of a client application, generating a simple (real-time) ticking table of timestamps.

import (
   "context"
   "fmt"
   "github.com/deephaven/deephaven-core/go/client/client"
)

ctx := context.Background()
myClient, err := client.NewClient(ctx, "localhost", "10000", client.WithConsole("python"))
defer myClient.Close()

timeTable, err := myClient.TimeTable(ctx, time.Second, time.Now())
err = myClient.BindToVariable(ctx, "myTimeTable", timeTable)

The Godocs for the client API are bookmarked in the reference section of our doc site.

Improvements to the updateBy() operation

In the last release, we introduced a new table method, updateBy(), to support common operations like cum-sums, -maxes, -mins, -products, and time- and count-based EMAs. In this release, we’ve now wrapped it for Python users (i.e. update_by()), addressed usability, and improved performance by using open address hashing under the covers. The Pydoc and Javadoc will soon be augmented with other documentation.

More Python Table API improvements

As noted above, since we were wrapping an aggregation, we double-backed on some earlier work. We added weighted-average, weighted-sum, and absolute-sum to join the list of other expected keyed aggregations in the Python Table API.

In the last several releases, we’ve added features related to creating subtables based on keys. Supporting such a structure with real-time data will give you superpowers for speed and parallelization for workloads with natural stripes. In this release, we have improved the ease-of-use of partition_by() via the Python Table API.

Real-time plotting API now supports Treemap charts

Deephaven has a low-level integration with plotly, enabling you to inherit various real-time charts and graphs. This release adds plotly’s treemap charts to the arsenal. You can find guidance on how to use this feature – for both static and updating data sources – in the docs. And again, these Tablemaps update in real time as new data arrives, as you'd expect with Deephaven.

Current priorities

Developers are focusing current efforts on:

1. Final testing of a feature to receive updating data via our C++ client API.
2. Architectural work to ensure Deephaven as a library is easy to use regardless of your operating system.
3. Further window-related use cases to extend updateBy().
4. Authentication and authorization hooks.
5. Direct support for Python plotly chart rendering in the web IDE experience (for snapshot data without the need for the Deephaven plotting API).
6. Ease-of-use for deploying iframe-embedded widgets.
7. Research related to data persistence and cloud deployment.

Further communication

As usual, we itemized changes in the docs since the last release in a blog piece and we welcome your engagement on Deephaven’s Slack or its GitHub Discussions.

Check out those Jupyter widgets!