Alan Kleber

Data Engineer / Software - IT Director

[Orhun Parmaksız 👾 @orhundev]

Ladies and gentlemen, it's finally here...

📺 ttv — Play videos directly in the terminal!

💯 It works™ with a naive implementation.

🦀 Written in Rust & built with @ratatui_rs & @FFmpeg

⭐ GitHub: https://t.co/vxnib6bOZo

#rustlang #ratatui #tui #media #player #terminal #image #commandline #ffmpeg #video

[AstraKernel 💫 @AstraKernel]

✨ How to build small and secure Docker images for Rust (FROM scratch)

https://t.co/21ZEV65sfF

[Matthias @matthiasendler]

There is no single 'Rust learning curve'. Instead, it looks different for every developer attempting to learn the language.

However, there are a few ways that can help flatten the learning curve that I didn't see anyone talk about.

https://t.co/g3ZgbVgKXH

#rustlang #rust

[Aadit Sheth @aaditsh]

This guy literally shares the best AI app-building advice in one page

[The Rust Dev @the_Rust_Dev]

🔹 24 code snippets covering Rust essentials - pattern matching, ownership, lifetimes, generics, traits, error handling and async. #DEVCommunity #RustLang
https://t.co/NS6H9yuxda

[GoLang Trends @GolangTrends]

Don't Cry about Pointers anymore - Deep Dive with C, Go and #Rust #golang #dormosheio #pointer #c https://t.co/oFyEdNQUOq

[Miguel Ángel Durán @midudev]

Hosting de Base de Datos SQL en 20 segundos.
¡Gratuito, sin registro ni tarjetas de crédito!

Entras aquí y consigues la cadena de conexión:
→ https://t.co/EAGRVu6v6K

Perfecto para hacer pruebas y practicar.

[Roy Carrilho @RuiCarrilho5]

link: https://t.co/9XEmC2ltL1

[Tech with Mak @techNmak]

Understand MCP in 15 Points.

1./ MCP stands for Model Context Protocol - a framework that allows AI models to interact with external tools and services.

2./ Developed by Anthropic as a way to extend AI capabilities beyond conversation.

3./ MCP uses a client-server architecture - the AI (client) makes requests to specialized servers that perform actions.

4./ It creates standardized communication between AI systems and external resources.

5./ MCP servers act as intermediaries - they execute actions on behalf of the AI and return results.

6./ The protocol enables AI models to access information beyond their training data.

7./ Security is a core design element - MCP servers control what resources the AI can access and how.

8./ MCP addresses the integration challenge that previously required custom code for each AI-tool connection.

9./ The protocol is designed to be an open standard - enabling widespread adoption and compatibility.

10./ MCP allows for tool use without retraining the underlying AI model.

11./ Applications include file access, web search, and code repositories among other tools.

12./ For users, MCP enables AI assistants to provide more helpful responses using current information.

13./ The protocol separates concerns - AI models handle reasoning while MCP servers handle specific actions.

14./ MCP represents an evolution in AI capabilities - moving from static knowledge to dynamic tool use.

15./ The architecture is conceptually similar to other communication protocols that standardize how different systems interact.

Follow @techNmak

[Rust Bytes 🦀 @rustaceans_rs]

How Prime Video Cut UI Latency 7.6x by Switching to Rust crab

“The problem was JavaScript, so we don't have that anymore.”

#rust #rustlang #programming

https://t.co/7bPZaBFtZq

[GoLang Trends @GolangTrends]

From C# to Go: Simplifying Design for Object-Oriented Developers #golang #dormosheio #webdev #programming #csharp https://t.co/pC7pB4AbnK

[Armin Ronacher ⇌ @mitsuhiko]

The next version of Rust might be one of the most transformative to the Rust ecosystem due to support for up-casting of trait objects. This makes `Any` significantly more powerful and potent!

[Raul Junco @RaulJuncoV]

Amazon S3 added Conditional Writes last year.

But most teams are still not using them.

S3 used to be where you dumped backups and static files. Reliable, cheap, boring.

Now? It's a core piece of modern architecture. It powers serverless apps, stores ML outputs, holds database snapshots, and feeds real-time analytics.

And with conditional writes, it just leveled up again.

Imagine you're building a collaborative document editor.

1. Two users load project-plan-v1.json.
2. Both make changes.
3. Both try to save project-plan-v2.json.
4. Without coordination, one overwrites the other.

Classic race condition.

With conditional writes, each user sends a PUT to S3 with If-None-Match: *.

The first write succeeds. The second fails with a 412.
No overwrites. No locks.

The second user reads the latest version, merges, and retries as project-plan-v3.json.

