dsp_person

I've been writing C code a lot more like scripting after familiarizing with how easy it is to use gdb compared to jumping through hoops say in vscode to setup a new build target for every new C file I want to mess with.

Just write `test_x.c`, `gcc -o test_x test_x.c -g`, and `gdb --args ./test_x --blah --blah` allows for much faster iteration on things.

PLUS the gdb commands end up far easier and more powerful to probe things than mess with the GUI most of the time.

I was just googling to see if there's any Emscripten/WASM implementation of OpenMP. The emscripten github issue [1] has a link to this "simpleomp" [2][3] where

> In ncnn project, we implement a minimal openmp runtime for webassembly target

> It only works for #pragma omp parallel for num_threads(N)

[1] https://github.com/emscripten-core/emscripten/issues/13892

[2] https://github.com/Tencent/ncnn/blob/master/src/simpleomp.h

[3] https://github.com/Tencent/ncnn/blob/master/src/simpleomp.cp...

so how much do these bad boys cost

it would be cool to see a more comprehensive comparison including methods with raytracing

they have MLAB in their performance comparison table, is that ray traced? from this blog i think it sounds like it there's a rasterized version and a way to use ray tracing https://interplayoflight.wordpress.com/2023/07/30/raytraced-...

I would have clicked even faster if the title had "with Wavelets"

In the referenced paper https://arxiv.org/pdf/2201.00094 in section 2 they give a couple examples for why not ray tracing. Also FWIW they used an RTX3090 in the performance comparison section.

native wayland windows maybe you're thinking? still, it has the requirements that it does (see the wiki link)

waydroid requires a kernel module or a kernel with support built in like zen https://wiki.archlinux.org/title/Waydroid#Kernel_Modules

From a quick look at the gitlab I don't see any mention of similar requirements. If that's the case, it would be easier to run. Also bonus if gpu support is better than "NVIDIA GPUs do not work currently"

Feel the same as GP here.

How expensive is the COLMAP step to run? I was also really impressed with the speed in the demo (but thinking that the shown training was the only step)

Could you ELI5 what the training is versus what the COLMAP part is?

