samuell

I think this is a cool project. I see a lot of use cases for this, for cases where it is preferable to keep issues local to the repo, distributed via git only, and not the least for all kinds of personal task management. Avoiding the context switching to a web based tool is a nice plus.

> “People who go all in on AI agents now are guaranteeing their obsolescence. If you outsource all your thinking to computers, you stop upskilling, learning, and becoming more competent.”

> – Jeremy Howard, creator of fast.ai

This so much summarizes it.

I wrote shortly about it from a slightly different angle (piano playing) just this morning: https://livingsystems.substack.com/p/playing-freely

I think the village would be a healthy model for sure. But that is something that was pretty much killed in the modern society as well as most people, especially lower/mid-income workers in larger cities, are spending exceedingly little time of their day in their local neighborhoods.

It is a bit curious with the Mojo 1.0 beta coincidence, as Pascal was the other langauge with a highly readable and quite simple language combined with performant compiled code without GC.

What it lacked was a modern compiler and stack. There is FreePascal for sure, and Lazarus is impressive, but it for sure has its baggage.

As someone who would have strong reasons to invest time in Modular (simple high performant language for implementing bioinformatics scripts), I would say primarily the worry that development might be too tied to Modular, the startup behind it, which eventually might pivot into other priorities.

One would want to see either a strong community build up around it, or really hard evidence for a long-term commitment to the language from Modular. And the latter will take a long time to be assured of I think.

Also, editing tools need to catch up before very wide adoption of a language with a lot of new syntax.

The communication had me try to run some very simple python code assuming it of course should run (reading files line by line), which didn't work at all.

For me this was a big disappointment, and I wonder how much this has backfired across developers.

Which is probably one of the biggest problem with the outsourcing of parenting for half their awake time that is happening with our established school system.

Not that I claim it is super easy to find an alternative on a large scale, but I think societies need to think hard about how to enable involving parents to be as much involved as possible in the kid's day. (For parents working full time shifts + commuting in a major city, this is very hard).

There is also epiq, which is a bit more bleeding edge but has a more powerful UI story, being a TUI app, providing an issue board in the terminal:

https://github.com/ljtn/epiq

So the execution model is now even more similar to Go's one, with the M:N scheduling, IIUC?

I much like to hear that, as I found Crystal to provide pretty much exactly the same concurrency primitives as Go, but with a much nicer syntax, as I compared here:

https://livesys.se/posts/crystal-concurrency-easier-syntax-t...

Indeed! I generally like awk a lot for simpler CSV/TSV processing, but when it comes to cases where you need things like combining/joining multiple CSV files or aggregating for certain columns, SQL really shines IME.

Did you try https://elicit.org ?

I have been impressed by its results.

I think this fact stems more from its initial search phase than its pure LLM processing power, but to me it seems the approach works really well.

Nice experiment and writeup!

On a tangent, nice to see Plasmidsaurus using Emu [1], which has been shown to work great for 16S ribosomal RNA analysis on ONT by basically everyone I've heard who tried it. It has a nice algorithm for predicting if variants are due to ONT sequencing errors or are true variants, based on an expectation maximization algorithm, and thus working around the somewhat limited accuracy in ONT reads. Pretty clever stuff.

And if you want to run your own analysis on the raw data using Emu, you might want to try out our Trana pipeline built around Emu in Nextflow [2]. Apart from running Emu, it does some of the preprocessing like filtering, as well as exporting as Krona diagrams etc.

We're just putting it through validation at the clinical microbiology lab at Karolinska here in Stockholm right now.

The main caveat worth mentioning is that the choice of database seems to be able to affect results quite a lot in some cases.

[1] https://github.com/treangenlab/emu

[2] https://github.com/genomic-medicine-sweden/TRANA

Curious that this hit the front page.

What kind of projects is this software used for?

I tried this to try to extract some speech from an audio track with heavy noise from wind (filmed out on a windy sea shore without mic windscreen), and the result unfortunately was less intelligible than the original.

I got much better results, though still not perfect, with the voice isolator in ElevenLabs.

I love Prolog, and have seen so many interesting use cases for it.

In the end though, it mostly just feels enough of a separate universe to any other language or ecosystem I'm using for projects that there's a clear threshold for bringing it in.

If there was a really strong prolog implementation with a great community and ecosystem around, in say Python or Go, that would be killer. I know there are some implementations, but the ones I've looked into seem to be either not very full-blown in their Prolog support, or have close to non-existent usage.

Yea, a bit like a cheating student rote memorizing and copying another students technique for solving a type of problem, and failing hard as soon as there's too much variation from the original problem.

I was going to ask about wine support. Anyone tried in Bottles (wine distribution)? I've had better luck with Bottles than plain Wine with other software. Hoping to try soon.

I thought protonmail was the go-to for de-googling.

Wine can be a bit of a headache if you are on a couple year older distro as it can make it harder to install newer Wine versions.

But I found that the Bottles project pretty much solves this, by installing everything in some kind of sandboxed environment:

https://usebottles.com/

https://github.com/bottlesdevs/Bottles

Has worked wonderfully for the few cases where plain Wine failed.

Also:

- https://news.ycombinator.com/item?id=44891333

- https://news.ycombinator.com/item?id=44902206

- https://news.ycombinator.com/item?id=44902941 (1 comment)

- https://news.ycombinator.com/item?id=44910951 (1 comment)

- https://news.ycombinator.com/item?id=44918111

I wonder if the control system was running windows 98 :)

Jokes aside, would be interesting with some more details, if anybody got them.

Markdown + Vim-wiki plugin is a really powerful combo, that is still all only markdown underneath.

And yes, you can combine that with something like Obsididan at any time.

fun is the best, as it makes the function name align with the code block indented 4 characters :D

    fun main() {
        println("Hello, world!")
    }
        ^ aligned here! \o/

On Twitter, Andreas points out that his Keynote Presentation on the Ladybird Browser on the FUTO conference in Texas earlier in the year, might be the best current introduction to the project:

https://www.youtube.com/watch?v=9YM7pDMLvr4

This is such an important project, to keep the big corporations from completely controlling the future of the web.

And it doesn't hurt that Andreas seems to be such a nice, humble guy.

Yeah, perhaps the GitHub README [1] had been better ... but it seemed like the most "official" page.

[1] https://github.com/carbon-language/carbon-lang/?tab=readme-o...

See also: https://www.hackster.io/news/embedded-computing-startup-effi...

Sounds super interesting, though as a novice I'd be interested to know about how it differs from FPGAs?

... and if you (the parent comment author) wants a really easy tool for creating a UI for the Python code, I'd recommend looking at Streamlit: https://streamlit.io/

I'd go out on a limb and say the rock-solid out-of-the box experience is what is keeping many people using R-studio (and even R itself), rather than the messy ecosystem of Python. I'm seeing this tendency in myself for some tasks.

Also, my impression is that that is also a big part of why MATLAB still exists, despite outraging prices.

I think the common theme among these tools' main user groups is that they are not developers. They are not comfortable fiddling a lot with a dev environment, but can be productive in an environment where everything just works.

Thus, if Positron can get the same smooth and rock-solid out-of-the box experience, it will be able to reach a lot of these non-developer user groups.

At least that's my 5c.