pushfoo · HackerTrans

4 maanden geledendiscuss

Consider: a cheap VPS can have disk latency above 10ms while the in-datacenter LAN can be ~1ms.

4 maanden geledendiscuss

ctrl-f for "This isn't" and note how many instances of this pattern there are:

> This isn't X. It's Y.

9 maanden geledendiscuss

ARM/RISC-V extensions may be another reason. If a wide-spread variant configuration exists, why not build for it? See: - RISC-V's official extensions[1] - ARM's JS-specific float-to-fixed[2]

1. https://riscv.atlassian.net/wiki/spaces/HOME/pages/16154732/... 2. https://developer.arm.com/documentation/dui0801/h/A64-Floati...

pushfoo

vorig jaardiscuss

This seems to be from astral, the organization behind ruff[1], uv[2], and rye[3] (all good things!).

They seem to force using python -m pip on Windows since they don't ship pip.exe[4]? This is very interesting.

From their doc[5] since the README.md's super-bare:

> These Python distributions contain a fully-usable, full-featured Python installation: most extension modules from the Python standard library are present and their library dependencies are either distributed with the distribution or are statically linked.

> The Python distributions are built in a manner to minimize run-time dependencies. This includes limiting the CPU instructions that can be used and limiting the set of shared libraries required at run-time. The goal is for the produced distribution to work on any system for the targeted architecture.

[1]: https://github.com/astral-sh/ruff

[2]: Significantly faster than regular pip: https://github.com/astral-sh/uv

[3]: https://rye.astral.sh/

[4]: https://gregoryszorc.com/docs/python-build-standalone/main/q...

[5]: https://gregoryszorc.com/docs/python-build-standalone/main/

pushfoo

vorig jaardiscuss

Lacking named tuple support is a deal-breaker for some projects. This is directly from their GitHub issues comments[1]:

> Duplicate of #5613, still low priority, better use dataclasses, as suggested above.

1. https://github.com/python/mypy/issues/5944#issuecomment-4412...

pushfoo

2 jaar geledendiscuss

TL;DR: Why not add a capability/permissions model to CI?

I agree that pinning commits is reasonable and that GitHub's UI and Actions system are awful. However, you said:

> Maybe accounts should even require ID verification

This would worsen the following problems:

1. GitHub actions are seen as "trustworthy"

2. GitHub actions lack granular permissions with default no

3. Rising incentives to attempt developer machine compromise, including via $5 wrench[1]

4. Risk of identity information being stolen via breach

> It's time to take things seriously.

Why not add strong capability models to CI? We have SEGFAULT for programs, right? Let's expand on the idea. Stop an action run when:

* an action attempts unexpected network access

* an action attempts IO on unexpected files or folders

The US DoD and related organizations seem to like enforcing this at the compiler level. For example, Ada's got:

* a heavily contract-based approach[2] for function preconditions

* pragma capabilities to forbid using certain features in a module

Other languages have inherited similar ideas in weaker forms, and I mean more than just Rust's borrow checker. Even C# requires explicit declaration to accept null values as arguments [3].

Some languages are taking a stronger approach. For example, Gren's[4] developers are considering the following for IO:

1. you need to have permission to access the disk and other devices

2. permissions default to no

> We can't afford to fuck around anymore,

Sadly, the "industry" seems to disagree with us here. Do you remember when:

1. Microsoft tried to ship 99% of a credit card number and SSN exfiltration tool[5] as a core OS component?

2. BSoD-as-service stopped global air travel?

It seems like a great time to be selling better CI solutions. ¯\_(ツ)_/¯

[1]: https://xkcd.com/538/

[2]: https://learn.adacore.com/courses/intro-to-ada/chapters/cont...

[3]: https://learn.microsoft.com/en-us/dotnet/csharp/language-ref...

[4]: https://gren-lang.org/

[5]: https://arstechnica.com/ai/2024/06/windows-recall-demands-an...

pushfoo

2 jaar geledendiscuss

TL;DR: Yes and it's creating "It's X and limited by Y, but it works" projects

In web front-end, the same pattern crops up repeatedly. Two examples:

* Elm[1]: It's brutally functional and limited by purity, but it works

* htmx[2]: It's grug-brained[3] and limited by that, but it works

I'll let others enumerate web frameworks. On desktop, software for uxn and Varvara[4] by Hundred Rabbits fits the same pattern:

* 64k of RAM and limited to 4 colors, but it works

* Created when Xcode was painful to install on a boat over pre-Starlink satellite internet

Who knew rage-quitting could be so productive? ¯\_(ツ)_/¯

[1]: https://elm-lang.org/

[2]: https://htmx.org/

[3]: Said to be by the HTMX creator: https://grugbrain.dev/

[4]: https://wiki.xxiivv.com/site/roms.html

pushfoo

2 jaar geledendiscuss

Line length is definitely configurable. All it takes is adding the following on pyproject.toml[1]:

  [tool.black]
  line-length = 100

Aside from matrix-like or column aligned data, the only truly awful thing I've encountered has been broken f-string handling[2].

[1]: Example from https://github.com/pythonarcade/arcade/blob/808e1dafcf1da30f...

[2]: https://github.com/psf/black/issues/4389

pushfoo

2 jaar geledendiscuss

My understanding of black is that it solves bikeshedding by making everyone a little unhappy.

For aligned column readability and other scenarios, # fmt: off and # fmt: on become crucial. The problem is that like # type: ignore, those start spreading if you're not careful.

pushfoo

2 jaar geledendiscuss

we keep having similar problems, lol.

pushfoo

2 jaar geledendiscuss

TL;DR: Octo[1] and OctoJam were cozy little highlights despite the grimness of the pandemic years.

Octo[1] targets variants of CHIP-8, an ancient virtual console. The language is so different from daily work that even its annoyances were refreshing. Yes, that includes having to overwrite parts of instructions to get desired behavior.

The maintainer has moved on[2] to working on Decker[3], but I'm still grateful for his dedication. He underestimates his contributions to encouraging a new generation of emulator developers. I haven't had time to do a deep dive into emulation beyond CHIP-8, but I've enjoyed making:

