[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"me":3,"catalog:en:backend\u002Frs-concurrency-send-sync":4,"config":275},null,{"field_key":5,"field_name":6,"seniority":7,"topic_key":8,"topic_name":9,"spec_key":7,"spec_name":7,"locale":10,"cell_total":11,"field_total":12,"seniorities":13,"topics":17,"specs":166,"samples":189},"backend","Backend","","rs-concurrency-send-sync","Rs Concurrency Send Sync","en",75,3750,[14,15,16],"junior","mid","senior",[18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99,102,105,108,111,114,117,120,123,126,129,132,135,138,141,144,147,148,151,154,157,160,163],{"key":19,"name":20,"count":11},"api-design","API Design",{"key":22,"name":23,"count":11},"caching","Caching",{"key":25,"name":26,"count":11},"concurrency","Concurrency",{"key":28,"name":29,"count":11},"csharp-concurrency-async","Csharp Concurrency Async",{"key":31,"name":32,"count":11},"csharp-exceptions","Csharp Exceptions",{"key":34,"name":35,"count":11},"csharp-generics-interfaces","Csharp Generics Interfaces",{"key":37,"name":38,"count":11},"csharp-memory-performance","Csharp Memory Performance",{"key":40,"name":41,"count":11},"csharp-stdlib-http","Csharp Stdlib Http",{"key":43,"name":44,"count":11},"csharp-testing-tooling","Csharp Testing Tooling",{"key":46,"name":47,"count":11},"databases-sql","Databases \u002F SQL",{"key":49,"name":50,"count":11},"go-concurrency","Go Concurrency",{"key":52,"name":53,"count":11},"go-errors","Go Errors",{"key":55,"name":56,"count":11},"go-interfaces-generics","Go Interfaces Generics",{"key":58,"name":59,"count":11},"go-memory-performance","Go Memory Performance",{"key":61,"name":62,"count":11},"go-stdlib-http","Go Stdlib Http",{"key":64,"name":65,"count":11},"go-testing-tooling","Go Testing Tooling",{"key":67,"name":68,"count":11},"java-concurrency","Java Concurrency",{"key":70,"name":71,"count":11},"java-exceptions","Java Exceptions",{"key":73,"name":74,"count":11},"java-generics-interfaces","Java Generics Interfaces",{"key":76,"name":77,"count":11},"java-memory-jvm","Java Memory Jvm",{"key":79,"name":80,"count":11},"java-stdlib-http","Java Stdlib Http",{"key":82,"name":83,"count":11},"java-testing-tooling","Java Testing Tooling",{"key":85,"name":86,"count":11},"messaging-queues","Messaging \u002F Queues",{"key":88,"name":89,"count":11},"networking-http","Networking \u002F HTTP",{"key":91,"name":92,"count":11},"nodejs-error-handling","Nodejs Error Handling",{"key":94,"name":95,"count":11},"nodejs-event-loop-async","Nodejs Event Loop Async",{"key":97,"name":98,"count":11},"nodejs-memory-performance","Nodejs Memory Performance",{"key":100,"name":101,"count":11},"nodejs-modules-streams","Nodejs Modules Streams",{"key":103,"name":104,"count":11},"nodejs-stdlib-http","Nodejs Stdlib Http",{"key":106,"name":107,"count":11},"nodejs-testing-tooling","Nodejs Testing Tooling",{"key":109,"name":110,"count":11},"php-concurrency-async","Php Concurrency Async",{"key":112,"name":113,"count":11},"php-exceptions","Php Exceptions",{"key":115,"name":116,"count":11},"php-generics-interfaces","Php Generics Interfaces",{"key":118,"name":119,"count":11},"php-memory-performance","Php Memory Performance",{"key":121,"name":122,"count":11},"php-stdlib-http","Php Stdlib Http",{"key":124,"name":125,"count":11},"php-testing-tooling","Php Testing Tooling",{"key":127,"name":128,"count":11},"python-concurrency-async","Python Concurrency Async",{"key":130,"name":131,"count":11},"python-errors-context","Python Errors Context",{"key":133,"name":134,"count":11},"python-memory-performance","Python Memory Performance",{"key":136,"name":137,"count":11},"python-stdlib-http","Python Stdlib Http",{"key":139,"name":140,"count":11},"python-testing-tooling","Python Testing Tooling",{"key":142,"name":143,"count":11},"python-typing-oop","Python Typing Oop",{"key":145,"name":146,"count":11},"rs-async-runtime-futures","Rs Async Runtime Futures",{"key":8,"name":9,"count":11},{"key":149,"name":150,"count":11},"rs-error-handling-result-option","Rs Error Handling Result Option",{"key":152,"name":153,"count":11},"rs-memory-smart-pointers-unsafe","Rs Memory Smart Pointers Unsafe",{"key":155,"name":156,"count":11},"rs-ownership-borrowing-lifetimes","Rs Ownership Borrowing Lifetimes",{"key":158,"name":159,"count":11},"rs-traits-generics-dispatch","Rs Traits Generics Dispatch",{"key":161,"name":162,"count":11},"security","Security",{"key":164,"name":165,"count":11},"testing","Testing",[167,171,174,177,180,183,186],{"key":168,"name":169,"count":170},"csharp","C#\u002F.NET",450,{"key":172,"name":173,"count":170},"go","Go",{"key":175,"name":176,"count":170},"java","Java",{"key":178,"name":179,"count":170},"nodejs","Node.js",{"key":181,"name":182,"count":170},"php","PHP",{"key":184,"name":185,"count":170},"python","Python",{"key":187,"name":188,"count":170},"rust","Rust",[190,208,221,235,249,262],{"id":191,"topic":9,"difficulty":192,"body":193,"options":194,"correct_key":202,"explanation":207},"01a0608e-d29b-74c4-a515-dc2915b1e190",1,"```rust\nfn main() {\n    let name = String::from(\"worker\");\n    let h = std::thread::spawn(|| println!(\"{}\", name));\n    h.join().unwrap();\n}\n```\nWhat happens when this is compiled?",[195,198,201,204],{"key":196,"text":197},"a","It compiles and prints `worker` once the spawned thread gets scheduled",{"key":199,"text":200},"b","It compiles, but may print an empty string, since `name` can be dropped before the thread runs",{"key":202,"text":203},"c","E0373: the closure may outlive `main` yet borrows `name`, and `move` is required",{"key":205,"text":206},"d","E0382: `name` is moved into the closure and then used again by `join`","`thread::spawn` requires a `'static` closure: the new thread might run after `main`'s stack frame is gone, so the closure cannot hold a borrow of a local. The compiler reports E0373 and suggests `move ||`, which transfers ownership of `name` into the closure. There is no runtime path here at all; the program never builds.",{"id":209,"topic":9,"difficulty":192,"body":210,"options":211,"correct_key":199,"explanation":220},"01a0608e-d29c-74c8-a0e6-10bae14e25db","```rust\nuse std::rc::Rc;\nfn main() {\n    let r = Rc::new(5);\n    let h = std::thread::spawn(move || println!(\"{}\", r));\n    h.join().unwrap();\n}\n```\nWhat is the result?",[212,214,216,218],{"key":196,"text":213},"It compiles and prints `5`; `move` hands the `Rc` to the thread",{"key":199,"text":215},"E0277: `Rc\u003Ci32>` cannot be sent between threads safely",{"key":202,"text":217},"It compiles, then panics at runtime when the non-atomic reference count is touched from two threads",{"key":205,"text":219},"E0382: `r` is used after being moved into the closure","`Rc` uses a non-atomic reference count, so the standard library marks it `!Send`. `thread::spawn` demands `F: Send`, and the closure captures `r` by value, so the whole closure is `!Send` and the compiler stops with E0277. The message literally says the type \"cannot be sent between threads safely\". `Arc` is the thread-safe counterpart and would compile.",{"id":222,"topic":9,"difficulty":223,"body":224,"options":225,"correct_key":205,"explanation":234},"01a0608e-d29d-7b1b-9521-3e462c9f320b",3,"```rust\nuse std::cell::Cell;\nuse std::sync::Arc;\nfn main() {\n    let c = Arc::new(Cell::new(1));\n    let c2 = Arc::clone(&c);\n    std::thread::spawn(move || c2.set(2)).join().unwrap();\n    println!(\"{}\", c.get());\n}\n```\nWhat does the compiler say?",[226,228,230,232],{"key":196,"text":227},"Nothing; it compiles and prints `1` due to a lost update between the two threads",{"key":199,"text":229},"Nothing; it compiles and prints `2` after the join",{"key":202,"text":231},"E0277: `Arc\u003CCell\u003Ci32>>` cannot be sent, since `Arc` is only `Sync` and not `Send`",{"key":205,"text":233},"E0277: `Cell\u003Ci32>` cannot be shared between threads safely","`Arc\u003CT>` is `Send` only when `T: Send + Sync`, because every clone can reach the same `T` from a different thread. `Cell` allows mutation through a shared reference without synchronization, so it is `!Sync`. The error names `Cell\u003Ci32>` and uses the word \"shared\", which is the `Sync` failure wording; the `Send` wording is \"sent\". Wrapping the value in `Mutex` or using `AtomicI32` fixes it.",{"id":236,"topic":9,"difficulty":237,"body":238,"options":239,"correct_key":205,"explanation":248},"01a0608e-d29e-7a6b-a76f-b024b1cb5a6f",2,"```rust\nfn main() {\n    let v = vec![1, 2, 3];\n    let mut total = 0;\n    std::thread::scope(|s| {\n        s.spawn(|| { total = v.iter().sum(); });\n    });\n    println!(\"{} {:?}\", total, v);\n}\n```\nWhat is printed?",[240,242,244,246],{"key":196,"text":241},"Nothing; E0373 is reported since the closure borrows `v` and `total` without `move`",{"key":199,"text":243},"`0 [1, 2, 3]`, since `total` is read before the scoped thread has finished its work",{"key":202,"text":245},"Nothing; E0499 is reported since `total` is mutably borrowed by the closure and by `println!`",{"key":205,"text":247},"`6 [1, 2, 3]`; the scope joins its threads before returning","`thread::scope` guarantees that every thread spawned inside it has been joined by the time `scope` returns. That guarantee is what lets scoped closures borrow non-`'static` data such as `v` and `total`. After the scope, `total` holds `6` and `v` is untouched. The plain `thread::spawn` API cannot offer this and therefore insists on `'static` captures.",{"id":250,"topic":9,"difficulty":192,"body":251,"options":252,"correct_key":199,"explanation":261},"01a0608e-d29f-79c5-b548-68e3c1b5b2bd","```rust\nfn main() {\n    let h = std::thread::spawn(|| {\n        panic!(\"boom\");\n    });\n    let r = h.join();\n    println!(\"is_err={}\", r.is_err());\n    println!(\"main continues\");\n}\n```\nWhat happens at runtime?",[253,255,257,259],{"key":196,"text":254},"The panic propagates through `join`, so `main` panics before printing anything",{"key":199,"text":256},"The panic message goes to stderr; then `is_err=true` and `main continues` are printed, because a panic unwinds only its own thread",{"key":202,"text":258},"The whole process aborts the moment the spawned thread panics",{"key":205,"text":260},"`is_err=false` is printed; a panic inside a thread counts as a normal return","A panic unwinds only the thread it happens in. The spawned thread's panic hook still prints \"thread '\u003Cunnamed>' panicked\" to stderr, but `main` keeps running. `JoinHandle::join` returns `Result\u003CT, Box\u003Cdyn Any + Send>>`, and the `Err` variant carries the panic payload, so `is_err=true` is printed and execution continues.",{"id":263,"topic":9,"difficulty":237,"body":264,"options":265,"correct_key":202,"explanation":274},"01a0608e-d2a0-77ae-bb4c-fd2f57f8de35","```rust\nuse std::sync::{Arc, Mutex};\nfn main() {\n    let data = Arc::new(Mutex::new(0));\n    let mut hs = vec![];\n    for _ in 0..3 {\n        hs.push(std::thread::spawn(move || {\n            *data.lock().unwrap() += 1;\n        }));\n    }\n    for h in hs { h.join().unwrap(); }\n}\n```\nWhy does this not compile?",[266,268,270,272],{"key":196,"text":267},"`Mutex\u003Ci32>` is not `Send`, so the closure cannot go to `thread::spawn`",{"key":199,"text":269},"`+=` needs a mutable guard, but `lock()` only returns a shared reference to the value",{"key":202,"text":271},"`data` is moved into the closure on the first iteration; E0382 on the next one",{"key":205,"text":273},"`Arc` cannot be captured by a `move` closure; it must be cloned outside `main`","A `move` closure takes ownership of `data`. Since the closure is created inside a loop, the second iteration tries to move a value that was already moved, and the compiler reports E0382 (\"value moved into closure here, in previous iteration of loop\"). The idiomatic fix is `let data = Arc::clone(&data);` at the top of each iteration so that every thread owns its own handle to the shared mutex.",{"fields":276,"seniorities":495,"interview_shapes":496,"locales":503,"oauth":505,"question_count":508,"coach_enabled":509,"jd_match_enabled":509},[277,289,309,326,350,363,382,401,421,440,455,477],{"key":5,"name_tr":6,"name_en":6,"sort":192,"specializations":278},[279,282,283,284,285,286,287,288],{"key":280,"name":281,"field":5},"general","Genel",{"key":172,"name":173,"field":5},{"key":184,"name":185,"field":5},{"key":175,"name":176,"field":5},{"key":168,"name":169,"field":5},{"key":178,"name":179,"field":5},{"key":181,"name":182,"field":5},{"key":187,"name":188,"field":5},{"key":290,"name_tr":291,"name_en":291,"sort":237,"specializations":292},"frontend","Frontend",[293,294,297,300,303,306],{"key":280,"name":281,"field":290},{"key":295,"name":296,"field":290},"javascript","JavaScript",{"key":298,"name":299,"field":290},"typescript","TypeScript",{"key":301,"name":302,"field":290},"react","React",{"key":304,"name":305,"field":290},"vue","Vue",{"key":307,"name":308,"field":290},"angular","Angular",{"key":310,"name_tr":311,"name_en":311,"sort":223,"specializations":312},"fullstack","Fullstack",[313,314,315,316,317,318,319,320,321,322,323,324,325],{"key":280,"name":281,"field":310},{"key":172,"name":173,"field":5},{"key":184,"name":185,"field":5},{"key":175,"name":176,"field":5},{"key":168,"name":169,"field":5},{"key":178,"name":179,"field":5},{"key":181,"name":182,"field":5},{"key":187,"name":188,"field":5},{"key":295,"name":296,"field":290},{"key":298,"name":299,"field":290},{"key":301,"name":302,"field":290},{"key":304,"name":305,"field":290},{"key":307,"name":308,"field":290},{"key":327,"name_tr":328,"name_en":328,"sort":329,"specializations":330},"devops-cloud","DevOps \u002F Cloud",4,[331,332,335,338,341,344,347],{"key":280,"name":281,"field":327},{"key":333,"name":334,"field":327},"aws","AWS",{"key":336,"name":337,"field":327},"gcp","GCP",{"key":339,"name":340,"field":327},"azure","Azure",{"key":342,"name":343,"field":327},"kubernetes","Kubernetes",{"key":345,"name":346,"field":327},"terraform","Terraform",{"key":348,"name":349,"field":327},"linux","Linux",{"key":351,"name_tr":352,"name_en":352,"sort":353,"specializations":354},"ai-engineer","AI Engineer",5,[355,356,357,360],{"key":280,"name":281,"field":351},{"key":184,"name":185,"field":351},{"key":358,"name":359,"field":351},"llm-rag","LLM\u002FRAG",{"key":361,"name":362,"field":351},"mlops","MLOps",{"key":364,"name_tr":365,"name_en":366,"sort":367,"specializations":368},"database","Veritabanı","Database",6,[369,370,373,376,379],{"key":280,"name":281,"field":364},{"key":371,"name":372,"field":364},"postgresql","PostgreSQL",{"key":374,"name":375,"field":364},"mysql","MySQL",{"key":377,"name":378,"field":364},"mongodb","MongoDB",{"key":380,"name":381,"field":364},"redis","Redis",{"key":383,"name_tr":384,"name_en":385,"sort":386,"specializations":387},"mobile","Mobil","Mobile",7,[388,389,392,395,398],{"key":280,"name":281,"field":383},{"key":390,"name":391,"field":383},"ios-swift","iOS (Swift)",{"key":393,"name":394,"field":383},"android-kotlin","Android (Kotlin)",{"key":396,"name":397,"field":383},"flutter","Flutter",{"key":399,"name":400,"field":383},"react-native","React Native",{"key":161,"name_tr":402,"name_en":162,"sort":403,"specializations":404},"Güvenlik",8,[405,406,409,412,415,418],{"key":280,"name":281,"field":161},{"key":407,"name":408,"field":161},"appsec","AppSec",{"key":410,"name":411,"field":161},"offensive-pentest","Offensive \u002F Pentest",{"key":413,"name":414,"field":161},"cloud-security","Cloud Security",{"key":416,"name":417,"field":161},"devsecops","DevSecOps",{"key":419,"name":420,"field":161},"blue-team-incident","Blue Team \u002F Incident",{"key":422,"name_tr":423,"name_en":424,"sort":425,"specializations":426},"qa-test-automation","QA \u002F Test Otomasyonu","QA \u002F Test Automation",9,[427,428,431,434,437],{"key":280,"name":281,"field":422},{"key":429,"name":430,"field":422},"test-automation","Test Automation",{"key":432,"name":433,"field":422},"sdet","SDET",{"key":435,"name":436,"field":422},"performance-testing","Performance Testing",{"key":438,"name":439,"field":422},"mobile-qa","Mobile QA",{"key":441,"name_tr":442,"name_en":442,"sort":443,"specializations":444},"data-engineer","Data Engineer",10,[445,446,449,452],{"key":280,"name":281,"field":441},{"key":447,"name":448,"field":441},"pipelines-etl","Pipelines \u002F ETL",{"key":450,"name":451,"field":441},"streaming","Streaming",{"key":453,"name":454,"field":441},"warehousing","Warehousing",{"key":456,"name_tr":457,"name_en":458,"sort":459,"specializations":460},"game-dev","Oyun Geliştirme","Game Development",11,[461,462,465,468,471,474],{"key":280,"name":281,"field":456},{"key":463,"name":464,"field":456},"unity-csharp","Unity (C#)",{"key":466,"name":467,"field":456},"unreal-cpp","Unreal (C++)",{"key":469,"name":470,"field":456},"gameplay","Gameplay",{"key":472,"name":473,"field":456},"graphics-rendering","Graphics \u002F Rendering",{"key":475,"name":476,"field":456},"multiplayer-netcode","Multiplayer \u002F Netcode",{"key":478,"name_tr":479,"name_en":479,"sort":480,"specializations":481},"ml-engineer","ML Engineer",12,[482,483,486,489,492],{"key":280,"name":281,"field":478},{"key":484,"name":485,"field":478},"classical-ml","Classical ML",{"key":487,"name":488,"field":478},"feature-engineering","Feature Engineering",{"key":490,"name":491,"field":478},"deep-learning","Deep Learning",{"key":493,"name":494,"field":478},"training-infrastructure","Training Infrastructure",[14,15,16],{"junior":497,"mid":499,"placement":500,"senior":502},{"questions":498,"median_sec":3},20,{"questions":498,"median_sec":3},{"questions":501,"median_sec":3},24,{"questions":498,"median_sec":3},[504,10],"tr",[506,507],"google","github",29400,true]