shpongled

It's still a great idea - I haven't heard anyone else suggest using such context for predicting AGI timelines.

To be pedantic, I would argue that we aren't even close to being able to simulate the full brain of a flatworm on a supercomputer at anything deeper than a simple representation of neurons.

We can't even simulate all of the chemical processes inside a single cell. We don't even know all of the chemical processes. We don't know the function of most proteins.

Maybe in CS?

In the life sciences, practically no one knows how to use LaTeX, or has even heard of it.

Polars is written in Rust!

I would argue that mass spectrometry based proteomics is capable of offering much better insight into functional relevance than transcriptomics. Proteins carry out function... and mRNA levels are only loosely coupled to protein levels (at best, expect an R^2 < 0.4). Why measure RNA when what you really care about are proteins? People just do transcriptomics because it's cheap.

This particular paper has flaws - as you mentioned, only a very small number of peptides are measured. I work on proteomics, and I remember this discussion from when the paper was initially published: https://mstdn.social/@pwilmart@scicomm.xyz/11087205681645628...

Paleoproteomics isn't what I would call well developed at this stage. How do we know that the peptides that were detected were actually from Vlad? Many people may have handled the letters over the years.

That sounds like a major skill or motivation issue.

I wouldn't want a "dev" who spent 2-3 hours a day doing something like this manually working with me.

Definitely agree - when I say slightly slower I'm mostly referring to the happy-path/basic uses (reading files, using hashmaps, web servers, etc).

There are definitely aspects of Rust that are much more complex (typically with a tradeoff of more expressiveness, but not always), but at least in my experience, these are usually areas where you can't easily express the same thing in Python. I think many times people forget that you can frequently `clone` your way out of many issues if you are trying to move fast.

And of course areas where I still only use python: manipulating tabular data, making graphs, quick scripts for interacting with APIs etc.

I also use it professionally, for both web apps and HPC algorithms.

Are there some things faster to write in python? Sure. But I find the mental overhead is significantly less (for me) in Rust, and overall dev time is about equal, since I typically hit far fewer bugs and spend less time reading docs in Rust. I can't remember the last time I hit a footgun in Rust. Seems I hit one every week in python.

We recently migrated a ~10k SLOC Django JSON API server to axum/sqlx (Rust). I couldn't be happier - faster to ship new features, faster to refactor, fewer bugs, and response times got about 10x quicker.

I would as well. I've also placed in the top 100 of advent of code before... using Rust :)

I think once you get familiar with it, it is just slightly slower to write than python.

I had the exact same experience - I did some of AoC in SML, fell in love with the core language, and even hacked on a toy SML compiler (didn't get too far).

It really is a wonderful language held back by a lack of good tooling and ecosystem, and well, users.

I sold the 590 :)

Yeah, sorry that wasn't very clear. One option for a partial update is do define a new `Update` struct:

    struct Bar {
        id: Uuid,
        column_1: i64,
        column_2: i64,
        column_3: String,
        column_4: Uuid,
    }

    struct UpdateBar {
        column_1: Option<i64>,
        column_2: Option<i64>,
        column_3: Option<String>,
        column_4: Option<Uuid>,
    }

    UPDATE some_table SET
    column_1 = COALESCE($1, column_1),
    column_2 = COALESCE($2, column_2),
    column_3 = COALESCE($3, column_3),
    column_4 = COALESCE($4, column_4),
    WHERE id = some_id;

Or, you just never do partial updates :)

Either do a patch with a new struct, or do full updates (what I typically do).

I have a few dynamic queries, but for the most what I'm doing is relatively straightforward. I still prefer this over using an ORM, personally.

There is some trade-off in development speed, but I think it's outweighed by the productivity gains from a great static type system and language that is relatively free of footguns.

I have built several APIs with Rust + Axum + Sqlx. I get statically typed SQL queries, rock-solid performance, easy to deploy. Most of these APIs also interface with AWS stuff at some point, and the Rust SDK is just phenomenal to use.

