hotspot | Web site that sits in front of a FHIR terminology server | Frontend Framework library

Try passing pickingHotspot in your dependency array for useEffect.

Your event handler is attached to your element in the useEffect on componentDidMount because of the empty dependency array. This will only happen once and that old function will be used. That old function will close over the value of the previous state. You can attach your event handler again on every relevant state change by passing pickHotSpot in your dependency array.

It is also a recommended approach to keep all your relevant code inside the hook. You could have put your listener function inside your hook, and would have seen a missing dependency warning from one of your lint tools.

Also, if there is no specific reason for you to add event hanlder like this from javascript, then add inline usin JSX, like @MB__ suggested. That will be executed on every render so it should be correct. At any time only one eventhandler for the particular event will be attached.

What you're doing is creating a new keypress event listener, every time the $( ".main-nav__menu-hotspot" ).focus() event listener is triggered.

e.g. if you hover over the menu 4 times (or whatever triggers the focus event), it'll create 4 keypress event listeners. So when you do the keypress, it'll execute 4 times.

Move the keypress event listener creation out of the other one:

You need enable Annotation-Driven injection in the container. In your case, declare at dispatcher-servlet.xml (I assumed you don't use JavaConfig).

It's quite likely the IP addresses that you use and possibly your current network setup. If you run Flask locally, by default it will use 127.0.0.1 (localhost) and the application can only be reached from your own computer. Other hosts on the network cannot. So your intuition is correct, you need to run it on 0.0.0.0 so that the application becomes accessible on any interface, not just localhost but also the LAN IP address and WAN IP address (provided you have got one).

Now the remaining question is, is 10.104.2.114 is the correct address for your PC where the Flask application is running ? Assuming that you use DHCP, the IP address is subject to change. From what you are saying your ESP8266 is on the same network but I think the connection sharing applies some form of isolation between guests (possibly by VLAN). So, for that reason, the guests on that network may not be able to see each other and this is by design. It is normal for wifi hotspots to segregate traffic per client.

Putting all your devices on the same router/switch could work. Note that you can still use your home router/switch to connect devices, even if Internet access is out of service. This is something you could try, as long as your hardware is in good condition.

The problem is your Maven version is too old. It's not compatible with JDK 16.

Try to manually install maven version 3.8.1:

https://maven.apache.org/install.html

This will solve your problem without downgrading your JDK version.

Here is a nice starter for you to play with.

Intel VTune, Intel Advisor and some other profilers (eg Crhome profiler) report BOTH inclusive (including B, C, D) and exclusive (A, except B, C,D, thus additive) time metrics. Inclusive is called "Total-Time" and exclusive is called "Self-Time". Read more at: https://software.intel.com/content/www/us/en/develop/documentation/vtune-help/top/reference/cpu-metrics-reference/self-time-and-total-time.html

Make sure that your gradle is using proper JDK. Try running ./gradlew --version in your project's directory, output should be something like this:

The thing to understand about Constraint Streams is that it is not imperative programming, and therefore traditional performance optimization techniques such as code profiling are not going to be very helpful. Instead, I suggest you think of Constraint Streams as SQL - the way to have fast SQL is to think about how your data flows, how you join and what gets indexed.

Recently I wrote a blog post explaining the tricks behind making CS run fast. However, CS is internally interpreted by the Drools engine, and therefore studying it may give you some insights too. Not all insights there are applicable to CS, but if you take a look at drools-metric, you should be able to see which constraints are comparatively slow. And then it becomes a game of tweaking.