Thanks DC 😊

Hi Evgeny,
In ISOS, the "quit" command is inherited from MUMPS ("Q[UIT]") and has two forms (see the documentation for details) : 

• with arguments : terminates a method, function or routine, returning it's arguments as value
• without arguments : exits the current context (e.g. for, while, ...)

The "return" command was introduced by InterSystems, I think in Caché 2016.2  (@all please, correct me if I'm wrong).  It was added to avoid confusion, making ISOS clearer and also more aligned with 'modern' programming conventions.
"return" is equivalent to "quit" with argument, thus is has only one form and one, clear meaning : returning a value.
When the code intent is to return a value, nowadays I favor using "return".

p.s. IMHO, generative AIs, while useful in some contexts, are nor artificial, because they are trained with human sourced corpus, nor intelligent, because they are not able of any real creativity and are not doing any reasoning (even if they can mimic both rather well) 😇

Hi Evgeny,
Thank you for sharing the details, now I see why you have so much lines in a single class 😊
As an example of what Scott and Robert are explaining in their excellent answers, when dealing with a REST API spec defining (mostly) CRUD operation on many resources, I think one way to divide and, hopefully, conquer is to delegate the implementation of operations related to each resource to a separate class.
Taking as example petstore, for which, of course, this is an overkill, this would result in five classes :

1. Class dc.petstore.impl Extends %REST.Impl : (generated), all endpoints class methods, with most bodies being single line call to another class method
2. Class dc.petstore.Commons : logic common to all the classes below
3. Class dc.petstore.PetOperations Extends Commons : class methods dealing with 'pet' resource (CRUD + other)
4. Class dc.petstore.StoreOperations Extends Commons : same for 'store' resource
5. Class dc.petstore.UserOperation Extends Commons : same for 'user' resource

dc.petstore.impl class methods simply delegate the call to resource class, e.g.

ClassMethod findPetsByStatus(status As%String) As%DynamicArray
{
    return##class(PetOperations).FindByStatus(status)
}

Hope this helps

Why is there so many lines in this class ? 

From code quality point of view, a class exceeding 500 lines is usually considered a candidate for refactoring.

Is the code generated ?

Following these two insightful days, I wanted to thank you for the incredibly warm welcome and kind feedback. 
Here is my Bingo card 😁

🖼 Musée du Quai Branly

• Photo of something at Musée du Quai Branly that sparked your curiosity

Le Jardin d’O outside the Museum

• Describe one Musée du Quai Branly exhibit in three words

Much common ancestry!

The Diola mask from Senegal with horns, woven leafs canvas and seeds, share similarities with Celt masks of Cernunos made of plants, fruits and deer horns

• An exhibit you’d like to revisit and why

I'm particularly interested in the musical instrument collection, we did not have the time to visit

• Your favorite song sung by Laure Poissonnier at the Gala dinner

« Take Me to the Moon » 🌙

Shoot for the moon, even if you miss, you’ll land among the stars — Oscar Wilde

🎤 Sessions & Ideas

• A project you discovered at READY and one question you have about it

CHU Toulouse FHIR + interop, a very inspiring design. I wonder what is the strategy for change/release management, such as FHIR release migration.

• The most unexpected analogy used by a speaker

Zweder Bergman talking about how difficult it is to pick a bakery in Paris and comparing this to the many choices facing us with FHIR interoperabiliy

• One key takeaway from a session

From « Care Coordination: From Patient Journey to Sustainable Population Health » : public health agencies often do not measure the value of prevention and how quality data exchange networks contribute to cost reduction.

• A session outside your usual role and what surprised you

Retailer SPAR putting InterSytems technologies to effective and global use on such a large scale is quite surprising to me, I wonder how it initially sparked.

☕️ Informal Moments

• A READY conversation that made you laugh

Chatting about where we are now, in a world obsessed by AI, with MUMPS developers about my age 😁

• Your favorite non-session moment of the day

Meeting Egveny Shvarov, Guillaume Rongier, Irène Mykhailova and Anastasia Dyubaylo in real life : we are now more than avatars to each other 😊

• One insight gained outside a session

The vast collection of python libraries is now available to IRIS, and it’s especially useful when dealing with AI. Thanks @Guillaume Rongier 
 for pointing this out !

• Your favorite informal discussion (coffee, lunch, evening)

During the evening, chatting about using a FHIR repository a central storage for an hospital, and how it empowers the institution vs data being captive in supplier software. Also outlining how it is difficult to convince hospital boards and software suppliers to invest in the technology, the ROI being on the long term.

🤝 Reflection & Connections

• Photo of your favorite session

• Your READY moment of the day (one emoji + one sentence)

Learning more about EHDS initiative 😎

• Exchange business cards or LinkedIn with two attendees

I offered some cards during informal moments, but cards seems to be somewhat deprecated, and attendees did not have a card to exchange.

• Meet someone new at READY and tag them in your post

It was a pleasure to meet @Lorenzo Scalese  in real life, and sharing about developping with ObjectScript.

My rules, motivated by readability :

• use #dim with no inline assignment
• group dims at the beginning of the method/routine
• use set to assign variables

By the look of the stack trace, I think the adapter is trying to write request but it fails. Check the SSLConfiguration setting of the operation, it should be the name of an existing, valid, TLS configuration.

It is also possible to specify an ODBC connection string instead of system DSN name :

Driver={ODBC Driver 13 for SQL Server};server=localhost;database=WideWorldImporters;trusted_connection=Yes;

I would check out EnsLib.REST.DynamicObjVDoc, looks like it can parse something like JSONPath.

You can achieve this by querying Ens.MessageHeader (see https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic…).

something along the lines of

select top 1 TimeProcessed From Ens.MessageHeader where TargetConfigName='MyConfigItem'orderby TimeProcessed desc

Congratulations everyone, and thank you so much for making such an excellent community of developers possible !💐

Another approach would be to write a custom router class extending EnsLib.MsgRouter.RoutingEngine, overriding OnRequest() method.

In OnRequest(), before calling ##super(), assign the JSON %DynamicAbstractObject build from the input request stream to a property.

Use the property in the router rules.

You can override the Page() method of %CSP.Page and redirect output to a stream, process the resulting stream and write it to the original device the page is using to send data back to client.
Here is a quick and dirty example, using IO-Redirect package available on OpenExchange.
The redirecting page : 

Class test.src.RedirectedPage Extends%CSP.Page
{

ClassMethod Page(skipHeader As%Boolean = 1) As%Status [ ServerOnly = 1 ]
{
    #dim sc as%Status#dim ex as%Exception.AbstractException#dim pageStream,processedPageStream As%Stream.Object#dim len as%Integer#dim buffer as%Strings sc = $$$OKtry {
    
    Set pageStream = ##class(%Stream.GlobalCharacter).%New()
    Do##class(IORedirect.Redirect).ToStream(pageStream)
    $$$TOE(sc,##super(skipHeader))
    Do##class(IORedirect.Redirect).RestoreIO()
    Set pageStream = ##class(IORedirect.Redirect).Get()
    $$$TOE(sc,..ProcessPageStream(pageStream,.processedPageStream))
    while 'processedPageStream.AtEnd {
        s len = 32768s buffer = processedPageStream.Read(.len,.sc)
        $$$TOE(sc,sc)
        write buffer
    }
    } catch (ex) {
      s sc = ex.AsStatus()
    }
    return sc
}

ClassMethod ProcessPageStream(pageStream As%Stream.Object, Output processedPageStream As%Stream.Object) As%Status
{
    #dim sc as%Status#dim ex as%Exception.AbstractExceptions sc = $$$OKtry {
        s processedPageStream = ##class(%Stream.TmpCharacter).%New()
        $$$TOE(sc,processedPageStream.CopyFrom(pageStream))
        d processedPageStream.Write("<div><span>original page had "_pageStream.Size_" bytes </span></div>")
    } catch (ex) {
      s sc = ex.AsStatus()
    }
    return sc
}

}

