conventions | GraphQL Conventions Library for .NET | GraphQL library

The plugin by default comes with Checkstyle version 8.29. Try explicitly defining the CheckStyle version (plus a small version bump to 3.1.2). For example, with version 9.2:

If you really want to write, as just an exercise, an assembly function that "conforms" to all the common calling conventions for x86_64 (I know only the Windows one and the System V one), without relying on attributes or compiler flags to force the calling convention, let's take a look at what's common.

The Windows GPR passing order is rcx, rdx, r8, r9. The System V passing order is rdi, rsi, rdx, rcx, r8, r9. In both cases, rax holds the return value if it fits and is a piece of POD. Technically speaking, you can get away with a "polyglot" called function if it (0) saves the union of what each ABI considers non-volatile, and (1) returns something that can fit in a single register, and (2) takes no more than 2 GPR arguments, because overlap would happen past that. To be absolutely generic, you could make it take a single pointer to some structure that would hold whatever arbitrary return data you want.

So now our arguments will come through either rcx and rdx or rdi and rsi. How do you tell which will contain the arguments? I'm actually not sure of a good way. Maybe what you could do instead is have a wrapper that puts the arguments in the right spot, and have your actual function take "padding" arguments, so that your arguments always land in rcx and rdx. You could technically expand to r8 and r9 this way.

Yes, each ABI version is incompatible, but most of the changes affect only rare cases, and hopefully certain versions like 12 are rare because they were fixed quickly. The reason such changes are made at all is usually that certain things mangle to the same name, which breaks even if only one component uses it rather than needing two to be incompatible.

It is likely that the cc65 compiler only supports access to symbols with the ABI-specificed decoration, i.e. those beginning in an underscore _.

To access other symbols, they therefore must either be renamed to follow the decoration or a decorated alias must be created.

Finally because I don't want to change my .net version, I installed the

I think your question is very interesting but a little subjective..

My thought is that we must be build applications that are robust to changes, but remain pragmatic. We need to find the good point between abstraction and implementation (as described in the Clean Architecture book).

In the Java eco-system, The standard JSRs is very often defined around interfaces and not implementations, offering you a good way to avoid tight coupling to a specific framework (ex: JPA instead of Hibernate, JAX-RS instead of Jackson..).

In the Spring ecosystem, you can use these standards annotation (@Inject vs @Autowired), and it will work perfectly, but you will often loose some functionalities offered by the implementations.

Some architectures tends to separate totally the layers between your business code and the framework code (the hexagonal architecture call it the infrastructure and application layers), but it comes at a price..

The probability of this type of migration is unknown and depends on the changing needs of your project (I've never encountered a change of JPA vendor implementation). But I believe that with the most active project (Hibernate, Jackson..), you can try to reduce it.

So... Be pragmatic :)

In short, yes, it's legal.

The concept of an identifier is a syntactic one: when parsing Raku, the parser needs to classify the things it sees, and the identifier rules indicate what sequences of characters should be recognized as an identifier.

By contrast, stashes, method tables, and lexical scopes are ultimately hash-like data structures: they map string keys into stored values. Just as there's no limit on what keys one can put into a hash, there's not one here either. Given meta-objects can be user-defined, it's unclear one could reliably enforce limits, even if it was considered desirable.

The ::(...) indirect name syntax in declarative contexts comes only with the restriction that what you put there must be a compile-time constant. So far as parsing goes, what comes inside of the parentheses is an expression. The compiler wants to get a string that it can use to install a symbol somewhere; with identifiers it comes directly from the program source text, and with indirect name syntax by evaluating the constant that is found there. In either case, it's used to make an entry in a symbol table, and those don't care, and thus between the two, you have a way to get symbol table entries that don't have identifier syntax.

Edit: As @Olivier mentions, my original answer referred to OData in .NET and not Olingo.

Unfortunately as you probably have found out yourself, the standard Olingo documentation doesn't answer this particular question directly, though it does mention support for lazy-loading and streaming behaviour (which would not make any sense to filter on the application level).

However, you would be hard-pressed to find an ORM or DB Adapter nowadays that does not support filtering on the database level, as this will almost always be faster than doing so in your application for non-trivial workloads.

I will try to update this answer with a more authorative source.

(original answer)

According to this analysis:

As long as your data provider supports deferred queries and you don't force evaluation by calling something like .ToList(), the query will not be evaluated until the OData filters are applied, and they'll be handled at the database level.

There is no way inside Remix to run code before loaders.

As you found out, there is the loader context but it runs even before remix starts to do its job (so you won't know which route modules are matched for example).

You can also run arbitrary code before handing the request to remix in the JS file where you use the adapter for the platform you're deploying to (this depend on the starter you used. This file doesn't exist if you've chosen remix server as your server)

For now it should work for some use cases, but I agree this is a missing feature in remix for now.