best-practices | Documents best practices for software development

To understand what's going on you need to be familiar with Hibernate ORM entity states.

In your case, both entities are managed and therefore Hibernate ORM knows that it needs to apply the changes. item3 is managed because it has been persisted, order is managed because it's the result of a find.

The javadoc for session.save starts with:

Persist the given transient instance ...

None of the entities are transient in this case.

Note that you would be able to change the example, depending on how you map the association with different cascade types.

For example, if the association items is mapped using CascadeType.PERSIST, this would also work:

The problem here is that Group is a component returned by the navigator. If we create a JSX component that returns that group instead, then this is technically not a Group anymore but its own JSX component.

This is an unsolved problem in react-native-navigation and is discussed in this GitHub issue, but has apparently no satisfying solution other than an ugly hack.

We can call the functional component inline.

Instead of using that and following setup of GCP CA setup i would suggest using cert-manager with the ingress.

Cert-manager will get the TLS cert from let's-encrypt CA , cert-manager will create the secret into k8s and store verified certificate into a secret.

You can attach secret with the ingress, as per host and use it.

Cert-manager installation

YAML example :

I'm confused about where and when I should use Task.Run

On ASP.NET, almost never. You can adopt "never" as a general rule.

and where and when I should (can) write async web API.

Your controller actions should be asynchronous if and only if they invoke asynchronous code. Generally speaking, you should prefer asynchronous APIs at the lowest level for all code that performs I/O. Then your action methods are asynchronous only if they need to call that asynchronous code.

I should write a web method synchronously because there is no async version ... but for method 2 I can change it this way

Yup.

Is there any way to run the first API async?

Think of it this way: if there is synchronous (CPU-bound) work to do, then that work needs a thread. It's already running on a thread pool thread (because web requests run on threads from thread pool). Task.Run will move that work to a different thread pool thread, but it will still run on a thread pool thread. So Task.Run doesn't help anything; it just adds overhead and provides no benefit. Hence the general rule of "don't use Task.Run on ASP.NET".

There's a difference between these attributes. text asks Git to perform line ending conversion. Any time Git does this, it will store LF endings in the repository, and it will convert them when it checks files out in the working tree. text=auto asks Git to search the beginning of the file for a NUL byte, and if it finds one, then the file is binary and conversions are not performed; otherwise, the file is text, and conversions are performed. This usually works fine in most cases, and is a sensible default.

By default, Git honors several configuration variables to decide what line ending conversion should be used in the working tree (LF or CRLF), unless the eol attribute is set. If eol is set, then (a) the file is automatically set to be text and (b) that line ending is always used.

So in the former case, * text=auto says, "Guess whether this is a text file, and if it is, check this file out with the user's preferred line endings." The eol=lf applies only to files that are guessed as text in this case, as of Git 2.10. In general, eol applies if text is set explicitly, text=auto is set and the file is detected as text, or if text is left unspecified; in Git 2.10 and newer, it doesn't affect files explicitly marked -text or detected as binary with text=auto.

However, if you're using older versions of Git, this can cause some binary files to be mishandled, since it will force them to always be text. If your repository contains only text files, then it will work, but this is better written as * text eol=lf. Otherwise, you can specify different types of files separately:

"Persisting" in most cases means "storing". Just that. Fancy word for simple thing.

It doesn't really matter if it's database storage, file storage, internet cloud storage, or, yes, even in-memory storage -- even though "in-memory" doesn't usually coincide with thinking about storage, since it tends to evaporate when the power goes out. It's more about how you are going to use this data, rather than where you are going to store it. So even building a in-memory most-recently-used list of terms can be thought as "persisting", if it's kept long enough in a typical non-disastrous case.

So, yes, storing unicode strings in a database is exactly as good use case for the word "persisting" as it can be.

--

However, for your use-case of determining whever the text entered by the user has changed, I'm not sure if you should focus on the 'persisting' aspect. At this point I think you don't really care about storing, you care about "has it been changed", and that should determine the choice of string comparison.

All StringComparison flags have some effects. Culture vs Invariant, Case-Sensitive or not, how would you like the comparison to behave, so that the result will be clear and understandable to the user?

If old text was "Mary has a lamb" and new text is "mAry HaS a Lamb", should it be treated as a change?

If old text was "Maria hat ein weißes Lamm" and new text is "Maria hat ein weisses Lamm", should it be treated as a change?

and so on. Right now I can't think of better examples, I'm sure you could think of some when focusing on your userbase and on what will be of the most use to them.

Please note, that they also may not care, and that you may be overthinking it or focusing on too tiny details too soon. Maybe the default comparison would be just fine for first few years until users tell you it could be better here and there? Dunno. YMMV :)

There are very few possibilities where this test would do something useful. All of them would involve that the constructor of Test does some kind of registration on a global variable (either register itself on a global event or store the this pointer in a static member). Since that is something that's very rarely done, doing the above test for all classes is overshooting. Also, the test does not cover the far more typical cases for a memory leak in C#: Building up a data structure (e.g. a List) and never clean it up.

This test may fail for a number of reasons: GC.Collect() does not necessarily force all garbage to be cleaned. It should, but there's no guarantee that it will always happen. Also, since testObj is a local variable, it is not yet out of scope when you call GC.Collect(), so depending on how the code is optimized, the variable cannot be considered garbage yet, which makes the test fail.

I discovered a cool feature in Android Developer options, called App Compatibility Changes. Google describes these Compatibility Framework Tools in this way:

Android 11 introduced new developer tools for testing and debugging your app against the behavior changes in newer versions of the Android platform. These tools are part of a compatibility framework that lets app developers turn breaking changes on and off individually using developer options or ADB. Use this flexibility as you prepare to target the latest stable API version and as you test your app with the preview release of the next Android version.

Wow, and looking at it on the phone, it appears you can actually toggle each new feature/change on or off individually?

Well, let's see; first it gives us a list of all the debuggable apps on the device, and if we select one of them, say, targeting API 29, then we can actually toggle on/off each API 30 feature individually, as shown in the example below, with CALLBACK_ON_CLEAR_CHANGE.

Cool! Just two points to note: this works with debuggable apps only; and if you're wanting to turn on/off features of API 30, build your debuggable app targeting the API level below it, i.e., API 29 in this case, and then turn on/off features and test away! If you've no idea which feature is causing the problem(s), you can speed up the search by selecting, say, half of the 30 or so changes, see if the problem(s) are there or not, and so on, to zoom in to the right toggles.

In my opinion, the priority requirement of a theme system is easily changing the appearance. So your first solution would be suitable for this case. Let's talk about its cons.

This approach obviously results in a myriad of variables, as we need to define a separate variable for each place where we need to apply a different color.

More variables are needed. Cause they serve different purposes. And when you re-design your theme, it will help you quickly change the appearance without traveling into all the components files. And you only need to care about it just in case re-design the theme. So I think it should not be counted as cons.

If you later want to introduce additional button variations, you'd have to edit both colors.css and button.css.

Again, I don't consider this is cons because you just need to add some extra code in 2 files. And these codes will not affect anything that exists before.

But you forgot to mention the biggest con of this approach. It is you need to rewrite the CSS rules. What's happens if we use a gradient background? The code will be something like that: