scream | Virtual network sound card for Microsoft Windows

The createUser() method returns a UserRecord which has no user property. Also it seems you are trying to get a user's ID Token using Admin SDK which is not possible natively. Checkout In firebase - How to generate an idToken on the server for testing purposes? for more information.

When the user is created on server, you can simply send back a response and then log in the user using Firebase Client SDKs. Also try refactoring the code as shown below:

My question is if this is common and what the reason would be to not include the layer structure in some way?

The question is "Does the structure of the code give you any benefit?" and this depends on the programming language you use.

In Java, for example, you have the access modifiers public, protected, private and default (no modifier). The default and the protected allows access within the same package. The protected also allows access in extended classes elsewhere. This means that if you make use of this modifiers you can control the visibility of classes, methods and fields.

Controlling access to classes and class members can make your life a lot easier. I often see that the public modifier is extensively used. This leads to some problems:

1. Developers often introduce dependencies between classes that were never intended, but they are introduced because you could do it.
2. If everything is public the IDE can not support you well. Developers ususally use some kind of auto-completion or they use type searches when writing code. If everything is public, then everything can be accessed from everywhere. Since the IDE will list you all accsessible options, it will show you a long list of entries. Thus public doesn't make life easier. It's also sad but true that as a result of this developers often introduce more packages to organize the code and therefore make it worse by thinking they make it better.

Simon Brown, who wrote the chapter "The missing chapter" in the clean architecture book, says:

The access modifiers in Java are not perfect, but ignoring them is just asking for trouble. The way Java types are placed into packaged can actually make a huge difference to how accessible (or inaccessible) those types can be when Java's access modifiers are applied appropriately. If I bring packages back and mark (by graphically fading) those types where the access modifier can be made more restrictive, the picture becomes pretty interresting.

The diagram is taken from the clean architecture book, chapter "the missing chapter", page 318.

Now you can see the differences between the packaging types. If everything is public they are all effectively equal.

More information can be found here:

• Modular Monoliths, Simon Brown, GOTO 2018
• Separation of api and implementation, René Link, Feb. 2012

You may try:

You should give the value to the closures. Here both closures have an input parameter of a String type, and the multipleTrailing function gives the sound parameter to both of them. On the caller site this parameter can have any name (here I gave them sound in both places), and you can access those values

You need to modify the code to implement Box> rather than Box. The latter presumably implements Cu32Tst<'static>, which is not what you want for the blanket implementation of Clone for Cu32Tst<'a>. This compiles:

I would assume the last line (3, 11) in the targeted result is a mistake.

You can find the repeated names with a window function in a subquery and then join it during the update. In short, you can do:

The reason why the expression arr[index:-1, index:-1] = arr[index + 1:, index + 1:] is slow in both Numpy and Cython and the Cython code is much faster is a bit counter intuitive: this expression is not efficiently implemented in both Numpy and Cython.

Indeed, Numpy copy the right-hand side (arr[index + 1:, index + 1:]) in a temporary array allocated on-the-fly. The temporary array is then copied to the left-hand side (arr[index:-1, index:-1]). This means that two memory copy are performed while only one could be used. It is even worse: the copied memory is pretty big and will not fit in the cache resulting in a bigger overhead (on some processors, like the mainstream x86/x86-64 ones, the write-back policy cause additional slow reads). Moreover, the new temporary array will cause many page fault slowing down even more the copy.

Numpy do this because the left-hand side and the right-hand side may overlap (which is the case here) and thus the order in which the memory bytes are copied matter a lot. Numpy use a slow conservative approach rather than an optimized implementation. This is a missed optimization. Cython does exactly the same thing.

Your Cython code do not suffer from all these overheads: it directly copy the array in-place relatively efficiently. The value read are kept in the cache and then written just after so that the write-back policy is not an issue. Moreover, there are no temporary array nor page faults. Finally, your Cython code do not copy the lower-part of the triangular matrix resulting in fewer bytes to be copied compared to the expression previously mentioned.

One way to reduce the overhead of the Numpy expression is to copy the matrix chunk-by-chunk and allocates a small temporary buffer for that (typically few lines of the matrix). However, this is far from being easy since CPython loops are generally very slow and the chunk size should fit in cache so the method can be useful...

Further optimization: conditionals are slow. You can remove them by starting the j-based loop at i+1 and ending it at n-1. Another j-based loop can then fill the value greater than n-1. For the same reason, the i-based loop should end at n-1 and another loop can then fill the remaining part of the array. A good compiler should use faster SIMD instructions.

That's because T will never resolve inside the function implementation as it can be anything. You added an extends Person constraint on it but it can still be anything that extends Person. The actual T type is only known outside the function.

Notice how this code works when you hover the person variable:

The calculation of trId results in overlapping of some indices, and skipping of other values.

With a 4x2 grid of vertices (idx shown) and yColumnHeight of 4: