<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/switching-between-high-level-and-low-level-views-makes-better-rust-developers-oy2yjsmo3" -->

---
title: How Great Rust Developers Think | daily.dev
description: Writing good Rust means switching between a high-level timeline view of borrows and a low-level view of memory locations, a video argues. A shared reference to...
canonical: https://daily.dev/posts/how-great-rust-developers-think-oy2yjsmo3
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: How Great Rust Developers Think | daily.dev
og:description: Writing good Rust means switching between a high-level timeline view of borrows and a low-level view of memory locations, a video argues. A shared reference to...
og:url: https://daily.dev/posts/how-great-rust-developers-think-oy2yjsmo3
og:image: https://api.daily.dev/og/posts/oy2yjSmo3.png
og:image:alt: How Great Rust Developers Think
og:image:width: 1200
og:image:height: 630
og:locale: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# How Great Rust Developers Think

**[Let's Get Rusty](https://daily.dev/sources/letsgetrusty)** · 4 min read · 19 upvotes · 1 comments

## Summary

Writing good Rust means switching between a high-level timeline view of borrows and a low-level view of memory locations, a video argues. A shared reference to x called y blocks a later exclusive write to x if y is used afterward, but moving the assertion earlier lets the write succeed. Shadowing x with 'let x = 43' creates a new memory location, leaving the original value at the old location still reachable through y. The video ends promoting the creator's 'Rust Live Accelerator' mentorship program.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://www.youtube.com/watch?v=DoYl2ODMTc0>

## Questions this post answers

### why does Rust reject my code when I try to mutate a variable after taking a shared reference to it

Rust rejects the mutation because the shared reference is still in use later in the code; if the borrowed value is read again after the mutation point, the borrow checker treats it as overlapping with the exclusive access needed to change the value, and refuses to compile. Moving the read of the reference to before the mutation resolves the conflict since the borrow ends earlier.

_Debugging a borrow checker error like this is exactly the kind of thing daily.dev's feed can keep surfacing guidance on._

### what does shadowing a variable do to memory in Rust, like let x = 43 after x already existed

Shadowing with 'let x = 43' creates a brand new variable bound to a new memory location, rather than overwriting the original. The old value stays in its original location and any reference pointing to it, such as a variable y created earlier, continues to read the old value, while the new x reads 43 from its own separate location.

_Understanding shadowing versus mutation matters when choosing how to structure Rust ownership patterns, something daily.dev readers track closely._

## Community discussion

Top comments from developers on daily.dev.

**@baturhanpro** · 0 upvotes

> ![GIF](https://static.klipy.com/ii/935d7ab9d8c6202580a668421940ec81/81/4c/YtXuBB0N.gif)

## Similar posts on daily.dev

- [One week of view\_types](https://daily.dev/posts/one-week-of-view-types-ofjwjlxxt) · Lobsters · 1 upvotes · 1 comments
- [Yet another Rust ownership tutorial](https://daily.dev/posts/yet-another-rust-ownership-tutorial-b8mdaw6qk) · A Java geek · 4 upvotes · 1 comments

---

Tags: [#rust](https://daily.dev/tags/rust)

[View this post on daily.dev](https://daily.dev/posts/how-great-rust-developers-think-oy2yjsmo3)

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]}
{"@context":"https://schema.org","@type":"TechArticle","headline":"How Great Rust Developers Think","url":"https://daily.dev/posts/how-great-rust-developers-think-oy2yjsmo3","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/how-great-rust-developers-think-oy2yjsmo3"},"datePublished":"2026-11-18T16:28:24.761Z","dateModified":"2026-11-18T16:28:47.309Z","description":"Writing good Rust means switching between a high-level timeline view of borrows and a low-level view of memory locations, a video argues. A shared reference to...","image":"https://i.ytimg.com/vi/DoYl2ODMTc0/sddefault.jpg","thumbnailUrl":"https://i.ytimg.com/vi/DoYl2ODMTc0/sddefault.jpg","isAccessibleForFree":true,"articleSection":"Let's Get Rusty","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Let's Get Rusty","logo":"https://media.daily.dev/image/upload/s--iqd05ejH--/f_auto/v1725035314/logos/letsgetrusty","url":"https://daily.dev/sources/letsgetrusty"},"commentCount":1,"discussionUrl":"https://daily.dev/posts/how-great-rust-developers-think-oy2yjsmo3","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":18},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":1}],"keywords":"rust","timeRequired":"PT4M","video":{"@type":"VideoObject","name":"How Great Rust Developers Think","description":"Writing good Rust means switching between a high-level timeline view of borrows and a low-level view of memory locations, a video argues. A shared reference to...","thumbnailUrl":"https://i.ytimg.com/vi/DoYl2ODMTc0/sddefault.jpg","uploadDate":"2026-11-18T16:28:24.761Z","duration":"PT4M","url":"https://api.daily.dev/r/oy2yjSmo3","embedUrl":"https://www.youtube.com/embed/DoYl2ODMTc0"}}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Let's Get Rusty","item":"https://daily.dev/sources/letsgetrusty"},{"@type":"ListItem","position":3,"name":"How Great Rust Developers Think"}]}
{"@context":"https://schema.org","@type":"WebPage","@id":"https://daily.dev/posts/how-great-rust-developers-think-oy2yjsmo3","comment":[{"@type":"Comment","text":"","datePublished":"2026-11-21T13:52:51.463Z","url":"https://daily.dev/posts/oy2yjSmo3#c-r9sSJuk2n","author":{"@type":"Person","name":"baturhan","url":"https://daily.dev/baturhanpro","image":"https://lh3.googleusercontent.com/a/ACg8ocJQ5s2w7kYYdDOtufZ5g50O0V3n1gmNk50z9iPj53RuGAjc2Ss=s96-c"}}]}
{"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/how-great-rust-developers-think-oy2yjsmo3#faq","mainEntity":[{"@type":"Question","name":"why does Rust reject my code when I try to mutate a variable after taking a shared reference to it","acceptedAnswer":{"@type":"Answer","text":"Rust rejects the mutation because the shared reference is still in use later in the code; if the borrowed value is read again after the mutation point, the borrow checker treats it as overlapping with the exclusive access needed to change the value, and refuses to compile. Moving the read of the reference to before the mutation resolves the conflict since the borrow ends earlier. Debugging a borrow checker error like this is exactly the kind of thing daily.dev's feed can keep surfacing guidance on."}},{"@type":"Question","name":"what does shadowing a variable do to memory in Rust, like let x = 43 after x already existed","acceptedAnswer":{"@type":"Answer","text":"Shadowing with 'let x = 43' creates a brand new variable bound to a new memory location, rather than overwriting the original. The old value stays in its original location and any reference pointing to it, such as a variable y created earlier, continues to read the old value, while the new x reads 43 from its own separate location. Understanding shadowing versus mutation matters when choosing how to structure Rust ownership patterns, something daily.dev readers track closely."}}]}
```

