kotlin VS rust

### Curated list of people blogging and vlogging about Kotlin (with links) - Roman Elizarov — https://medium.com/@elizarov - Jake Wharton — https://jakewharton.com/ - Marcin Moskala (Kotlin Academy) — https://blog.kotlin-academy.com/ - Gábor Varadi (Zhuinden) — https://zhuinden.medium.com/ - Antonio Leiva — https://antonioleiva.com/ • YouTube: https://www.youtube.com/@AntonioLeiva - Donn Felker — https://www.donnfelker.com/ - Kaushik Gopal — https://kaush.co/ - Nate Ebel (Goobar) — YouTube: https://www.youtube.com/@Goobar - Rahul Pandey — YouTube: https://www.youtube.com/@rahulpn7 - Philipp Lackner — YouTube: https://www.youtube.com/@PhilippLackner • Site: https://pl-coding.com/ - Stevdza-San — YouTube: https://www.youtube.com/@StevdzaSan - Reso Coder — https://resocoder.com/ • YouTube: https://www.youtube.com/@ResoCoder - Code With Mitch (Mitch Tabian) — https://codewithmitch.com/ • YouTube: https://www.youtube.com/@mitchtabian - Igor Wojda — https://medium.com/@igorwojda - Alexey Soshin — https://soshin.dev/ - Kevin Galligan — https://kevingalligan.com/ • Company blog: https://touchlab.co/blog - John O’Reilly — https://johnoreilly.dev/ - Rick Clephas — https://rickclephas.com/ - Arkadii Ivanov — https://arkivanov.github.io/ ### Official channels and team sources (Kotlin-heavy) - Kotlin by JetBrains (talks, news) — YouTube: https://www.youtube.com/@Kotlin - JetBrains Kotlin Blog — https://blog.jetbrains.com/kotlin/ - Kotlinlang Blog — https://kotlinlang.org/blog - Talking Kotlin (podcast) — https://kotlinlang.org/podcast - Android Developers (Kotlin-first Android) — Blog: https://android-developers.googleblog.com • YouTube: https://www.youtube.com/c/AndroidDevelopers

All code examples in this article are written in Kotlin, leveraging its concise syntax, null safety, and seamless Java interoperability. Kotlin's expressive language features make the implementation more readable and maintainable compared to traditional Java approaches, while providing full compatibility with the Spring Boot ecosystem.

I've never heard of language lock in. The source is here: https://github.com/JetBrains/kotlin

Come in; the water is fine.

Doodle helps you create beautiful, modern apps entirely in Kotlin. Its render model is intuitive yet powerful, making it easy to achieve complex UIs with pixel level precision and layouts. This simplicity and power applies to everything from user input to drag and drop. Doodle lets you build and animate anything.

5. Kotlin: The Modern Java Alternative

Kotlin Official Website

Kotlin Official Website: Your one-stop shop for all things Kotlin, with comprehensive documentation, tutorials, and resources: https://kotlinlang.org/

Next, I selected the technologies and frameworks I want to focus on during this challenge. For frontend development, I'll be exploring Reactjs, Vue.js, Bootstrap, Next.js, and MUI. For backend development, I'll be diving into Express, Django, Node.js, PHP, and Firebase. Additionally, I'll be learning Kotlin, React Native, and Flutter for mobile development, and APIs, PostgreSQL, Cloud, and MongoDB for full stack projects.

Funnily this is satire/educational code - notice the license is "GLWTPL" (Good Luck With That Public License).

Repo is based on exploiting this bug - https://github.com/rust-lang/rust/issues/25860 (Open since 2015)

The bug allows you to "extend" any lifetime 'a to 'static in safe code:

This converts a reference with any lifetime into a 'static reference, which violates Rust's safety guarantees. Once you can do this, you can create dangling references, access freed memory, etc.

This is a type system bug, not just an implementation bug. From the discussions:

- The easy fix (banning contravariance in function arguments) would eliminate valid Rust programs

- The proper fix requires changes to how higher-ranked lifetime variables carry subtyping relations

- The Rust team chose to pursue the more rigorous solution as part of replacing the trait solver (the "Chalk" project)

I just created a ticket to better gate that suggestion so it doesn't trigger here[3].

But the second suggestion is exactly what the user intended. The only thing missing would be for the message to actually mention "that Arc::clone() creates a new owned handle that can be moved into the closure independently" as part of the message. That gives makes me think we should have something like `#[diagnostic::on_move("message")]`, so I filed a ticket for that too[4]. At worst we could hardcode better messages for std types.

I am not impressed with the rest of the article, neither the tone nor the substance. I wouldn't have commented if it hadn't been due to the combination of the title with that specific wording (given that I've spent a decade making rustc errors teach you things), the actionable feedback being buried under layers of snark and indirection, and the actual feedback being given being wrong (but hey, at least I did find two other tangential things that could do with fixing, so small wins I guess?).

[1]: https://play.rust-lang.org/?version=stable&mode=debug&editio...

[2]: https://github.com/rust-lang/rust/pull/121652

[3]: https://github.com/rust-lang/rust/issues/149861

[4]: https://github.com/rust-lang/rust/issues/149862

There are plans to experiment with language level comptime support too: https://github.com/rust-lang/rust/pull/148820

SAFETY comments do not magically make unsafe Rust correct nor safe. And Miri cannot catch everything, and is magnitudes slower than regular program running.

https://github.com/rust-lang/rust/commit/71f5cfb21f3fd2f1740...

https://materialize.com/blog/rust-concurrency-bug-unbounded-...

format_args! is slow rust/#76490

> The main benefit of parking lot is that it makes locks very small, which then encourages the use of fine grained locking. For example, in JavaScriptCore (ParkingLot’s first customer), we stuff a 2-bit lock into every object header - so if there is ever a need to do some locking for internal VM reasons on any object we can do that without increasing the size of the object

IMHO that's a very cool feature which is essentially wasted when using it as a `Mutex` because the mutex's size will get rounded up to the alignment of `InnerBlah`. And even when not doing that, afaict `parking_lot` doesn't expose a way to use the remaining six bits in `parking_lot::RawMutex`. I think the new std mutexes made the right choice to use a different design.

> I’m surprised that this only compared to std on one platform (Linux).

Can't speak for the author, but I suspect a lot of people really only care about performance under Linux. I write software that I often develop from a Mac but almost entirely deploy on Linux. (But speaking of Macs: std::mutex doesn't yet use futexes on macOS. Might happen soon. https://github.com/rust-lang/rust/pull/122408)