10 ms·

Borrow Checking, RC, GC, and Eleven Other Memory Safety Approaches

184 points by PotatoPancakes 2y ago

andrewstuart 2y ago
I’d love to see a language that kept everything as familiar as possible and implement memory safety as “the hard bit”, instead of the Rust approach of cooking in multiple different new sub languages and concepts.
- brabel 2y ago
  The author of the post is trying pretty much that with his language, Vale.
- phicoh 2y ago
  As a long time C programmer I like Rust because it combines two things from C that are important to me (low runtime overhead, no runtime system required) with a focus on writing correct programs. Memory safety is just one aspect where the compiler can help making sure a program is correct. The more the compiler helps with static analysis, the less we need to rely on creating tests for edge cases.
  - zamalek 2y ago
    > Memory safety is just one aspect I feel as though not enough attention is given to how std is designed. For example: [u8], str, Path, and OsStr may be confusing at first, but when you understand why they are there any other approach feels icky. std guides you down a path of caring about things that really should matter (at least if you're only unwrapping provably safe values). Have you considered what happens if not-utf8 data winds up in an environment variable that you are writing to stdout? What if it contains malicious VT commands?
    - shiomiru 2y ago
      > Have you considered what happens if not-utf8 data winds up in an environment variable that you are writing to stdout? What if it contains malicious VT commands? Unless you're talking about terminal bugs in parsing invalid UTF-8 - and parsing invalid UTF-8 is easier than rendering valid UTF-8 - VT commands are UTF-8 compatible. You just need to embed an ASCII escape character.
      - adgjlsfhk1 2y ago
        yeah I think this is an area where rust (and python) just get it wrong. files, the Internet and input devices can all give you invalid Unicode. IMO it's better to have a primary string type that includes invalid Unicode since most algorithms will handle it correctly anyway, and the ones that won't can pretty clearly check and throw errors appropriately (especially since very few algorithms work correctly for all of Unicode in the first place)
        dwattttt 2y ago
        There's a primary type that holds invalid utf8; it's [u8]. If you want a string from that, you try turn it into a string, and deal with the errors then. If an algorithm works for invalid Unicode, it should probably be an algorithm on bytes, not strings.
- ramon156 2y ago
  Tbf I would already consider a different language when it has al the nice syntax sugar and design choices of Rust. I like almost every choice they made, and I miss things like `if let Some` or unwrapping in other languages. It's just not the same
- chrismorgan 2y ago
  As an experienced Rust developer, I have absolutely no idea what you mean by this. Could you write a little more about what you have in mind, and even what you mean by sub-languages and concepts in Rust?
- karmakurtisaani 2y ago
  Isn't that just C/C++?
- frou_dh 2y ago
  "Familiar" is subjective so it's not really something to hang your hat on.
- nicoburns 2y ago
  Familiar to whom? I came from a JavaScript background, and Rust's syntax and "functional lite" style felt very familiar.
- pornel 2y ago
  Safety is not an extra feature a'la carte. These concepts are all inter-connected: Safety requires unions to be safe, so unions have to become tagged enums. To have tagged enums usable, you have to have pattern matching, otherwise you'd get something awkward like C++ std::variant. Borrow checking works only on borrowed values (as the name suggests), so you will need something else for long-lived/non-lexical storage. To avoid GC or automatic refcounting, you'll want moves with exclusive ownership. Exclusive ownership lets you find all the places where a value is used for the last time, and you will want to prevent double-free and uninitialized memory, which is a job for RAII and destructors. Static analysis of manual malloc/realloc and casting to/from void* is difficult, slow, and in many cases provably impossible, so you'll want to have safely implemented standard collections, and for these you'll want generics. Not all bounds checks can be eliminated, so you'll want to have iterators to implement typical patterns without redundant bounds checks. Iterators need closures to be ergonomic. …and so on. Every time you plug a safety hole, it needs a language feature to control it, and then it needs another language feature to make this control fast and ergonomic. If you start with "C but safe", and keep pulling that thread, nearly all of Rust will come out.
  - AlotOfReading 2y ago
    I've experienced that frustration myself several times and tried to do "rust but simpler". I just recently failed attempt #4 at not reinventing rust but worse. Attempt #2 ended with Erlang but worse, which was a pleasant surprise.
  - mpweiher 2y ago
    Hm...Smalltalk is also safe. So there are obviously different ways of addressing this.
    - pornel 2y ago
      Bash is also memory-safe. Almost every programming language is memory-safe, but Smalltalk and most high-level dynamically typed languages require a fat runtime, and have a much higher overhead than C or Rust. For languages that can be credible C and C++ competitors, the design space is much smaller.
nahuel0x 2y ago
It's surprising to see an article with such a large encompassing of different techniques, hybrid techniques and design interactions with the type system, but is more surprising that a whole dimension of memory (un)management was left out: memory fragmentation
- Quekid5 2y ago
  It's probably because fragmentation isn't a safety issue. (In the sense of 'safety' being discussed here.)
  - galangalalgol 2y ago
    It doesn't create UB, but it is something safety critical software has to address.
    - Quekid5 2y ago
      ... which is why I had that little bit at the end there.
willvarfar 2y ago
Meta comment, but I really like the formatting of the blog post! It reminds me of the early days of the web, when text was king and content was king. I particularly like the sidenotes in the margins approach. (Hope the author sees this comment :) Hats off)
- brabel 2y ago
  Yeah the author always uses this in his blog about his language, Vale (which is very unfortunately not being developed anymore, at least for now). The other posts are also worth a read: https://vale.dev/ https://vale.dev/
  - ivell 2y ago
    He now works on Mojo, to bring linear types into Mojo.
- dgan 2y ago
  I am sorry, I am maybe dumb but i can't see the 14 techniques been listed anywhere? Where do i even click?
  - hawski 2y ago
    You need to read the post. > Wait a minute, this list goes to 17, yet the intro only mentions 14! I actually did that because a couple might overlap and a couple of them are half-approaches, and that last one is just here for fun. Besides, as I learn more approaches and add them to the list, the title will get more and more out of date anyway.
- _kb 2y ago
  Side notes are a great layout for most deeper reads. There's some great tooling for that via https://edwardtufte.github.io/tufte-css/ https://edwardtufte.github.io/tufte-css/ and https://tufte-latex.github.io/tufte-latex/ https://tufte-latex.github.io/tufte-latex/.
chrismorgan 2y ago
> Curséd With an acute accent, that should be roughly /ˌkɜːrˈseɪd/ “curse-ay-d”. (Think “café” or “sashayed”.) The stylised pronunciation being evoked is roughly /ˈkɜːrˌsɛd/, “curse-ed”, and would be written with a grave accent: “cursèd”.
- rzzzt 2y ago
  Italians will get close to the first pronunciation both ways, I think. The Zalgo line noise is an international way of signaling the level of curse in writing.
- bloppe 2y ago
  Accents mean different things in different languages. I'm assuming the author was invoking Spanish, where the acute accent impacts syllable stress but not pronunciation.
mgaunard 2y ago
The fact that re-using a slot for a different object of the same type is considered a memory safety technique is ridiculous.
- obl 2y ago
  It is not ridiculous at all. Those things have pretty precise definitions and type segregation absolutely does remove a bunch of soundness issues related to type confusion. You can think of it as the rather classic "Vec of struct + numeric IDs" that is used a lot e.g. in Rust to represent complex graph-like structures. This combined with bound checking is absolutely memory safe. It has a bunch of correctness issue that can arise due to index confusion but those are not safety issues. When combined with some kind of generational counters those correctness issue also go away but are only caught at runtime not at compile time (and they incur a runtime cost). Rust's memory safety is about avoiding liveness issues (that become type confusions since all memory allocators will reuse memory for different types), nothing more, nothing less.
  - jandrewrogers 2y ago
    FWIW, arrays of structs + integer handles is the primary way objects are represented in performance-engineered C++.
  - gpderetta 2y ago
    > but those are not safety issues. there are not memory safety issues. But they definitely can lead to security issues with some sort of confused deputy attack. For example a capability based system that relied on just this form of memory safety would be pointless. Of course this can be mitigated by adding version counters to objects and object selectors.
- adamrezich 2y ago
  “Safety” is a very overloaded English word with strong connotations, and the popularization of it in the context of “memory safety” has been good in some ways, but has really poisoned the discourse in many others.
- 2y ago
hawski 2y ago
That is very informational. Thank you. I am interested in Vale and it feels very promising, though because my interested in bootstrapping I don't like that it is written in Scala. I know, that is shallow, but that's a thing that limits my enthusiasm. If you are like me and don't like jumping around between notes and text and you prefer to read the notes anyway, here is a little snippet you can run in Web Inspector's Console: document.querySelectorAll(".slice-contents a[data-noteid]").forEach(e => {document.querySelectorAll('.slice-notes [data-noteid="' + e.attributes["data-noteid"].nodeValue + '"] p').forEach(p => {p.style.fontSize = 'smaller'; e.parentNode.insertBefore(p, e)}); e.remove() }) It will replace note links with notes themselves making them smaller, because they will not always fit smoothly.
tialaramex 2y ago
The list gets very woolly by the end. CHERI exists (though not at volume), Cornucopia Reloaded is a research paper, "plus some techniques to prevent use-after-free on the stack" is entirely hand waving. It is really good as food for thought though.
nemetroid 2y ago
No mention of RCU?
- gpderetta 2y ago
  RCU, despite the name, is indeed a reclamation algorithm, but not a general one. I.e. you would use RCU (or some other deferred reclamation algorithm like hazard pointers) for specific data structures when you do not have generalized garbage collection. A generalized RCU is just a tracing GC.
  - nemetroid 2y ago
    The part where the article limits itself to general techniques eludes me.
DanielHB 2y ago
I am not experienced with rust and borrow checkers, but my impression is that borrow checkers also statically ensures thread/async safety while most other memory safety systems don't. Is this accurate?
- PeterWhittaker 2y ago
  The first part - that the Rust borrow checker and overall memory model ensures thread/async safety - is true. I cannot speak to the second part - that other systems don't have this assurance.
  - tialaramex 2y ago
    Just the borrowck isn't enough, you need the Send and Sync marker traits. Marker traits are something lots of languages could do but they'd be useless (or always unsafe) without a lot of other machinery Rust had already.
    - kibwen 2y ago
      And Sync might just be there for performance, I think you could get away with only Send if you didn't mind some additional copying?
  - DanielHB 2y ago
    > that other systems don't have this assurance My understanding is that most (all?) GC languages are memory safe, but do not ensure statically verifiable thread safety at all. Like Java, Go, C#, Python, etc.
- kibwen 2y ago
  The borrow checker is only one component of the means by which Rust statically enforces thread safety. If you design a language that doesn't allow pointers to be shared across threads at all, then you wouldn't need a borrow checker. Likewise if you have an immutable-only language. What's interesting about Rust is that it actually supports this safely, which is still unbelievable sometimes (like being able to send references to the stack to other threads via std::thread::scoped).
alexisread 2y ago
Previous discussion: https://news.ycombinator.com/item?id=40146615 https://news.ycombinator.com/item?id=40146615 https://news.ycombinator.com/item?id=41974185 https://news.ycombinator.com/item?id=41974185
- dang 2y ago
  Thanks! Macroexpanded: Borrow Checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches - https://news.ycombinator.com/item?id=41974185 https://news.ycombinator.com/item?id=41974185 - Oct 2024 (1 comment) Borrow Checking, RC, GC, and the Eleven () Other Memory Safety Approaches - https://news.ycombinator.com/item?id=40146615 https://news.ycombinator.com/item?id=40146615 - April 2024 (68 comments)
amelius 2y ago
I like many of the ideas of Rust, but I still think it is an unsuitable language for most projects. The problem is that it is very easy to write non-GC'd code in a GC'd language, but the other way around it is much much harder. Therefore, I think the fundamental choice of Rust to not support a GC is wrong.
- FridgeSeal 2y ago
  It does have a GC. It just runs at compile time. Bonus feature, it helpfully prevents a number of common bugs too.
  - amelius 2y ago
    GC is short for automatic GC. If you have to do it yourself, then it does not "have" a GC.
    - FridgeSeal 2y ago
      Ssshhh you’re ruining my silly and “hasn’t gone over terribly well” joke.
- f1shy 2y ago
  Yet another PoV: for some things with critical timing or so, GC might be a problem. But most of the time, it isn’t. The performance/predictability topic could also be reviewed… I was talking with a colleague about that, he said “in C I know exactly where things are when” And I replied that under any OS with virtual memory, you have basically no clue where are things at any time, in the N levels of cache, and you cannot do accurate time predictions anyway… [1] I’m convinced today GC is the way to go for almost all. And I was until 5 years ago or so, totally opposed to that view. [1] https://news.ycombinator.com/item?id=42456310 https://news.ycombinator.com/item?id=42456310
  - pjmlp 2y ago
    Even with critical timing, real time GCs exist for decades now, PTC and Aicas are two surviving companies selling software tooling for embedded markets, including their own JVM implementations, with AOT compilers, bare metal deployments and real time GC. Many of their customers are factory processes and military deployments with weapons control, two scenarios where any kind of stall might produce deadly results.
naasking 2y ago
More people need to read up on C#'s ref's: https://em-tg.github.io/csborrow/ https://em-tg.github.io/csborrow/ These kinda-sorta fall under borrow checking or regions, just without any annotations. Then again, Ada/Spark's strategy also technically falls under Tofte-Talpin regions: https://www.cs.cornell.edu/people/fluet/research/substruct-regions/ESOP06/esop06.pdf https://www.cs.cornell.edu/people/fluet/research/substruct-r...
- mastax 2y ago
  Yeah C# is very well designed for gradually introducing low level concepts for performance.
  - jimbob45 2y ago
    The reverse is arguably the one trait Rust is missing that is holding it back from mass adoption. You can write high-level C# code and seamlessly introduce low-level concepts into it as you see fit. However, although you can write low-level Rust code easily, introducing high-level concepts is very painful and, in many cases, impossible.
  - akkad33 2y ago
    Also F#
    - neonsunset 2y ago
      As of now - F# needs more work w.r.t. support for [<Struct; IsByRefLike>] types and byref<'T>s. There's a reason ref lifetime analysis in Roslyn is quite a sophisticated part of its implementation even if most developers aren't aware of it. F# has other cool features like `inline` bindings and [<IlineIfLambda>] function attributes but I found it more difficult to work with for systems programming when attempting to stay within safe constructs. But if you don't need byrefs, ref structs and spans, then regular pointer-based or even array-based code is quite pleasant to write, for example https://benchmarksgame-team.pages.debian.net/benchmarksgame/program/spectralnorm-fsharpcore-6.html https://benchmarksgame-team.pages.debian.net/benchmarksgame/... With that said - F# is an incredible language, but for systems programming you are likely to get better results in C#. I hope eventually someone contributes subsequent spec and compiler work to change this (and if you think you have time and could try it - please do! it's a nice small community).
xmcqdpt2 2y ago
Not a fan of the framing of the article. Firstly, there are millions of Mayans alive today, https://en.wikipedia.org/wiki/Maya_peoples https://en.wikipedia.org/wiki/Maya_peoples and secondly, the reason why the pre-Colombian cultural texts and script are not in use today, even by the people who speak the 28 Mayan languages currently in use, is because of genocide by Columbus and those that followed. The Catholic church destroyed every piece of Mayan script they could get their hands on. The article reads like the author is not aware of these basic facts of American geography and history.
- constantcrying 2y ago
  I thought it was just annoying to read. Irrelevant analogies never helped me understand anything.
