Is it possible to find out the location of a search result from within the Start Menu of Windows 10?

With Windows 7, I was able to perform a search for a program/file from within the Search box of the Start Menu, right-click the resulting search match and click “Properties” to easily find out the location of what I was about to open. With Windows 10, however, performing a right-click on any search results doesn’t appear to display a context menu from where this can be done.

Is there an alternative way of carrying out this task on Windows 10, or is it just not possible to do?

Is it legal to disassemble a Microsoft dll and post the result on my blog?

I’m writing an article for my blog about undocumented functions which exist in the dwmapi.dll library. I want to post the result of the disassembled code to explain how the names and parameters of these functions are obtained, something like the article from this blog. This is only for educational purposes to show a couple of samples using these undocumented functions. So the question is: Can I post the disassembled code of this library on my blog?

UPDATE : There exist a couple of applications like Aura which uses these undocumented functions (DwmGetColorizationParameters, DwmSetColorizationParameters), obviously the authors in some point disassembled the dwmapi.dll file in order to get the parameters and functions names. But they (the authors) only publish the final source code to access to these functions. This makes me think that I can disassemble in private a Microsoft dll and then publish an application or source code based in this research. Is this correct?

Any barrier result for this kind of (non-relativising) technique?

We think that non-deterministic machines are more powerful than deterministic machines, by giving an oracle access to $ P\subseteq L\subseteq NP$ , it seems reasonable to expect there’s some $ L$ that is so weak compared to $ SAT$ and thus gives “relatively more” power to $ P$ than to $ NP$ .

Suppose we’re given a monotonically harder sequence of oracle access, $ $ L_0 (\in P)\leq_P L_1 \leq_P L_2\leq_P\dots\leq_P L_k= SAT, $ $ We’ll have $ $ P=P^{L_0}\subseteq P^{L_1}\subseteq … \subseteq P^{L_k}=NP\ NP=NP^{L_0}\subseteq NP^{L_1}\subseteq … \subseteq NP^{L_k}=\Sigma_2P $ $

Suppose we can find, in the middle $ L_i$ that does not give extra power to $ NP$ , i.e. $ NP^{L_i}\subseteq NP$ , but in such relativised world we could resolve $ P^{L_i}\neq NP^{L_i}$ , then we’ll have $ P\subseteq P^{L_i}\subsetneq NP^{L_i}=NP$ . So my question is,

Do we have any barrier result against this type of technique when resolving $ P$ vs $ NP$ ? It seems neither a relativizing technique nor a natural proof.

Postgesql non-deterministic order of result with LIMIT and ORDER BY

I understand that Postgresql may return results in non-deterministic order when the query parameters are non-unique. This is especially a problem when we use LIMIT since this may return entirely different results. So the suggestion for safety is to use ORDER BY with LIMIT.

However, what if we use ORDER BY on an non-unique column name? Will this produce a deterministic result or no? Let me demonstrate with an example:

We have the following data:

id | name | index 1    foo     5 1    bar     2 1    test    5 

If I query SELECT * FROM <table> WHERE id = 1 ORDER BY index LIMIT 1;. Will this produce the same result every time?

I just created a Store System using Electron, React, Material-UI, Redux, Redux-Saga, MySQL and Sequelize, and here is the result

This project is part of my personal portfolio, so, I’ll be happy if you could provide me any feedback about the project, code, structure or anything that you can report that could make me a better developer!

Also, you can use this Project as you wish, be for study, be for make improvements or earn money with it!

const whenShouldHelpCommunity = () => {     const when = 'always';      return when; } 

Scanning multiple hosts with Nmap’s Default Accounts NSE script not producing the expected result

I’m utilizing Nmap’s default account credential scanner. I’ve built a couple of my own fingerprints and I’ve tested that the fingerprints work when scanning one host at a time.
Example command line usage:

nmap -p80 --script http-default-accounts --script-args http-default-accounts.category=web,http-default-accounts.fingerprintfile=./my-fingerprints.lua 

When I try to scan more then one host either using -iL (input file) or by defining multiple IPs at the command line, nmap is not identifying that all of the hosts are utilizing default credentials. Nmap is only reporting that one of the hosts is utilizing default credentials. And the host nmap identifies as utilizing default credentials varies (it is not always the same host). I have also tried adding –scan-delay, but that does not change the scan results.

Example command line usage (input file):

nmap -p80 --script http-default-accounts --script-args http-default-accounts.category=web,http-default-accounts.fingerprintfile=./my-fingerprints.lua -iL hosts.txt 

Example command line usage (command line):

nmap -p80 --script http-default-accounts --script-args http-default-accounts.category=web,http-default-accounts.fingerprintfile=./my-fingerprints.lua 

