gregod

https://github.com/GoogleChromeLabs/critters Might be a good starting point. It’s designed to inline the css afterward so it’s more focused on extracting used css than removing unused.

Yes, that was poorly worded. It has a very neat accounting system! Its just a little more complex to setup and keep in sync.

Slurm [1] is a open-source HPC scheduler thats a good example. Its featureful and (surprisingly) easy to run if no user accounting (i.e., accounting for individual computation budgets) is needed.

[1]: https://slurm.schedmd.com/documentation.html

The Evolutionary Computation Bestiary [1] list a wide variety of animal behavior inspired heuristics.

The foreword includes this great disclaimer: "While we personally believe that the literature could do with more mathematics and less marsupials, and that we, as a community, should grow past this metaphor-rich phase in our field’s history (a bit like chemistry outgrew alchemy), please note that this list makes no claims about the scientific quality of the papers listed."

[1]: https://fcampelo.github.io/EC-Bestiary/

Related: MS Office 2010 was/is available as "click-to-run" edition, based on a virtual streaming file system.

https://learn.microsoft.com/en-us/office/troubleshoot/office...

The tech/product behind it has its roots in game distribution: https://en.wikipedia.org/wiki/Microsoft_App-V

This is a good example for an interactive non-SPA. JS only for cosmetics and all state is fully stored in the URLs. The main pages could even be statically generated (858705 combinations * 3 views * 8KB = 20GB).

https://www.wikifolio.com/ does something similar for the German speaking market. One part is a social portfolio sharing / tracking component. The other is that they create securities from popular portfolios under a revenue share model with the creators.

Weirdly enough, PGO equalizes and increases the runtime, where both methods take approximately 330 us. (I simply applied PGO to the full benchmark harness, no idea if this is proper). Them being equal sounds more reasonable, but the increase in runtime doesn't feel right.

Micro benchmarking remains a fickle beast :)

Good point. Here it is premature optimization anyway and too dependent on the input. In general, I think a balance between likelihood and cost should be found.

Out of curiosity, I just did a small benchmark (criterion) using the input.txt provided, and reordering results in a 10% difference:

  Old Order time:[307.28 us 309.12 us 311.17 us]
  Reversed  time:[270.82 us 271.18 us 271.54 us]

This feels weird since the input.txt contains few pairs of equal characters, so there is likely something else going on. The inequality is very inexpensive but the ignore case compare should not be that expensive either.

I think the following minor optimizations can further decrease the runtime:

* There is no use in first pop()ing a candidate from the "reacts" list and then potentially re-pushing them later. Getting a pointer to the last element, and removing it if it is not needed, is more efficient.

* Reordering the character equality condition could help a tiny bit since the inequality check should be faster than the ignore case check.

Btw: The Apple Notes application has this functionality built-in if you are just interested in scanning.

Could you elaborate?

I'm working on a project where the evaluation of a 4th degree polynomial is on the hot path. My micro benchmark (evaluating two polynomials + little bit of addition) shows that using simple Horner's rule is already somewhat faster, and implementing Horner's rule with fused-mul-add is more than twice as fast.

If you do not need the more granular firewall configuration options there is also classic port knocking (https://en.wikipedia.org/wiki/Port_knocking) where the daemon sits behind the firewall so all ports can be closed by default.

I have used an low-power ESP8266 together with a native drawing library for this use case. As getting the drawing perfect is quite cumbersome i have mocked the graphics library in javascript using the canvas api [1].

The syntax is so similar that you can mostly copy and paste the drawing code between js and the arduino project with only a few adjustments. This has the huge advantage that you can use modern JS dev tools including livereload to get the drawing right while still ending up with native code.

[1] https://www.godberit.de/2019/11/08/Mock-for-ESP8266-graphics...

It seems that they are not quite there yet.

From the FAQ: "Voicefill sends the audio to Google’s Speech-to-Text engine, which returns transcribed text. [...] In the future, we expect to enable Mozilla’s own technology for Speech-to-Text [...]"

I have also found https://accessibilityinsights.io/ from microsoft to be usefull. It only covers the in-browser test side for web but has a nice ui.

No. But i don't have an need for mass access so the basic case works fine for me. I keep a backup key on a separate yubikey that does not require touch for key maintenance.

Apparently there is a new "cached" option for the touch settings "Touch is cached for 15s after use (valid from 4.3)." Which would work for your use case but also neglect some/most? of the security advantages.

For Firefox there is https://addons.mozilla.org/en-US/firefox/addon/passff/ which I'm quite happy with.

When combined with a yubikey set to decrypt only on touch this setup has a very low attack surface compared to other browser password managers.

I can recommend openpaper[1] for desktop usage. Combines (multi page) scanning, ocr, automatic labeling and search into a nice gui.

If you have a network enabled scanner than can scan straight to an ftp folder, these two server based projects [2][3] offer even more convenience.

[1] https://openpaper.work/en-us/ [2] https://github.com/the-paperless-project/paperless [3] https://www.mayan-edms.com/

There is also https://github.com/cyberman54/ESP32-Paxcounter

"Wifi & Bluetooth driven, LoRaWAN enabled, battery powered mini Paxcounter built on cheap ESP32 LoRa IoT boards"

You might also want to look at the very comprehensive office 365 react components from MS which is build on. https://github.com/OfficeDev/office-ui-fabric-react

Meant for developing Sharepoint/Office Apps but released under MIT License (Only the custom Microsoft Fonts are restricted but easily replaced)

If you have the csvsimple [1] latex package available this can be done as latex macro. This allows for easy integration with other latex packages (drawing stuff with tikz for example [2]).

Python and a makefile might perform better for larger data sets though.

[1] https://ctan.org/pkg/csvsimple [2] http://www.godberit.de/2016/01/31/Keeping-documentation-up-t...

Related project matching against a database of >3Mio. fingerprints: https://panopticlick.eff.org/

Works in Chrome, Firefox however shows the flash dialog with a large grey box around it.