4ad 2y ago
> Interaction nets are a very fast way to manage purely immutable data without garbage collection or reference counting.[...] HVM starts with affine types (like move-only programming), but then adds an extremely efficient lazy .clone() primitive, so it can strategically clone objects instead of referencing them. This is wrong, Interaction nets (and combinators) can model any kind of computational systems, including ones that use mutation. In fact, ICs are not really about types at all, although they do come from a generalization of Girard's proofs nets, which came from work in linear logic. The interesting thing about ICs is that they are beta-optimal (any encoding of a computation will be done in the minimum number of steps required -- there is no useless work being done), and maximum-parallel with only local synchonization (all reduction steps are local, and all work that can be parallelized will be parallelized). Additionally ICs have the property that any encoding of a different computational system in ICs will preserve the asymptotic behavior of all programs written for the encoded computational system. In fact, ICs are the only computational system with this property. Interaction nets absolutely require garbage collection in the general sense. However, interaction combinators are linear and all garbage collection is explicit (but still exists). HVMs innovation is that by restricting the class of programs encoded in the ICs you can get very cheap lambda duplication and eschew the need for complex garbage collection while also reducing the overhead of implementing ICs on regular CPUs (no croissants or brackets, see Asperti[1] for what that means). Having a linear language with the above restriction allows for a very efficient implementation with a very simple GC, while maximizing the benefits of ICs. In principle any language can be implemented on top of ICs, but to get most benefits you want a language with these properties. It's not that HVM starts with affine types and an efficient lazy clone operation, it's that a linear language allows extremely efficient lazy cloning (including lambda cloning) to be implemented on top of ICs, and the result of that is HVM. > The HVM runtime implements this for Haskell. This is very wrong. HVM has nothing to do with Haskell. HVM3 is written in C[2], HVM2 has three implementations, one in C[3], one in Rust[4], and a CUDA[5] one. HVM1 was just a prototype and was written in Rust[6]. HOC[7], the company behing HVM provides two languages that compile to HVM, Bend[8], and Kind[9]. Bend is a usual functional language, while Kind is a theorem prover based on self types. Haskell is not involved in any of these things except that the HVM compiler (not runtime) is written in Haskell, but that is irrelevant, before Haskell it used to be written in TypeScript and then in Agda (Twitter discussion, sorry, no reference). It's an implementation detail, it's not something the user sees. Please note that HVM adds some stuff on top of ICs that makes it not strictly beta-optimal, but nevertheless the stuff added is useful in practice and the practical downgrade from theoretical behaviour is minimal. [1] Andrea Asperti, The Optimal Implementation of Functional Programming Languages, ISBN-13: 978-0060815424 [2] https://github.com/HigherOrderCO/HVM3/blob/main/src/HVML/Runtime.c https://github.com/HigherOrderCO/HVM3/blob/main/src/HVML/Run... [3] https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.c https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.c [4] https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.rs https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.rs [5] https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.cu https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.cu [6] https://github.com/HigherOrderCO/HVM1 https://github.com/HigherOrderCO/HVM1 [7] https://higherorderco.com https://higherorderco.com [8] https://github.com/HigherOrderCO/bend https://github.com/HigherOrderCO/bend [9] https://github.com/HigherOrderCO/kind https://github.com/HigherOrderCO/kind
pizlonator 2y ago
The way you make garbage collection deterministic is not by doing regions but by making it concurrent. That’s increasingly common, though fully concurrent GCs are not as common as “sorta concurrent” ones because there is a throughput hit to going fully concurrent (albeit probably a smaller one than if you partitioned your heap as the article suggests). Also, no point in calling it “tracing garbage collection”. Its just “garbage collection”. If you’re garbage collecting, you’re tracing.
- jakewins 2y ago
  Do you have any recommended reading material on this? Intuitively it feels like making it concurrent should do the opposite of making GC deterministic! I’d love to read something showing that intuition is wrong
  - pizlonator 2y ago
    Garbage collection handbook https://gchandbook.org/ https://gchandbook.org/ If you want to see my latest concurrent GC, see https://github.com/pizlonator/llvm-project-deluge/blob/deluge/Manifesto.md https://github.com/pizlonator/llvm-project-deluge/blob/delug... https://github.com/pizlonator/llvm-project-deluge/blob/deluge/libpas/src/libpas/fugc.c https://github.com/pizlonator/llvm-project-deluge/blob/delug...
- roetlich 2y ago
  > Also, no point in calling it “tracing garbage collection”. You're against more explicit naming just for the sake of it? In the literature reference counting is also referred to as a type of garbage collection, and doesn't involve tracing. If you talking about a specific context you can probably drop the "tracing", but in a general article like this it would just be very confusing? This way, someone can google "tracing garbage collection", and will find the relevant wikipedia article: https://en.wikipedia.org/wiki/Tracing_garbage_collection https://en.wikipedia.org/wiki/Tracing_garbage_collection
  - pizlonator 2y ago
bluGill 2y ago
Why is garbage collection called memory safety? Garbage collection in whatever form is only memory safe if it doesn't free memory that will still be used. (which means if you actually get all your free calls correct C is memory safe - most long lived C code bases have been beat on enough that they get this right for even the obscure paths). Use after free is important, but in my experience not common and not too hard to track down when it happens (maybe I'm lucky? - we generally used a referenced counted GC for the cases where ownership is hard to track down in C++) I'm more worried about other issues of memory safety that are not addressed: write into someone else's buffer - which is generally caused by write off the end of your buffer.
- constantcrying 2y ago
  >Why is garbage collection called memory safety? Garbage collection in whatever form is only memory safe if it doesn't free memory that will still be used. Yes. A garbage collector is only safe if it works correctly. What an irrelevant observation. Nothing can guarantee that something works correctly if it doesn't work correctly.
  - bluGill 2y ago
    Keep reading. That is all a garbage collector gives me. there are lots of other things that that are memory unsafe that garbage collectors don't give me.