Done.

You get optimistic concurrency with a single HTTP header. No external locks. No extra logic. Just safe, versioned updates built into S3.

This works anywhere:

- Upload APIs
- ML checkpoints
- ETL outputs
- Config files

Any system where multiple writers need to avoid stepping on each other.

S3 is no longer just object storage. It's a write-once, conflict-aware coordination primitive.

If you're still writing coordination code around S3, stop.

The storage layer has your back now.

What's the most challenging concurrency issue you've faced with S3?

[void__zero2 @void_zero2]

I continue to experiment with Go versus Rust, reimplementing the same functionality in both languages to compare & really understand both tools from a realistic, unbiased view

I can understand why there are lots of loud anti-Rust people, because I too remember how annoying it was at first not understanding any of it and thinking "why would anyone ever overcomplicate to this degree when a simpler language can do the same just fine". Constant errors, the compiler always screaming at you, wtf is an Arc<Mutex<>>, wtf is a Clone trait...? It's easy to hate, because anyone supporting this difficult madness has to be a dumb ego-coder, right? After all "an idiot admires complexity, a genius admires simplicity"

Well I'm really thankful that I stuck with the annoyingly difficult Rust, because these days when I code idiomatic Go and idiomatic Rust side-by-side, the Go really isn't "simpler". Sure, there are fewer keywords. Sure, there are fewer concepts one has to understand to get started. But at the end of the day, I always feel it's easier to wrap my head around the Rust code when I ask myself

1) what does this code do and 2) what can go wrong

The biggest factor for me is that Rust code is often less LOC for the same logic AND verifiably safe (as long as there's no `unsafe`, of course). Instead of being distracted from the happy path with `if err != nil` you get the same by the simple `?`. match is fantastic for describing conditional logic in a simple way. Zero cost abstractions!

You can write crap code in both. You can write overly complex code in Rust overusing generics, Arcs, whatever, just as you can write overly verbose messy code in Go. A bad architecture is not the language's fault. And I remember how easy it is to make bad design decisions when you're still learning the language, something I wrongly blamed Rust for while I was learning it.

At the end of the day I really feel Rust is an investment. It takes time and it's annoying, sure. But once I grasped the concepts of the language and got comfortable with it, I really don't feel more productive in Go and I don't feel it's simpler. If anything, Go is more annoying because it takes more LOC for the same logic, it's not as safe (read: future me needs to deal with this in prod), and it's often slower at runtime than the Rust counterpart. Also, Cargo is the nicest tooling I've ever had the pleasure of using.

And back to the anti-Rust people, I get it: when people sharing Rust success/praise it's easier to brand them as "cultists" than admitting it's a skill issue. The only things I like about the language is that 1) it's easy to onboard if there are lots of devs on the same project of varying skill and experience, 2) the stdlib having most of what you need is really nice, and 3) there's no function coloring (which is something you pay for with CGO overhead).

This slideshow (pic) from this (https://t.co/SkGInAcvXL) talk shows what happens when devs get comfortable with Rust

This (longer than expected) post is what I wish I'd read a couple of years ago when I got into the "simplicity bro" mindset of Go thinking all Rustaceans were dumb ego-coders

[AstraKernel 💫 @AstraKernel]

This is great 😊

Ubuntu 25.10 Looks To Make Use Of Rust Coreutils &amp; Other Rust System Components

https://t.co/p96HL4ZZED

[chinedu🦀 @chinedu_10]

#RustDay 70

`std::mem::drop` and avoiding temporary values

In Rust, temporary values can lead to unexpected behavior and performance issues. To avoid this, use `std::mem::drop` to explicitly drop values when you're done with them.

By using `std::mem::drop`, you ensure that values are dropped at the correct time, avoiding temporary values and potential issues.

[AstraKernel 💫 @AstraKernel]

🦀 Youtube Channels on Rust

- A curated list of YouTube channels cover Rust

- Organized by Category

https://t.co/BxTp6XvE1P

[The Rust Dev @the_Rust_Dev]

Exploring various Rust methods to compute Fibonacci. Naive, memoized, and bottom-up strategies compared in performance exercise. #DEVCommunity #RustLang
https://t.co/FeuKM8tQ28

[Orhun Parmaksız 👾 @orhundev]

No more signal-desktop! I'm now using this TUI 🔥

🥒 gurk: Signal Messenger client for the terminal

🚀 Easy to set up & supports custom key bindings!

🦀 Written in Rust & built with @ratatui_rs

⭐ GitHub: https://t.co/DTO5rlULd9

#rustlang #ratatui #tui #signal #messenger #terminal #chat #commandline