Deschide articolul original într-un tab nou Schimbarea acestei opțiuni se aplică imediat și reîncarcă pagina.
LECTURA
← Înapoi la Urmăritori

Languages and Architecture

verdagon.dev/rss.xml
Vizitează site-ul

Cel mai recent articol

Ultima verificare

Urmăritori 0 urmăritori
Articole: 35

  1. Ante: A New Way to Blend Borrow Checking and Reference Counting

    (Languages and Architecture)

  2. Group Borrowing: Zero-Cost Memory Safety with Fewer Restrictions

    (Languages and Architecture)

  3. The Impossible Optimization, and the Metaprogramming To Achieve It

    (Languages and Architecture)

  4. On Joining the Mojo Compiler Team

    (Languages and Architecture)

  5. Crossing the Impossible FFI Boundary, and My Gradual Descent Into Madness

    (Languages and Architecture)

  6. Exploring Seamless Rust Interop for Newer Languages, Part 1

    (Languages and Architecture)

  7. Higher RAII, and the Seven Arcane Uses of Linear Types

    (Languages and Architecture)

  8. Layer-wise inferencing + batching: Small VRAM doesn't limit LLM throughput anymore

    (Languages and Architecture)

  9. Borrow checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches

    (Languages and Architecture)

  10. Vale's First Prototype for Immutable Region Borrowing

    (Languages and Architecture)

  11. Generational References (Expanded)

    (Languages and Architecture)

  12. Making C++ Memory-Safe Without Borrow Checking, Reference Counting, or Tracing Garbage Collection

    (Languages and Architecture)

  13. Single Ownership and Memory Safety without Borrow Checking, Reference Counting, or Garbage Collection

    (Languages and Architecture)

  14. Chasing the Myth of Zero-Overhead Memory Safety (plus pictures of mythical birds!)

    (Languages and Architecture)

  15. The Link Between Generics, Compile Times, Type-Erasure, Cloud Building, and Hot-Code Reloading

    (Languages and Architecture)

  16. What Vale Taught Me About Linear Types, Borrowing, and Memory Safety

    (Languages and Architecture)

  17. An Unexpected Quest in Implementing Vale's Region Borrowing

    (Languages and Architecture)

  18. How To Survive Your Project's First 100,000 Lines

    (Languages and Architecture)

  19. How Memory Safety Approaches Speed Up and Slow Down Development Velocity

    (Languages and Architecture)

  20. Implementing a New Memory Safety Approach, Part 1

    (Languages and Architecture)

  21. Zero-Cost Memory Safety with Vale Regions (Preview)

    (Languages and Architecture)

  22. Hash Codes, Non-Determinism, and Other Eldritch Horrors

    (Languages and Architecture)

  23. Perfect Replayability

    (Languages and Architecture)

  24. Vale's Fearless FFI, for Safer Dependencies and Supply-Chain Attack Mitigation

    (Languages and Architecture)

  25. Vale 0.2 Released: Higher RAII, Concept Functions, Const Generics, FFI, Modules, Faster Compiles, set Keyword

    (Languages and Architecture)

  26. Added to Vale 0.2 Beta: Concept Functions

    (Languages and Architecture)

    Like traits, but way more straightforward!

  27. Const Generics and the Compile Time Spread Operator

    (Languages and Architecture)

    A compile-time for-each operator!

  28. On Removing Let and Let Mut

    (Languages and Architecture)

    So small a thing, yet such an improvement!

  29. A Tale of Yak Shaving: Accidentally Making a Language, for an Engine, for a Game

    (Languages and Architecture)

    The longest yak-shave in history!

  30. Surprising Weak-Ref Implementations: Swift, Obj-C, C++, Rust, and Vale

    (Languages and Architecture)

    Such shenanigans, right under our noses!

  31. Vale's Higher RAII, the pattern that saved me a vital 5 hours in the 7DRL Challenge

    (Languages and Architecture)

    How a language can enforce that we call an arbitrary function before destroying an object.

  32. Seamless, Fearless, and Structured Concurrency

    (Languages and Architecture)

    We can combine the best parts of different structured concurrency approaches!

  33. Vale's Hybrid-Generational Memory

    (Languages and Architecture)

    For speed and simplicity!

  34. Zero-Cost References with Regions in Vale

    (Languages and Architecture)

    Watch regions eliminate reference-counting overhead!

  35. The Next Steps for Single Ownership and RAII

    (Languages and Architecture)

    How constraint references enable easy safety, speed, and much more powerful RAII!