The original page :

Class test.src.OriginalPage Extends test.src.RedirectedPage
{

ClassMethod OnPage() As%Status [ ServerOnly = 1 ]
{
    &html<
        <div><span>Hello, world, again</span></div>
    >return$$$OK
}

To see the content, the CSP Gateway has an HTTP trace facility, see  documentation.

To access the response just before it is sent back to client, override methods of %CSP.Page

There is a limit to string length, as explained in the documentation.
To convert a binary stream to a base64 encoded character stream, you have to call the function in a loop using a buffer. Due the way the function works, the buffer length must be a  multiple of 57.
Here a sample implementation, from ks.lib.stream.Utils class in the ks-iris-lib package available on Open Exchange.
 

/// encode stream data into encoded using bufferSize (due the implementation of $system.Encryption.Base64Encode, this must be a multiple of 57)ClassMethod Base64Encode(stream As%Stream.Object, Output encoded As%Stream.Object, bufferSize As%Integer = 5700) As%Status
{
  #Dim sc as%Status#Dim ex as%Exception.AbstractException#Dim len As%Integers sc = $$$OKtry {
    throw:((bufferSize#57)'=0) ##class(%Exception.General).%New("buffer size must be a multiple of 57")
    $$$TOE(sc,stream.Rewind())
    s:'$d(encoded) encoded = ##class(%Stream.TmpCharacter).%New()
    s len=bufferSize
    while 'stream.AtEnd {
      $$$TOE(sc,encoded.Write($system.Encryption.Base64Encode(stream.Read(.len),1)))
      s len = bufferSize
    }
  }
  catch (ex) {
    s sc = ex.AsStatus()
  }
  return sc
}

Alas, I'm well behind : 54 characters (according to %Dictionary.MethodDefinition Implementation.Size).
Please, enlighten me 😅

ClassMethodascii() [ CodeMode = objectgenerator ]
{
 f i=0,83,0,33,29,2,3:1:94,2d%code.Write($c(i+32))
}