project | Easy setup of grunt-based automation

If you are using vuetify from vue-cli-plugin-vuetify (vue add vuetify), treeshaking and auto component import is enabled by default, by using vuetify-loader.

If you look into the source code of vue-cli-plugin-vuetify, it only uses vuetify-loader if it is present in your package.json. So removing vuetify-loader from package.json should disable this behavior.

I don't know if I understood your question, but this is what the code is doing:

var_list is a list with two elements [100, 2025].

slice1 and slice2 are being defined as (var_list + [None]*2)[:2]. This expression adds the var_list to a new list of 2 None objects ([None] * 2 == [None, None]). The result of this expression ((var_list + [None] *2)) is the addition of these 2 lists, which is: [100, 2025, None, None]

Then the last part ([:2]) is just slicing the first 2 elements of this resulting list and assigning it to the variables. And since, in this case, the first 2 items are the var_list itself, it will assign the first element to slice1 and the second to slice2.

Since, I am not 100% sure the context in which you are trying to apply the MVC pattern, a good generic explanation of MVC can be found in GoF's 1995 book, Design Patterns: Elements of Reusable Object Oriented Software.

In the book, they state the following.

The Model is the application object, the View is its screen presentation, and the Controller defines the way the user interface reacts to user input.

A more robust explanation can be found from Martin Fowler where he also makes the case for a variation of Model View Controller that uses a Presentation Model.

If you are referring to Spring MVC then there is some magic that blurs the lines a bit. But in general, you have a controller that represents some screen or an encapsulated piece of functionality that the user (web requests) interact with. The controller serves up responses that are derived from the domain, usually via a Spring Service (i.e. @Service). The domain (Model) doesn't know anything about the View and the View may or may not know anything about the domain.

Given that, the View should be derived from the Model. But that's not always the case since sometimes how we present things to a screen is not the best logical way to model things in our domain - not to mention, the domain should be presentation agnostic. This leads into Fowler's argument for a Presentation Model, which is a model that belongs to the Presentation.

I call this a Presentation Model because it's a model that is really designed for and thus part of the presentation layer.

Microsoft took that idea and ran with it in a variant of MVC called MVVM (Model View ViewModel).

You can read more about that in Microsoft's documentation on ASP.Net Core.

So, back to your original question of "Should you pass the model directly to the view?" If you are using MVC then the controller is what provides the interaction. But if you're really asking, "Can you bind your view directly to the model?" If your model has all the stuff you need organized how your view needs it, then sure. And if it's simple enough, maybe that's the way to go. Otherwise, you could go with something like a Presentation Model or MVVM.

You have to initialize all instance properties somehow. And you have to do it right up front, either in the declaration line or in your init method.

But what if you don't actually have the initial value until later, like in viewDidLoad? Then it is silly to supply a real heavyweight value only to replace it later:

I haven't come across such a ConcurrentCounter library, but crates.io is huge, maybe you find something. However, if you are mostly concerned with primitives such as i32, there is a better alternative call: Atomics, definitely worth checking out.

Nevertheless, your approach of generalizing the ConcurrentCounter is going in a good direction. In the context of operation overloading, std::ops is worth a look. Specifically, you need Add, Sub, and Mul, respectively. Also, you need a Copy bound (alternatively, a Clone would also do). So you were pretty close:

Seems like you already have the part where you are extracting the attachments. Try this code to retrieve the body of a multipart email.

You may have to figure out how to merge your part with this one.

Never used protobuf, but, as I understand it's a plugin that generate stuff.

So I'm gonna give you generic pointer hoping it will help. I think you should either try to make 2 jar with different classifier from a single module, see https://maven.apache.org/plugins/maven-jar-plugin/examples/attached-jar.html For example classifier proto2.4 and proto2.5 then you can add the classifier when you define the dependency to that module.

Other option I see is having 2 modules, the real one, you have now, and another one for 2.5 Generate a zip from the main one and the second module would be empty but have a dependency on the generated zip, unzip it and then compile with the plugin config for 2.5 Slower at execution, a bit dirtier imho, but can be needed if for example you need more customization than just the version.

Something like this could work