diagrams | : art : Diagram as Code for prototyping cloud system | Architecture library

It's quite simple really. You take the last bar from 4(a) and stick it on the first bar of 4(a). That results in the first bar of chart 4(b). Then you take the second to last and second bar of chart 4(a), stick them on top of each other and you get the second bar for chart 4(b). And you can do this for the other bars as well.

That's just a visual representation of the formula so that you can easily see it's n(n+1)/2.

When you think of it in more mathematical terms it's also quite logical.

We have n summands.

1 + 2 + 3 + ... + (n-3) + (n-2) + (n-1) + n

Now write the same numbers from 1 to n beneath this in reversed order so from n to 1.

n + (n-1) + (n-2) + n(n-3) + ... + 3 + 2 + 1

Now merge those two sequences and rearrange the summands intelligently and set some parenthesis.

[n + 1] + [(n-1) + 2] + [(n-2) + 3] + [(n-3) + 4] + ... =

We still have n summands, each of them is (n + 1) but as we've just written the same numbers twice we need to divide our result by 2.

(n + 1) + (n + 1) + (n + 1) + (n + 1) + ... = n (n+1) /2

Given the hypothesis n (n+1) /2 it's not hard to proof via induction that this is in fact true. See Wikipedia.

From the error (below) returned by your code when calling plot_diagram('not B'):

Fun question! I haven't encountered it yet, but there might be a package to help do this automatically. Here's a manual approach using two hacks:

1. the clip = "off" parameter of the coord_* functions, to allow us to add annotations outside the plot area.
2. building a density plot, extracting its coordinates, and then rotating and translating those.

First, we can make a density plot of the change from initial to final, seeing a left skewed distribution:

Normally, when people talk about using composition vs. inheritance, they are talking about alternative ways of solving the same problem. In both cases, a "base class" provides an implementation of an interface that you want to reuse in your "derived class"

When you implement this with inheritance, there is an undesirable is-a relationship between the derived class and the base class, with the effect that implementation details of the base class, which should be hidden, can become changes in the derived class class.

When you implement this with composition -- a real composition relationship -- the "derived" only has an is-a relationship with the interface that it wants to implement, and the cost of this is that it must delegate calls to the "base" class.

In the Bridge pattern, which you reference, the goal is a little different. You do want to isolate the containing class from change to the connected implementation, but there is no is-a relationship between the containing class and an interface of the contained class.

The relationship between them may be one of composition, or may be simple aggregation -- that is an implementation detail. Often, the concrete implementation of the contained class will be injected as an interface into the containing class constructor, and in that case the relationship is just aggregation.

The purpose of the feature is not necessarily to accelerate code.

An important purpose of the feature is to enable reliable use of programming models such as producer-consumer within a warp (amongst threads in the same warp) that would have been either brittle or prone to hang using the previous thread schedulers pre-volta.

The typical example IMO of which you can find various examples here on the cuda tag, is people trying to negotiate for atomic locks among threads in the same warp. This would have been "brittle" (and here) or not workable (hangs) on previous architectures. It works well, on volta, in my experience.

Here is another example of an algorithm that just hangs on pre-volta, but "works" (does not hang) on volta+.

There are two main ways of representing the sending of a movement message between two devices:

1. A movement() operation on the target device, with parameters for the velocity and direction. You would typically show the exchange in a sequence diagram, with a call arrow from the sender to the receiver. The return message could just be label as ACK.

2. A «signal» Movement: Signals correspond to event messages. In a class diagram, they are represented like a class but with the «signal» keyword: velocity and direction would be attributes of that signal. ACK would be another signal. The classes that are able to receive the signals show it as reception (looks like an operation, but again with «signal» keyword).

In both cases, you would show the interactions of your communication protocol with an almost identical sequence diagram. But signals are meant for asynchronous communication and better reflect imho the nature of the communication. It's semantic is more suitable for your needs.

If you prefer communication diagram over interaction diagrams, the signal approach would be clearer, since communication diagrams don't show return messages.

With the diagrams, your edited question is much clearer. My position about the use of signals is unchanged: signals would correspond to the information exchanged between the computer and the car. So in a class diagram, you could document the «signal»Movement as having attributes id, velocity and direction:

In your sequence diagram, you'd then send and arrow with Movement (X,100,0). Signal allows to show the high level view of the protocol exchanges, without getting lost on the practical implementation details:

The implementation details could then be shown in a separate diagram. There are certainly several classes involved on the side of the computer (one diagram, the final action being some kind of sending) and on the side of the car (another diagram: how to receive and dispatch the message, and decode its content). I do not provide examples because it would very much look like your current diagram, but the send functions would probably be implemented by a communication controller.

If you try to put the protocol and its implementation in the same diagram, as in your second diagram, it gets confusing because of the lack of separation of concerns: here you say the computer is calling a send function on the car, which is not at all what you want. The reader has then difficulty to see what's really required by the protocol, and what's the implementation details. For instance, I still don't know according to your diagram, if setVelocity is supposed to directly send something to the car, or if its a preparatory step for sending the movement message with a velocity.

Last but not least, keep in mind that the sequence diagram represents just a specific scenario. If you want to formally define a protocol in UML, you'd need to create as well a protocol state machine that tells the valid succession of messages. When you use signals, you can use their name directly as state transition trigger/event.

For Azure DevOps Services' Wiki, adding this line works with your chart. It's line #3 in the full chart source below.

• %%{init: {"flowchart": { "useMaxWidth": false } }}%%

In short: yes. You can do that with no issue.

In more detail: try to stick to UML rules but don't get blocked by just looking into the law book. Of course it's best to not violate the rules set up by the UML gods. But like when you are standing a red cossing light at night where you can see and hear nobody else, then what would hinder you to cross the street anyway?

One common mistake seen so often is to forget putting join nodes in ADs which will make the whole network get stuck at a particlar action. Yes, wrong. But basically only to machines and most people can read the meaning witout any issue. Only the lawyers will pick that up as being wrong.

So to sum up: when you model something and you feel that it transports the message then it's okay. Even when being not 100% correct. Strive for correctness but don't let it block you from doing the job. If you raise discussion it ain't bad. Not at all! Models are meant to discuss about something. So if your model got a discussion started it's even better. You can always ask for advice and fix it later.

I think my favorite page 110 of UML 2.5 is quite clear about this:

Sometimes a Property is used to model circumstances in which one instance is used to group together a set of instances; this is called aggregation. To represent such circumstances, a Property has an aggregation property, of type AggregationKind; the instance representing the whole group is classified by the owner of the Property, and the instances representing the grouped individuals are classified by the type of the Property. AggregationKind is an enumeration with the following literal values:

none Indicates that the Property has no aggregation semantics. shared Indicates that the Property has shared aggregation semantics. Precise semantics of shared aggregation varies by application area and modeler. composite Indicates that the Property is aggregated compositely, i.e., the composite object has responsibility for the existence and storage of the composed objects (see the definition of parts in 11.2.3).

Composite aggregation is a strong form of aggregation that requires a part object be included in at most one composite object at a time. If a composite object is deleted, all of its part instances that are objects are deleted with it.

Emphasis by me. Shared aggregation is out of the run in any case since its semantic is undefined by definition. So the implication is only for composite aggregation.

What is the standard?

UML has quite some history. And there are lots of citations out there. Only the fewest get updates along with UML evolving. Although Booch et al. invented UML, they are no longer defining the standard. That's done by OMG and they publish the ISO standard (for which you can pay extra money if you like). Quite some terms go round which have ancient origins and are outdated the one or other way. Still, they are being used - and in the now wrong context.

Is the standard perfect?

Definitely not. It's evolving and still has quite some flaws or misconceptions. In my opinion the introduction of shared aggregation in UML 2.0 was not a so good idea. To define something that has no definition per definition seems odd. And looking at the confusion about this concept proves me right.