592 karma · joined January 21, 2013
Nearly. There are still some things easier to do in Python or JS, but the gap is closing quickly and I'm fine with spending small amount of convenience to get quality of Rust code. I am looking now into having nearly 100% Rust frontend + Rust backend for some simple project and it does look promising.
In the spirit on nitpicking on edge cases: It does, but quiet often you pass a number to some C library (other than stdlib) and C does not honour this arrangement.
Which is great - for creating custom admin panels easily. You can't use it as "generic app" you just turn on and it works, so someone has to do it.
There was an joke (real story maybe) about soldiers being allowed to carry up to 25kg of gear, and therefore a device weighting 104kg supposed to be carried by 4 people was deemed not to be portable.
Which is reasonable advice for a code running in a browser, not for a proxy/CDN (and you don't want proxy inserting it's own js).
Nothing matches Solr/ES on functionality though, and ES doesn't require anyone to deal with Java (until you need tweak perfomance).
TypeScript type checker written in Rust Ruff – a fast Python Linter written in Rust Introducing Turbopack: Rust-based successor to Webpack Deno is a simple, modern and secure runtime for JavaScript, TypeScript, and WebAssembly that uses V8 and is built in Rust.
Mostly, but Rust is increasingly replacing them.
It's a feature, not bug. In the world where many components are created independently by different developers, It's suddenly possible to define element style easily, without requiring you to consider affecting tons of other things that are not in any way related and you know nothing about. Less sharing is good when sharing requires expensive coordination.
Important things:
1. Consider what developer need and what devops need. Those are different needs. 2. Packages should be immutable. 3. Take care about what text you print. This should be to the point, no spamming. 4. Having reliable package repository is the best way to go. Getting dependencies from random git repos is a recipe for production issues, as those come and go.
(I do not now Rel, so maybe this is irrelevant).
What "versioning" means depends heavily on the database. "Versioning" for typical relational databases like Postgres does not achieve many of expected git features like branching and ability to materialize data for arbitrary point in time, unless you build something extra on top (or just use db as git storage). There are databases like dolt where "versioning" idea is similar to git.
> is the tamper-evidence what's needed and missing or something else?
I always work in controlled environments, so don't care much about tamper-evidence (unless its used for detecting integrity issues perhaps).
I didn't know datomic, that's looks like solution for half of the problem (distribution and history). I may still be missing something more human-focused like git, where you have branches, collaboration and push or pull when needed.
I was just commenting, not disagreeing.
Biggest issue with git for me is that its only usable for plain text. There is Dolt and few other projects that try to solve it,
> The value of git is distributed operation and tamper-evidence. What would be the value of these attributes for a cloud-based app?
Cloud based apps are very often distributed internally. For example consider a book store that has data in a database and replicates that in elasticsearch and some data analytics platform. Being able to use data versioning for those replications could be useful.
I encountered this case once, and they are considered to be different types (in my case the issue was that using v1.0::foo with v1.1::foo traits wouldn't compile), so either keep them separated or pick one. Error messages can be confusing though, if you don't suspect using two versions.
import unicodedata list(unicodedata.normalize('NFD', "ñ")) >> ['n', '̃']
list(unicodedata.normalize('NFC', "ñ")) >> ['ñ']
both are correct, the issue is that unicode allows accented letters to be written as _accented_letter_ or _letter_, _accent_. The idea of "character" in uncicode is not very useful, most of the time you will want graphemes, not codepoints. User-friendliness wise, this is what Python should use (another rant - strings should not have length method, they should have byte_length, codepoint_length and grapheme_length).
https://www.linuxjournal.com/content/getting-started-rust-wo...
It leaves many concepts without full explanation, but that's not necessary to do something useful.
There is your problem
The learning curve is usually different because you will need to understand more before program will compile and because most materials aims to cover 100% of the language from day one, but if you want to approach it differently, productivity wouldn't be a problem.
Due to ability to work without stdlib, Rust is system language in a sense Go never will be, to the point Go authors withdrawn this definition.
> Is Rust really a suitable replacement for Go?
It depends on your requirements for the ecosystem. If you need compatibility with Go or Go libraries, than it's not a replacement.
Libraries and support aside, any program written in Go can be written in Rust (and going back to nostdlib, many programs written in Rust cannot be written in Go). If you have required libraries, I'd say it can be written comparably quickly and easy. For example you can have web service returning hello world in 10 lines of code or so in either.
They are popular in different circles, but that is mostly not related to technical abilities. For 99% of of applications, you could pick either one.