New look for the documentation it's really great. But also, how about improving search over documentation?

Look at the Atelier API, they have versioning.

Multi-line blocks

It's actually working. And it's because of code from RUN command goes to chosen SHELL as one line without line endings, \ at the end of the line, is not line ending it is line continuation. So, you can write code in Dockerfile visually like multi-line but it is no so.

Error handling

Any error in iris session will change exit code, so, any such error will fail docker build anyway.

So, with, such lines in my Dockerfile

SHELL ["/irissession.sh"]
RUN \
  write !,"Start",! \  
  for i=1:1:10 { \
    write !,"Test Loop",i \ 
  }\
  write !,"Finish",! \
  write !, error

I will get this

Starting IRIS

Node: 24032930b1e3, Instance: IRIS
%SYS>
%SYS>
Start
Test Loop1
Test Loop2
Test Loop3
Test Loop4
Test Loop5
Test Loop6
Test Loop7
Test Loop8
Test Loop9
Test Loop10
Finish

WRITE !,"Start",!   FOR i=1:1:10 {     WRITE !,"Test Loop",i   }  WRITE !,"Finis
h",!   WRITE !, error
                ^
<UNDEFINED> *error
%SYS>
ERROR: Service 'iris' failed to build: The command '/irissession.sh write !,"Start",!   for i=1:1:10 {     write !,"Test Loop",i   }  write !,"Finish",!   write !, error' returned a non-zero code: 1

As you can see, for loop working well, and UNDEFINED error fails to build

I would rather expect that some kind of irissession.sh was implemented by InterSystems. It is a docker build process, InterSystems already added ##class(SYS.Container).QuiesceForBundling() which in fact I would expect it should be called automatically while IRIS stopping during docker build.

I'm against putting all of those container's only lines to Installer manifest, just because of Installer manifests can be used in non-container's environment as well. And those lines need only during docker build.

PS. With 2019.4 this line

do ##class(SYS.Container).SetMonitorStateOK("irisowner")

should not be used (even will give an error), as it is already as part of 

do ##class(SYS.Container).QuiesceForBundling()

1. Faster to type (as you said).

Every developer should think not only about himself but about the next developer, who will have to read his code. You can type it faster when you use IntelliSense, like in any modern IDE. Like we already have it with VSCode-ObjectScript. It now supports extending commands and functions, and I see the near future when it will be able to extend any old-school code, with dots, or inline do.

More compact. Allowing the reader to "see" more of the structure in one go.

So, you say that this very compact code, is readable because you can see all code at once? No, no, no, it makes the code completely unreadable. When you put many commands in one line, with one or even more F and D  it makes so much pain,  to understand what's going on there. And it very fast becomes like a black box, nobody understands how it works, and nobody wants to touch it, just to not break it completely.

I'm just a developer of this particular tool. If you will be happy you will use it. I'm not from InterSystems, so, I can just recommend it, as a developer and user of own product.

I'm not sure if Atelier will get too much anymore.

I would suggest you move to VSCode-ObjectScript extension, which is more useful already by now. Don't hesitate to contact me directly or publicly here, if you have any questions about it.

// Changes the max-limit on the process memory from the default 16384 Kilobytes
set $ZS=49152

It's already 256Mb, since 2012.2

It's pretty easy to convert from one to the other using the Expand and Compress commands option in Studio.

Or Alt+Shift+F in VSCode-ObjectScript

Don't even try to write code like this

Q N R,Q,C,D,E,W,B,G,H,S,T,U,V,F,L,P,N,J,A S N=$G(N),Q='N,F=Q+Q,P=F+F,W=$L($T(Q))
 S W=$E(W,Q),S='N_+N,W=W-F*S,L=$G(L),R=$C(Q_F_P),R(F)=$C(F+Q_F),R(P)=$C(W-F) W #
 S T=$E($T(Q+F),F,W\S)_$C(W+S+F) X T S B=$P(T,$C(P_P),F),C=B\(W*W),D=B-(C*W*W)\W
 F G=S-Q:F:S+F+Q S E=B-(C*W*W+(D*W)),H=$E($T(Q),G),@H=$S(@H<S:'Q,Q:N)_@H,T=C_D_E
 F A=Q:Q:W\S S J=$E(T,A),C(F)=$S(J>(F+Q)&(J<(S-F)):Q,Q:+N),C(P)=$S(J#F:Q,Q:+N) D
 .S C(Q)=$S(J<(S-F):+N,Q:Q),C(F+Q)=$S(J>Q&(J<(S-F))&(J'=(P+'L))&(J'=(P)):Q,Q:+N)
 .S H('L)=L F  S H(N?.E)=$O(C(H('$G(N)))) Q:H('+L)=L  S F(A,H('L))=C(H(W[(W\S)))
 F U=Q:Q:P W !,R F V=Q:Q:P+F W $S(F(V,U):'Q,Q:$C(P_(W\S))) W:'(V#F) $C('N_F_F+F)
 W !!,R(F)_C_R(P)_D_R(P)_E_R(F) X $RE($E($T(Q),Q+F,P+Q))_R(P)_'N W # G:N=L Q+F Q

For sure full commands and functions more readable. Not only for your current developers but for any who will come later.

Scott, could you please specify, are you going to use Visual Studio or Visual Studio Code. Both are from Microsoft, but completely different products.

I know nothing about MS SQL. Visual Studio (not code) does support officially IRIS. There was one project, but already closed.

Visual Studio Code or VSCode itself supports GitHub by default very easy, just edit files locally, commit and push changes.

VSCode-ObjectScript is my extension for VSCode, adds support for Caché, Ensemble, and IRIS, any versions from 2016.2 (where were added Atelier support). It perfectly supports classes and routines, but if talk about "DTL, Business Process, Schema Editor, and etc" it does not have native support for it, but all of those staff based on classes, so, you can edit it as classes.

IRIS itself does not need to have support for GitHub, this task for an editor.

How secure is the Source Control if you integrate it with GitHub?

What do you mean here? Developers should manually choose what to commit to source control. It is not an automated task.

BTW, FHIR specs also say to use GET and query parameters. I'm really like the way how REST defined in FHIR.

I found this, quite close to your question.

POST/PUT, means that you create/update some data. 

I would use a query parameters, in such case.

This device uses USB to connect to PC, and some tools for communication. So, looks there are some ways how to do it actually.

So, how you going to connect these devices to the server for control?

I'm sure if you will find somebody here who already did the same task, even when you have to do it from server-side.

This task quite interesting and so tricky, I would like to help you to realize it, please contact me directly, I hope I can help you.

I wouldn't even tried to use ActiveX by now as it outdated already.

So, telnet access means, that all work only on server side. While user and such device should be somewhere else, and to get access from server to this device, you should use network. Is it correct?

Just found signoPAD-API/WEB which is better suited for a web-based application. It uses the WebSocket protocol for communication.

Wow, thats actually very different from what I expected.

So, now it depends, what is your application right now. If your application is a WEB Based, or textual terminal application it will be very different.

If it is a WEB, so, I think you can try some TWAIN libraries, as this device should support twain.

Or, it looks like it can just export image files somewhere, where you can just catch them.

Can you give some more details about your application and expected workflow?

The best solution right now would be to use something more modern than Jenkins, something base on Docker.

You can do it with any other on-prem tools like GitLab-CI, or Jenkins-X.

Some time ago I did some example repository for GitLab-CI, with Kubernetes deployment. I did not check it for a while, so, it may not work like it in the beginning, but I think it still can be useful as an example.