Would be nice to have the support corner again to talk with the WRC folks. 

Benefits? Healthcare? comp band? remote possible? 

while you can (clumsily) script terminal sessions, it might be easier to connect to your db via odbc and use isql, or maybe even use the newer python capabilities to get your data out via a python script

especially when there are cases where the first few people per problem took hours for the split time and then there's a lot of people with sub 1 minute times.  I won't go through the effort of looking through their code to see if they actually only had to do a one line change to solve the second part. i would call that suspicious. 

a really good analysis is also to look at the split times of everybody (=how long between submitting part 1 and part 2).  the api gives us the data. 

you weren't the only one :) 

Please note that 12 characters is very much not a secure password, regardless of the characterset.
https://www.explainxkcd.com/wiki/index.php/936:_Password_Strength

any other restrictions on the code we should be aware of?

How are you protected in this setup against two instances coming up and writing into the same db? I.e. due to flaky network?

The link doesn't work.  Also note my other response, there is actually an API for that already. 

I think this " OAuth authorization is much more robust and recommended for production use. " should be emphasized a bit more :) This might lead to people getting the idea that rolling their own encryption related code is an acceptable idea :/

typo: zuauthenticat -> zauthenticate

It's a proprietary compiler compiling into a proprietary bytecode. So no llvm support, and certainly no in depth documentation of it ;)

Even just doing a read access is significantly slower with the %DynamicArray types. I ran into that during the Advent of Code puzzles and had to fall back to $LB lists and arrays. consider a simple loop to go through 100k items:

Class fkh2019.Bench Extends %RegisteredObject
{

ClassMethod listtest()
{

    #; let's build a long list
    s mylist=""
    for i=1:1:100000{
        s mylist=mylist_$LB(i)
    }
    s start=$P($ZTS,",",2)
    Set P=0
    While $LISTNEXT(mylist,P,value) {
        s disgard=value
    }
    s end=$P($ZTS,",",2)
    return end-start
}

ClassMethod dyntest()
{
    #; let's build a long list
    s mylist=[]
    for i=1:1:100000{
        d mylist.%Push(i)

    }

    s start=$P($ZTS,",",2)
    Set it=mylist.%GetIterator()
    While it.%GetNext(.key,.value) {
        s disgard=value
    }
    s end=$P($ZTS,",",2)
    return end-start
}

ClassMethod runtests()
{
    s t1=..listtest()
    s t2=..dyntest()
    w "list access took ",t1, " seconds",!
    w "dyn array access took ",t2, " seconds",!
}

}

The %DynamicArray takes about 15x longer:

IRISAPP>d ##class(fkh2019.Bench).runtests()
list access took .005273 seconds
dyn array access took .082946 seconds

Thanks, it was a lot of fun! Good coding everybody and a happy new year to you all!

Anything using process memory usually falls over really quick as soon as you try and start using it for real use cases. Even increasing bbsiz is only a temporary band-aid in most cases.

It's a graph library that allows me to create a generic graph. the shortestPath method uses A* (https://en.wikipedia.org/wiki/A*_search_algorithm) to find the shortest path connecting two nodes in the graph. This is reusable in all of the 'find a path through a maze' kind of puzzles. The lack of generalized libraries/tools is the biggest drawback in COS. For example Day20, part1: https://github.com/kazamatzuri/AoC/blob/1387289dbcacfa2d7dd62906e873c074...

 k ^grid,^ports,^portals
    d ..parseInitial()
    d ..buildGraph()
    d ..findPortals()
    d ..linkPortals()

    s entry=$LG(^portals("AA"),1)
    s exit=$LG(^portals("ZZ"),1)
    zw entry
    w " -> ",!
    zw exit
    s path=..graph.shortestPath(entry,exit)    
    s length=$LL(..graph.shortestPath(entry,exit))-1
    return length