It's interesting to see that they let you mix markup with logic directly in rust, but I have worries about maintainability. I remember the bad old days of PHP where you'd mix markup with logic directly, even when doing OOP with classes and it really made things more difficult long term.
It’s not a rust thing. Custom markup is usually implemented in rust frameworks using macros. If mixing macros and logic becomes a problem, we can change how the macros are implemented.
Yes, I saw that's it's via macros, but my point is that it reminded me of some web development practices from a much earlier era, and why we moved towards doing templates and separating app logic from presentation
Some absolutely great work, but I don't know why you would come up with a new term for a server component (shard). Why not just use the obvious client/server annotations so you don't have to define a novel term for new users?
I haven't tried to the web app part but I've tried Toasty. The API seemed to be a little simpler and nicer to use than SeaORM for me. Here are a few things I liked in Toasty:
- In SQLite UUIDs are default stored as compact blobs instead of inefficient varchar/text (SeaORM)
- Timestamps were easier via jiff instead of chrono (SeaORM)
- Model structs use the actual name of the $table instead of being named like $tablemodule.(Model|ActiveModel) (SeaORM) they are just $Table. This makes writing libraries a little simpler that need to use entity struct's from two separate modules/crates otherwise you get a name collision on Model/ActiveModel and need to do alias imports.
- There's an API to fetch related data to a query similar to Django ORM. IIRC this is missing from SeaORM
- The query expression language doesn't cover as much of SQL as SeaORM but seems to be enough for most web apps.
- I didn't like how the migration system works. I would skip that part of the library
I have tried it.
It feels pretty good to use, but you have to keep in mind that it's very early software.
They currently break the API every other week, and it's still missing a lot of fundamental features.
I have made a few basic web apps with it, and on v0.8.1 it was still missing a lot of reactivity which meant you had to use Javascript to bridge the gap.
We’re using it to build our web app (https://uncook.xyz) and while it’s a slight departure from my team’s NodeJS background it’s been pretty cool to work with
Luckily there's a lot of people who write prototype code, toy projects, and other "non-production" code that can experiment with a new project like this
> write it in C and ask an LLM to weed out the memory bugs?
because a non-determinist chain of reasoning is not the same as a fully deterministic algorithm. Its the best tool when a deterministic system is not feasable.
>because a non-determinist chain of reasoning is not the same as a fully deterministic algorithm.
It is not. But rust's borrow checker has its costs. It forces awkward implementations. Either suffer the horrible life time syntax, or pay the price of clone everywhere.
If you use C and run LLMs over it once in a while, I think it will get you most of the way.
Reuse is bad / NIHS is good and it's hard to reach token metrics using accepted engineering practices. That leads to the point of having the LLM invent a new specialized job security chip architecture for your IR just to run CRUD app.
Why bother with rust when you can write it in C and ask an LLM to weed out the memory bugs?
Here is a idea, why not combine both? Have the advantage of Rust its build in checks and LLMs independent checks. Now you get both for a even more safe program.
I don't get the complaints about the horrible syntax. The syntax is fine... Which is weird cause I only get complains from c/c++ folk, and that set of languages have objectively AWFUL syntax
Rust's syntax is horrible not because of the braces. But due to the type system information the code has to carry. And the type system, unlike something like Haskell, is not always smart enough to infer the types from the context. Which cause even more noise in the form of type hints!
Add to that the horror of life time annotations, you really have a mess at your hands. I have seen projects litter clone everywhere just to sidestep this mess.
So actually the answer to your question is that Rust provides excellent guardrails against memory safety issues, and in some cases, for code correctness as well, by allowing more behavior to be encoded in types. One of those guardrails is borrow checker.
I really like the direction Topcoat is going in as a Rails developer. Although it is just a bit itchy to my eyes, it is not acid-level, though.
The things that look great are LiveView and getting rid of boilerplate for client-side reactivity
It's interesting to see that they let you mix markup with logic directly in rust, but I have worries about maintainability. I remember the bad old days of PHP where you'd mix markup with logic directly, even when doing OOP with classes and it really made things more difficult long term.
It’s not a rust thing. Custom markup is usually implemented in rust frameworks using macros. If mixing macros and logic becomes a problem, we can change how the macros are implemented.
Yes, I saw that's it's via macros, but my point is that it reminded me of some web development practices from a much earlier era, and why we moved towards doing templates and separating app logic from presentation
Some absolutely great work, but I don't know why you would come up with a new term for a server component (shard). Why not just use the obvious client/server annotations so you don't have to define a novel term for new users?
Sounds a lot like Liveview in Phoenix.
Has anyone here tried it?
I haven't tried to the web app part but I've tried Toasty. The API seemed to be a little simpler and nicer to use than SeaORM for me. Here are a few things I liked in Toasty:
- In SQLite UUIDs are default stored as compact blobs instead of inefficient varchar/text (SeaORM)
- Timestamps were easier via jiff instead of chrono (SeaORM)
- Model structs use the actual name of the $table instead of being named like $tablemodule.(Model|ActiveModel) (SeaORM) they are just $Table. This makes writing libraries a little simpler that need to use entity struct's from two separate modules/crates otherwise you get a name collision on Model/ActiveModel and need to do alias imports.
- There's an API to fetch related data to a query similar to Django ORM. IIRC this is missing from SeaORM
- The query expression language doesn't cover as much of SQL as SeaORM but seems to be enough for most web apps.
- I didn't like how the migration system works. I would skip that part of the library
I have tried it. It feels pretty good to use, but you have to keep in mind that it's very early software. They currently break the API every other week, and it's still missing a lot of fundamental features. I have made a few basic web apps with it, and on v0.8.1 it was still missing a lot of reactivity which meant you had to use Javascript to bridge the gap.
I used it in the early days, and it seems it's still the same. Thank you.
We’re using it to build our web app (https://uncook.xyz) and while it’s a slight departure from my team’s NodeJS background it’s been pretty cool to work with
cute app
> Look, I don’t know where we are going.
As honest as it is I can't risk using this anywhere near production if this is the attitude.
Luckily there's a lot of people who write prototype code, toy projects, and other "non-production" code that can experiment with a new project like this
I'd rather honestly than false confidence, there's something admirable about being this clear for sure
Go use Java then.
Why bother with rust when you can write it in C and ask an LLM to weed out the memory bugs?
> write it in C and ask an LLM to weed out the memory bugs?
because a non-determinist chain of reasoning is not the same as a fully deterministic algorithm. Its the best tool when a deterministic system is not feasable.
>because a non-determinist chain of reasoning is not the same as a fully deterministic algorithm.
It is not. But rust's borrow checker has its costs. It forces awkward implementations. Either suffer the horrible life time syntax, or pay the price of clone everywhere.
If you use C and run LLMs over it once in a while, I think it will get you most of the way.
If you go that way, why not write LLVM Intermediate Representation? And if you know your server CPU anyway, why not write machine code?
I personally like Rust for web applications a lot because you can catch many bugs at compile time instead of during tests or runtime.
>If you go that way, why not write LLVM Intermediate Representation? And if you know your server arch anyway, why not write machine code?
Nah, C is good enough for me.
> catch many bugs at compile time...
Rust borrow checker is too dumb that you catch many non-bugs as well...I don't like that.
Mmm..LLMs also generates false positives. But at least you can reason with it...
Reuse is bad / NIHS is good and it's hard to reach token metrics using accepted engineering practices. That leads to the point of having the LLM invent a new specialized job security chip architecture for your IR just to run CRUD app.
Soon we're gonna need a way to catch bugs at prompt time
Why bother with rust when you can write it in C and ask an LLM to weed out the memory bugs?
Here is a idea, why not combine both? Have the advantage of Rust its build in checks and LLMs independent checks. Now you get both for a even more safe program.
Why bother with asking an LLM to weed out the memory bugs when you can write it in Rust?
> when you can write it in Rust..
Because fuck borrow checker..(and the horrible syntax)
I don't get the complaints about the horrible syntax. The syntax is fine... Which is weird cause I only get complains from c/c++ folk, and that set of languages have objectively AWFUL syntax
Rust's syntax is horrible not because of the braces. But due to the type system information the code has to carry. And the type system, unlike something like Haskell, is not always smart enough to infer the types from the context. Which cause even more noise in the form of type hints!
Add to that the horror of life time annotations, you really have a mess at your hands. I have seen projects litter clone everywhere just to sidestep this mess.
It’s subjective. Some folks think lisps are it, others basic. Folks need to accept that we do not need global alignment on what good syntax means.
As if C was any better than rust. So much clutter. So hard to grok with all the macros. I'd rather read rust than C.
So actually the answer to your question is that Rust provides excellent guardrails against memory safety issues, and in some cases, for code correctness as well, by allowing more behavior to be encoded in types. One of those guardrails is borrow checker.
Thus, the agent needs to iterate less.
>Thus, the agent needs to iterate less.
I mean, I didn't meant to run the LLM every compile cycle. May be just before a release or something..
Why bother with C when you can get an LLM to write it in Rust and not waste tokens on finding memory bugs