- foota 2y ago
  To answer your question, I'd say it's memory safe when it's a part of the runtime. At some point, you're relying on your runtime to be correct, so if it says it does garbage collection then you can rely on it, in the same way you rely on the allocator not to randomly trash your memory etc.,.
  - bluGill 2y ago
    You misunderstand. Sure that is a part of memory safe, but why is the much larger problem of running off the end of the buffer into something else not considered a larger part. In my experience the later is a worse problem (the blame for issues goes to someone else who's code is working perfectly correct and so they spend months trying to find a logic error before someone finally looks elsewhere - often the fix is just a random fix by those who are at fault and so the team will spend months more looking before closed as "doesn't happen anymore, no idea why". Memory leaks by contrast are hard to track down, but at least they leave obvious clues and so the blame doesn't go to the wrong person.
the__alchemist 2y ago
After pondering, my single favorite capability of rust is this: fn modify(val: &mut u8) { // ... } No other language appears to have this seemingly trivial capability; their canonical alternatives are all, IMO, clumsier. In light of the article, is this due to Rust's memory model, or an unrelated language insight?
- constantcrying 2y ago
  How is a mutable reference as an argument to a function in any way unique? C++ has mutable references as arguments to functions.
  - the__alchemist 2y ago
    You're right; you can do this in C++, although the patterns I've seen usually involve pointers. There is no equivalent in Python, Javascript, Typescript, Java, or Kotlin.
    - constantcrying 2y ago
      >I've seen usually involve pointers. If only C++ had a thing called "references", which conveniently also used the "&" symbol and are a way to do exactly this without pointers. https://en.cppreference.com/w/cpp/language/reference https://en.cppreference.com/w/cpp/language/reference
      - the__alchemist 2y ago
        I stand corrected on C++. Can you think of any other languages? Of the ones I listed, I use all of, and am continuously frustrated by this limitation.
        constantcrying 2y ago
        >Can you think of any other languages? Yes. E.g. every language where you can pass pointers can do this. Reference are a construct around pointers. >Of the ones I listed, I use all of, and am continuously frustrated by this limitation. Why? This is only a limitation for a few basic types. All the language you mention allow you to modify objects passed to a function. If it ever were any issue though you can always return the modified object and overwrite the original. a = modify(a) works even if you can only pass a value. In practice this should never be a limitation, certainly I have never encountered it as one.
bitbasher 2y ago
I'm kinda torn. It seems there are only three approaches. 1. laissez-faire / manual memory management (c, c++, etc) In this approach, the programmer decides everything. 2. dictatorship / garbage collection (java, go, etc) In this approach, the runtime decides everything. 3. deterministic / lifetime memory management (rust, c with arenas, etc) In this approach, the problem determines everything.
- ryao 2y ago
  There is another option, which is to use a sound static analyzer that can prove the absence of memory safety issues like astree, and fix things that cause it to complain until it stops complaining: https://www.absint.com/astree/index.htm https://www.absint.com/astree/index.htm For those who think static analyzers cannot do that, notice the word “sound”. This is a different type of static analyzer than the more common ones that do not catch everything. Sadly, there is no open source option that works across a broad range of software. NASA’s IKOS is open source for example, but it does not support multithreading and some other things that I do not recall offhand, which makes it unable to catch all memory safety bugs in software using the features that it does not support. For now, people who want to use sound static analyzers need to use closed source tools or restrict themselves to a subset of what C/C++ can do so they can use IKOS: https://github.com/NASA-SW-VnV/ikos https://github.com/NASA-SW-VnV/ikos
  - voxl 2y ago
    Even in their own list of features "Memory Safety" does not pop up, and none of the listed features indicate to me that they would entail memory safety. Academics aren't publishing droves of work on separation logic for a problem that can be solved by 1980s static analyzers.
    - ryao 2y ago
      They say that they can prove the absence of classes of bugs that make up memory safety: * out-of-bounds array indexing, * erroneous pointer manipulation and dereferencing (NULL, uninitialized and dangling pointers), * read access to uninitialized variables, NIST gave them a glowing review: https://nvlpubs.nist.gov/nistpubs/ir/2020/NIST.IR.8304.pdf https://nvlpubs.nist.gov/nistpubs/ir/2020/NIST.IR.8304.pdf It is possible to make sound static analyzers that can prove code to be free from memory safety bugs, but it is difficult and you need to implement checks that either complain or mathematically prove the absence of each class to do it. These tools have been used for years in the aviation and nuclear industries, but almost nobody outside of those industries knows anything about them. If others had broader awareness of the existence of these tools, we could get open source equivalents and memory safety issues would be a thing of the past in C/C++ code. Finally, your 1980s remark reveals enormous ignorance of what the field of formal methods has produced. Astree was not available in the 1980s. It took over 40 years of work to make and only became available about 20 years ago. C++ support took much longer for it to add, with it only adding it around 6 years ago if my recollection of the public documentation is correct. Some other things in this space are the Polyspace Code Prover and Frama-C.
westurner 2y ago
From https://news.ycombinator.com/item?id=33560227#33563857 https://news.ycombinator.com/item?id=33560227#33563857 : - Type safety > Memory management and type safety: https://en.wikipedia.org/wiki/Type_safety#Memory_management_and_type_safety https://en.wikipedia.org/wiki/Type_safety#Memory_management_... - Memory safety > Classification of memory safety errors: https://en.wikipedia.org/wiki/Memory_safety#Classification_of_memory_safety_errors https://en.wikipedia.org/wiki/Memory_safety#Classification_o... - Template:Memory management https://en.wikipedia.org/wiki/Template:Memory_management https://en.wikipedia.org/wiki/Template:Memory_management - Category:Memory_management https://en.wikipedia.org/wiki/Category:Memory_management https://en.wikipedia.org/wiki/Category:Memory_management
deleted 2y ago
[deleted]
eklitzke 2y ago
I don't understand why they say that reference counting is "slow". Slow compared to what? Atomic increments/decrements to integers are one of the fastest operations you can do on modern x86 and ARM hardware, and except in pathological cases will pretty much always be faster than pointer chasing done in a traditional mark and sweep VMs. This isn't to say reference counting is without problems (there are plenty of them, inability to collect cyclical references being the most well known), but I don't normally think of it as a slow technique, particularly on modern CPUs.
- gpderetta 2y ago
  Atomic reference counting per se is fairly slow compared to other simple operations [1]. But the biggest issue with reference counting is that it doesn't scale well in multithreaded programs: even pure readers have to write to shared memory locations. Also acquiring a new reference from a shared atomic pointer is complex and need something like hazard pointers or a lock. [1] an atomic inc on x86 is typically ~30 clock cycles, doesn't really pipeline well and will stall at the very least other load operations.
immibis 2y ago
MMM++ is a variation of standard malloc/free. You can still UAF, but only to another object of the same type, which may or may not prevent an exploit. Something that's missing is full-on formal verification where you write unrestricted C code and then mathematically prove it doesn't have any bugs. Nobody does this because proving a C program is correct is harder than mining a bitcoin block by hand, but it's useful to anchor one end of the safety/freedom spectrum. Many other approaches (such as borrow checking) can also be viewed as variants of this where you restrict the allowed program constructs to ones that are easier to prove things about.
lilyball 2y ago
I don't see any mention of epoch-based garbage collection (see crossbeam https://docs.rs/crossbeam/latest/crossbeam/epoch/index.html https://docs.rs/crossbeam/latest/crossbeam/epoch/index.html). Generational References sounds like a related concept but it's not the same. I'm also surprised nobody's mentioned that one lance corporal goat yet.
tliltocatl 2y ago
Not mentioned: do not do any dynamic allocation at all. Never ever. Everything is either a global variable or goes on the stack. Doesn't work when you need to handle unknown input size, but when you need to make sure you don't OOM ever, it's the only way. Stack overflow is still a possibility, unfortunately, because existing languages cannot provide any guarantee here (Zig tried, but didn't got it done afair). The only real problem with this approach is code reuse, because library writers will insist on opaque structs and malloc rather than letting the caller allocate.
- ryao 2y ago
  What you describe is stack exhaustion. Stack overflow is running past the end of an object on the stack. “Memory safe” languages claim to protect against stack overflows, as does the astree sound static analyzer for C/C++: https://www.absint.com/astree/index.htm https://www.absint.com/astree/index.htm None make any mention of stack exhaustion that I can find in a cursory search.
  - tliltocatl 2y ago
    Wikipedia doesn't agree. https://en.wikipedia.org/wiki/Stack_overflow https://en.wikipedia.org/wiki/Stack_overflow > In software, a stack overflow occurs if the call stack pointer exceeds the stack bound. Also your searching astree site reveals: > StackAnalyzer automatically determines the worst-case stack usage of the tasks in your application. It lets you find any stack overflows, or formally prove the absence thereof.
    - ryao 2y ago
      To me, stack overflow is a synonym for stack buffer overflow: https://en.wikipedia.org/wiki/Stack_buffer_overflow https://en.wikipedia.org/wiki/Stack_buffer_overflow What you call stack overflow appears to be what I call stack exhaustion. The two different cases are very different things when you look at what happens in memory. In computers, the stack grows down, so exhausting the stack occurs in a downward direction. When you overflow an object on the stack, this typically occurs in an upward direction, and continues until older stack frames. Downward is also possible for that case, but it is rare and when it happens it can also be the other issue at the same time. Hearing stack overflow used to describe the other kind of issue is what prompted my reply. I had not known that others use these terms differently. In all cases, we are describing something going past a boundary, with the only difference being what, so the ambiguous usage makes sense. The ambiguous usage appears to be acknowledged by Wikipedia: https://en.wikipedia.org/wiki/Stack_overflow_(disambiguation) https://en.wikipedia.org/wiki/Stack_overflow_(disambiguation... I will continue to use stack exhaustion for this, as it is more accurate. There is also a third case, which is jumping the stack guard page. I am not sure if you consider this to be a “stack overflow” too. It is a third class of bug. Wikipedia appears to lump it together with stack exhaustion under stack overflow. I never expected bug taxonomy to be controversial, yet here we are.

I’d love to see a language that kept everything as familiar as possible and implement memory safety as “the hard bit”, instead of the Rust approach of cooking in multiple different new sub languages and concepts.

brabel 2y ago
The author of the post is trying pretty much that with his language, Vale.
phicoh 2y ago
As a long time C programmer I like Rust because it combines two things from C that are important to me (low runtime overhead, no runtime system required) with a focus on writing correct programs. Memory safety is just one aspect where the compiler can help making sure a program is correct. The more the compiler helps with static analysis, the less we need to rely on creating tests for edge cases.
- zamalek 2y ago
  > Memory safety is just one aspect I feel as though not enough attention is given to how std is designed. For example: [u8], str, Path, and OsStr may be confusing at first, but when you understand why they are there any other approach feels icky. std guides you down a path of caring about things that really should matter (at least if you're only unwrapping provably safe values). Have you considered what happens if not-utf8 data winds up in an environment variable that you are writing to stdout? What if it contains malicious VT commands?
  - shiomiru 2y ago
    > Have you considered what happens if not-utf8 data winds up in an environment variable that you are writing to stdout? What if it contains malicious VT commands? Unless you're talking about terminal bugs in parsing invalid UTF-8 - and parsing invalid UTF-8 is easier than rendering valid UTF-8 - VT commands are UTF-8 compatible. You just need to embed an ASCII escape character.
    - adgjlsfhk1 2y ago
      yeah I think this is an area where rust (and python) just get it wrong. files, the Internet and input devices can all give you invalid Unicode. IMO it's better to have a primary string type that includes invalid Unicode since most algorithms will handle it correctly anyway, and the ones that won't can pretty clearly check and throw errors appropriately (especially since very few algorithms work correctly for all of Unicode in the first place)
      - dwattttt 2y ago
        There's a primary type that holds invalid utf8; it's [u8]. If you want a string from that, you try turn it into a string, and deal with the errors then. If an algorithm works for invalid Unicode, it should probably be an algorithm on bytes, not strings.
ramon156 2y ago
Tbf I would already consider a different language when it has al the nice syntax sugar and design choices of Rust. I like almost every choice they made, and I miss things like `if let Some` or unwrapping in other languages. It's just not the same
chrismorgan 2y ago
As an experienced Rust developer, I have absolutely no idea what you mean by this. Could you write a little more about what you have in mind, and even what you mean by sub-languages and concepts in Rust?
karmakurtisaani 2y ago
Isn't that just C/C++?
frou_dh 2y ago
"Familiar" is subjective so it's not really something to hang your hat on.
nicoburns 2y ago
Familiar to whom? I came from a JavaScript background, and Rust's syntax and "functional lite" style felt very familiar.
pornel 2y ago
Safety is not an extra feature a'la carte. These concepts are all inter-connected: Safety requires unions to be safe, so unions have to become tagged enums. To have tagged enums usable, you have to have pattern matching, otherwise you'd get something awkward like C++ std::variant. Borrow checking works only on borrowed values (as the name suggests), so you will need something else for long-lived/non-lexical storage. To avoid GC or automatic refcounting, you'll want moves with exclusive ownership. Exclusive ownership lets you find all the places where a value is used for the last time, and you will want to prevent double-free and uninitialized memory, which is a job for RAII and destructors. Static analysis of manual malloc/realloc and casting to/from void* is difficult, slow, and in many cases provably impossible, so you'll want to have safely implemented standard collections, and for these you'll want generics. Not all bounds checks can be eliminated, so you'll want to have iterators to implement typical patterns without redundant bounds checks. Iterators need closures to be ergonomic. …and so on. Every time you plug a safety hole, it needs a language feature to control it, and then it needs another language feature to make this control fast and ergonomic. If you start with "C but safe", and keep pulling that thread, nearly all of Rust will come out.
- AlotOfReading 2y ago
  I've experienced that frustration myself several times and tried to do "rust but simpler". I just recently failed attempt #4 at not reinventing rust but worse. Attempt #2 ended with Erlang but worse, which was a pleasant surprise.
- mpweiher 2y ago
  Hm...Smalltalk is also safe. So there are obviously different ways of addressing this.
  - pornel 2y ago
    Bash is also memory-safe. Almost every programming language is memory-safe, but Smalltalk and most high-level dynamically typed languages require a fat runtime, and have a much higher overhead than C or Rust. For languages that can be credible C and C++ competitors, the design space is much smaller.

nahuel0x 2y ago

It's surprising to see an article with such a large encompassing of different techniques, hybrid techniques and design interactions with the type system, but is more surprising that a whole dimension of memory (un)management was left out: memory fragmentation

Quekid5 2y ago
It's probably because fragmentation isn't a safety issue. (In the sense of 'safety' being discussed here.)
- galangalalgol 2y ago
  It doesn't create UB, but it is something safety critical software has to address.
  - Quekid5 2y ago
    ... which is why I had that little bit at the end there.

willvarfar 2y ago

Meta comment, but I really like the formatting of the blog post! It reminds me of the early days of the web, when text was king and content was king. I particularly like the sidenotes in the margins approach. (Hope the author sees this comment :) Hats off)

brabel 2y ago
Yeah the author always uses this in his blog about his language, Vale (which is very unfortunately not being developed anymore, at least for now). The other posts are also worth a read: https://vale.dev/ https://vale.dev/
- ivell 2y ago
  He now works on Mojo, to bring linear types into Mojo.
dgan 2y ago
I am sorry, I am maybe dumb but i can't see the 14 techniques been listed anywhere? Where do i even click?
- hawski 2y ago
  You need to read the post. > Wait a minute, this list goes to 17, yet the intro only mentions 14! I actually did that because a couple might overlap and a couple of them are half-approaches, and that last one is just here for fun. Besides, as I learn more approaches and add them to the list, the title will get more and more out of date anyway.
_kb 2y ago
Side notes are a great layout for most deeper reads. There's some great tooling for that via https://edwardtufte.github.io/tufte-css/ https://edwardtufte.github.io/tufte-css/ and https://tufte-latex.github.io/tufte-latex/ https://tufte-latex.github.io/tufte-latex/.

chrismorgan 2y ago

> Curséd With an acute accent, that should be roughly /ˌkɜːrˈseɪd/ “curse-ay-d”. (Think “café” or “sashayed”.) The stylised pronunciation being evoked is roughly /ˈkɜːrˌsɛd/, “curse-ed”, and would be written with a grave accent: “cursèd”.

rzzzt 2y ago
Italians will get close to the first pronunciation both ways, I think. The Zalgo line noise is an international way of signaling the level of curse in writing.
bloppe 2y ago
Accents mean different things in different languages. I'm assuming the author was invoking Spanish, where the acute accent impacts syllable stress but not pronunciation.

mgaunard 2y ago

The fact that re-using a slot for a different object of the same type is considered a memory safety technique is ridiculous.

obl 2y ago
It is not ridiculous at all. Those things have pretty precise definitions and type segregation absolutely does remove a bunch of soundness issues related to type confusion. You can think of it as the rather classic "Vec of struct + numeric IDs" that is used a lot e.g. in Rust to represent complex graph-like structures. This combined with bound checking is absolutely memory safe. It has a bunch of correctness issue that can arise due to index confusion but those are not safety issues. When combined with some kind of generational counters those correctness issue also go away but are only caught at runtime not at compile time (and they incur a runtime cost). Rust's memory safety is about avoiding liveness issues (that become type confusions since all memory allocators will reuse memory for different types), nothing more, nothing less.
- jandrewrogers 2y ago
  FWIW, arrays of structs + integer handles is the primary way objects are represented in performance-engineered C++.
- gpderetta 2y ago
  > but those are not safety issues. there are not memory safety issues. But they definitely can lead to security issues with some sort of confused deputy attack. For example a capability based system that relied on just this form of memory safety would be pointless. Of course this can be mitigated by adding version counters to objects and object selectors.
adamrezich 2y ago
“Safety” is a very overloaded English word with strong connotations, and the popularization of it in the context of “memory safety” has been good in some ways, but has really poisoned the discourse in many others.
2y ago

hawski 2y ago

That is very informational. Thank you. I am interested in Vale and it feels very promising, though because my interested in bootstrapping I don't like that it is written in Scala. I know, that is shallow, but that's a thing that limits my enthusiasm. If you are like me and don't like jumping around between notes and text and you prefer to read the notes anyway, here is a little snippet you can run in Web Inspector's Console: document.querySelectorAll(".slice-contents a[data-noteid]").forEach(e => {document.querySelectorAll('.slice-notes [data-noteid="' + e.attributes["data-noteid"].nodeValue + '"] p').forEach(p => {p.style.fontSize = 'smaller'; e.parentNode.insertBefore(p, e)}); e.remove() }) It will replace note links with notes themselves making them smaller, because they will not always fit smoothly.

tialaramex 2y ago

The list gets very woolly by the end. CHERI exists (though not at volume), Cornucopia Reloaded is a research paper, "plus some techniques to prevent use-after-free on the stack" is entirely hand waving. It is really good as food for thought though.

nemetroid 2y ago

No mention of RCU?

gpderetta 2y ago
RCU, despite the name, is indeed a reclamation algorithm, but not a general one. I.e. you would use RCU (or some other deferred reclamation algorithm like hazard pointers) for specific data structures when you do not have generalized garbage collection. A generalized RCU is just a tracing GC.
- nemetroid 2y ago
  The part where the article limits itself to general techniques eludes me.

DanielHB 2y ago

I am not experienced with rust and borrow checkers, but my impression is that borrow checkers also statically ensures thread/async safety while most other memory safety systems don't. Is this accurate?

PeterWhittaker 2y ago
The first part - that the Rust borrow checker and overall memory model ensures thread/async safety - is true. I cannot speak to the second part - that other systems don't have this assurance.
- tialaramex 2y ago
  Just the borrowck isn't enough, you need the Send and Sync marker traits. Marker traits are something lots of languages could do but they'd be useless (or always unsafe) without a lot of other machinery Rust had already.
  - kibwen 2y ago
    And Sync might just be there for performance, I think you could get away with only Send if you didn't mind some additional copying?
- DanielHB 2y ago
  > that other systems don't have this assurance My understanding is that most (all?) GC languages are memory safe, but do not ensure statically verifiable thread safety at all. Like Java, Go, C#, Python, etc.
kibwen 2y ago
The borrow checker is only one component of the means by which Rust statically enforces thread safety. If you design a language that doesn't allow pointers to be shared across threads at all, then you wouldn't need a borrow checker. Likewise if you have an immutable-only language. What's interesting about Rust is that it actually supports this safely, which is still unbelievable sometimes (like being able to send references to the stack to other threads via std::thread::scoped).

alexisread 2y ago

Previous discussion: https://news.ycombinator.com/item?id=40146615 https://news.ycombinator.com/item?id=40146615 https://news.ycombinator.com/item?id=41974185 https://news.ycombinator.com/item?id=41974185

dang 2y ago
Thanks! Macroexpanded: Borrow Checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches - https://news.ycombinator.com/item?id=41974185 https://news.ycombinator.com/item?id=41974185 - Oct 2024 (1 comment) Borrow Checking, RC, GC, and the Eleven () Other Memory Safety Approaches - https://news.ycombinator.com/item?id=40146615 https://news.ycombinator.com/item?id=40146615 - April 2024 (68 comments)

amelius 2y ago

I like many of the ideas of Rust, but I still think it is an unsuitable language for most projects. The problem is that it is very easy to write non-GC'd code in a GC'd language, but the other way around it is much much harder. Therefore, I think the fundamental choice of Rust to not support a GC is wrong.

FridgeSeal 2y ago
It does have a GC. It just runs at compile time. Bonus feature, it helpfully prevents a number of common bugs too.
- amelius 2y ago
  GC is short for automatic GC. If you have to do it yourself, then it does not "have" a GC.
  - FridgeSeal 2y ago
    Ssshhh you’re ruining my silly and “hasn’t gone over terribly well” joke.
f1shy 2y ago
Yet another PoV: for some things with critical timing or so, GC might be a problem. But most of the time, it isn’t. The performance/predictability topic could also be reviewed… I was talking with a colleague about that, he said “in C I know exactly where things are when” And I replied that under any OS with virtual memory, you have basically no clue where are things at any time, in the N levels of cache, and you cannot do accurate time predictions anyway… [1] I’m convinced today GC is the way to go for almost all. And I was until 5 years ago or so, totally opposed to that view. [1] https://news.ycombinator.com/item?id=42456310 https://news.ycombinator.com/item?id=42456310
- pjmlp 2y ago
  Even with critical timing, real time GCs exist for decades now, PTC and Aicas are two surviving companies selling software tooling for embedded markets, including their own JVM implementations, with AOT compilers, bare metal deployments and real time GC. Many of their customers are factory processes and military deployments with weapons control, two scenarios where any kind of stall might produce deadly results.

naasking 2y ago

More people need to read up on C#'s ref's: https://em-tg.github.io/csborrow/ https://em-tg.github.io/csborrow/ These kinda-sorta fall under borrow checking or regions, just without any annotations. Then again, Ada/Spark's strategy also technically falls under Tofte-Talpin regions: https://www.cs.cornell.edu/people/fluet/research/substruct-regions/ESOP06/esop06.pdf https://www.cs.cornell.edu/people/fluet/research/substruct-r...

mastax 2y ago
Yeah C# is very well designed for gradually introducing low level concepts for performance.
- jimbob45 2y ago
  The reverse is arguably the one trait Rust is missing that is holding it back from mass adoption. You can write high-level C# code and seamlessly introduce low-level concepts into it as you see fit. However, although you can write low-level Rust code easily, introducing high-level concepts is very painful and, in many cases, impossible.
- akkad33 2y ago
  Also F#
  - neonsunset 2y ago
    As of now - F# needs more work w.r.t. support for [<Struct; IsByRefLike>] types and byref<'T>s. There's a reason ref lifetime analysis in Roslyn is quite a sophisticated part of its implementation even if most developers aren't aware of it. F# has other cool features like `inline` bindings and [<IlineIfLambda>] function attributes but I found it more difficult to work with for systems programming when attempting to stay within safe constructs. But if you don't need byrefs, ref structs and spans, then regular pointer-based or even array-based code is quite pleasant to write, for example https://benchmarksgame-team.pages.debian.net/benchmarksgame/program/spectralnorm-fsharpcore-6.html https://benchmarksgame-team.pages.debian.net/benchmarksgame/... With that said - F# is an incredible language, but for systems programming you are likely to get better results in C#. I hope eventually someone contributes subsequent spec and compiler work to change this (and if you think you have time and could try it - please do! it's a nice small community).

xmcqdpt2 2y ago

Not a fan of the framing of the article. Firstly, there are millions of Mayans alive today, https://en.wikipedia.org/wiki/Maya_peoples https://en.wikipedia.org/wiki/Maya_peoples and secondly, the reason why the pre-Colombian cultural texts and script are not in use today, even by the people who speak the 28 Mayan languages currently in use, is because of genocide by Columbus and those that followed. The Catholic church destroyed every piece of Mayan script they could get their hands on. The article reads like the author is not aware of these basic facts of American geography and history.

constantcrying 2y ago
I thought it was just annoying to read. Irrelevant analogies never helped me understand anything.

4ad 2y ago

> Interaction nets are a very fast way to manage purely immutable data without garbage collection or reference counting.[...] HVM starts with affine types (like move-only programming), but then adds an extremely efficient lazy .clone() primitive, so it can strategically clone objects instead of referencing them. This is wrong, Interaction nets (and combinators) can model any kind of computational systems, including ones that use mutation. In fact, ICs are not really about types at all, although they do come from a generalization of Girard's proofs nets, which came from work in linear logic. The interesting thing about ICs is that they are beta-optimal (any encoding of a computation will be done in the minimum number of steps required -- there is no useless work being done), and maximum-parallel with only local synchonization (all reduction steps are local, and all work that can be parallelized will be parallelized). Additionally ICs have the property that any encoding of a different computational system in ICs will preserve the asymptotic behavior of all programs written for the encoded computational system. In fact, ICs are the only computational system with this property. Interaction nets absolutely require garbage collection in the general sense. However, interaction combinators are linear and all garbage collection is explicit (but still exists). HVMs innovation is that by restricting the class of programs encoded in the ICs you can get very cheap lambda duplication and eschew the need for complex garbage collection while also reducing the overhead of implementing ICs on regular CPUs (no croissants or brackets, see Asperti[1] for what that means). Having a linear language with the above restriction allows for a very efficient implementation with a very simple GC, while maximizing the benefits of ICs. In principle any language can be implemented on top of ICs, but to get most benefits you want a language with these properties. It's not that HVM starts with affine types and an efficient lazy clone operation, it's that a linear language allows extremely efficient lazy cloning (including lambda cloning) to be implemented on top of ICs, and the result of that is HVM. > The HVM runtime implements this for Haskell. This is very wrong. HVM has nothing to do with Haskell. HVM3 is written in C[2], HVM2 has three implementations, one in C[3], one in Rust[4], and a CUDA[5] one. HVM1 was just a prototype and was written in Rust[6]. HOC[7], the company behing HVM provides two languages that compile to HVM, Bend[8], and Kind[9]. Bend is a usual functional language, while Kind is a theorem prover based on self types. Haskell is not involved in any of these things except that the HVM compiler (not runtime) is written in Haskell, but that is irrelevant, before Haskell it used to be written in TypeScript and then in Agda (Twitter discussion, sorry, no reference). It's an implementation detail, it's not something the user sees. Please note that HVM adds some stuff on top of ICs that makes it not strictly beta-optimal, but nevertheless the stuff added is useful in practice and the practical downgrade from theoretical behaviour is minimal. [1] Andrea Asperti, The Optimal Implementation of Functional Programming Languages, ISBN-13: 978-0060815424 [2] https://github.com/HigherOrderCO/HVM3/blob/main/src/HVML/Runtime.c https://github.com/HigherOrderCO/HVM3/blob/main/src/HVML/Run... [3] https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.c https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.c [4] https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.rs https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.rs [5] https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.cu https://github.com/HigherOrderCO/HVM/blob/main/src/hvm.cu [6] https://github.com/HigherOrderCO/HVM1 https://github.com/HigherOrderCO/HVM1 [7] https://higherorderco.com https://higherorderco.com [8] https://github.com/HigherOrderCO/bend https://github.com/HigherOrderCO/bend [9] https://github.com/HigherOrderCO/kind https://github.com/HigherOrderCO/kind

pizlonator 2y ago

The way you make garbage collection deterministic is not by doing regions but by making it concurrent. That’s increasingly common, though fully concurrent GCs are not as common as “sorta concurrent” ones because there is a throughput hit to going fully concurrent (albeit probably a smaller one than if you partitioned your heap as the article suggests). Also, no point in calling it “tracing garbage collection”. Its just “garbage collection”. If you’re garbage collecting, you’re tracing.

jakewins 2y ago
Do you have any recommended reading material on this? Intuitively it feels like making it concurrent should do the opposite of making GC deterministic! I’d love to read something showing that intuition is wrong
- pizlonator 2y ago
  Garbage collection handbook https://gchandbook.org/ https://gchandbook.org/ If you want to see my latest concurrent GC, see https://github.com/pizlonator/llvm-project-deluge/blob/deluge/Manifesto.md https://github.com/pizlonator/llvm-project-deluge/blob/delug... https://github.com/pizlonator/llvm-project-deluge/blob/deluge/libpas/src/libpas/fugc.c https://github.com/pizlonator/llvm-project-deluge/blob/delug...
roetlich 2y ago
> Also, no point in calling it “tracing garbage collection”. You're against more explicit naming just for the sake of it? In the literature reference counting is also referred to as a type of garbage collection, and doesn't involve tracing. If you talking about a specific context you can probably drop the "tracing", but in a general article like this it would just be very confusing? This way, someone can google "tracing garbage collection", and will find the relevant wikipedia article: https://en.wikipedia.org/wiki/Tracing_garbage_collection https://en.wikipedia.org/wiki/Tracing_garbage_collection
- pizlonator 2y ago

bluGill 2y ago

Why is garbage collection called memory safety? Garbage collection in whatever form is only memory safe if it doesn't free memory that will still be used. (which means if you actually get all your free calls correct C is memory safe - most long lived C code bases have been beat on enough that they get this right for even the obscure paths). Use after free is important, but in my experience not common and not too hard to track down when it happens (maybe I'm lucky? - we generally used a referenced counted GC for the cases where ownership is hard to track down in C++) I'm more worried about other issues of memory safety that are not addressed: write into someone else's buffer - which is generally caused by write off the end of your buffer.

