atfzl

npmjs.com search input doesn't even have proper throttling/debounce. If you type fast, there is a high chance that you get result of the partial input that you entered than the complete one. Ideally they should discard the response for the old partial search if there is a new one.

Reminds me of the danish movie "Another Round".

> Four high-school teachers consume alcohol on a daily basis to see how it affects their social and professional lives.

Hey, I wanted to try this out but I am seeing a lot of performance issues. There are forced reflows of >1s on normal interactions. I ran it on my MacBook Air M1.

Vite uses esbuild for transpiling and rollup for bundling. esbuild (written in go) is already pretty fast for transpiling but there might be a lot of possibilities to optimize in rollup as rollup is written in JavaScript.

All the devices with Apple silicon are supported, even the first MacBook Air 2020 with M1.

Resident Evil Village is launching on 28 Oct with Apple Silicon support!

Try https://fasterthanli.me/articles/a-half-hour-to-learn-rust which is also written by the same author.

Wait a bit, it takes some time.

This tool needs better UX:

- A loading bar, or some feedback that it is "analyzing data"

- clicking on "Reddit" or "Hacker News" doesn't select the radio buttons

I don't have a lot of comments on hn but the result is still super accurate. FML.

The person who posted the link says they were the one who broke into Uber recently.

> My previous work: https://www.nytimes.com/2022/09/15/technology/uber-hacking-b...

The code with this method looks a lot ugly for the basic binary search where you return -1 when an element isn't found.

https://leetcode.com/problems/binary-search/

JavaScript code:

  function binarySearch(arr, target) {
    let left = 0;
    let right = arr.length - 1;
  
    // empty arr, so we won't find anything
    if (!arr.length) {
      return -1;
    }
  
    // the target is less than the smallest number in arr
    if (target < arr[left]) {
      return -1;
    }
  
    // the target is greater then the smallest number in arr
    if (arr[right] < target) {
      return -1;
    }
  
    // These two `if` are needed for the case when there are only 2 elements
    // in the array.
    if (arr[left] === target) {
      return left;
    }
    if (arr[right] === target) {
      return right;
    }
  
    while (left + 1 !== right) {
      const middle = left + Math.floor((right - left) / 2);
      if (arr[middle] < target) {
        left = middle;
      } else {
        right = middle;
      }
    }
  
    if (arr[right] === target) {
      return right;
    }
    
    return -1;
  }

How does it compare with https://httptoolkit.tech/

xi-editor https://xi-editor.io/docs.html

This is written in rust and has docs about rope data structure and editor architecture.

This made be curious to check the real and virtual memory of some processes on my laptop (MacBook Air M1).

The real memory size of Safari is ~160MB but virtual memory size is 392GB which doesn't look right. I checked other processes and all the processes have similar virtual memory size which is around ~390GB.

I wonder if this is a bug in Activity Monitor or the virtual memory allocations really are this big for each process.

Having `display: none` is not required for the tooltip container.

The container is an empty div which is not visible, and even after adding children which are not directly visible `inside` this div keeps this container div invisible.

You can check out some examples in https://github.com/mui-org/material-ui/issues/27879

I can't find the link but there was some discussion about mem.ai on hackernews. mem.ai doesn't sound very privacy friendly.

https://techcrunch.com/2021/04/06/note-taking-app-mem-raises...

> The broader hope of the founders and investors behind Mem is that the team can leverage the platform’s intelligence over time to better understand the data dump from your brain — and likely other information sources across your digital footprint — to know you better than any ad network or social media graph does.

Looks like it is using Netsurf Browser (http://www.netsurf-browser.org).

Why didn't you directly use SDL for rendering instead of OpenGL? Was it for performance reasons? OpenGL is deprecated on mac, and SDL use Vulkan on Window and Linux which I guess is better, performance wise than OpenGL.

Have you used the firefox performance timeline, it is awful. Chrome's performance timeline is amazingly smooth and has much more features.

So, it's like https://slides.com but collaborative.

And where are you getting all this knowledge from?

state changes are not tracked by diffing, it is much more interesting. You can read about it here https://www.atfzl.com/understanding-solid-reactivity-basics

Still not sure if having a mind map would make it more usable. Do you feel having mind map like this would help you ?