pushfoo

Agreed. If the resource usage can be optimized further, it'll be feasible to train specialist models both on-prem and from scratch. That would sidestep the liability and privacy issues of current cloud-based offerings.

Google's search appliances did the same thing before they were retired. Hospitals were especially keen on them. They eliminated HIPAA risks because data never left the hospital intranet, but then Google eliminated the product line in favor of cloud offerings.

TL;DR: It looks like a convenient and explainable starting point for the proof-of-concept.

Manually combining specialist variants is a known technique. This paper automates it with a router component which mixes 2 sub-models at any given time. Training 8 slight variants of a base seems safe and configurable compared to n > 16 specialists. The latter seems like the parts could interact unpredictably.

Also, the memory usage seems predictable: it follows 2^m memory conventions by mixing 2 models at a time, so ~2x the memory is actively used at a time. I'm not up to date on the hardware implications, so it might not mean anything yet. It might one day if this approach works well enough to design around.

There's another elephant in the room: can we use this to distribute tickets to a team effectively?

I can see it being useful any time there are issues nobody wants to handle. Backlog grooming seems to stand out as a prime use case.

If you can spare extra pixels, Tom Thumb (3x5) [1] is more legible. The upper case M and N are somewhat hard to distinguish without context, but it's the only major flaw compared to this one.

Tom Thumb is also Public Domain (CC0).

[1] https://robey.lag.net/2010/01/23/tiny-monospace-font.html

> We have to add LLMs and MMMs (multi modal models) into all standard Linux distributions.

Why? This seems like a quick road to remote-execution-vuln-as-system-service.

> and voila we can search for anything with natural language.

What if your model keeps misunderstanding you?

TL;DR: that's an outdated idea with an ever-growing body of research refuting it

Autistic and neurotypical people can empathize with others like them, but have trouble between the groups [1]. This is called the "double-empathy problem" by the paper which proposed the idea [2]. More recent papers explore subjects such as information transfer accuracy [3] with the same results: autistic participants understand each other perfectly well when allowed to use their preferred means of communication, as do neurotypicals. However, the two groups have trouble understanding each other. Further work extends this to a generalized model with extremely unsurprising results: people tend to be closer with people who think like them [4].

[1] https://link.springer.com/article/10.1007/s10803-015-2662-8

[2] https://kar.kent.ac.uk/62639/

[3] https://journals.sagepub.com/doi/10.1177/1362361320919286

[4] https://academic.oup.com/scan/article/16/1-2/222/5940490

Do you have recommendations for getting into ML-family languages and functional approaches, or even just F#? Although Python's ecosystem and plentiful training data for LLMs are useful, trying Elm made me want to find something better at types.

To my understanding, pyramidal cells are already partially emulated by certain structures of weights. It's not the same as dedicated multi-layer mechanisms outside the local flow, but that option seems difficult to implement efficiently with current compute technology.

Maybe more VRAM to hold the added inter-layer features would allow it? NVidia seems reluctant or unable to do that on the consumer side. I haven't had time to thoroughly read up on why. All of these seem plausible:

* Offsetting rising per-unit costs from other components

* Intentional market segmentation

* Export restrictions

Previously discussed: https://news.ycombinator.com/item?id=38713215

You might be able to drop the PDF backend since they're close to getting HTML running well: https://news.ycombinator.com/item?id=38713215

Using that might be easier than a multi-modal approach. Bonus points for:

* Multiple papers at once

* Comparing PDF and HTML output with the LLM as input for it correcting similar converter code

Adding shape or location is better than color alone. For example, most countries accommodate color-blind drivers by standardizing the ordering and orientation of traffic lights in addition to the colors. In the US, there's no shape variation, but some other countries add it.

I think you're looking at this from a nuts and bolts perspective rather than a broader security mindset.

The incentives and goals for malware are what matter here. The first steps for satisfying those are always achieving undetected write and execution. In this context, RTs and everything else are just means to that end.

I can second this. Although my queries per month are limited due to using free tier, they almost always get relevant results for technical questions. If Google keeps getting worse, I'll switch to Kagi's paid tier. The LLM demo they briefly made available a few months ago was also impressive.

Using living cells as a read/write storage medium also makes them a target for malware. It's not limited to ransomware and classics, but also fun new possibilities [1]. Figuring out how to implement W^X should be a top research priority.

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

> Wonder how badly it could go if the data storage container is ruptured while against someone's body?

TL;DR: pretty much zero unless you're immunocompromised

The price tag of the broken equipment and bacterial infections are probably the biggest concerns.

Genetic information is like software. It doesn't do anything unless it's in a compatible environment. Eukaryotic cells like those in plants, animals, fungi are delicate. Viruses which can write DNA into them without killing them have to be complicated, which makes the viruses delicate. Being this delicate means work with these cells and viruses can be very expensive.

Why try to use a multi-Xeon server rack with fiber links when all you need is a cluster of 5 Raspberry Pis and a bare bones router? The latter is way cheaper.

For the same reasons, well-understood bacterial models like tame E. Coli strains are popular in biocomputing [1]. Slime molds [2][3] are also popular, and they're even famously good at pathfinding.

