demeter | DEPRECATED — Security Group Management For AWS | Cloud Functions library

I think you grok the idea but I'm not sure if your example really makes sense. In the context of a board game, it's difficult for the Board to not be concerned with the possible movements! (So applying Demeter here would not make sense as possible the Board already has access to the Movement class).

Don't mock the JPA API, just write integration tests with proper test data and execute the real queries against real data to see if everything works. Projects like testcontainers make it very easy to get started.

I think a lot of what you did, specifically around data wrangling, was not necessary, especially since you called d3.hierarchy() and d3.cluster() afterwards. I've replaced this with d3.stratify (which deals with hierarchical data that is not yet in the right format).

I've also replaced d3.cluster with d3.tree() because it was unclear to me why you'd want to use d3.cluster here. Your data has multiple parents, multiple roots and even floating nodes, and d3 is not meant to deal with that. My workaround has been to attach pseudonodes to every level, so as to make sure that there is only one node and that all nodes are at the right level at all times. To make sure the links were drawn correctly, I've written a custom getLinks function, that can deal with multiple parents.

I've also written a custom link generator that draws the links somewhat in the way that you want them. d3 doesn't offer much of flexibility here, but you can use the source code for inspiration.

Edit

I've changed the logic to be more focused on which "partners" got a child, so both links to the same child are on the same level - like in your picture. I've also drawn the nodes based on how many partners they have, and have given every link an offset so the lines are more distinct.

I've sorted the nodes so that the real pro-creators are at the top (Zeus), which gives a more balanced and less crowded view.

"When your method takes parameters, your method can call methods on those parameters directly."

I'd say the way it's written leaves to interpretation whether the whole method's execution stack should be considered or not (to me it's implied it's to be considered). If it is then it's a violation no matter the added level of indirection (m2) and if it's not then the code doesn't violate the rule. However, this is a guideline and it won't help developers who don't understand the goal it serves: increase encapsulation and limit coupling.

There's certainly a multitude of creative ways to create awful models that still complies to rules & definitions of most design principles, but that's obviously not the point. That's like stating private modifiers can easily be by-passed using reflection: that's true, but it's pretty hard to do that by mistake.

In terms of encapsulation and coupling, there's no distinction between the code you posted and a1.m1().m2(): C1 is coupled to C2 AND C3 which was acquired through C2. The fact C2 clients (e.g. C1) need to dig it's internals is a good indicator that it's encapsulation could be improved.

Another principle which goes hand in hand with the Law of Demeter is the Tell Don't Ask principle, which states that objects should be told what to do rather than asked for their state. This also favors better encapsulation and therefore reduces coupling.

One important note to make though is that there are two types of objects, data structures and "real objects" (data & behaviors). Data structures (e.g. DTOs -- getter/setter bags) aren't subject to most design principles such as the Law of Demeter as their role is solely to represent and share data. However, such data structures are usually found at system boundaries (e.g. application services, HTTP APIs, etc.) and having many of such objects in a model's core is an object-oriented code smell.

The Law Of Demeter strives to reduce coupling between objects following the principle of information hiding. In your example the method m which contains the statement:

This question is indeed interesting from a purely theoretical standpoint. Setting aside whether or not a unary, mutating boolean toggle operator would be useful, or why many languages have opted to not provide one, I ventured on a quest to see whether or not it indeed exists.

TL;DR apparently no, but Swift lets you implement one. If you'd only like to see how it's done, you can scroll to the bottom of this answer.

After a (quick) search to features of various languages, I'd feel safe to say that no language has implemented this operator as a strict mutating in-place operation (do correct me if you find one). So the next thing would be to see if there are languages that let you build one. What this would require is two things:

1. being able to implement (unary) operators with functions
2. allowing said functions to have pass-by-reference arguments (so that they may mutate their arguments directly)

Many languages will immediately get ruled out for not supporting either or both of these requirements. Java for one does not allow operator overloading (or custom operators) and in addition, all primitive types are passed by value. Go has no support for operator overloading (except by hacks) whatsoever. Rust only allows operator overloading for custom types. You could almost achieve this in Scala, which let's you use very creatively named functions and also omit parentheses, but sadly there's no pass-by-reference. Fortran gets very close in that it allows for custom operators, but specifically forbids them from having inout parameters (which are allowed in normal functions and subroutines).

There is however at least one language that ticks all the necessary boxes: Swift. While some people have linked to the upcoming .toggle() member function, you can also write your own operator, which indeed supports inout arguments. Lo and behold:

Finally, I resolved my problem.

Reason was in line - eval $(ssh-agent -s) - when I commented it, the job could be finished (but of course, connection didn't work). So, I attempted add killing command at the end of script:

I don't think so.

Especially this:

Any objects created/instantiated within m

I would apply that to the factory as well. Even though strictly the object's constructor is called in the factory, the object is still constructed by, and especially for m. I would interpret the factory as a special kind of constructor, and look past the fact that you don't see a new keyword there.

Given the various important roles that factories play in software design (inversion of control is one of them), I think they are too valuable to let go. It's better to change your interpretation of this law, or of what a constructor is and use those factories when you want.

Yes, it does violate the law of Demeter. It reaches through truck to get to car.do(), using truck (an alias for parameter car) as a parameter. Car is being passed itself as a parameter)