gof | Go Freely -- a shell script

I am trying to get the second last value in each row of a data frame, meaning the first job a person has had. (Job1_latest is the most recent job and people had a different number of jobs in the past and I want to get the first one). I managed to get the last value per row with the code below:

first_job <- function(x) tail(x[!is.na(x)], 1)

first_job <- apply(data, 1, first_job)

I'm learning Java design patterns by "Patterns in Java", volume 1 by Mark Grand (Factory Method specifically). My point is to highlight difference between closest patterns for myself. There are good answers that clarify the difference between Factory Method and Abstract Factory (Design Patterns: Factory vs Factory method vs Abstract Factory, What is the basic difference between the Factory and Abstract Factory Design Patterns?). But I noticed that most of authors mean some other interpretation of Factory Method compared to one I have read in "Patterns in Java". The interpretation from the answers is closer to Factory Method from GoF book.

GoF interpretation:

Grand's interpretation:

To be specific I will describe what in my opinion is a key difference between Grand's and GoF interpretations. The source of polymorphism in GoF interpretation is inheritance: different implementations of Creator create different types of Products. The source of polymorphism in Mark Grand interpretations apparently is "data-driven class determination" (example from book):

Don't angry with me. I am new in c++ and qt I have used singleton calss following the example from Gof But get Error

Using this little code snippet on CompilerExplorer with std=c++20 for x86-64 clang 11.0.0 compiles and runs.

I am using lmerTest::lmer() to perform linear regression with repeated measures data.

My model contains a fixed effect (factor with 5 levels) and a random effect (subject):

Im a bit confused as to how I should be thinking of my domain aggregate roots. Basically they seem to me as a public api for the client to use which hides the implementation of the aggregate roots children.

so for example if Foo is the aggregate root and Bar is a child entity. If I want the aggregate to perform some sort of action which Bar is involved in then its okay to call methods similar to:

I have an object A used to replace text sequences in a given Word document. To construct A, the following dependency has to be passed to its constructor:

• ReplaceBehaviour: an implementation of an abstract Visitor (Design Pattern) used to replace different types of content (e.g., text, images, tables) in the Word document

A internally uses ApachePOI to process Word documents. The replacement logic is defined in the Visitor implementation (B) which is passed as a dependency to A. However, to perform the replacement, B also requires C. In terms of ApachePOI, C is a XWPFDocument (https://poi.apache.org/apidocs/dev/org/apache/poi/xwpf/usermodel/XWPFDocument.html). Executing the replaceContent method of A, three things happen in the following order:

1. A instantiates a new XWPFDocument (C) based upon the input file path of the Word document
2. A assigns C to the visitor B
3. Visitor is executed on the objects that should be replaced

If I am correct, A is a Facade (GoF design pattern), because it provides an "easier" interface to replace content in the Word document. A is considered "easier", because it encapsulates the entire Apache-POI related code. However, A internally creates the XWPFDocument C and (also internally) assigns it to the Visitor B. I am not sure if assigning C to the Visitor before executing B is considered good practice? If not, how can we solve this in a better way? Alternatively, one could construct C and B, assign C to B and then pass both of them to A on construction. But then, a client using A would have to instantiate a ApachePOI-class (XWPFDocument) him/herself which defeates the purpose of the Facade. The following pseudo code summarizes the problem described above:

I use modelsummary() with kableExtra() to generate a regression table in an Rmd file (final output format: LaTex and HTML).

I run regressions for several variable combinations and model specifications. The regressions are grouped in the table by variable combinations via kable::add_header_above().

For different variable combinations, I run the same models (e.g. OLS & Poisson, or other). To improve readability I would, therefore, like to name the models simply as such, e.g.

I asked here how I should handle the situation when I need to inform observers only when specific attribute of object changes.

I received very nice reply with reference to GoF where is written:

Blockquote Specifying modifications of interest explicitly. You can improve update efficiency by extending the subject's registration interface to allow registering observers only for specific events of interest. When such an event occurs, the subject informs only those observers that have registered interest in that event. One way to support this uses the notion of aspects for Subject objects. To register interest in particular events, observers are attached to their subjects using

void Subject::Attach(Observer*, Aspects interest);

Blockquote where interest specifies the event of interest. At notification time, the subject supplies the changed aspect to its observers as a parameter to the Update operation. For example:

void Observer::Update(Subject*, Aspect& interest);

This makes sense and I would like to ask how to correctly implement this in Java. I have few ideas but I am not sure if there isn't something better.

Let's imagine I have subject class WeatherStation[temperature, humidity, windSpeed ...] and I have observer class LimitedDisplay[show (shows only temperature and humidity) and for some reason I need that the display should be able to differentiate when only temperature was changed and when only humidity was changed.

I was thinking that I could create some enum WeatherStationInterest[TEMPERATURE, HUMIDITY WIND_SPEED...] and then have the subject interface like this: