josephernest

These new Nokia models/re-issues are of very poor quality, see my other comment.

They are not made by Nokia, but by HMD which has very low standards of product quality.

Would you release an update that works on Android 9+?

Pro tip: don't buy the new versions "Nokia 3210 2024" and similar models. I did, two times, with slightly different models, and they are of exceptionally poor quality: dead after one year, very buggy firmware. The customer support is an AI with no real answer. They recommended to install an app "from the Google Play app store" which is nonsense for a dumbphone.

They are very cheap noname phones, branded with the name Nokia, but I am sure no Nokia R&D team was involved in these products.

Out of curiosity, which API are you using, not available in Android 9 / API_LEVEL_28?

Are you sure you need a specific feature of Android 11 / API_LEVEL_30?

Would it be totally impossible technically to target API_LEVEL_28 (Android 9)?

Many people in your users "niche" deliberately use an older device (such as Android 9) to limit the phone addiction: newer device => richer experience => even more addiction => for this reason some people in your niche use an older phone.

Jarko27: on my Android 9 phone of a few years ago, i cant install it : the play store says it Cant be installed on my device. Why?

Have you worked on the paid vesion yet? (10$ after 1000 saves)

I've built a few browser extensions, but not found a super simple way to monetize them. Which technical solution do you plan to use for a paid version of your extension? Authentication? Other?

My title was maybe confusing. By "built-in" bookmarking system, I mean the built-in feature "drag-and-drop into .url file". (As opposed to using a browser extension).

> Putting tags in the file name with a hash mark feels “ick” and like the Wrong Way to solve this problem. Using folders and symlinks [...]

I respectfully disagree. If we were speaking about millions or billions of data points, yes, performance would be important, and we would look for the "Right Way" to do it, either with a DB or with files+symlinks, as you describe.

But here simplicity and portability is key. "Title of the page #tag1 #tag2.url" does the job: easily searchable with the OS search. Why complicate this with symlinks and folders for tags for just a few 10k bookmarks?

Efficiency/performance questions would be important if we would process thousands of such files per second, but this is not the case, or is it? We read/write these .url files at a pace of maybe 1 file per second maximum, if we are browsing fast, and want to save many bookmarks in a short time.

IMHO filesystem efficiency questions never arise for bookmarks of a user of a computer. If one day you want to do some data mining on your 10k bookmarks, it will probably take < 1 second, even if done with Python.

Do you see a real-life situation for which reading a .url in 1 µs instead of 100 µs would make any difference?

(If you're speaking about search/querying, then the OS search feature does it for us)

Genuine question: why using the bookmark bar which is so tiny (a narrow 30 pixel high bar) to browse through thousands of bookmarks, when you can comfortably move/delete/rename/group in folders/use CTRL-C, CTRL-V, CTRL-X, CTRL-Z to undo/etc. in a big file explorer window?

My point is: the file explorer seems to have (at least for me) a far better UX than the browser's bookmark bar.

Example: you accidentally renamed a bookmark in the bookmark bar. Can you do CTRL-Z? No! With files in file explorer, you could.

You can use your OS file search tool (even the built-in File Explorer search), that you use for your everyday file searches.

But this file-based bookmarking system totally support tags :)

Example:

  - Let's say you bookmark my article https://afewthingz.com/browserbookmark

  - drag and drop => it creates a file "The best browser bookmarking system is already built-in.url"

  - you rename this file into "The best browser bookmarking system is already built-in #tag1 #tag2 #productivity.url" in 2 seconds

  - later when searching, you search with query="bookmarking #productivity", bam, you find it with tag "productivity" :)

You can put all .url files in a single folder with "#tags" in the filename. It works exactly like a tagging system, no more, no less.

What is the real problem on having duplicates? They are only 1 KB files.

Having duplicates with different names is even better, and helps to find it more easily in the future: let's say I have bookmarked 2 times this question https://stackoverflow.com/questions/19165259/python-numpy-sc...:

1. "python numpy/scipy curve fitting"

2. "scipy.optimize.curve_fit question"

Later I can find it with query="curve fitting", or I can also find it with query="optimize". So it increases the chance of me finding it again :)

For me, it totally fixed the problem you mentioned: each time I find something really interesting, I drag and drop the bookmark to either a folder "MISC" (unsorted) or to a dedicated folder if it's specific to a project I'm working on.

Since the shortcut's file name contains the Page title, I can later search with my OS's search tool "curve fitting .url" => it finds the right bookmark.

If I use it in a particular project, I can copy/paste this .url file into the project folder, etc.

Having thousands of bookmarks creates no real problem: you end up with thousands of 1KB file in various folders, there is no mental burden in that: it doesn't add "weight" to the UX of a particular browser extension, since they are only files.

Drag-drop only takes 1 sec, there is no friction, no prompt.

Out of curiosity, do some of you also use this bookmarking technique?

Can it run with llama-cpp-python? If so, where can we find and download the gguf files? Are they distributed directly by meta, or are they converted to gguf format by third parties?

Your numpad solution looks great! Would you have a photo of the whole setup? I thought about doing the same, but I fear to end with cables and PCB everywhere in my children's room if I take this path :)

With the same idea but more minimalistic, I have done Swap JS two years ago :

https://github.com/josephernest/Swap

Used it for a few projects it works well !

If I remember correctly, when you have 2 RPi located at F and F', the solutions M are on an hyperbola : MF = MF' + delta_distance where delta_distance is simply computed with delta_t in the two signals.

I tried this too years ago, that was interesting!

How do you time-synchronize the 4 RPi? When you power them off, you lose the sync. So it is difficult to do it correctly.

Also it may be possible that the different RPi have different clock drift over time? i.e. 1.0000 hour on one of them = 1 hour + 20 milliseconds on another one

> adding words but now flipping a coin immediately after adding it

Edit: I thought your formulation was correct but not really:

We flip the coin after adding, but we also flip the coin even if we didn't add the word (because it was already there). This is subtle!

wrong:

    if k not in mem:
        mem += [k]
        if np.random.rand() > p:
            mem.remove(k)

wrong:

    if k not in mem:
        mem += [k]
    else:
        if np.random.rand() > p:
            mem.remove(k)

correct:

    if k not in mem:
        mem += [k]
    if k in mem:      # not the same than "else" here
        if np.random.rand() > p:
            mem.remove(k)

correct:

    if k not in mem:
        mem += [k]
    if np.random.rand() > p:
        mem.remove(k)

I got the same problem.

When implementing the exact method as described in quanta magazine (without looking at the arxiv paper), I always had estimates like 461746372167462146216468796214962164.

Then after reading the arxiv paper, I got the the correct estimate, with this code (very close to mudiadamz's comment solution):

    import numpy as np
    L = np.random.randint(0, 3900, 30557)
    print(f"{len(set(L))=}")
    thresh = 100
    p = 1
    mem =  set()  
    for k in L:
        if k in mem:
            mem.remove(k)
        if np.random.rand() < p:
            mem.add(k)
        if len(mem) == thresh:
            mem = {m for m in mem if np.random.rand() < 0.5}
            p /= 2
    print(f"{len(mem)=} {p=} {len(mem)/p=}")

Or equivalently:

    import numpy as np
    L = np.random.randint(0, 3900, 30557)
    print(f"{len(set(L))=}")
    thresh = 100
    p = 1
    mem = []
    for k in L:
        if k not in mem:
            mem += [k]
        if np.random.rand() > p:
            mem.remove(k)
        if len(mem) == thresh:
            mem = [m for m in mem if np.random.rand() < 0.5]
            p /= 2
    print(f"{len(mem)=} {p=} {len(mem)/p=}")

Now I found the quanta magazine formulation problem. By reading:

> Round 1. Keep going through Hamlet, adding new words as you go. If you come to a word that’s already on your list, flip a coin again. If it’s tails, delete the word; heads, and the word stays on the list. Proceed in this fashion until you have 100 words on the whiteboard. Then randomly delete about half again, based on the outcome of 100 coin tosses. That concludes Round 1.

we want to write:

    for k in L:
        if k not in mem:
            mem += [k]
        else:
            if np.random.rand() > p:
                mem.remove(k)
        if len(mem) == thresh:
            mem = [m for m in mem if np.random.rand() < 0.5]
            p /= 2

whereas it should be (correct):

    for k in L:
        if k not in mem:
            mem += [k]
        if np.random.rand() > p:    # without the else
            mem.remove(k)
        if len(mem) == thresh:
            mem = [m for m in mem if np.random.rand() < 0.5]
            p /= 2

Just this little "else" made it wrong!

> to record the mouse movement in much higher res than needed

how can this be done? if the monitor resolution is say 1600 x 900, how can it record the frames and/or mouse movement in higher resolution than this?

With which of these 2 software can you do the "zoom in", "move mouse cursor", and "zoom out"?

Anyone a recommendation for Windows? Something simple and lightweight? (Screenstudio is Mac only)

Very promising!

Would it be possible to use your framework with any server of my choice (Python or Node or even PHP), and use Nue only for the frontend?

In this case, since it's just JS + HTML + CSS, can we have an "Option #3" in https://nuejs.org/docs/nuejs/getting-started.html with no command-line, no `npm install`, no `npm run start`, no use of `npm` at all?

It would be nice to have a Hello world example with just a HTM file + import of Nue from your CDN (or from local). Is that possible?

I'd like to totally avoid npm, etc, just write JS + HTML + CSS, and use my own server.

Haha! I don't drink coffee, and can say chocolate-fueled doesn't work so well to work without sleep :)

Good question... I haven't thought about it deeply, but I would say that using this lib itself won't have impact on accessibility: if the HTML fragments are carefully crafted to take accessibility into account, then after HTML fragments swapping the DOM will keep this aspect.

I would say the construction of the HTML fragments (done by the user of this lib) is the most impactful part.

Since the URL can change after a HTML-fragment-swapping with this lib, I can imagine that screenreaders will detect the URL change and take the new layout into consideration, is that right?

Thanks a lot! This is very motivating!