constantcrying 2y ago
>Why is garbage collection called memory safety? Garbage collection in whatever form is only memory safe if it doesn't free memory that will still be used. Yes. A garbage collector is only safe if it works correctly. What an irrelevant observation. Nothing can guarantee that something works correctly if it doesn't work correctly.
- bluGill 2y ago
  Keep reading. That is all a garbage collector gives me. there are lots of other things that that are memory unsafe that garbage collectors don't give me.
foota 2y ago
To answer your question, I'd say it's memory safe when it's a part of the runtime. At some point, you're relying on your runtime to be correct, so if it says it does garbage collection then you can rely on it, in the same way you rely on the allocator not to randomly trash your memory etc.,.
- bluGill 2y ago
  You misunderstand. Sure that is a part of memory safe, but why is the much larger problem of running off the end of the buffer into something else not considered a larger part. In my experience the later is a worse problem (the blame for issues goes to someone else who's code is working perfectly correct and so they spend months trying to find a logic error before someone finally looks elsewhere - often the fix is just a random fix by those who are at fault and so the team will spend months more looking before closed as "doesn't happen anymore, no idea why". Memory leaks by contrast are hard to track down, but at least they leave obvious clues and so the blame doesn't go to the wrong person.

the__alchemist 2y ago

After pondering, my single favorite capability of rust is this: fn modify(val: &mut u8) { // ... } No other language appears to have this seemingly trivial capability; their canonical alternatives are all, IMO, clumsier. In light of the article, is this due to Rust's memory model, or an unrelated language insight?

constantcrying 2y ago
How is a mutable reference as an argument to a function in any way unique? C++ has mutable references as arguments to functions.
- the__alchemist 2y ago
  You're right; you can do this in C++, although the patterns I've seen usually involve pointers. There is no equivalent in Python, Javascript, Typescript, Java, or Kotlin.
  - constantcrying 2y ago
    >I've seen usually involve pointers. If only C++ had a thing called "references", which conveniently also used the "&" symbol and are a way to do exactly this without pointers. https://en.cppreference.com/w/cpp/language/reference https://en.cppreference.com/w/cpp/language/reference
    - the__alchemist 2y ago
      I stand corrected on C++. Can you think of any other languages? Of the ones I listed, I use all of, and am continuously frustrated by this limitation.
      - constantcrying 2y ago
        >Can you think of any other languages? Yes. E.g. every language where you can pass pointers can do this. Reference are a construct around pointers. >Of the ones I listed, I use all of, and am continuously frustrated by this limitation. Why? This is only a limitation for a few basic types. All the language you mention allow you to modify objects passed to a function. If it ever were any issue though you can always return the modified object and overwrite the original. a = modify(a) works even if you can only pass a value. In practice this should never be a limitation, certainly I have never encountered it as one.

bitbasher 2y ago

I'm kinda torn. It seems there are only three approaches. 1. laissez-faire / manual memory management (c, c++, etc) In this approach, the programmer decides everything. 2. dictatorship / garbage collection (java, go, etc) In this approach, the runtime decides everything. 3. deterministic / lifetime memory management (rust, c with arenas, etc) In this approach, the problem determines everything.

ryao 2y ago
There is another option, which is to use a sound static analyzer that can prove the absence of memory safety issues like astree, and fix things that cause it to complain until it stops complaining: https://www.absint.com/astree/index.htm https://www.absint.com/astree/index.htm For those who think static analyzers cannot do that, notice the word “sound”. This is a different type of static analyzer than the more common ones that do not catch everything. Sadly, there is no open source option that works across a broad range of software. NASA’s IKOS is open source for example, but it does not support multithreading and some other things that I do not recall offhand, which makes it unable to catch all memory safety bugs in software using the features that it does not support. For now, people who want to use sound static analyzers need to use closed source tools or restrict themselves to a subset of what C/C++ can do so they can use IKOS: https://github.com/NASA-SW-VnV/ikos https://github.com/NASA-SW-VnV/ikos
- voxl 2y ago
  Even in their own list of features "Memory Safety" does not pop up, and none of the listed features indicate to me that they would entail memory safety. Academics aren't publishing droves of work on separation logic for a problem that can be solved by 1980s static analyzers.
  - ryao 2y ago
    They say that they can prove the absence of classes of bugs that make up memory safety: * out-of-bounds array indexing, * erroneous pointer manipulation and dereferencing (NULL, uninitialized and dangling pointers), * read access to uninitialized variables, NIST gave them a glowing review: https://nvlpubs.nist.gov/nistpubs/ir/2020/NIST.IR.8304.pdf https://nvlpubs.nist.gov/nistpubs/ir/2020/NIST.IR.8304.pdf It is possible to make sound static analyzers that can prove code to be free from memory safety bugs, but it is difficult and you need to implement checks that either complain or mathematically prove the absence of each class to do it. These tools have been used for years in the aviation and nuclear industries, but almost nobody outside of those industries knows anything about them. If others had broader awareness of the existence of these tools, we could get open source equivalents and memory safety issues would be a thing of the past in C/C++ code. Finally, your 1980s remark reveals enormous ignorance of what the field of formal methods has produced. Astree was not available in the 1980s. It took over 40 years of work to make and only became available about 20 years ago. C++ support took much longer for it to add, with it only adding it around 6 years ago if my recollection of the public documentation is correct. Some other things in this space are the Polyspace Code Prover and Frama-C.

westurner 2y ago

From https://news.ycombinator.com/item?id=33560227#33563857 https://news.ycombinator.com/item?id=33560227#33563857 : - Type safety > Memory management and type safety: https://en.wikipedia.org/wiki/Type_safety#Memory_management_and_type_safety https://en.wikipedia.org/wiki/Type_safety#Memory_management_... - Memory safety > Classification of memory safety errors: https://en.wikipedia.org/wiki/Memory_safety#Classification_of_memory_safety_errors https://en.wikipedia.org/wiki/Memory_safety#Classification_o... - Template:Memory management https://en.wikipedia.org/wiki/Template:Memory_management https://en.wikipedia.org/wiki/Template:Memory_management - Category:Memory_management https://en.wikipedia.org/wiki/Category:Memory_management https://en.wikipedia.org/wiki/Category:Memory_management

deleted 2y ago

[deleted]

eklitzke 2y ago

I don't understand why they say that reference counting is "slow". Slow compared to what? Atomic increments/decrements to integers are one of the fastest operations you can do on modern x86 and ARM hardware, and except in pathological cases will pretty much always be faster than pointer chasing done in a traditional mark and sweep VMs. This isn't to say reference counting is without problems (there are plenty of them, inability to collect cyclical references being the most well known), but I don't normally think of it as a slow technique, particularly on modern CPUs.

gpderetta 2y ago
Atomic reference counting per se is fairly slow compared to other simple operations [1]. But the biggest issue with reference counting is that it doesn't scale well in multithreaded programs: even pure readers have to write to shared memory locations. Also acquiring a new reference from a shared atomic pointer is complex and need something like hazard pointers or a lock. [1] an atomic inc on x86 is typically ~30 clock cycles, doesn't really pipeline well and will stall at the very least other load operations.

immibis 2y ago

MMM++ is a variation of standard malloc/free. You can still UAF, but only to another object of the same type, which may or may not prevent an exploit. Something that's missing is full-on formal verification where you write unrestricted C code and then mathematically prove it doesn't have any bugs. Nobody does this because proving a C program is correct is harder than mining a bitcoin block by hand, but it's useful to anchor one end of the safety/freedom spectrum. Many other approaches (such as borrow checking) can also be viewed as variants of this where you restrict the allowed program constructs to ones that are easier to prove things about.

lilyball 2y ago

I don't see any mention of epoch-based garbage collection (see crossbeam https://docs.rs/crossbeam/latest/crossbeam/epoch/index.html https://docs.rs/crossbeam/latest/crossbeam/epoch/index.html). Generational References sounds like a related concept but it's not the same. I'm also surprised nobody's mentioned that one lance corporal goat yet.

tliltocatl 2y ago

Not mentioned: do not do any dynamic allocation at all. Never ever. Everything is either a global variable or goes on the stack. Doesn't work when you need to handle unknown input size, but when you need to make sure you don't OOM ever, it's the only way. Stack overflow is still a possibility, unfortunately, because existing languages cannot provide any guarantee here (Zig tried, but didn't got it done afair). The only real problem with this approach is code reuse, because library writers will insist on opaque structs and malloc rather than letting the caller allocate.

ryao 2y ago
What you describe is stack exhaustion. Stack overflow is running past the end of an object on the stack. “Memory safe” languages claim to protect against stack overflows, as does the astree sound static analyzer for C/C++: https://www.absint.com/astree/index.htm https://www.absint.com/astree/index.htm None make any mention of stack exhaustion that I can find in a cursory search.
- tliltocatl 2y ago
  Wikipedia doesn't agree. https://en.wikipedia.org/wiki/Stack_overflow https://en.wikipedia.org/wiki/Stack_overflow > In software, a stack overflow occurs if the call stack pointer exceeds the stack bound. Also your searching astree site reveals: > StackAnalyzer automatically determines the worst-case stack usage of the tasks in your application. It lets you find any stack overflows, or formally prove the absence thereof.
  - ryao 2y ago
    To me, stack overflow is a synonym for stack buffer overflow: https://en.wikipedia.org/wiki/Stack_buffer_overflow https://en.wikipedia.org/wiki/Stack_buffer_overflow What you call stack overflow appears to be what I call stack exhaustion. The two different cases are very different things when you look at what happens in memory. In computers, the stack grows down, so exhausting the stack occurs in a downward direction. When you overflow an object on the stack, this typically occurs in an upward direction, and continues until older stack frames. Downward is also possible for that case, but it is rare and when it happens it can also be the other issue at the same time. Hearing stack overflow used to describe the other kind of issue is what prompted my reply. I had not known that others use these terms differently. In all cases, we are describing something going past a boundary, with the only difference being what, so the ambiguous usage makes sense. The ambiguous usage appears to be acknowledged by Wikipedia: https://en.wikipedia.org/wiki/Stack_overflow_(disambiguation) https://en.wikipedia.org/wiki/Stack_overflow_(disambiguation... I will continue to use stack exhaustion for this, as it is more accurate. There is also a third case, which is jumping the stack guard page. I am not sure if you consider this to be a “stack overflow” too. It is a third class of bug. Wikipedia appears to lump it together with stack exhaustion under stack overflow. I never expected bug taxonomy to be controversial, yet here we are.