2010 confirmed. Anyone with earlier versions?
W $System.Version.GetMajor()
2010
 

Try using BETWEEN.

cls/My/Deep/Class.cls

I don't think subdirectories should be applied for routines, originally routines aren't supposed to have submodules or subpackages and dots might be part of their name. Also if you need some complexity, you wouldn't prefer using routines but classes to keep things organized.
 

I DO NOT recommend using src, unless you want to mix both back-end and front-end code. 
Or you want to keep the server code in a separated repository.
Here is a scaffolding based on React for better understanding.
my-app-project /
   package.json
    server
          cls
          mac
          int
          csp <- this is our build path, nothing should be added manually because everything is handle by the bundler.

    scripts /

         test.js
         build.js
        dev.js
   config /
         webpack.config.dev.js
         webpack.config.prod.js
         webpack.config.test.js
   src /

         components
               Header
                   index.js
                   Header.js                   
                   HeaderSearchBar.js
               Footer

                   index.js
                   Footer.js
                   FooterCopyright.js
                AppContainer
                    index.js
                   AppContainer.js
          containers
                App.js
           tests
               components

                  Header
                      Header.js                   
                      HeaderSearchBar.js
                  Footer
                      Footer.js
                      FooterCopyright.js
                   AppContainer
                       index.js
                   AppContainer

                              
You can use folders to separate both client and server codes inside the same project. You can even structure your project

using a monorepo approach if you want to keep multiple application modules together.
                  

Now since React will be using webpack's hot module reloading along with webpack-dev-middleware that builds everything within the memory, your Caché server should only work following SPA conventions and providing consumable data.
There's a catch though, whenever the developer builds a new version (using webpack.config.prod), it's mandatory to delete the older bundle and import the project back to Caché to keep the source in sync on the server and the project.
     

http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY…
Check the "Configuring an ECP Application Server" section. However, I advise you to read everything.
Remote databases should be created on the client instance (A). They represent the connection with the local database on the server instance (B).
If you follow the steps from the guide, when creating a remote database you'll notice that the wizard will ask you for a server, that's where you should select the ECP server you just defined.
Now create a local database on the client instance if you need to store something on it (like, let's say... code). And finally create a namespace, this is where you can define where to use local or remote database (GLOBALS AND/OR ROUTINES).
CAUTION: If you configure globals to use the remote database, any changes you do on the client instance will reflect on it's provider counterpart. The same applies for routines.
EDIT: Answering your question. No, as I far as I know, using this method you can't have more than one remote database for each global or routines. But I think you can workaround it by defining another namespace, from another remote database that links a local database on instance C and map what you want.
But you'll be responsible for dealing with name conflicts.

Are you using Dynamic SQL (%ResultSet, %SQL.Statement)?
http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY…
Are you using embedded SQL or named queries?
Then it's the same as Oracle. Ex: :parameterName

You might want to check this out.
https://community.intersystems.com/post/how-do-i-get-list-files-directo…

Although Caché does have a %DataTypes layer for SQL, the database engine itself is purely based on globals, which is losely typed.

Thus, what I can say for you is:
Local variables (memory) is by default around 32 kilobytes, you can upgrade this amount up to 50x.

So, straight from the documentation:
 

Caché supports two maximum string length options:

• The traditional maximum string length of 32,767 characters.

• Long Strings maximum string length of 3,641,144 characters.

Globals can go way beyond, since it's persisted.
How huge a number can go? I suppose you're talking about floating precision.
This might help you.
And this explains about how Caché manages variables.
Caché also provides you the possibility to redefine the memory allocation size for the context process.

set key = ""
set var1 = "code2"
for  {
    set key = $order(^myglobal(key), 1, list)
    quit:key=""
    if $listget(list, 1) = var2 kill ^myglobal(key)
}

Use $order to iterate over global subscripts.

If you can't release memory by ajusting your own source code, then what you need is to do is expand it's size by using $zstorage or the configuration.
Also, is that a recursive call?

Since you said it's arbitrary, where did you get that +3? Is that a constant or variable value?
Maybe if you update your line to:
ZBREAK *LINE:"T"::"ZWRITE LINE(I+C)"

Where C should be your other arbitrary data (but provided as variable as well).

%request.Content will provide you the raw string (or stream) contained on your request payload.

I only return the result when I'm absolutely sure that the method cannot throw any error. Otherwise I follow the rule:
1 - Obligatory arguments first.

2 - Result by second.

2 - Parameter with initial values third.

3 - Rest parameters for last.
(obligatoryParamA,  obligatoryParamB, obligatoryParamC, result,  optionalA, optionalB,  rest...)

Hello Coty.
I noticed that you starred my github repository and I thank you for that. :)

Back to your question, I think you're detecting changes by applying an unusual way to do that, since you said you can't trigger an action when modifying static files. Just so you know, as long as you're working with the Studio's SourceControl API, you should be able to do whatever you want whenever an  item is modified, you're even free to decide how to restrict the implementation, all of this regardless of the item you're updating.
Look at this part to understand how it's done.

About your use-case, we're actually testing Port with this development format. We have one code base, that's our development server, multiple namespaces simulating different customer configurations and mock data (not mock, actually their test data).
Even though this model works, by our analysis it can get pretty frustrating for users coming from a distributed version control, because they notice that multiple developers interacting with their "repository". Still, it's already a step ahead from not versioning at all.
However, the team is expected to migrate all their source to projects, since Port annoys the user about trying to save default projects and even detects items that are already owned by other projects. This forces all the team to prioritize organizing their code base.

Hello Benjamin,

This is how I binded a class to some git cli commands on the earlier versions of my project.
The main tip here is to use ZF along with ">" to output the result to a file. This way you can make Caché aware about what happened when the command was executed.

You'll notice that you can even create a custom query for operations like log, diff, etc.
If you don't want with the logic behind the outputs, you can simply use RunCommandViaZF from %Net.Remote.Utility.
But remember that older versions haven't this method.
Also, when reading the command string you'll notice a lot of {PLACEHOLDERS}. You don't need to implement it to work, just rewrite it to use static parameters instead.

They are:
{VCS} - The absolute path to the git executable.

{SLASH} - The resolution from \ or / depending the OS.
{Pn} - Where n is a sequential number, they are the parameters needed to call the command.
And finally, here's a sample:
do $zf(-1, "C:\Program Files (x86)\Git\bin\git.exe --work-tree="C:\Projects\Test" --git-dir=C:\Projects\Test\.git add cls 2> ""outputfilepath"" > ""errorfilepath""")

Hello Athanassios,

I think you're on the right track. But that should be only the beginning.

To capture "writes" from Caché you need to redirect your IO and write the data back to the device you binded your Python interpreter. This is your writer device. If you need help about how to configure your writer device, check the Job Command Example.
Remember that it's your responsibility how you'll implement a buffer and how much it can store before writing it back to the implementer. I do recommend using a stream here.

Now I don't know if simply by calling the binded method you're able to see it's output before returning. If it doesn't, you problably need to open a TCP connection from the implementer's side too and listen to the writer device using a separated thread.

Hello Kevin,

From my experience you cannot use Studio's output window to ask for input from the user and I think that's because the Studio's output window  is not really a terminal device.
I also tried to read the input from this device without success as well. I hope  I'm wrong and you can find an answer for that (and mine as well).