Afterthought | An open source .NET compile-time code amender | Database library

I found an answer while looking around for related problems: Django 1.11 Annotating a Subquery Aggregate

What I've done is:

• Create a filter with an OuterRef() which points to a User and checks if Useris the same as correct_person and also a comparison between guessed_person and correct_person, outputs a value correct_user in a queryset for all elements which the filter accepts.
• Do an annotated count for how many occurrences there are of a correct_user in the filtered queryset.
• Annotate User based on the annotated-count, this is the annotation that really drives the whole operation. Notice how OuterRef() and Subquery are used to tell the filter which user is supposed to be correct_user.

Below is the code snippet which I made it work with, it looks very similar to the answer-post in the above linked question:

these subtle behaviors

There isn't really anything subtle here.

1. A weak definition means: use this symbol unless another strong definition is also present, in which case use the other symbol.
   
   Normally two same-named symbols result in a multiply-defined link error, but when all but one definitions are weak, no multiply-defined error is produced.

2. A weak (unresolved) reference means: don't consider this symbol when deciding whether to pull an object which defines this symbol out of archive library or not (an object may still be pulled in if it satisfies a different strong undefined symbol).
   
   Normally if the symbol is unresolved after all objects are selected, the linker will report unresolved symbol error. But if the unresolved symbol is weak, the error is suppressed.

That's really all there is to it.

Update:

You are repeating incorrect understanding in comments.

What makes me feel subtle is, for a weak reference, the linker doesn't pull an object from an archive library, but still check a standalone object file.

This is entirely consistent with the answer above. When a linker deals with archive library, it has to make a decision: to select contained foo.o into the link or not. It is that decision that is affected by the type of reference.

When bar.o is given on the link line as a "standalone object file", the linker makes no decisions about it -- bar.o will be selected into the link.

And if that object happens to contain a definition for the weak reference, will the weak reference be also resolved by the way?

Yes.

Even the weak attribute tells the linker not to.

This is the apparent root of misunderstanding: the weak attribute doesn't tell the linker not to resolve the reference; it only tells the linker (pardon repetition) "don't consider this symbol when deciding whether to pull an object which defines this symbol out of archive library".

I think it's all about whether or not an object containing a definition for that weak reference is pulled in for linking.

Correct.

Be it a standalone object or from an archive lib.

Wrong: a standalone object is always selected into the link.

I managed to make it sticky with content going under getting blurred using few tricks:

1. Changed margin to padding so mt-12 becomes pt-12
2. Added pb-10
3. Changed backdrop-filter backdrop-blur from nav to header

This is the code that has changed:

Assuming that dist is a tibble and choice is a vector of values (whose length is equal to the number of columns in dist), I would try something like this:

According to ISO 6709, the correct order is [latitude, longitude].

But many software products and standards require [lon, lat] order. It's not only OpenLayers but for example also PostGis, GeoJSON, KML and almost all professinal GIS applications.

I can think of two reasons why computer scientists have defined it differently than geographers.

• It is conventional math to write f(x,y), i.e. easting before northing.
• The WMS specification 1.0 from 2000 indirectly defined the [lon, lat] order. Software products of that time have implemented this standard. Even if the standard was revised a short time later, the software products remained at [lon, lat] to avoid version problems.

You can get close to what you want with flutter create. If you specify all the same parameters, it will attempt to rebuild rather than replace everything each time. It will overwrite the iOS/Android files as necessary, but it will not overwrite main.dart.

One way to do it is as follows. You can keep an arbitrary number of your experiments in (lib/main1.dart, lib/main2.dart, ...) within a single project. You'd keep all the "intermediate" files in place. You can then run different main.dart files just by typing, for example, flutter run -d "" lib/main2.dart from the same project.

Technically, all your Dart files would still belong to the same project, but you'd be launching just one screen at a time. The screen you're launching would run independently from the remaining n-1 main.dart files in lib.

However, each time you run one main_n.dart, it will replace the existing app on the phone (they'd all have the same app id as that's defined in the native side of things). This is suitable for experimenting quickly, but wouldn't be good for actually publishing.

The O(n*log(n)) lower bound on sorting algorithms only applies to algorithms that can sort arbitrary objects by comparing them to one another. If you know that your data is from a limited domain, you can use more efficient algorithms. For example, if the values are all small integers you can use a counting sort to efficiently sort the data in O(n) time.

Here's an example that can sort sequences that only contain integers from the domain 0-5, like in your example.

Hi can you please check this link -> Click me

It might have to do with Node.js services being smaller in size. If you're coming from an enterprise background, you're well aware mixing business-logic with controller code doesn't fly in the long run. Perhaps small projects can get away with defying that, but once the size increases, you can't avoid the laws of physics. It's best to separate concerns and keep the codebase maintainable.

I'd also add that below services, it's good to have a separate layer that handles talking to outside process boundaries. That way, you can test business logic in isolation by providing appropriate test doubles for integrations. Here's a longer explanation of how it would work in a Node project: Organize Node.js API project using 3-layer architecture.