Introduction

My guess is that most IRIS developers create their applications using its native ObjectScript language or, if using an external language, then most likely using either Java, Python or perhaps C++.

I suspect that only a minority have considered using JavaScript as their language of choice, which, if true, is a great shame, because, In my opinion and experience, JavaScript is the closest equivalent to ObjectScript in terms of its ability to integrate with the IRIS's underlying multi-dimensional database. 

It's not clear to me, when using the InterSystems Container Repository, which version is the best / most recent non-preview Community Edition version to use.

I see lots of 2023.2.x versions, a single 2023.3 and 2024.1 version, but also a latest-cd and latest-em (with no explanation as to what cd and em mean).

I assume the trick is to use one of the latest-xx ones?  If so, which?

Unfortunately I haven't been able to find any explanatory information anywhere about the nomenclature conventions used.

Many thanks

A few weeks ago I posted an announcement about a JavaScript-based interface for our mg_web WebServer interfacing addon module.  mg_web isn't just restricted to use by JavaScript developers though.  Many readers will be ObjectScript developers who are more used to using CSP as their web gateway.  Some may even have much older legacy WebLink-based applications (and be wondering how to support them given that IRIS does not support WebLink).

This article aims to provide some more information on mg_web and to explain why it's worth a look for ObjectScript developers.

Hot on the heels of our announcement last week about our ultra-high-performance mg-dbx-napi JavaScript interface for IRIS, we are now pleased to announce a significant new technology - mg_web - which not only represents a new paradigm for JavaScript Web Frameworks, but also delivers significantly higher performance than even the fastest of the established Node.js Web Frameworks, whilst leveraging all the benefits of the big-three industry-standard Web Servers.

You may have heard about our mg-dbx-napi interface for IRIS which provides insanely fast access from Node.js.  If you've been following recent developments in the server-side JavaScript world, you'll be excited to know that mg-dbx-napi also works with Bun.js, the latter proving to be significantly faster than Node.js for many/most purposes.

Of course, if you're a Node.js user, you'll probably wonder how mg-dbx-napi compares with the Native API for Node.js that is included with IRIS.

With all that in mind, we've created a Github repository: mg-showcase

I'm using a customised IRIS Community Edition Docker Container: Node.js has been added and the Native API for Node.js directory moved to a node_modules folder in /home/irisowner.  I've changed the _SYSTEM password using the Management Portal (which connects to IRIS just fine)

