npe | Node Package Editor : a CLI for one-off inspection | JSON Processing library

I create a variable that points to that saved file. And use js to open the link. And it downloads itself.

why does in Java the call coll.contains(null) fail for ImmutableCollections?

Because the design team (the ones who have created guava) decided that, for their collections, null is unwanted, and therefore any interaction between their collections and a null check, even in this case, should just throw to highlight to the programmer, at the earliest possible opportunity, that there is a mismatch. Even where the established behaviour (as per the existing implementations in the core runtime itself, such as ArrayList and friends, as well as the javadoc), rather explicitly go the other way and say that a non-sequitur check (is this pear part of this list of apples?) strongly suggests that the right move is to just return false and not throw.

In other words, guava messed up. But now that they have done so, going back is potentially backwards compatibility breaking. It really isn't very - you are replacing an exception thrown with a false return value; presumably code could be out there that relies on the NPE (catching it and doing something different from what the code would do had contains(null) returned false instead of throwing) - but that's a rare case, and guava breaks backwards compatibility all the time.

And how can I properly check for nulls in a Collection in general?

By calling .contains(null), just as you are. The fact that guava doesn't do it right doesn't change the answer. You might as well ask 'how do I add elements to a list', and counter the answer of "well, you call list.add(item) to do that" with: Well, I have this implementation of the List interface that plays Rick Astley over the speaker instead of adding to the list, so, I reject your answer.

That's.. how java and interfaces work: You can have implementations of them, and the only guardianship that they do what the interface dictates they must, is that the author understands there is a contract that needs to be followed.

Now, normally a library so badly written they break contract for no good reason*, isn't popular. But guava IS popular. Very popular. That gets at a simple truth: No library is perfect. Guava's API design is generally quite good (in my opinion, vastly superior to e.g. Apache commons libraries), and the team actively spends a lot of time debating proper API design, in the sense that the code that one would write using guava is nice (as defined by: Easy to understand, has few surprises, easy to maintain, easy to test, and probably easy to mutate to deal with changing requirements - the only useful definition for nebulous terms like 'nice' or 'elegant' code - it's code that does those things, anything else is pointless aesthetic drivel). In other words, they are actively trying, and they usually get it right.

Just, not in this case. Work around it: return item != null && coll.contains(item); will get the job done.

There is one major argument in favour of guava's choice: They 'contract break' is an implicit break - one would expect that .contains(null) works, and always returns false, but it's not explicitly stated in the javadoc that one must do this. Contrast to e.g. IdentityHashMap, which uses identity equivalence (a==b) and not value equality (a.equals(b)) in its .containsKey etc implementations, which explicitly goes against the javadoc contract as stated in the j.u.Map interface. IHM has an excellent reason for it, and highlights the discrepancy, plus explains the reason, in the javadoc. Guava isn't nearly as clear about their bizarre null behaviour, but, here's a crucial thing about null in java:

Its meaning is nebulous. Sometimes it means 'empty', which is bad design: You should never write if (x == null || x.isEmpty()) - that implies some API is badly coded. If null is semantically equivalent to some value (such as "" or List.of()), then you should just return "" or List.of(), and not null. However, in such a design, list.contains(null) == false) would make sense.