Has anyone had experience with getting different results when scanning multiple hosts? Is there something I need to change when scanning multiple hosts?

How should I go about creating an intuitive Django filter to find the best result?

Summary of the problem

I have a basic Django form along with a list of dogs with attributes in an SQLite database. The idea is that the user will input/customise a bunch of inputs about the dog they’d most prefer, and the application will find the closest match and return the best result(s) based on the inputs they have submitted.

The attributes that are relevant to finding the best dog result are:

  • breed_name
  • activity_level
  • shedding_level
  • grooming_demand
  • intelligence
  • drools
  • coat_length
  • size
  • good_with_children

While simply totaling up the number of attribute matches is adequate, it would be preferred if the query for finding the best dog takes into account ‘value proximity’ (there is probably a better term for that), in the sense that if the user said they want a small dog, and that does not match but most of the other attributes do, then it would be preferable to find a medium sized dog (with the same number of total matches) rather than a large one. At present, my CASE statement does not take this into account.

The solution should be written at Django’s application-layer level, rather than at a database-layer level. So a Django filter would be appropriate, however a raw SQL query would not.

Additionally, in the Preferences section, there is an option to select ‘No preference’. In this case, the application should simply disregard anything related to that particular attribute and not take it into account when finding the best dog result.

If there are dog results that are exactly the same, then the application should return all of those applicable ones.

Background information

I have researched online and can find plenty of examples where people have simply totaled up the number of matches, but do not take into account the idea of ‘value proximity’. I want to see if others have had the same problem and how they approached it, but I haven’t been able to find similar questions/answers.

I have been thinking of the best and most effective way to tackle the problem and was thinking of representing each value as a key-value pair. When I construct the query, I would use a SELECT to find the nearest value if there was not an exact match through interpreting the strings as integers. For example…

  • {‘1’: ‘Small’}
  • {‘2’: ‘Medium’}
  • {‘3’: ‘Large’}
SELECT table_name.value     FROM table_name ORDER BY ABS(table_name.value - 2), rand()    LIMIT 1 

The rand() function in the ORDER BY clause would mean that if you selected a medium size dog (2), it will randomly pick either between either Small or Large.

Show some code

Below was the previous SQL CASE statement I wrote (which I will probably convert in some form to a Django filter once I have a better idea of how to approach this problem). The specified values (High, Medium etc) were simply there to give something for the database to work off.

SELECT activity_level_count, shedding_level_count, grooming_demand_count, intelligence_count, drools_count, coat_length_count, size_count, (activity_level_count + shedding_level_count + grooming_demand_count + intelligence_count + drools_count + coat_length_count + size_count)  AS total  FROM (SELECT        COUNT(CASE WHEN activity_level = 'High' THEN 1 END) AS activity_level_count,        COUNT(CASE WHEN shedding_level = 'Medium' THEN 1 END) AS shedding_level_count,        COUNT(CASE WHEN grooming_demand = 'Low' THEN 1 END) AS grooming_demand_count,       COUNT(CASE WHEN intelligence = 'Low' THEN 1 END) AS intelligence_count,       COUNT(CASE WHEN drools = 'FALSE' THEN 1 END) AS drools_count,       COUNT(CASE WHEN coat_length = 'Short' THEN 1 END) AS coat_length_count,       COUNT(CASE WHEN size = 'Giant' THEN 1 END) AS size_count        FROM dog_breed_website_dog AS dogs GROUP BY breed_name) AS result 

Expected results

Let’s say that there is a user that inputs the following attributes on the form:

  • Must be good with children: Yes
  • Drooling: No
  • Coat Length: Short
  • Activity Level: High
  • Shedding Level: Medium
  • Grooming Level: No preference
  • Intelligence Level: Low
  • Preferred Size: Small

And we have two dogs, with mostly similar (yet slightly different) attributes:

Dog 1

  • Must be good with children: Yes
  • Drooling : No
  • Coat Length: Short
  • Activity Level: High
  • Shedding Level: Medium
  • Grooming Level: No preference
  • Intelligence Level: High
  • Size: Large

Dog 2

  • Must be good with children: Yes
  • Drooling : No
  • Coat Length: Short
  • Activity Level: High
  • Shedding Level: Medium
  • Grooming Level: No preference
  • Intelligence Level: Medium
  • Size: Medium

The application should return Dog 2 as the final result, since although both dogs have an equal number of exact matches, Dog 2’s attributes that don’t exactly match are closer to the user’s selected choices than Dog 1. The Intelligence Level and Size attributes for Dog 2 are closer to what the user wanted originally.