The Artificial Intelligence (AI) podcast by Lex Fridman, in conversation with Bjarne Stroustrup, the creator of C++ programming language
https://youtu.be/uTxRF5ag27A
#CPP
https://youtu.be/uTxRF5ag27A
#CPP
YouTube
Bjarne Stroustrup: C++ | Lex Fridman Podcast #48
Technologique
Some notes to my personal experience in interviewing processes and how it should be like https://telegra.ph/on-interviews-02-09 I must to say directly that I really doesn't like a toxic interviewing processes, that are really stressful, especially such technical…
The most clear and comprehensive article about differences between C++ and Rust in side by side comparison of these languages
https://www.apriorit.com/dev-blog/520-rust-vs-c-comparison
Highly recommend to read.
The series of tutorials by Apriorit about basics in Rust programming language are also really good and exhaustive as an introduction:
https://www.apriorit.com/dev-blog/512-rust-language-tutorial-1
https://www.apriorit.com/dev-blog/514-rust-language-tutorial-2
https://www.apriorit.com/dev-blog/516-rust-language-tutorial-3
https://www.apriorit.com/dev-blog/518-rust-language-tutorial-4
#Rust
#CPP
https://www.apriorit.com/dev-blog/520-rust-vs-c-comparison
Highly recommend to read.
The series of tutorials by Apriorit about basics in Rust programming language are also really good and exhaustive as an introduction:
https://www.apriorit.com/dev-blog/512-rust-language-tutorial-1
https://www.apriorit.com/dev-blog/514-rust-language-tutorial-2
https://www.apriorit.com/dev-blog/516-rust-language-tutorial-3
https://www.apriorit.com/dev-blog/518-rust-language-tutorial-4
#Rust
#CPP
Apriorit
Rust vs C++ Comparison | Apriorit
Based on our experience in programming, we decided to create a Rust vs C++ comparison chart that clearly shows the differences between these two popular languages
A really well written article, contains a weighted observation about advantages and disadvantages of both languages - definitely worth reading!
https://pvs-studio.com/en/blog/posts/0733/
#Rust
#CPP
https://pvs-studio.com/en/blog/posts/0733/
#Rust
#CPP
PVS-Studio
C++ is faster and safer than Rust: benchmarked by Yandex
Spoiler: C++ isn′t faster or slower — that′s not the point, actually. This article continues our good tradition of busting myths about the Rust language shared by some big-name Russian companies.
A good intro, with an example on a poker black-jack game, to the relatively new features of C++, which are provides a good memory management practices (with unique_ptr and shared_ptr).
https://www.youtube.com/watch?v=b8V-WIjlScA
#CPP
https://www.youtube.com/watch?v=b8V-WIjlScA
#CPP
YouTube
Modern C++: Unique Ptrs and Vectors
Dave takes you on a tour of the modern C++ features you need to know in order to avoid memory leaks, corruption, and other common pitfalls of using C++.
Code: https://github.com/davepl/blackjack
Code: https://github.com/davepl/blackjack
Technologique
A good intro, with an example on a poker black-jack game, to the relatively new features of C++, which are provides a good memory management practices (with unique_ptr and shared_ptr). https://www.youtube.com/watch?v=b8V-WIjlScA #CPP
YouTube
Modern C++: Upgrade Your Skills with Shared Pointers!
Dave take you a tour of some core advanced C++ features including smart pointers, weak pointers, constructor aliasing, custom deleters, and atomic operations. All examples are presented in compilable code that can be downloaded below.
Code: https://gi…
Code: https://gi…
An article that unburied an old hatchet - Rust versus C++ debates.
https://lucisqr.substack.com/p/why-i-think-c-is-still-a-very-attractive
#Rust
#CPP
https://lucisqr.substack.com/p/why-i-think-c-is-still-a-very-attractive
#Rust
#CPP
Substack
Why I think C++ is still a desirable coding platform compared to Rust
When a question is asked about comparing compiled languages like C++ and Rust, the typical generic answer is: “Both are compiled languages with no/minimal runtime that let you write whatever the mach…
And here are another articles by the author from this series with more deep takes and better reasoning in comparison apples to apples, i.e. Rust and C++:
https://lucisqr.substack.com/p/quants-use-rust-devs-use-c
https://lucisqr.substack.com/p/move-semantics-and-low-latency-programming
https://lucisqr.substack.com/p/the-c-technique-that-slashes-rusts
Overall, I prefer to use move semantics by default, with explicit ownership transfer, with explicit copies and cloning, with immutability and locality for everything by default, with lifetimes (for region based memory management, with exclusive RCs, rather than GCed memory) tied to local scopes, to ownership transfers and to borrowing by reference (either one mutable or many immutable) - all of this prevents of easy creation of whole class of issues and vulnerabilities related to operations with allocated memory, as dangling pointers, use after free, undefined behavior for dangling pointers and use after free, memory leaks (mostly, but not always, due to logical possible issues in code), shared mutable states and data races, especially in concurrent and multi-threaded code (search for fearless concurrency with Rust), and, what's mostly important, all of this in compile time, with strongly typed safety guarantees.
And many other modern programming things too - functional approach (first class functions, Fn, FnOnce, FnMut traits), Ord and Eq traits for ordering and equality checks for data types, iterators, generators and streams, pattern matching, futures and channels for asynchronous code with deferred computations, trait based ad-hoc polymorphism (with compile-time monomorphization) and generics (with even higher kinded types!), dyn traits for dynamic dispatching, as an exception, rather than the rule, and this fair as well for unsafe local blocks (which gives only reasonable type system relaxation, for only five options, needed for more deep systems development and optimizations, mainly raw pointers dereferencing , all options listed here https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html, but unsafe mode inside particular local blocks not turns off borrow and ownership checker inside of unsafe blocks! only one owner allowed, with ownership transfer, with same rules for borrowing via references and for scope/ownership/borrowing based lifetimes!), and many many more wonderful things!
#Rust
#CPP
https://lucisqr.substack.com/p/quants-use-rust-devs-use-c
https://lucisqr.substack.com/p/move-semantics-and-low-latency-programming
https://lucisqr.substack.com/p/the-c-technique-that-slashes-rusts
Overall, I prefer to use move semantics by default, with explicit ownership transfer, with explicit copies and cloning, with immutability and locality for everything by default, with lifetimes (for region based memory management, with exclusive RCs, rather than GCed memory) tied to local scopes, to ownership transfers and to borrowing by reference (either one mutable or many immutable) - all of this prevents of easy creation of whole class of issues and vulnerabilities related to operations with allocated memory, as dangling pointers, use after free, undefined behavior for dangling pointers and use after free, memory leaks (mostly, but not always, due to logical possible issues in code), shared mutable states and data races, especially in concurrent and multi-threaded code (search for fearless concurrency with Rust), and, what's mostly important, all of this in compile time, with strongly typed safety guarantees.
And many other modern programming things too - functional approach (first class functions, Fn, FnOnce, FnMut traits), Ord and Eq traits for ordering and equality checks for data types, iterators, generators and streams, pattern matching, futures and channels for asynchronous code with deferred computations, trait based ad-hoc polymorphism (with compile-time monomorphization) and generics (with even higher kinded types!), dyn traits for dynamic dispatching, as an exception, rather than the rule, and this fair as well for unsafe local blocks (which gives only reasonable type system relaxation, for only five options, needed for more deep systems development and optimizations, mainly raw pointers dereferencing , all options listed here https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html, but unsafe mode inside particular local blocks not turns off borrow and ownership checker inside of unsafe blocks! only one owner allowed, with ownership transfer, with same rules for borrowing via references and for scope/ownership/borrowing based lifetimes!), and many many more wonderful things!
#Rust
#CPP
Substack
Quants use Rust; Devs use C++
In the past few years, much has been talked about switching from C++ to Rust, particularly in the low-latency trading industry. This is the second article on that line. Value vs. Reference Semantics U…