Ha, this post really made me laugh out loud. But I do see use cases for this kind of an integration. If you use slack for issue tracking you can easily create a channel where all Ensemble issues are automatically posted. Inactive Business Services, thrown errors, etc. If Slack is part of your company culture, this is a simple and nice enhancement to your workflow.
Also, if you are using the System Management Portal to activate a new key, make sure to double check the capabilities of the new key. You will be presented with a popup that displays the new key, so you can make sure that you really selected the correct key for activation (e.g. correct platform, all required features).
Activating a new key does not require a system restart unless there are major differences between the old and the new key. As an example: If the new key enables the same number of users (or more) a restart is not required. Downgrading the user count will require a system restart.
Congratulations John. Thumbs up.
The error means that the version of your Java runtime is too old. For more information on this error, please see a related stackoverflow thread:
http://stackoverflow.com/questions/10382929/how-to-fix-unsupported-majo…
Recent versions of Caché and Ensemble only support Java 7 and 8, as Java 6 has reached end-of-life and has multiple security flaws.
Upgrade your Java runtime to 7 or 8 and the error will go away.
Correct, bandwidth is not so much of an issue. Latency can be an issue as a high latency will make all actions that require server interaction be perceived slowly.
Also, you should be aware that Studio runs a server status check on a regular basis by default. If your latency or connection is bad you should increase the timeouts, otherwise, you will see a popup asking for a reconnection pretty often. The setting can be found here: Tools->Options, go to Environment->Advanced and take a look at the "Enable server status check" setting.
Again, it depends on what you are comparing to. Just looping over a global can be compared to a simple full table scan and the runtime performance should be pretty much the same.
If you have a complex query that can't be boosted by adding just another index or by running tune table, you can probably write your own custom logic. An even better solution is to implement a custom index that can be leveraged by SQL.
You have to keep in mind that the %SQL.CustomResultSet approach does not lead to reusable code. It can be used to solve a very specific problem, but it can't be reused for a similar problem on a different data set.
Well, that obviously depends on how good your owl logic is. 
I only recommend this approach if the standard interface is insufficient for a specific need and you have to optimize further.
Writing your own logic does not leverage optimizations from newer versions and you have to maintain it.
A major benefit of %SQL.CustomResultSet is that you can query any accessible data source, e.g. globals and files.
%Library.Result is the old SQL interface and it is recommended to use the new interface %SQL.Statement. %SQL.Statement is capable of providing metadata about the result set and performs better than the old interface in many cases.
This looks much better and should work.
Thanks for providing a workaround.
Stefan
Jochen, this code will only work if the template dispatch mode is enabled. If you are running in standard mode, this is the code you need to make the sample work:
Hi Benjamin,
regarding your questions:
1) String concatenation is possible with the underscore "_" character. For example:
Don't use the plus "+" character as this is the addition operator. It will evaluate your string and convert it into a number. Unless your string starts with a number, it will be evaluated to 0.
2) Multiline statements are not supported in Caché Object Script, so you have to concatenate your string if you want to spread the query on multiple lines.
HTH,
Stefan
Dropdownmenuitems did not attach event handlers when a key is present, which is a bug. This is fixed in the next release Zen Mojo 1.1.1. The new version is currently verified by QD, so you can expect a release within the next 2 weeks.
A couple of years ago I built my own UML class diagram viewer, but it was more for the fun of it. I just like to visualize relationships and workflows as I believe it helps the mind to understand complex entities better.
There is a UML Explorer tool available at this GitHub repo:
Just as a note, this is something you would usually tackle with a gulp or grunt task, e.g.
https://www.npmjs.com/package/gulp-minify
These watch external files and run a task every time they change. This means a gulp/grunt task can minify JavaScript files after you compiled your Zen/Zen Mojo classes.
John,
I just tried the link and it worked fine for me. I guess it took a while to get published for real. Sometime the cache is just in the way.
Please try again,
Stefan
Projections are indeed very powerful. A use case within the product is the generation of JavaScript, CSS and localization files when you compile a Zen or Zen Mojo page.
Projections are a good tool if you have to do something every time you compile a class.
I have played with Visual Studio Code, but at its core, it is nothing more than a smart text editor like TextMate2 with some extensions for running tasks. It includes the runtime and can, therefore, add a debugger, which is nice. But it is not a full blown IDE.
VS Code has a user group, but it is not build to allow more complex workflow integration, which is something Atelier wants to offer at some point.
I am sure Bill can provide more insight.
Congratulations! I am looking forward to meeting you at the Global Summit.
Stefan
For the moment, I subscribed to all group and post activity in my subscription tab. Make sure to select "content types". This way I get a mail for any activity, which can be noisy, but at least, I am sure I am not missing anything.
I hope for better days. ;)
Sounds like a use case for a DTL if you ask me. Even if it's not and you have to be very generic, I would start with a DTL and take a look at the compiled code as a starting point.
Take a look at the work queue manager. Tom posted a thread here:
https://community.intersystems.com/post/using-work-queue-manager-process-data-multiple-cores
In Zen applications, you can make use of asynchronous background tasks, but you can only observe one task at a time.
You can define quoted property names, e.g.:
Property "not_a_number" As %String;
same for runtime properties:
set object."not_a_number" = "28456"
Thanks Eduard for posting the working solution. The reason why this works is that you actually create an object of your registered class and assign the values. The jsonProvider API can now walk the object and project the types properly.
In the non-working example, you created a zenProxyObject and assigned the values on your own. The zenProxyObject just deals with auto-types and guesses the best possible type fit. As you see, this guess can't be correct all the time as in this case.
If you want to create a JSON structure with specific types, either use a) the new JSON support in 2016.1 (recommended if 2016.1 is available) or b) create a subclass from %RegisteredObject and use the jsonProvider API.
What Eduard means is that you can create a registered class, with typed properties (a boolean and a numeric in your case), populate it and then transform to JSON using the jsonProvider.
That is the only valid approach to control JSON types in versions before 2016.1. Everything else is a hack.
Scott,
the INFORMATION_SCHEMA sample works with pure SQL. Just run the query and substitute parameters:
select COLUMN_NAME from INFORMATION_SCHEMA.COLUMNS where TABLE_SCHEMA = ? and TABLE_NAME = ?
Tim just wrote a COS wrapper to output the column names as a string.
Java yes, fuzzy for dotNet. It depends how well we can increase the throughput of the TCP/IP mode there.
The managed provider uses TCP/IP.
The confusion probably stems from XEP (eXtreme Event Persistence).
XEP for dotNet still has an in-memory and a TCP/IP connection mode. As Bill indicated we are moving away from the in-memory mode, as we are improving the throughput of the TCP/IP mode. We already deprecated the in-memory connection mode for XEP for Java where the performance is already pretty much the same. The in-memory connection mode has two issues as a) crashes on the client can interfere with the server and b) it does not allow the client to run on a different machine, which is a problem for scaling up.
What I have done in previous projects is to link the correlated records, e.g.:
ID CitizenRef RelocationDate City Surname NextLocationId
...
48 1000 2015-04-01 Boston Smith 49
49 1000 2015-07-01 Seattle Smith 50
50 1000 2015-10-01 Boston Smith 51
51 1000 2016-01-15 NewYork Smith NULL
You can quickly filter for current locations by setting your filter to "NextLocationId IS NULL". This is not very different from the other comments so far, but this approach is more flexible.
If you ask the question: "Who lived in Boston and relocated to Seattle" you can check for the case (pseudo-filter)
City="Boston" AND NextLocationId.City="Seattle"
You can even ask more complex questions like "Who relocated to Boston and stayed longer than a year after living in NewYork?"
$push/$pop is already available and the other methods you mentioned are on our list for 2016.3.
A $lb conversion utility is not on our roadmap at the moment. $compose is available starting with 2016.2 and helps to convert dynamic objects into registered objects and vice versa (e.g. %ListOfDataTypes and %ArrayOfDataTypes).
You have to create a dedicated CSP application for REST calls using the %CSP.REST architecture as all calls that match the CSP application path will be forwarded to the REST dispatcher class.