I have been using VS Code with client-side editing exclusively. Now I'm playing with server-side editing, and I'm hoping that @John Murray or someone else can clear up my confusion about something. Before Server Manager had a GUI, my (possibly incorrect) understanding of server-side editing was that there were two ways to configure it:

• The preferred way was to use the isfs "technique" as described in the documentation
• Just click "Choose Server and Namespace" without creating a Workspace (no local folder)

It now appears that clicking "Choose Server and Namespace" automatically uses the isfs technique. Now I'm wondering:

• Did the behavior of "Choose Server and Namespace" actually change? I'm kind of hoping that it didn't change, but if it did...
• What's the difference (if any) between the two techniques for server-side editing, and is there any reason to still use the non-isfs approach, and if so, how would I configure that?

Also note, for the name of the global that is logging statuses:

• ^mtempinitials works (since the old days), like  ^mtemptl in Tim's example above.
• ^CacheTempinitials also works (since the Caché days). Maybe Tim would use ^CacheTempTL sometimes  and rock a little camelcase?
• ^IRIS.Tempinitials also works (for IRIS). Maybe Tim would use ^IRIS.Temp.TL periodically? (see what I did there?)

Nice article Tim! For posterity, I will try to clarify two statements you made:

1. "Note that this solution assumes uniform depth of subscripts/values across the whole local array; weird things would happen if this assumption was violated."
2. "$query, $qlength, and $qsubscript are handy for dealing with globals/local arrays of arbitrary depth."

Some readers might see a conflict in these two statements (I added the bold), but there is no conflict. Statement #2 is correct. Statement #1 applies to using $query for the specific goal Tim had in mind.

If controlling order is important, and you don't need the bi-directionality of 1-M relationships, you can use a list or an array collection instead.

I haven’t used any of the Gateways before, nor have I played with any of the External Language Servers. It looks like the new skill demoed here is that an IRIS object (persons in this example) is able to hold a reference to a Java class outside of IRIS, and you can call methods from that Java class as if they are methods inside IRIS, including making use of Java libraries (AsciiTable in this example). So Java System.out redirects to the IRIS Terminal window? If so, that all seems amazing! Do you have some examples you can share about how we expect developers to use this?

For those of you that like GUI tools in an IDE, I just installed the Microsoft Docker extension for VS Code. It shows my Containers and Images just like Docker Desktop Dashboard does, and lets me start/stop/launch CLI/inspect etc.

But the real reason I installed it is because there's also a Registries section with a Connect Registry icon (looks like a plug).

Using that, I chose "Generic Docker Registry" (other choices: Azure, Docker Hub, GitLab). I supplied the registry URL. It prompted me for my username and password (Docker login token as described above) and I can now browse the registry. Beautiful!

zen(id) is shorthand for zenPage.getComponentById(id) which as @Vitaliy Serdtsev said gives you access to the Zen component identified by id. document.getElementById(id) gives you access to the element identified by id in HTML/JavaScript document object model. Since a Zen component could comprise several HTML elements, it's usually better to use zen(id).

Point #11: one-to-one is not supported but can be imperfectly simulated. many-to-many is supported by combining one-to-many among 3 classes.

Oops! I posted this without noticing that Robert already handled this one!

Point 5-5: Relationship on the object side is bi-directional. Class A has a reference to class B, and class B has a collection of references to class A. On the SQL side, table A has a reference to table B, along with automatic referential integrity.

Point 16: Important: for a class to be persistent, %Persistent must be the first class. So the example should be: Class Person extends (%Persistent, Animal)

Point #16: There is only one type of database. Databases can hold code only, data only, or code and data together.

On #5: %IsModified() and propertynameIsModified() methods tell you whether the object in memory has been changed in memory (not on disk).

That looks like a fun course! One correction on point 20: the default datatype for variables is string, not %String. And there's more to know about what that means, but come and take the course to find out...

Interesting, thanks for this. Related question: when running the Portal with this method of enabling ssl, do the Help links to docs.intersystems.com also become https links? For example, the Help links on this page:
System Administration > Configuration > Additional Settings > Startup

To answer the original question: What is the difference?

There are 3 ways to use SQL in Caché/IRIS:

Dynamic SQL: The main use case for this approach is that you, the developer, don't know the complete SQL statement at design/compile time. Instead, inside your Method, you build the complete SQL statement at run time (adding columns to the SELECT, conditions to the WHERE clause, whatever you need), prepare the finished SQL, and execute it. This approach uses %SQL.Statement and %SQL.StatementResult. As you loop through the result set, to access the data in each column, you can use rs.columnname or rs.%Get("columnname"). But neither one will work if you don't actually know the names of all the columns, which can obviously happen when the SQL is dynamic. So the only other approach is to use rs.%GetData(columnnumber).

The other two alternatives are for the case where you, the developer, know the complete SQL statement as design/compile time. Note that you can use Dynamic SQL for this case also.

Embedded SQL: In this approach, you embed the complete SELECT statement inside your Method using &sql(). This is similar to embedding SQL in procedural languages provided by other vendors, such as PL/SQL (Oracle) and T-SQL (MS).

Class queries: In this approach, you create a Query in your class that contains the complete SELECT statement, and you use that query in a Method. For this, it's recommended to use the %PrepareClassQuery() method of %SQL.Statement.

Note: the original implementation of Class queries and Dynamic SQL also used %Library.ResultSet.

We may need more clarity in order to answer this question. This is what I think you mean. You want to take an ObjectScript array of arbitrary structure, like this:

a(1)="a"
a(3,4)="b"
a(3,6)="c"
a(5,6,7)="d"

...and turn it into JSON. But what should the target JSON for this example look like? Something like this?

{"1":"a", "3":{"4":"b","6":"c"}, "5":{"6":{"7":"d"}}}

...or something different?

In any case, to loop through an ObjectScript array of arbitrary structure, you need to use $Query.

There is also ^$LOCK, which is a "structured system variable." It's been in the language for a long time. So instead of setting tMyGlobalLocked and checking it, the code could use ^$LOCK like this:

    // Cleanup: locks
    If $data(^$LOCK("^MyGlobal(42)") {
         Lock -^MyGlobal(42)
    }  

This is a very good article. I have 2 comments:

1. Why do you need the while loop and tInitLevel at all? I think that code that uses transactions must balance each tstart with either a tcommit or trollback 1. So the difference between $tlevel and tInitTLevel should always be 1. And no code should ever use trollback without the 1. Your code should roll back your transaction and no one else's.
2. When tstart/tcommit was first added to the language, best practice was placing the tstart and tcommitat the beginning of the code that is about to change globals, keeping it isolated as much as possible from anything else. I’d suggest moving the tstarts in your examples lower in the code block, right before the “do the important stuff” code.

Would you please try adding ReturnResultSets to your original method and let us know? This works for me.

ClassMethod Get(pId As %String) As %String [ SqlName = GetMsg, SqlProc,  ReturnResultSets]

%OnNew() must return a %Status to %New(). But the code that calls %New() also needs the %Status. I think a "best practice" is simply to add an Output  %Status argument to %OnNew() that will therefore be returned to %New(). So the %Status is being returned using return (for %New()) and by using a pass-by-reference argument (for the code that calls %New()).

/// constructor
Method %OnNew(name As %String = "", phone As %String = "", dob as %Date, Output st As %Status) As %Status [Private]
{
    set st = $$$OK
    set ..Name = name
    set ..Phone = phone
    set ..DOB = dob
    set st = ..%ValidateObject() // validate the new object
    return st
}