But I also love Rust. I've been writing it for 6 years now, and I am more productive in Rust than any other language (for non-trivial projects). I can write up an API faster in Rust than in Django, because I don't have to spend time digging through configuration files or installing plugins and reading arcane documentation to do what I want. The above stack in Rust is incredibly simple.

`if err != nil` is the easiest example.

Sum types allow you to express type-level OR. Structs/tuples etc are AND (product types). I like to be able to use both OR and AND at both the expression and type level.

Lack of sum types is complete deal-breaker for me unfortunately.

> solid type system

Politely closes door in your face

Who wouldn't. But let's not pretend that stackage and crates.io are covering the same functionality space.

As just one example: there are no OCaml or Haskell packages for natively reading or writing parquet files. There are at least 2 such packages for Rust.

I'm familiar with both - but not really the same order of magnitude. crates.io lists >120k packages. opam has ~4500, and stackage ~3000. And the package ecosystem is only part of it. Admittedly, I haven't written any OCaml or Haskell in the last year or so, but my experience of just getting a new library or executable up and running isn't comparable to cargo either. But also hard to separate my strong familiarity with Rust from the comparison.

It's not a dumb take at all. I have been using Rust for > 6 years now. A significant portion of my projects don't benefit strongly from the borrow checker (the other ones massively do). I use Rust primarily because it has a solid type system, functional bent, and - most importantly - phenomenal tooling (cargo, rust-analyzer), package ecosystem, and developer UX.

If OCaml/StandardML/Haskell/etc had anything close to the ergonomics and convenience of cargo for testing, setting up projects, adding deps, deploying them to any OS/platform, I would probably write about 30-40% less Rust.

I'm not saying we should add GC to Rust - but I think there is space for a Rust+GC language (or just improved ecosystem and tooling for other functional langs)

Readability is a function of familiarity though. I have been programming in Rust for > 5 years, I find it to be an incredibly readable language, because I am so familiar with it.

> You should try talking to some actual graduates in the life sciences department at your local state school, and not just MD-PHDs. I am willing to bet money that the number of non-medical biology researchers whose number one choice is medicine outnumbers wannabe researchers.

As a biochem PhD holder, you're really gonna have to back this up.

I would look into AWS Batch - it works pretty well for running diverse jobs. I have a few jobs that are triggered by S3 uploads that run for 1-30 minutes, and other jobs that run for ~hours. All on Fargate

See the tweets from the other replier, as well as my reply above.

The former dean of Harvard Medical School: https://twitter.com/jflier/status/1495833104510038026

A slew of retracted papers from his mentor's lab, and image duplications/fabricated western blots from David's lab:

https://forbetterscience.com/2020/05/14/never-ageing-anti-ag...

https://forbetterscience.com/2023/04/17/the-original-sins-of...

Several blog posts on the resveratrol controversy by Derek Lowe (required reading in pharma/biotech):

https://www.science.org/content/blog-post/resveratrol-srt501...

https://www.science.org/content/blog-post/does-resveratrol-r...

https://www.science.org/content/blog-post/resveratrol-humans...

https://www.science.org/content/blog-post/latest-sirtuin-con...

Also anecdotal, but I personally know several PIs who worked on sirtuins during their PhDs and they all say that David is full of shit.

David Sinclair is considered to be a quack (bordering on a fraud) by many within the scientific community.

Seriously, what is with all of the people in this thread that take offense at the flaws of ChatGPT/LLMs being pointed out? Are you all just working at AI companies?

> My prof developed a production SML compiler that's fairly widely used

MLton? I've been playing around on-and-off with a non-production SML compiler and MLton is such a fantastic resource.

This is just a hobby for me, but I have read (and own) several different compiler textbooks. What I really want is one that focuses on compiling functional languages down to assembly.

Rust, but practically no other mainstream or OO/imperative style language

Super cool - I have gone done the rabbit hole of trying to compile functional languages/lambda calculus with continuations a few times. I will be bookmarking and returning to this when the I get the itch again!