flows | repository contains a library of flows and function

No, it doesn't work like this. Each item in the input collection gets processed separately, and so each execution of it gets its own unchanged copy of the Validated dataset.

section 16.12.3: tokens offered on ActivityEdges that cross into an ExpansionRegion from outside it are duplicated for each expansion execution

In order to get what you want, you need to use «stream» instead of «iterative».

If the value is stream, there is exactly one expansion execution

You don't even need the central buffer. The first execution of Apply Template will consume the token with the Validated Dataset. The second and all following executions will receive the Partial result from its own output pin.

Output pins on expansion regions are allowed, but no semantics is defined in UML

ExpansionRegions may also have OutputPins and ActivityEdges that cross out of the ExpansionRegion from inside it. However, the semantics are undefined for offering tokens to such OutputPins or ActivityEdges.

That is a little strange. I think it makes sense to define, that any token that is offered to the output pin will be stored there, but only offered to the outgoing edge once all executions are completed. This would correspond to the behavior defined for expansion nodes:

When the ExpansionRegion completes all expansion executions, it offers the output collections on its output ExpansionNodes on any ActivityEdges outgoing from those nodes (they are not offered during the execution of the ExpansionRegion).

In order to only return the final result you could use «overwrite» on the output pin. This way, each subsequent result will overwrite the previous results.

I think there are some issues that you should correct in the diagram that are not related to your questions.

• The rectangles in the top row of the diagram are probably Activity Parameter Nodes. As such they are supposed to overlap the border of the diagram. Also their types would be shown inside the rectangles and they would need to be connected to input pins on the other side.
• You are mixing pin (e.g. Partial res validation) and object notation (e.g. Partial result). I recommend sticking with one possiblity.
• Object notation is only possible, where an object flow connects two pins. For example the rectangle labeled Templates on an object flow connecting a pin to an expansion node is not correct.
• The partial result is used multiple times. Since a token can only be consumed once, this is a deadlock. You need to use a fork node to split it into four.
• The output pin on the expansion region should be on the outside of it.
• The zigzag shaped arrows are exception handlers. I guess you wanted them to be interrupting edges, but those can only be used within interruptible regions. You would need to add these regions. Then you also need a decision node to test the result of the validations and if it's a failure leave the interuptible region via an interrupting edge.
• The three incomming edges to Error Report mean, that all of them must have a token. You need to add a merge node before the action.

I found a solution after looking into open issues on github. Apparently, node.x and node.y cannot be equal to 0: https://github.com/plotly/plotly.py/issues/3002

I'm not sure why, once that problem was solved, the dynamically created y positions now resulted in reverse of intended order. I supposed they are counted from the top rather than the bottom?

This had very little (read no) connection to fragments, lifecycle, flows and coroutines blocking - which I thought was behind this.

You are going to run into problems with this approach because the call to start a new flow may not immediately cause the list_executions() to show a new number. There may be some seconds between requesting that a new workflow start, and the workflow actually starting. As far as I'm aware there are no strong consistency guarantees for the list_executions() API call.

You need something that is strongly consistent, and DynamoDB atomic counters is a great solution for this problem. Amazon published a blog post detailing the use of DynamoDB for this exact scenario. The gist is that you would attempt to increment an atomic counter in DynamoDB, with a limit expression that causes the increment to fail if it would cause the counter to go above a certain value. Catching that failure/exception is how your Lambda function knows to send the message back to the queue. Then at the end of the workflow you call another Lambda function to decrement the counter.

UML is method-agnostic. Even when there are no choices to make, there are different approaches to modeling, fo example:

• Have one model and refine it succesfully getting it through the stages requirements, analysis (domain model of the problem), design (abstraction to be implemented), implementation (classes that are really in the code).
• Have different models for different stage and keep them all up to date
• Have successive models, without updating the previous stages.
• keep only a high level design model to get the big picture, but without implementation details that could be found in the code.

Likewise, for your question, you could consider having different alternative models, or one model with different alternatives grouped in different packages (to avoid naming conflicts). Personally, I’d go for the latter, because the different alternatives should NOT be detailed too much. But ultimately, it’s a question of cost and benefits in your context.

By the way, Ivar Jacobson’s book, the Object advantage applies OO modeling techniques to business process design. So UML is perfectly suitable for a human solution. It’s just that the system under consideration is no longer an IT system, but a broader organisational system, in which IT represents some components among others.

Let me frame this by saying I don't think there's an "authoritative" answer to this question. That said, you've provided enough constraints that a suggested path is at least worthwhile. Let's review the requirements:

• Solution must use std::vector. This is in my opinion the most unfortunate requirement for reasons I won't get into here.
• Solution must be standards compliant and not resort to rule violations, like the strict aliasing rule.
• Solution must either reduce the number of allocations performed, or reduce the overhead of allocations to the point of being negligible.

In my opinion this is definitely a job for a custom allocator. There are a couple of off-the-shelf options that come close to doing what you want, for example the Boost Pool Allocators. The one you're most interested in is boost::pool_allocator. This allocator will create a singleton "pool" for each distinct object size (note: not object type), which grows as needed, but never shrinks until you explicitly purge it.

The main difference between this and your solution is that you'll have distinct pools of memory for objects of different sizes, which means it will use more memory than your posted solution, but in my opinion this is a reasonable trade-off. To be maximally efficient, you could simply start a batch of operations by creating vectors of each needed type with an appropriate size. All subsequent vector operations which use these allocators will do trivial O(1) allocations and deallocations. Roughly in pseudo-code:

Using a void * as an argument compiled successfully for me. It's ABI-compatible with the pybind11 interfaces (an MPI_Comm is a pointer in any case). All I had to change was this:

You can use something like this:

This diagram is not bad. It is however somewhat confusing, because:

• Login is not really a use-case, even if it's a popular practice. This has however no impact on your SD diagram itself.
• Showing actors in a sequence diagram is not formally correct, even if it's a popular practice.
• Login Screen is in fact a part of System, which creates a kind of implicit redundancy.

Don't worry about too much about the two first points, if this is the kind of practices that your teacher showed you.

The last point could easily be addressed:

• The last lifeline could be more specific about the internals (example here), or,
• Keep only two lifelines, one for the actor and one for the system. THis is in my view the better alternative when you use actors in a SD.