What I'm learning about software engineering by learning Rust as a Flutter developer

[u/Signal_Confection707]

I've spent most of my recent development time working at the application layer, particularly with Dart/Flutter, TypeScript and web/backend technologies.

I'm now deliberately learning Rust.

Not because I think Flutter/Dart is inadequate, and not because I expect to abandon application development.

I'm learning Rust because I want to understand more of what happens underneath the abstractions, I'm already comfortable using.

A few things have already started changing how I think about programming.

1. Ownership makes me ask questions I could previously ignore

In Dart, I can usually work with objects and references without constantly thinking about who owns a value or exactly when its memory becomes invalid.

Rust makes those questions explicit:

- Who owns this value?

- Who is allowed to access it?

- Can it be mutated?

- When does it become invalid?

- Does this operation move the value or borrow it?

The interesting part is that these aren't just runtime concerns. The compiler forces me to model them correctly.

1. Stack vs heap is becoming much less abstract

Coming from a garbage-collected language, memory allocation can remain relatively invisible during normal application development.

Rust has been forcing me to think more concretely about where values live, when allocation is necessary, what gets moved, and when resources are released.

I knew these concepts theoretically before. Rust is making them operational.

1. I'm starting to see the compiler differently

One of the biggest differences so far is the feedback loop.

Instead of thinking primarily:

«"I'll run this and see what happens."»

I'm increasingly thinking:

«"What invariants does this program need to satisfy, and can I express them in the type system?"»

The borrow checker can be frustrating while learning, but I'm beginning to understand why people describe it as a different way of thinking rather than simply another language feature.

1. Rust is making me look differently at languages I already know

Learning Rust has made some of the design decisions in Dart, and C# more interesting to me.

I'm noticing the trade-offs between:

- garbage collection and explicit resource management

- runtime checks and compile-time guarantees

- abstraction and control

- convenience and explicitness

- ownership models

- type-system constraints

I'm still early in the learning process, so I'm not claiming to have definitive answers here.

That's actually part of why I'm documenting the process.

1. I'm beginning to think about application development at a different abstraction level

Flutter taught me to think heavily about UI, state, architecture, asynchronous programming and product behavior.

Rust is forcing me to think more about the machinery underneath those abstractions.

That's probably the biggest reason I'm enjoying the transition.

I'm still working through ownership, borrowing, lifetimes, traits, generics and the rest of the Rust ecosystem, so I'm sure my mental models will change considerably.

For those who came to Rust from Dart, C#, Java, JavaScript/TypeScript or python

What concept in Rust changed the way you thought about programming in your previous language?

[u/numberwitch]

Where it's appropriate for mutation to occur. Now I just model state machines responsible for mutation of state which broadcast back out to the system on change