it was just discontinued for android :(

Imagine both ideas as inspired by Jupyter Notebooks and their kernels.

Persistent kernel: e.g. each ```python``` code block is the same interpreter process with all the same variables. Same for bash, etc. The process is kept open and lines to exec piped to it. Or use a wrapper like Jupyter kernels (example [1]). Have the ability to run/re-run a specific code block.

Output capture: Yes if you echo something it could appear in an output block following the code block. Very much like a Jupyter Notebook cell showing it's output. The simplest output capture is just text, but you could also figure out how to hook into things like matplotlib and show plots (e.g. option to allow the output to be shown as a markdown sub-section).

[1] https://github.com/digitalsignalperson/comma-python

Some ideas:

- can capture output and be updated & displayed in the markdown doc.

- persistent kernels

What [2] is doing is exposing the raw send stream as a file, not what the contents of the hidden .zfs folder contains.

https://github.com/UNFmontreal/zfs_fuse_snapshot/blob/64b17b...

Imagine you want to glue together something to use with a syncing tool. ~100 lines of python can turn data from one format into a presented set of files. The application doesn't have to be a general purpose filesystem.

e.g. https://github.com/UNFmontreal/zfs_fuse_snapshot/blob/master...

The libfuse github has some good examples for C/C++ in [0] of increasing complexity:

- passthrough.c mirrors existing filesystem, "Its performance is terrible."

- passthrough_fh.c "performance is not quite as bad."

- passthrough_ll.c implemented with low level api and "the least bad among the three"

- passthrough_hp.cc high performance version written in C++

Some interesting fuse projects in my notes: [1] splitting large files into segments; [2] show ZFS incremental snapshots as files; [3] transparent filesystem compression; [4] and [5] options for mounting archives as filesytems.

- [0] https://github.com/libfuse/libfuse/tree/master/example

- [1] https://github.com/seiferma/splitviewfuse

- [2] https://github.com/UNFmontreal/zfs_fuse_snapshot

- [3] https://github.com/FS-make-simple/fusecompress

- [4] https://github.com/google/fuse-archive

- [5] https://github.com/mxmlnkn/ratarmount

but is there quantum advantage for the mentioned dating app?

Recently I was googling for "stateless windows" and found this article [1] & associated repo [2] for doing a complete reinstall and config of various programs and settings. It would be cool to have a solid way to keep an up to date "clean" windows install this way. But expect the scripts will break often and require many hours of messing with to keep current. If not an open source effort, I could even see paying for curated and maintained windows scripts.

But I haven't been dual booting lately out of uhg from every time I do involves waiting 5 mins for windows update and multiple reboots, taking forever to bake something when why isn't this just extracting some binary packages or write out some new golden image at max SSD speed please!

[1] https://anduin.aiursoft.cn/post/2021/11/4/use-windows-as-a-s...

[2] https://github.com/Anduin2017/Reimage-Windows

Are there are good unofficial gcc plugins/extensions out there? It would be cool to extend C with a thing or two without adopting a full blown compiler like C2 or C3.

crashes when I try to open in firefox on linux

Hmm this versus Kagi Assistant?

Plan page says $20/mo Unlimited powerful Phind-405B and Phind-70B searches; Daily GPT-4o (500+) , Claude 3.5 Sonnet (500+), Claude Opus (10) uses

> Phind-405B scores 92% on HumanEval (0-shot), matching Claude 3.5 Sonnet.

Any other benchmarks?

DeepSeek sounds really good, but the terms/privacy policy look a bit sketch (e.g. grant full license to use/reproduce inputs and outputs). Is there anywhere feasible to spin up the 240B model for a similarly cheap price in private?

The following quotes from a reddit comment here https://www.reddit.com/r/LocalLLaMA/comments/1dkgjqg/comment...

> under International Data Transfers (in the Privacy Policy): """ The personal information we collect from you may be stored on a server located outside of the country where you live. We store the information we collect in secure servers located in the People's Republic of China . """

> under How We Share Your Information > Our Corporate Group (in the Privacy Policy): """ The Services are supported by certain entities within our corporate group. These entities process Information You Provide, and Automatically Collected Information for us, as necessary to provide certain functions, such as storage, content delivery, security, research and development, analytics, customer and technical support, and content moderation. """

> under How We Use Your Information (in the Privacy Policy): """ Carry out data analysis, research and investigations, and test the Services to ensure its stability and security; """

> under 4.Intellectual Property (in the Terms): """ 4.3 By using our Services, you hereby grant us an unconditional, irrevocable, non-exclusive, royalty-free, sublicensable, transferable, perpetual and worldwide licence, to the extent permitted by local law, to reproduce, use, modify your Inputs and Outputs in connection with the provision of the Services. """

user_pref("extensions.pocket.enabled", false);

I'm curious about this too. Is this just preference/taste and the way everyone does things, or is there evidence to back it up. What could a modern study look like? There are so many aspects like the font, size, width or how much fixed width spacing between chars, screen/page size, background color, type of content. And are there other metrics than reading speed? Like information retention, or psychological effects like do people feel positively or negatively about the content/topic/reading experience.

I found this https://ux.stackexchange.com/questions/48753/does-the-use-of...

- > In Universal Principles of Design, the entry on legibility states: Proportionally spaced typefaces are preferred over monospaced.

- It's unclear if that book provides further evidence to this statement

- > One famous research on this is Beldie I. P., Pastoor S. & Schwarz E, 1983, “Fixed versus variable letter width for televised text”, Human Factors, 25, pp.273-277, where part of the results include: The reading time (Task 1) with the variable-matrix character design was 69.1 s on the average, and the mean reading time with the fixed-matrix character set was 73.3 s, t (8) = 2.76, p < 0.02. The difference is 4.2 s or 6.1% (related to fixed-matrix characters).

- I couldn't find a pdf of that one in particular. The difference seems small

- https://www.tandfonline.com/doi/abs/10.1080/0144929021014673...

- > Comic Sans MS, Arial and Times New Roman typefaces, regardless of size, were found to be more readable (as measured by a reading efficiency score) than Courier New.

- small sample size 27 children. also the children preferred comic sans... we could pick a cooler monospace font than courier new

- https://link.springer.com/article/10.1007/s10209-015-0438-8

- > It was found that larger text and larger character spacings lead the participants with and without dyslexia to read significantly faster

- unclear if those were monospaced

- https://www.researchgate.net/publication/20925173_Reading_wi...

> We compared the effects of fixed and variable (proportional) spacing on reading speeds and found variable pitch to yield better performance at medium and large character sizes and fixed pitch to be superior for character sizes approaching the acuity limit.

> One possible implementation might be to literally have the operating system allocate a chunk of physical memory and load the file into it, byte by byte, right when mmap is called… but this is slow, and defeats half the magic of memory mapped IO: manipulating files without having to pull them into memory

This doesn't defeat the purpose necessarily. How about for example, implementing a text editor: I want the best performance by loading the existing file initially (say it is <1MB), and the convenience and robustness of any writes to this memory being efficiently written to disk.

I'm always curious to see how people are selling desktop software like this. This developer has many other misc tools for sale on this website.

Q: Are mac people more likely to look for and buy misc desktop utilities?

I wonder about market size vs niche size for windows vs macos vs linux tools. Clearly windows is the biggest market, but I feel like I run into a lot of these niche macos utilities for sale, often here on hackernews.

For linux which I'm most interested in, I have a harder time imagining people wanting to pay for a closed source tool. But am trying to note successes with people using patreon, itch.io, or github sponsors.

Click to drag yes since it's just using ImGui::SetScrollX, ImGui::SetScrollY based on mouse events. For zoom, it could be in user code if it's your own custom widgets or rendering with ImGui::GetWindowDrawList()->Add{Something}, but I don't think Dear ImGui has a super great api for zoom with the built in windows/widgets like we're talking about here. It's a limitation of this api, not the immediate mode paradigm in general (like the article argues).

For example, ImColorTextEdit renders an ImGui:Dummy() to create a dummy widget of a specified width and height which defines the scroll area, and then based on the current ImGui::GetScrollX() and ImGui::GetScrollY() it uses ImGui::GetWindowDrawList()->Add{Rectangle,Line,Text, etc} to custom render the contents inside the widget based on what should be visible at the scroll positions. Since it's custom code it would be easy to use a zoom param to adjust the scale of things and what is submitted to the draw list.

That sounds exactly like a scroll area. For example Dear ImGui has scrolling based on a draw list which will be clipped to the current visible area. Nothing stopping adding panning and zoom controls for this. In fact I saw mouse panning added in one of the ImColorTextEdit forks. Maybe Dear Imgui doesn't have a "zoom" feature built-in, but I don't imagine that being hard to implement. Just additional scaling and clipping to the draw list.

> IMGUI does not mean it needs to refresh all-or-nothing.

The author of microui described an interesting approach to this here https://rxi.github.io/cached_software_rendering.html

This is the associated repo: https://github.com/Anduin2017/Reimage-Windows

> I wish there was a way to get Zig code out of comptime

I often just take an approach similar to cog [1], but it's simple enough I prefer to roll my own to do whatever code generation I'm wanting. E.g. write a ~100 line python file that reads source file(s), reads special comments with code gen or introspection instructions, and then insert generated code at some designated point(s).

[1] https://github.com/nedbat/cog