* A little Mastermind-like game (https://pushfoo.itch.io/safecracker)

* A terminal-like text library (https://pushfoo.itch.io/termlib-demo)

Others have done far better. Timendus even wrote his own linker toolkit to build a multi-tasking operating system[4]. If you're interested, there have been some rumblings of an October event of some sort now and then on the EmuDev Discord server to fill the gap left by OctoJam's end.

[1]: https://github.com/JohnEarnest/Octo

[2]: https://beyondloom.com/blog/octojam.html

[3]: https://github.com/JohnEarnest/Decker

[4]: https://timendus.itch.io/chipception-os

pushfoo

2 jaar geledendiscuss

TL;DR: How much of this is a potential class-action[1] and how much of this is failure to deliver on AI?

Am I missing something? On one hand, I think I get it: Intel hasn't been a GPU company historically. On the other, this quotes seems suspicious given Intel's gen 13 and 14 cores have issues:

> Simply put, we must align our cost structure with our new operating model and fundamentally change the way we operate

At the same time, my understanding is AMD seems ahead[2] of Intel in AI / CUDA support. This quote seems to be a nod to that without saying much else:

> Our revenues have not grown as expected — and we’ve yet to fully benefit from powerful trends, like AI. Our costs are too high, our margins are too low.

Before anyone point oout "Intel® Extension for Pytorch*" exists[3]:

1. That seems to be the official name (what?)

2. Their installation homepage seems a little convoluted[4]

[1]: https://www.pcmag.com/news/intel-faces-potential-class-actio...

[2]: https://github.com/vosen/ZLUDA

[3]: https://intel.github.io/intel-extension-for-pytorch/xpu/late...

[4]: https://intel.github.io/intel-extension-for-pytorch/xpu/late...

pushfoo

2 jaar geledendiscuss

TL;DR: They already wrote Varvara[1] + software[2] for it

My understanding is:

* The authors wanted to run on a Raspberry Pi powered by solar + batteries

* They're often somewhere in the Pacific so their internet connection is often bad

* Varvara[1] is the portable-enough solution which works for them

* Others liked it enough to write a bunch of other tools[2]

It's all pretty much self-hosting at this point. It's not for everyone, but why bother with Windows if it fits your needs?

[1]: https://wiki.xxiivv.com/site/varvara.html

[2]: https://github.com/hundredrabbits/awesome-uxn?tab=readme-ov-...

pushfoo

2 jaar geledendiscuss

TL;DR: Cut scope and call it done?

These sound like you're trying to build something with professional polish when you wanted to have fun:

> Part of it feels like I've tried to do too much at once instead of building piece by piece

> writing the tests for these and going back and forth on different decisions has killed all productivity and drive within me.

Why not build something awful and silly? Alternatively: add an awful plugin system and say it's left up to the user.

pushfoo

2 jaar geledendiscuss

I agree for smaller projects, especially personal ones. For larger projects, approaches like GitHub's web client + terminal interface might be the next best thing since grepping doesn't scale well. For better or worse, GitHub branding also helps make their specific terminal tool an easier sell in large org environments.

pushfoo

2 jaar geledendiscuss

Do you remember WordArt[1]?

> does it really cheapen it to have an obvious AI thumbnail?

> Does it say "trying too hard"?

If the article isn't about AI images, they often signal one more of the things WordArt used to:

1. Cluelessness (using $HOT_NEW_THING out of FOMO)

2. Sales pitches (trying to sell you something)

3. Irrelevance (lead-ins for B2B sales to 1 and 2)

4. Hard social & technical problems

The last case is the worst:

1. They're about to discuss font rendering problems

2. Consider leaving before someone assigns you the ticket(s) for them[2]

[1]: https://filestore.community.support.microsoft.com/api/images...

[2]: https://faultlore.com/blah/text-hates-you/

pushfoo

2 jaar geledendiscuss

TL;DR: Did the lab get a chance to try integrating sensors into a nice looking, non-smart wristwatch form factor?

> What we found is that seniors had essentially no desire to wear any sensors

My understanding is that much of it comes down to:

1. Fashion / utility concerns ("It looks stupid!")

2. Perceived loss of independence ("I don't want a baby monitor!")

However, even a phone accelerometer in the pocket seems to get useful if imperfect gait data[1]. If it's on the wrist, then it's enough for Apple to use it for fall detection[2].

My understanding is that you might have something fairly effective if you:

1. Made a watch look like wrist watches which seniors are used to and enjoy (no annoying screen, etc)

2. Integrated Wi-Fi sensing data like I mentioned elsewhere in this thread[3]

3. Found and added any features the sensors perceive as useful (there might not be any, however)

I know the regulatory and privacy hurdles for using Wi-fi radar data in a health-related device are formidable. However, there's a clear use case for it: detecting stroke-related movement abnormalities.

The paper on phone gait tracking I mentioned earlier[1] seemed to show the opposite side of the body had signal quality issues. Yes, using Wi-Fi data probably requires an additional device to combine it with data from the watch. However, "BE FAST" is an acronym used in patient education on stroke care because response time is critical[4].

[1]: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC8622042/

[2]: https://support.apple.com/en-us/108896

[3]: https://news.ycombinator.com/item?id=40893636

[4]: https://www.beaumont.org/health-wellness/blogs/stroke-sympto...

pushfoo

2 jaar geledendiscuss

TL;DR: Wi-Fi can already provide that signal.

We can already get full 3D pose estimation from Wi-Fi. Whether that's a good thing is a separate topic, but there's a recent paper[1] which also has a poster page[2] and a youtube video[3] embedded on it. The audio quality of the video is poor, however. There's a lot of echo.

This general line of work is what the comment from transpute[4] seems to have been implying. There's also a prior body of work on this which I'm not really familiar with.

[1]: https://openaccess.thecvf.com/content/CVPR2024/papers/Yan_Pe...

[2]: https://cvpr.thecvf.com/virtual/2024/poster/30463

[3]: https://www.youtube.com/watch?v=39oG-PJIZ14

[4]: https://news.ycombinator.com/item?id=40893391

pushfoo

2 jaar geledendiscuss

TL;DR: My concerns are more directly practical ones about approaches (formal and humor-based) to overcoming language barriers between devs across language families

> visual basic did that too

I haven't seen this on recent versions. An old MS support thread[1] suggests VB's editor has been English-only for the past decade-ish. Do you remember whether it's a built-in feature or an add-on? For example, did it get handled by replacing text, or storing ASTs of built-ins and remapping the display name? I'm not seeing much in search results.

I also haven't had time for an in-depth look at how Hedy handles their translation, but they do use Weblate to manage everything[2]. Their keywords page even has percentages for partial languages[3]. For Microsoft or whoever added a simliar feature to VB, I'd be surprised if they didn't have a way to do your own customization for an organization.

> while i'm sympathetic to complaints of cultural imperialism

My concerns are much more practical. Collaboration across language barriers:

* is fairly easy when the devs are all familiar with the same writing systems

* can become mutually frustrating across writing system families, especially between Latin-derived and logographic[4] CJK[5] systems

My best example involves attempting to discuss the same differences across the same writing system gap. I had to do some careful reading to make any sense of things. However, it led to some immediately useful conclusions about glyph cache and texture atlas / sprite sheet issues for everyone involved.

Fun fact: limited space in rewritable text editing tools may go back at least as far as the Romans.

However, de novo writing writing systems seem to have very few enduring examples. As far as I know, Korean Hangul[6] seems to be the oldest and it still experienced significant hurdles for hundreds of years.

Part of it seems to be that symbol systems tend to be domain-specific if they even have grammar, let alone executable properties. For example:

* Extensions to flowchart concepts such as Drakon[7]

* Toys such as Scratch[8], LEGO's old MindStorms environment, etc

* Non-executable domain-specific markup (7 Wonders[9] and other card / board games)

This goes all the way back to the Sumerians. Although we no longer use symbols primarily as primarily a means of agricultural contract record keeping, we did some of their timekeeping conventions. Our mathematical notation is better as I understand it, but still awful and inconsistent from an outsider's perspective.

That last point got me thinking. Diagramming and working demos both help with graphics, games, and geometry questions. The first two also seem to be specific cases of the third, which is a human interest predating digital or mechanical computers.

However, low-power or emulator developer communication seems to tend toward the following instead of clay cylinders or tablets:

* Non-freeform monospace text and text boxes (although the Left editor has both nice font support and syntax editing now, thank you for updating me on that)

* Audio calls or screen sharing text boxes or GUIs (more text and symbols)

Aside from inventing conlangs[10], we don't really invent new human languages, nor do we apply them at project scale. Instead, we seem to tend to come up with neologisms and project-specific slang.

Is this a feature or a bug? I see two extremes with regard to bridging grammatical structure and writing system gaps:

1. Reject: attempt to formalize how Esperanto did (or the way you said VB did)

2. Embrace: encourage and combine it with the following:

   * The way Forths tend toward being a family of dialects, each specific to an ISA or machine

   * Naturally emerging labels and slang

The second direction seems easier.

To me, Python seems to have "regional" dialects specific to industries or codebase purposes. It's not a standard, but an emergent thing the same way I've heard Newgrounds[11] projects had a reputation for offensive variable names.

Python had humor once too. Unlike Newgrounds Python's humor was Monty Python references in example code instead of choosing variable names based on shock value. Also, Python seems to have lost the humor as it "grew up"

It seems like this sense of humor is important to early-phase software and hardware ecosystems. For example, the Uxn / Varvara ecosystem we've been discussing has plenty of it. Potato[12] isn't quite a joke with a punchline, but it is an irreverent reference to low-power computers with "bad" graphics.

Community coherence is something Octo had issues with, but both Uxn and Decker seem to be doing well. My guess is humor as a key factor.

Do you have any thoughts on this and other parts of community building or emergence?

* In your specific area(s) of interest? (low-power, long-term hardware)?

* For retro languages+hardware?

* In general?

I also realize I might be bringing way too much process and theory into this. Do you still use the email listen on your about page?

It'd be nice to have a fallback in case this thread locks or something. It's been rare to have such long-lasting discussions, so I don't remember how thread locking works on this site.

[1]: https://answers.microsoft.com/en-us/msoffice/forum/all/visua...

[2]: https://hosted.weblate.org/projects/hedy/#information

[3]: https://hosted.weblate.org/projects/hedy/keywords/

[4]: https://en.wikipedia.org/wiki/Logogram

[5]: https://en.wikipedia.org/wiki/CJK_characters

[6]: https://en.wikipedia.org/wiki/Hangul

[7]: https://en.wikipedia.org/wiki/DRAKON

[8]: https://scratch.mit.edu/

[9]: https://boardgamegeek.com/boardgame/68448/7-wonders

[10]: https://en.wikipedia.org/wiki/Constructed_language

[11]: https://www.newgrounds.com/

[12]: https://wiki.xxiivv.com/site/potato.html

pushfoo

2 jaar geledendiscuss

Can I consider the UXF format stable?

UXF was one of the intended eventual targets of a very bad font converter I need to eventually rewrite.