review | 세미나 및 책, 강연등의 후기

I would go with a variant of your Repository solution. In a project, we had UseCase and Handler structures. To simply put;

1. It is the main method, so there is no need to cleanup. When main returns, the program exits. If this wasn't the main, then you would be correct.

2. There is no best practice that fits all use cases. The code you show here is a very common pattern. The function creates a goroutine, and returns a channel so that others can communicate with that goroutine. There is no rule that governs how channels must be created. There is no way to terminate that goroutine though. One use case this pattern fits well is reading a large resultset from a database. The channel allows streaming data as it is read from the database. In that case usually there are other means of terminating the goroutine though, like passing a context.

3. Again, there are no hard rules on how channels should be created/closed. A channel can be left open, and it will be garbage collected when it is no longer used. If the use case demands so, the channel can be left open indefinitely, and the scenario you worry about will never happen.

Try changing the file path to another directory. Sometimes there are some permission issues for C drive.

Are these HTML tags? Add crossorigin attribute to the end of your script tag then.

I believe that this is all related to the repo URL problems over the last week or so. More info is here https://github.com/grails/grails-core/issues/11825 but in general it sounds like the http URLs are either going away, or gone already.

Specifically reference https://github.com/grails/grails-core/issues/11825#issuecomment-859692299 in which Jeff Brown states

If the HTTP URLs do resume working without a redirect that will be for a limited period. I would not suggest reverting any updates you have already made to the HTTPS repository URLs. I would also strongly consider taking the time to update your remaining applications.

Change to https and come back with whatever problems you run into then...I would expect someone here can help work through those.

Or is it mandatory that a module has a screen?

No, of course not, modules have nothing to do with views or view models. They are just a set of registrations with the container.

what would be the best way to create the instance?

Let the container do the work. Normally, you have (at least) one assembly that only contains public interfaces (and the associated enums), but no modules. You reference that from the module and register the module's implementations of the relevant interfaces withing the module's Initialize method. Some other module (or the main app) can then have classes that get the interfaces as constructor parameters, and the container will resolve (i.e. create) the concrete types registered in the module, although they are internal or even private and completely unknown outside the module.

This is as loose a coupling as it gets if you don't want to sacrifice strong typing.

is there a way to get rid of that var searcher = containerProvider.Resolve(); and a better way to achieve this?

You can skip the var searcher = part :-) But if the HotfixSearcher is never injected anywhere, it won't be created unless you do it yourself. OnInitialized is the perfect spot for this, because it runs after all modules had their chance to RegisterTypes so all dependencies should be registered.

If HotfixSearcher is not meant to be injected, you can also drop IHotfixSearcher and resolve HotfixSearcher directly:

Hey everyone who reads this message! I have found the solution here:

https://gist.github.com/jherax/f11d669ba286f21b7a2dcff69621eb72

It's highly likely that you will find it there too if you are brought here by the same question as above.

I would suggest that you have separate tables for each entity:

• shop
• product
• review, which has foreign key references to the above

You can use constraints to limit one review per shop/user and product/user.

Why? First, this "naturally" fits your data. More importantly, you may change or relax your limitations over time. For instance:

• Reviews might be "replaced" or "updated" and you might want to keep a history of the reviews.
• You might allow more than one review at a given time.

When you have multiple YAML documents in one file these are separated with a line consisting of three dashes, or starting with three dashes followed by a space. Most YAML parsers, including ruamel.yaml either expect a single document file (when using YAML().load()) or a multi-document file (when using YAML().load_all()).

The method .load() returns the single data structure, and complains if there seems to be more than one document (i.e. when it encounters the second --- in your file). The .load_all() method can handle one or more YAML documents, but always returns an iterator.

Your input happens to be a valid multi-document YAML file but the markdown part often makes this not be the case. It easily could always have been valid YAML by just changing the second --- into --- | thereby making the markdown part a (multi-line) literal scalar string. I have no idea why the designers of such YAML frontmatter formats didn't specify that, it might have to do that some parsers (like PyYAML) fail to parse such non-indented literal scalar strings at the root level correctly, although examples of those are in the YAML specification.

In your example the markdown part is so simple that it is valid YAML without having to specify the | for literal scalar string. So you could use .load_all() on this input. But just adding e.g. a line starting with a dash to the markdown section, will result in an invalid YAML document, so you if you use .load_all(), you have to make sure you do not iterate so far as to parse the second document: