Use Javascript

class MyApp {
   constructor() {
       this.client = new Client('https://myserver/iris');
       // the actual token here can be a password, or any other supported auth token
       this.client.login({username: 'bob', token: '$₪£€₽$€₡₪₽€', type: 'password'})
                  .then(() => this.startApp(), console.error);
               // .then() is used to add callbacks to a Promise,
               // which will be used anywhere data is asynchronously loaded

   }
   startApp() {
     // now that the client is authenticated, all Deephaven functions,
     // such as opening persistent queries and opening tables, are available
   }
}
new MyApp();

startApp() {
    // Subscribe to updates on all persistent queries
    this.client.addEventListener('queryadded', e => addQuery(e.detail));
    this.client.addEventListener('queryremoved', (e) => removeQuery(e.detail));
    this.client.addEventListener('queryupdated', (e) => updateQuery(e.detail));

    // Fetch all known persistent queries (collections of tables)
    this.client.getKnownConfigs().forEach(queryInfo => addQuery(queryInfo));
}

addQuery(queryInfo) {
    console.log(`Loaded query ${queryInfo.name} [${queryInfo.serial}]`);
    for ( name in queryInfo.tableNames) {
        this.addTable(queryInfo, name);
    }
}
removeQuery(queryInfo) { ... }
updateQuery(queryInfo) { ... }
addTable(queryInfo, name) {
    // Render a list of queries and tables to choose from
}

addTable(queryInfo, name) {
    // Create an element to click to select table.
    show(new TableSelector(queryInfo, name);
}

class TableSelector {
  constructor(query, name) {
      // Create a function that returns a promise to load the table.
      // Connecting to a table to read information can be expensive, so we avoid doing it.
      this._table = () => queryInfo.table(name);
      this._name = name;
      someElement.innerText = name;
  }

  onClick() {
    this._table().then(table =>
        show(new TableView(this._name, table))
    );
  }
}

class TableView {
    constructor(name, table) {
        this._table = table;
        // Draw a placeholder
        renderFrame(name, table);

        // Subscribe to the updated event to get table data to render
        // addEventListener returns a function to easily perform cleanup
        this._cleanup = table.addEventListener('updated', e => this.renderTable(e));
        // This remote call does not return data directly;
        // instead, we use our subscription to the `updated` event, above.
        table.setViewport(startRow, endRow, table.columns);
    }

    renderFrame(name, table) {
        someHeader.innerText = name;
    }

    renderTable(event) {
        this._viewport = event.detail;
        drawViewport();
    }

    drawViewport() {
        var cnt = this._viewport.offset;
        this._viewport.rows.forEach(row => this.drawRow(cnt++, row));
    }

    drawRow(rowNum, row) {
        // Render a row of data using this._table.columns for type information.
        this._table._columns.forEach(column=> this.drawCell(rowNum, row, column) );
    }

    drawCell(rowNum, row, column) {
        doHtmlThings(rowNum, row.get(column));
    }

    dispose() {
        // Stop subscribing to the events from this table
        this._cleanup();

        // Additionally, it may make sense to close the Table entirely, if it is not to be used again
        this._table.close();
    }

}

class TableView {

    // Given a table with columns: type(String), index(Number), created(Date), modified(Date),
    // setSort(columns.type.asc(), columns.created.desc())
    setSort() {
        // all arguments should be iris.Sort objects.
        this._sorts = Array.prototype.slice.apply(arguments);
        var promise = this._table.applySort(this._sorts);
        return promise;
    }

    addSort(sort) {
        this._sorts.push(sort);
        return this._table.applySort(this._sorts);
    }

    // setFilter(
    //       columns.type.eq(FilterValue.ofString('Awesome')),
    //       columns.modified.greaterThan(FilterValue.ofDateTime(yesterday()))
    // )
    setFilter() {
        this._filters = Array.prototype.slice.apply(arguments);
        return this._table.applyFilter(this._filters);
    }

    addFilter(filter) {
        this._filters.push(filter);
        return this._table.applyFilter(this._filters);
    }

    // Use cloning when you want to create a new table to apply sorts and filters without modifying the existing table.
    // Note that each the original and the clone will fire their own events, maintain their own viewport, and
    // individual close() calls will need to be applied individually as appropriate.
    clone(name) {
        if (!name) {
            name = `${this._name}Clone`;
        }
        return this._table.copy()
            .then(newTable=>return new TableView(name, newTable));
    }

}