If I shell into the running container and try to connect with a JS script file containing this:

        const IRISNative = require('intersystems-iris-native');

        let connectionInfo = {

          host: 'localhost',

          port: 1972,

          ns: 'USER',

          user: '_SYSTEM',

          pwd: 'secret',

I think there have been articles published here before but I'm struggling to find them:

I'd like to be able to create my own customised version of the official IRIS Community Edition Container, eg with Node.js and a number of modules pre-installed.  So, for example, can I create my own Dockerfile that begins with something like:

         FROM containers.intersystems.com/intersystems/iris-community-arm64:2023.2.0.227.0

and then I can add my own stuff to it?

... or is there another recommended approach?

Any info appreciated

The latest Node.js Weekly newsletter included a link to this article:

https://thecodebarbarian.com/getting-started-with-vector-databases-in-n…

I'm wondering if anyone has been considering or actually using IRIS as a vector database for this kind of AI/ChatGPT work?

I'd like to announce the release of something really rather interesting - revolutionary in fact.  That may sound like hyperbole, but I don't think you'll have seen anything quite like this, or even thought it possible!

We've pushed out a new JavaScript/Node.js module named glsdb which you can read all about here in detail:

https://github.com/robtweed/glsdb

However, for the purposes of this announcement here, I just want to focus on one part of glsdb: its APIs that abstract IRIS (or Cache) Classes as equivalent JavaScript Objects.

For those of you who might be new to IRIS, and even those who have used Cache or IRIS for some time but want to explore beyond its usually-assumed boundaries and practices, you might want to dive into this detailed exploration of the database engine that is at its heart, and discover just what you can really do with it, going way beyond what InterSystems have done with it for you. 

At the heart of IRIS and Cache is a very interesting database architecture that we, at M/Gateway Developments, refer to as "Global Storage".  If you ever wanted to know more about the fundamentals and capabilities of this underlying database, you might want to read a major analysis we've put together:

https://github.com/robtweed/global_storage

Amongst other things you'll discover that:

- Global Storage provides the underpinnings of a full multi-model database, something we refer to as "Universal NoSQL", though, as you already know from IRIS and Cache, it also supports relational too.

I've posted this video on YouTube:

https://www.youtube.com/watch?v=gHUifpuav9I

Expand this article for some background to what it shows and what it's all about...

There's been quite a bit of discussion lately in this forum on the tools available in IRIS for using both XML and JSON, and debate on cross-conversion between the two formats.

QEWD is assumed by most people to only integrate with IRIS (or Cache) via a connection through IRIS's high-performance C interface.  This requires QEWD (and its Node.js environment) to be installed and configured on the same machine as IRIS.

I'm frequently asked if QEWD can run on a separate server (or servers), and access IRIS (or Cache) over a network connection.  The answer is yes it can, but the information on how to set it up in this way has been admittedly a bit tricky to discover.

I see this available as an option on Docker Hub:

What ARM platform(s) is it designed for?  When I saw it available, I rather hoped it might work on a Raspberry Pi but it failed to start!  

docker pull store/intersystems/iris-community-arm64:2020.4.0.524.0

Those of you who run and support older-style legacy systems on IRIS may be interested in learning about and trying out a new framework I've built on top of my colleague Chris Munt's mg_web technology (details at https://github.com/chrisemunt/mg_web).

There are quite a few older-style and legacy applications out there whose useful life can be extended by making their functionality available as REST APIs.  To make this something that can be done quickly and easily, using modern, industrial-strength web servers, I've created what I'm calling mgweb-server:

https://github.com/robtweed/mgweb-server

Those of you who are following the FullStack competition here in the Developer Community will know that I submitted an entry named qewd-conduit.  I wanted to summarise why I think it's something worth you taking a bit of time to check out.

qewd-conduit uses the Node.js-based QEWD framework alongside IRIS to implement the back-end REST APIs for something known as the RealWorld Conduit application:

https://github.com/gothinkster/realworld

The latest WebComponent-based, SB Admin 2-themed QEWD Monitor application now includes a cool D3-based viewer for visualising your IRIS or Cache Globals - see example below

This qewd-monitor-adminui application is automatically installed when you install QEWD on a Windows machine

See here for details on installing QEWD on Windows:

https://github.com/robtweed/qewd-microservices-examples/blob/master/WINDOWS-IRIS-2.md#initial-steps
 

If you're interested in building a browser-based CRUD application for maintaining data on IRIS, check out the detailed, step-by-step tutorial at:

https://github.com/robtweed/qewd-microservices-examples/blob/master/WIN…

To get a preview of the application you'll build in the tutorial, along with background on its technology stack, watch this video:

https://www.youtube.com/watch?v=d-NICYqv_2s

In summary, the key features and technologies that you'll be using and building out in this tutorial include:

I've created a new repository that I will use for providing examples of various scenarios and use cases for QEWD

https://github.com/robtweed/qewd-microservices-examples

Initially it contains a example of a scenario I'm often asked about: a set of REST APIs, with JWT support, implemented as a set of QEWD MicroServices, each of which uses Cache or IRIS running on a Windows system.

What I've provided is a detailed, step-by-step guide (with detailed explanations) of how to set up such a system.

The example shows a use case of REST APIs to:

- authenticate / login

Hot on the heels of the QEWD-JSdb announcement, QEWD-baseline provides a ready-to-run baseline environment for developing REST APIs.

The QEWD-baseline repository (https://github.com/robtweed/qewd-baseline) includes a fully-detailed tutorial on how to build RESY APIs using QEWD and the QEWD-JSdb database (running of course on IRIS).

https://github.com/robtweed/qewd-baseline/blob/master/REST.md

Included in the tutorial is:

- fully-worked examples, including how to integrate QEWD-JSdb's abstraction of the IRIS database 

- advice on debugging QEWD REST APIs

Want to see how IRIS can be used in a radically-new way, as a JavaScript-based Multi-model database?

Take a look at QEWD-JSdb: https://github.com/robtweed/qewd-jsdb

Full instructions on how to try it out on the AWS IRIS Community Edition are included in the repository.

There's a new and exciting enhancement to QEWD that has just been released - it's an additional layer of abstraction known as QEWD-Up.  QEWD-Up hides away all the mechanics of QEWD itself, allowing you to focus on just your REST APIs and the code that implements them.

Additionally, and importantly, QEWD-Up simplifies the maintenance of your REST APIs, allowing you (and others) to quickly and easily understand their life-cycle and implementation.

QEWD-Up supports both monolithic application designs and MicroService-based architectures where APIs are broken down by, for example, functional role.

As a result of Evgeny's recent questions regarding the use of QEWD.js with IRIS in another post, I thought it would be a good idea to create a separate post focusing specifically on how to use QEWD.js to create REST APIs for IRIS.

QEWD.js is,  of course, a Node.js framework, and all the REST API code can be written entirely in JavaScript. 

One for Luca, perhaps?

Interesting article here:

https://www.redhat.com/en/blog/containers-aren%E2%80%99t-just-applicati…

Would this be a fit for Cache / IRIS containerisation?

Not sure I fully "get" what's being proposed in the article, mind you.

Will any of this week's Global Summit be live-streamed for the benefit of those of us unable to attend?

if so, what's the link?

Quite a few enhancements have appeared over recent months in QEWD for easing and simplifying the creation of REST-based services.  It's now even more slick and powerful,  allowing you to very quickly create very high-performance, highly-scalable REST (and Web) services that make use of Cache.

I've therefore updated the training presentation deck (Part 31 on developing REST Services with QEWD).  It describes all the new features with worked examples.  See:

https://www.slideshare.net/robtweed/ewd-3-training-course-part-31-ewdxp…

If you read my previous post that introduced QEWD Micro-Services, you're hopefully eager to learn how to use them.  So in this post I'll explain what you need to know in order to get started.

If you look in the QEWD repository, you'll find the folder: 

  https://github.com/robtweed/qewd/blob/master/example/jwt

In my previous posting about the new support in QEWD for JSON Web Token (JWT) support, I mentioned that it was a key step in enabling Micro-Service support in QEWD.  In this post I'll give some background to how they work and the thinking behind them.

If you haven't heard about Micro-Services and/or want to learn more, there's lots of information available if you do a Google Search.  Here's a good starting point:

https://smartbear.com/learn/api-design/what-are-microservices/

I've written previous IDC articles about QEWD and how it provides a very high-performance, yet simple-to-use, way of integrating Node.js with Cache