Your coworkers, however, might be annoyed that you broke the biocomputer again.

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

[2] https://link.springer.com/referenceworkentry/10.1007/978-3-6...

[3] https://royalsocietypublishing.org/doi/10.1098/rsta.2014.021...

> It is likely that the future of biocomputing hardware and software will likely include a combination of all three technologies [19]: live cell, enzyme-free, and enzymatic logic gates.

This prediction has a bunch of fun implications for security:

* Viruses and malware for such computers will also have a physical virus stage

* Tradeoffs between DNA and traditional methods for data storage

* A possible arms race between obfuscating and detecting unusual retrotranscriptases

Why only the files edited by a human? What about edge cases where changes made by a program, such as a linter or auto-formatter? Those aren't guaranteed to be integrated into an IDE.

Can this be used alongside a Git repo?

I have an odd use case in mind:

1. Git handles intentional releases / commits

2. Klunok handles "timelapse" recording of development to avoid full screen capture

This would make it easier to re-play development and re-render code with zooming and styles as needed.

Do you have an interface in mind to reduce friction for building the catalog on a daily basis? GitHub and Gitea don't really seem to provide clean ways to do this out of the box.

There's an interesting question raised by the linked "rant": should updating copyright year serve as a sign of life for a project?

I'm currently inclined to think that:

1. Yes, it should

2. The OP of the linked issue may be mistaking a tools / social conventions issue for an error by the author

Would you be willing to add email-based sign-up? Some users, especially in Europe, may prefer it to using Google or GitHub accounts to log in.

> I do it all the time with running shoes — if I find a pair that fit & work well, get some spares!

How do you deal with more technical products? Geopolitical tensions have me worried about the supply of certain HID products and their parts.

Do you want to keep tools internal sort of like the uxn/varvara ecosystem's focus on dogfooding tal, or are external tools ok?

Replit's mobile app has a decent virtual trackpoint-like cursor widget. If you added an APL keyboard as you suggested, it might be a nice combination if you leave out their AI autocomplete.

If you want to get extreme about input method minimalism, you might be able to remap Applejak[1]'s WASD / E input approach to swipe and tap gestures.

1. https://internet-janitor.itch.io/applejak (previously discussed here https://news.ycombinator.com/item?id=26188165)

Text rendering / UI on minimal hardware and finding more time for ML-family languages.

A few months ago, an iced-rs maintainer[1] recommended I try Elm. So far, this has lead to:

1. A an MVP[2] of a curses[3]-like library for CHIP-8 derivatives (https://github.com/pushfoo/octo-termlib)

2. A growing interest in language design

3. An ongoing re-evaluation of my software development worldview

[1] 13r0ck / Brock on GitHub (https://github.com/13r0ck). Hire him if you get the chance. He has a rare blend of know-how, mentorship, and community management skills.

[2] Unsolved issues with octo-termlib:

1. Finding a license friendly toward beginners editing pre-made template assembly files (Maybe zlib + acknowledgement?)

2. Elegant & efficient syntax for ending screen X / Y parsing before all digits are used

[3] https://en.wikipedia.org/wiki/Curses_(programming_library)

https://github.com/pushfoo/Fontknife

tl;dr: a CLI bitmap font converter, slicer, and rasterizer

I would love suggestions and help with:

* The awful command line flags: which of the following sound(s) best?

  - Something FFmpeg style: repeatable optional args are applied to the previous source / output
  - Keep it as 1 input + 1 output 
  - Prioritize library use
    

* Should I keep Octo[1] code generation in this project or separate it out?

* General refactoring:

  - The current caching layer should probably be deleted
  - Replace PIL's font support with other BSD or MIT style libs

1. Octo, a CHIP-8 assembler: https://github.com/JohnEarnest/Octo

P.S. Octojam 10 runs until 12:00 AM PST on November 1st! See the following if you're interested! https://itch.io/jam/octojam-10

> we don't have any maps of neuron connectivity

We do for a at least one classic, small-scale example: C. Elegans. Despite mapping the roughly 300 neurons, the simulation attempts I'm aware of weren't very fruitful.

> with nearly the resolution required to do so.

I agree this may be part of why. Accurate simulation may require replicating subtle behavior outside the neuron body. Further maps or simulation attempts may have since been made, and possibly with better results. Given I don't remember headlines about this, it's likely that any improvements weren't groundbreaking.

I don't know enough about the roles of glia and inter-neuron (not interneuron) behavior to discuss this further beyond wild speculation. Nor does anyone, as far as I know. Gaining that knowledge would probably be necessary to build connectomes with sufficient accuracy for simulation.

If I read the paper correctly, it seems to support the old quip about all AI being decision trees, at least for smaller model sizes.

It also raises an interesting UX question: is there an implicit tradeoff between legibility and power for notations as for different ways of expressing rotation, or is that a consequence of using graphics hardware to implement AI?

This is the most beautiful site I've seen in years.

My only criticism is the search box's height seems to be a few pixels shorter than the search button.

Do you write about design or development anywhere, or have a GitHub profile? I didn't see anything linked in your profile here.

In your experience, how do LISPs compare to ML family languages in typing and readability?