But sometimes null means not found, irrelevant, not applicable, or unknown (for example, if map.get(k) returns null, that's what it means: Not found. Not 'I found an empty value for you'). This matches with what NULL means in e.g. SQL. In all those cases, .contains(null) should be returning neither true nor false. If I hand you a bag of marbles and ask you if there is a marble in there that is grue, and you have no idea what grue means, you shouldn't answer either yes or no to my query: Either answer is a meaningless guess. You should tell me that the question cannot be answered. Which is best represented in java by throwing, which is precisely what guava does. This also matches with what NULL does in SQL. In SQL, v IN (x) returns one of 3 values, not 2 values: It can resolve to true, false, or null. v IN (NULL) would resolve to NULL and not false. It is answering a question that can't be answered with the NULL value, which is to be read as: Don't know.

In other words, guava made a call on what null implies which evidently does not match with your definitions, as you expect .contains(null) to return false. I think your viewpoint is more idiomatic, but the point is, guava's viewpoint is different but also consistent, and the javadoc merely insinuates, but does not explicitly demand, that .contains(null) returns false.

That's not useful whatsoever in fixing your code, but hopefully it gives you a mental model, and answers your question of "why does it work like this?".

Thanks for the report - it seems that those changes (in PR #740) have been overlooked for the latest versions of the Vaadin Spring add-on. We're going through the changes and making sure those get forward-ported and will be released soon for Vaadin 20 too.

For similar cases, when updating the Vaadin version breaks something, it is recommended to just directly open a new issue to the corresponding repository (like vaadin/spring or vaadin/flow) so it will be noticed immediately by the development team. Thanks

EDIT: The fix has been released in the Vaadin Spring add-on version 17.0.1. You can specify your project to explicitly use that version of vaadin-spring artifact. It will be included in Vaadin 20.0.2 release which is coming by next Monday 14th of June at latest.

You get a NPE because Quarkus is not loaded properly so the CDI container didn't wired up the dependencies.

Quarkus only supports running Azure fonctions via its HTTP layer, it didn't support running arbitrary method like you setup.

You can have a look at the following guide for Quarkus Azure fonction support: https://quarkus.io/guides/azure-functions-http

You can propose an extension proposal to support this kind of Azure function via a new extension proposal on the Quarkus github repository: https://github.com/quarkusio/quarkus/issues/new?assignees=&labels=kind%2Fextension-proposal&template=extension_proposal.md&title=

Since you are already using SAAJ for your call, why not use the same API to read the response?

It seems the content-header hal+json was the missing piece, although i'm sure quite sure i tried this before. Probably something else was wrong before that has been fixed in between. At least the test case is now working with this:

From what I know KeyEvents are quite basic, User clicks 9 on the keyboard -> KeyEvents ACTION_DOWN, KEYCODE_9 , ACTION_UP are sent among others. EditorInfo is more based on what the "Key Press" will do. EditorInfo.IME_ACTION_SEARCH -> "the action key performs a "search" operation, taking the user to the results of searching for the text they have typed (in whatever context is appropriate)."

Comparing the two:

KEYCODE_9 is just 9.

IME_ACTION_SEARCH refers to a key event that denotes a standard practice for the context, like "Find on Page" allows you to type a string and search for that string. The key that allows you to do this sends the IME_ACTION_SEARCH event.

Typically you do not have a dictated button for SEARCH across apps and os version.

Typically you do have a dictated button for 9 though.

Editor https://developer.android.com/reference/android/view/inputmethod/EditorInfo

KeyEvent https://developer.android.com/reference/android/view/KeyEvent

This was one hair pulling exercise, the null was coming from the outer list. the Rating object had null fetched from DB.

This was how it was fixed.

doView is rendering a portlet's output, not a full page. Thus, it doesn't have a status code. The page is rendered elsewhere (e.g. decorated with the theme, and with any number of other portlets on the page that might still show relevant content).

In the portlet world you're not dealing with HttpServletRequest/Response pairs, but with PortletRequest/Response pairs (as seen here in the incarnation of RenderRequest/Response). Thinking in HTTP return codes is wrong: You can't even guarantee that the portlet is rendered before the response is already sent back to the browser: Once you determine that your portlet can't render appropriate output, the page might already be on its way, with status code 200. Or it might be rendered asynchronously and just injected into a page.

If the portlet can't render appropriate output in doView, you'll need to catch the exception and display a proper error message in the portlet.

Otherwise, consider implementing serveResource, where you have more control, or a REST endpoint. But note: 404 is a technical error, while you're handling a business layer error - both should be handled differently.