Mike Shah

0. Channel Update - Live streams, Training, Programming Courses, Free Video List, sRGB Color Article In this video I give you some June 2024 Updates about resources, training available, and upcoming livestream plans! If you're interested in a more formal in-person or virtual training (i.e. training for a group or company), please reach out to \"[email protected]\" with 'TRAINING' in the subject line. \n\n- For CPPCon Academy see: https:\/\/cppcon.org\/class-2024-Modern-Cpp-Training-Essentials\/\n- For courses check out: https:\/\/courses.mshah.io\/ or https:\/\/www.udemy.com\/course\/hands-on-debugging\/\n- Our article of the day: https:\/\/www.ultraengine.com\/community\/blogs\/entry\/2844-srgb-and-linear-color-spaces\/\n\nOtherwise, thanks for your time and attention folks, I want to thank our subscribers and members who support this channel -- more cool stuff coming!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. First Impression of Programming Languages [Programming Languages Episode 0] Series Opener!! Welcome to a new series on programming languages! This series represents my first hour visiting or in some cases, revisiting a programming language, getting things installed, and just otherwise exploring the language and the ecosystem. This series is about encouraging viewers to be curious, learn, and try something new every once in a while! Enjoy at your own pace! Music by: David Cardon\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. golang - First Impression [Programming Languages Episode 1] In this lesson we do a tour of the go programming language (golang). We'll install and walk through some of the tour and look at the language features. This is a first look -- hopefully you enjoy it, and maybe it will inspire you to take a look at this language!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. V language - First Impression [Programming Languages Episode 2] In this lesson we do a tour of the V programming language (pronounced as simply 'V'). We'll install and walk through some of the documents and look at the language features. This is a first look -- hopefully you enjoy it, and maybe it will inspire you to take a look at this language!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. Rust - First Impression [Programming Languages Episode 3] In this lesson we do a tour of the Rust programming language -- which is one of the more popular languages these days! Many folks have asked why I don't do more Rust videos, and until now I have not done any significant Rust -- let's see if I'm convinced with the language and ecosystem!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. Zig - First Impression [Programming Languages Episode 4] In this lesson we do a tour of the Zig programming language -- which is a competing language to C. Zig is a modern and compact language with some neat features that could fit very well in the C development environment.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. FreeBasic - First Impression [Programming Languages Episode 5] In this lesson we revisit the FreeBasic language after 15 years. It was fun to come back after 15 years since I had last seen the project and see it running. The language is neat and has some fun example code that might have some value. If I was starting programming again, it would probably be worthwhile to use a tool like FreeBasic. The interop with C and other libraries may also make it useful for professionals who prefer BASIC languages for whipping up quick tools.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. Free Pascal - First Impression [Programming Languages Episode 6] In this lesson we revisit Free Pascal, a language that I have always liked, and remember using almost a decade ago. Free Pascal has a very exciting and long history in computer science -- ranging back 53 years to Niklaus Writh (a Turing award winner!). The language has evolved and their have been variants with Delphi being one of the most famous rapid application development (RAD) environments. We'll take a look at the Free Pascal Compiler (fpc) and briefly preview the language.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. Ruby - First Impression [Programming Languages Episode 7] In this lesson we take a look at Ruby, which remains a very popular scripting language for building all types of applications. I remember this language specifically for building web applications with the ruby on rails framework, and Ruby for having many 'gems' (i.e. libraries) that could be easily interfaced with. Ruby is a nice modern language, designed for reading and writing -- so let's dive in!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

8. OCaml - First Impression [Programming Languages Episode 8] In this lesson we take a look at the multi-paradigm programming language ocaml. Ocaml has its roots in the functional world from the ML programming language, but remains perhaps one of the most successful functional programming languages -- at least that I know of. It has industry use at well known firms, and lots of great tooling support. We'll briefly walk through the language, and the ecosystem and learning environment is quite nice for beginners. Take a look, and perhaps this is the gateway language to functional programming for you!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

9. Swift - First Impression [Programming Languages Episode 9] In this lesson we take a look at the systems programming language Swift. Swift is a language that has been largely developed and supported by Apple, and it is a very actively evolving language. Swift is both a friendly introductory language for new programmers, as well as a powerful systems programming language for mobile, server, and desktop applications. Because Swift is primarily supported by Apple and has many integrations to XCode, I think folks often forget that it is available on many platforms (I will show you Swift on Linux in this video). We'll do a walk through of the language in this video, and see a language that has really taken to heart many of the modern programming language research ideas.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

10. Kotlin - First Impression [Programming Languages Episode 10] In this lesson we take a look at the Kotlin programming language, which is a language supported and developed by Jet Brains. Kotlin has recently become the preferred development language for Android applications by Google, and has quickly risen to popularity in a variety of programming polls. In this video, we'll find some nice features of a relatively concise and multiplatform and multi-paradigm language. Kotlin seems to also have the ecosystem to support its growth in regards to popular IDE support. The language also supports coroutines as a primary mechanism for concurrency. Take a look, and let me know what I missed in the comments!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

11. R and RStudio - First Impression [Programming Languages Episode 11] In this lesson we take a look at the R programming language as well as R Studio. The R programming language is a language with a reputation for being useful in statistics and other visualization tasks of data. R Studio is a free IDE for the R language that is useful for development. In this brief language investigation, we'll see that this is a language useful for working with vectors and matrices. If you want to see more of the R language (a pirates favorite language....ha ha) -- then let me know in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

12. Nim - First Impression [Programming Languages Episode 12] In this lesson we take a look at the Nim programming language. Nim is a systems programming language supporting several programming paradigms. It is largely influenced by Python, Ada, and Modula (Pascal-based langauges) -- and it shows! We'll look at Nim's basic features, and discuss how it makes a separation between compile-time and run-time evaluation. Nim can generate C and JavaScript code which makes it quite portable. Nim also appears to have an extremely powerful Macro system -- perhaps we'll get to that in a future episode! If you want to see more of the Nim language or have ideas of Nim resources\/tools others should know about -- then please share in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

13. Haxe - First Impression [Programming Languages Episode 13] In this lesson we take a look at the Haxe programming language. Haxe is a language that has been actively developed since 2005, and is able to target a wide variety of platforms by compiling to source or VM of many targetse. The language itself is going to be familiar to anyone who otherwise uses JavaScript or a C-based language -- and it offers strict-typing for safety. The ecosystem and commercial game projects around the language and active ecosystem and community otherwise make this an interesting language to use for getting software shipped to customers. Let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

14. Crystal - First Impression [Programming Languages Episode 14] In this lesson we take a look at the Crystal programming language -- a language influence by Ruby. Crystal is a compiled and statically typed language with a concurrency model inspired by Go. I found Crystal to be very easy to get into (from my limited Ruby experience), and had a nice ecosystem with an active community. Let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

15. Perl (and sneak peek at Raku)- First Impression [Programming Languages Episode 15] In this lesson we take a look at the Perl programming language -- a dynamic language that has been used for over 36 years in many domains. The language is very concise, and has surprised me with the 'There is more than one way to do it' (TIMTOWDI) philosophy. At least for small scripts, Perl appears to be very strong at text processing, and writing programs with ease! Let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

16. Ada - First Impression [Programming Languages Episode 16] In this lesson we take a look at the Ada programming language -- a strongly typed language known for design-by-contract features. The Ada language (named after Ada Lovelace) is now over 43 years, and used in various industries where safety is paramount. In this investigation, we'll get setup, run hello world, and try out a few programs to get a feel for this language. It's interesting to see how this language is influenced by the Pascal family, and how many features of Ada have also made it to modern languages. Let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

17. Clojure - First Impression [Programming Languages Episode 17] In this lesson we take a look at the Clojure programming language -- a Lisp dialect that is available on the Java Virtual Machine. Clojure I have found to be a very neat language, with a concise and powerful syntax (as should be expected as a lisp family language). Some takeaways are the ease at which data structures are available (maps, sets, vectors, and lists), the ease at creating functions with first-class functions, and the excellent REPL. I think this barely touches the surface, as we'll do a brief tour also showing some concurrency features, and perhaps that will have to be for another video to investigate further. Let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

18. Odin - First Impression [Programming Languages Episode 18] In this lesson we take a look at the Odin programming language -- a language for 'sane software development'. Odin is a general-purpose and systems programming language. It is clear to see it is inspired with the simplicity and readability of languages like Go and pascal. There are lots of mathematical types built-in, and the ease at which mathematical operations can be done which are common to games and graphics applications is very apparent. This remains one of the longest videos in this series, and I think there is yet more to check out! Let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

19. DLang - First Impression (FOSDEM 2024 Talk) [Programming Languages Episode 19] In this lesson I present one of my favorite languages -- in fact I'm breaking the rules a bit -- dlang! As many of you know, I use Dlang and have a dedicated series on this channel. That said, I wanted to share my FOSDEM 2024 talk with you here, so you can see how I introduce the D language to other parts of the world. Sit back, relax, and enjoy the talk! ! Let me know what resources\/tools I missed that others should know about in the comments below! (D deserves a talk in here -- I wonder what languages we will see next!)\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

20. Fortran - First Impression [Programming Languages Episode 20] In this lesson we take a look at a language that is over 67 years old ans till thriving--FORTRAN! Fortran has been a very popular language in the domains of scientific computing, and remains a growing language to this day. The language I have found to be very structured, clean, and easy to write in. In this regard, it's interesting to think about how Fortran may be perceived as an old language, but it really has many modern features and continues to stand the test of time! Let me know what resources\/tools I missed that others should know about in the comments below! \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

21. Elm - First Impression [Programming Languages Episode 21] In this lesson we take a look at a language that is used to build websites and web applications--Elm! Elm is a purely functional language that appears to be born from a thesis project from some top powered researchers and Mr. Evan. Elm's usage of functional paradigms and static type checking provide the ability to generate more bug-free code it appears, and I am quite impressed with who performant benchmarks are with the language. As always, let me know what resources\/tools I missed that others should know about in the comments below! \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

22. Lua - First Impression [Programming Languages Episode 22] In this lesson we take a look at an extremely popular scripting language -- Lua! Lua is a dynamically typed language that is meant typically for embedding into other applications (though can be standalone). It has influences from languages like Modula, though features of functional languages like anonymous functions and higher-order functions. Lua is interesting in that it has one data structure -- the table. Lua also has lots of utilities in its standard library. Finally, we'll briefly check out coroutines at the end. Let me know if you're using lua (or in which project it's embedded) or otherwise one of its varients (e.g. luajit). As always, let me know what resources\/tools I missed that others should know about in the comments below! \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

23. Erlang - First Impression [Programming Languages Episode 23] In this lesson we take a look at a language known for creating highly concurrent systems -- Erlang! Erlang is a language co-created by the late Joe Armstrong, that runs on a virtual machine with the slogan -- 'write once, run forever'. The language boosts many features like support for lightweight processes with message passing, process isolation, swapable code, and more. Erlang is primarily labeled a 'functional' language with features such as pattern matching, pattern guards, list comprehensions, higher-order functions, and more. Overall, it's a fun language to learn, and could be potentially very useful in many domains where concurrency and fault-tolerance are required. As an aside, Erlang was used to create one of my favorite tools -- wings3d! As always, let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

24. Dart - First Impression [Programming Languages Episode 24] In this lesson we take a look at a second language that was created by google -- the Dart programming language! Originally developed in 2011 and version 1.0 released around 2013, the Dart language has grown from a language that was initially a JavaScript replacement, to a language that is available for web, mobile, desktop, and server platforms. This is a modern programming language, with many features for concurrency, null safety, and pattern matching. I enjoyed my tour of Dart, and I think it's a valuable language for creating both frontend and backend parts of a software stack. It may even be a good language to learn for first time programmer, as it was relatively clean. This is the first 'first impression' series where I believe I did not make a single error -- so the error messaging will have to be looked at another time :) As always, let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

25. Haskell - First Impression [Programming Languages Episode 25] Have you tried Haskell? That seems to be a question I am always asked -- but there's good reason! In today's video we take a look at a 30+ year old language that is a 'purely functional language'. We'll explore things like pattern matching and the basic features of the Haskell language, a language that has otherwise a unique place in academia, industry, and research. I've always told folks that learning a functional language is a good idea if you primarily work in object-oriented or procedural paradigms -- so have a look! As always, let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

26. COBOL - First Impression [Programming Languages Episode 26] In this lesson we take a look at the Cobol programming language -- a language over 65 years old! The COBOL is designed to be a verbose and self-documenting language with many keywords. The language itself also promotes a very structured programming environment. COBOL itself has been evolving and is still used and maintained in various domains in government and infrastructure where mainframe computers exist. It was interesting to try out COBOL, and I wonder if the 'english like' language will pick up again in programming languages. Anyways, give this a try, perhaps in compiler explorer, so you can say you've written code in one of the oldest programming languages! As always, let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

27. Cpp2 - First Impression [Programming Languages Episode 27] In this lesson we take a look at the Cpp2 an experimental frontend for a 10x safer and 10x simpler C++ programming language. This is an interesting look in our series of a language that compiles to a known and active programming language, similar to the way that TypeScript compiles down to JavaScript. Cppfront is the tool, and it uses a 'Cpp2' syntax that compiles or otherwise 'transpiles' down to Cpp1 (Normal C++20 or later) syntax. This should provide an interesting way to write better (meaning safer and simpler) C++ code by having the write defaults enforced, as well as new or otherwise easier ways to access programming language features (e.g. pattern matching, reflection, type safety) within C++. I found this easy to setup, and also something that got me excited about C++ programming. As always, let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

28. Carbon - First Impression [Programming Languages Episode 28] In this lesson we take a look at Carbon -- a potential C++ successor language that was first announced in July of 2022. Carbon is in the early stages, and is a promising project to improve how we write and read C++ code. Carbon emphasizes the idea that we can interoperate and mix with C++ code, such that we'll be able to transition from one language to the other over time. Carbon is one of the earliest languages that we have looked at in this series, and it is perhaps interesting to watch the evolution of a programming language from start to design. I'll look forward to watching the development, and I'm curious what folks think of Carbon. As always, let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

29. Mojo - First Impression [Programming Languages Episode 29] In this lesson we take a look at Mojo, a new language targetted for Artificial Intelligence programmers. The Mojo programming language is designed by Chris Lattner (LLVM and Swift being other notable projects), and looks very promising as a language that folks can write all their code in (i.e. Write all CPU and GPU code in one single language). The Mojo language also has mechanisms for memory safety (borrow checker inspired by Rust) and meta programming (like DLang and Zig) which makes it a modern language. I'm very curious to see how this language develops over time, and we'll be sure to keep an eye on it! As always, let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

30. Lisp - First Impression [Programming Languages Episode 30] In this lesson we take a look at Lisp -- one of the oldest (perhaps second oldest) programming languages -- and it's still around! Lisp is the 'list processing' language, and it gives us a very powerful toolset with a simple syntax. The simple syntax however allows us to do powerful things like treat the code as data, do metaprogramming, and write fast code! Lisp is a fascinating look at a language that has had many commercial successes, but because of perhaps its 'different look' has not otherwise garnered wide scale adoption in the mainstream. That said, we'll look at some fun projects like Jak and Daxter briefly which used the GOAL lisp variant in this video (or rather, we'll look at OpenGOAL for those interested in seeing it). As always, let me know what resources\/tools I missed that others should know about in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. [Gaming] Doom Guy, Doom Books, and Some Doom Gameplay [Part 1 of 2] In this video we do a little book review of some of my favorite books based on the Doom franchise.Then we'll do a little bit of gameplay as well to show off the amazing Doom game that is now almost 30 years old! Note: I misspoke at one point in this video, and Doom 3 is actually part of id tech engine 4.\n\n00:00 Introduction\n00:57 Doom Book Collection\n05:45 Doom Gameplay\n14:03 Wrap up\n\n►...

1. [Gaming\/Technical] idTech Game Engine Black Books by Fabien Sanglard [Part 2 of 2] In this video I cover two more books related to Doom and the idTech engines. These two books were written by Fabien Sanglard, and are great technical books. I would even recommend students of game engines to read these books, as they provide great insight into the components of a game engine and many techniques still used today.\n\n►...

0. Mike's Linux Journey - Top\/First 3 Linux (or Unix) Distributions Challenge 2023 In this video I ramble a bit on my journey into linux :) Linux is my primary operating system, and I still remember the joy of getting my first linux setup. With all of the variety, it can be hard to choose, but I want to at the very least show you a few different linux\/unix variations that got me started. I am challenging @cppweekly @JacobSorber and @javidx9 to continue the trend through a video, tweet, or comment! My journey really began with Mandrake Linux which was available for free on the cover of a magazine. Then I started using Solaris (A Unix-based operating system, with some support for Linux binaries) in school, that helped change my mental model with using computers. Finally, I used debian, which is one of the most open operating systems during my graduate school work. And *spoiler alert* -- now I primarily use Ubuntu for my daily work (including WSL when on a windows machine :) ). Here's a link to the original nomination: https:\/\/www.youtube.com\/watch?v=pg8EX1T1It8&t=1s\n\n00:00 Introduction and Challenge\n02:23 Linux Distributions\n06:12 Linux Journey and First 3 Distributions\n16:13 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. Conversation #1 - Gustavo Pezzi - Education, Math, and Games In this conversation I talk with Gustavo Pezzi, a university lecturer and founder of Pikuma. Gustavo and I share many similar teaching philosophies, and in this conversation, Gustavo takes us through his journey in education, how he develops courses, and his education philosophy. Enjoy watching or listening!\n\nPlease check out the Pikuma Website: https:\/\/pikuma.com\/ \nand \nThe Pikuma YouTube Channel https:\/\/www.youtube.com\/@pikuma\n\n►...

1. Guest Lecture - Chasing Nodes by Victor CiuraClick to find out more!

2. Conversation #2 - Fabien Sanglard - Games, Graphics Programming, and Game Engine Black Books In this conversation I speak with Fabien Sanglard, a company founder, graphics programmer, and writer of the popular Game Engine Black Book series. Fabien and I, discuss his journey programming, sharing highlights of exciting projects along his journey as a graphics programmer.. In this conversation, we'll hear about how he thinks about software development and anecdotes of what is important for aspiring programmers. Enjoy watching or listening!\n\n- Please check out the Fabien's Website: https:\/\/fabiensanglard.net\/\n- Fabien's Doom Fire article: https:\/\/fabiensanglard.net\/doom_fire_psx\/index.html\n- Fabien's Ikaruga article: https:\/\/fabiensanglard.net\/neverGiveUp\/index.php\n- Fabien's Fluid App: https:\/\/fabiensanglard.net\/fluide\/\n- Fabien's Shmup: https:\/\/fabiensanglard.net\/shmupLite\/\n- Fabien's Wolf3D: https:\/\/fabiensanglard.net\/wolf3d\/index.php\n- One of Fabien's articles on Another World: https:\/\/fabiensanglard.net\/another_world_polygons\/index.html\n- Link to my prior idTech Game Engine Black Books video: https:\/\/www.youtube.com\/watch?v=xgTbZkdRx7A&list=PLvv0ScY6vfd_aFAFlyHvJhhUsO8HFixs-&index=3\n\n►...

3. Conversation #3 - Ginger Bill- Programming Proverbs and the Odin Programming Language In this conversation I speak with Bill (also known as Ginger Bill) who created the Odin programming language -- for Sane Software Development. Bill currently works at JangaFX (which uses Odin) and develops high performance tools for liquid, particle, and terrain simulations in games and movies. Throughout this conversation, we'll discuss Bills journey as a programmer, wisdom (through programming proverbs), and get some of his insights into the Odin programming language. It was a true honor to have an author of a language walking me through the Odin language, and learning from his experience. Sit back, relax, and get ready to take some notes on the wisdom Bill shares as he graciously joins us for this over one-hour conversation.\n\nPlease check out the following links from the talk:\n\nOdin Language website: https:\/\/odin-lang.org\/\nOdin Language demo: https:\/\/github.com\/odin-lang\/Odin\/tree\/master\/examples\/demo\nBill's Programming Proverbs: https:\/\/www.gingerbill.org\/article\/2020\/05\/31\/progamming-pragmatist-proverbs\/\nJangaFX: https:\/\/jangafx.com\/\nGingerBill's YouTube Channel: https:\/\/www.youtube.com\/channel\/UCUSck1dOH7VKmG4lRW7tZXg\nSean Barrett - Advice for Writing Small Programs in C: https:\/\/www.youtube.com\/watch?v=eAhWIO1Ra6M\nMike Acton Data-Oriented Design talk: https:\/\/www.youtube.com\/watch?v=rX0ItVEVjHc&t=1s\nHandmade Cities Conferences\/Network: https:\/\/handmadecities.com\/\n\n00:00 Conversation Preview\n00:17 Introduction\n00:46 Introduction to Ginger Bill\n02:59 When did Bill start programming? \n04:30 The Acorn Archimedes Machine\n05:29 Bill's Physics Background\n06:27 Early Game Development\n09:46 Programming Proverb: Simplicity is complicated\n14:05 Programming Proverb: The concept of programming\n16:40 How to teach students the reality in the young field of computer programming\n19:05 Programming Proverb: Generic Programming\n22:29 Breaking the rules in programming\n23:42 Programming Proverb: William James on being wise\n25:02 The gb Libraries, inspiration from stb_libraries, and importance of libraries in languages\n30:25 Where users are coming to Odin from?\n32:22 C23 and is it worth it to learn C?\n35:16 Programming Proverb: Purpose of a Program\n35:53 Mike's understanding of Odin and Odin's origin\n38:00 Screen share of Odin Code\n57:15 Showcase of Odin Projects\n58:06 Showcase: Cat and Onion commercial game in Odin\n58:30 Showcase: Spall Profiler\n59:10 Showcase: Odin Language Server (Ols)\n59:46 Odin Monthly Newsletter\n1:00:45 Showcase: JangaFX (EmberGen, GeoGen, LiquiGen)\n1:03:45 Using a different programming language as a competitive advantage\n1:06:50 Difference in writing a compiler versus other software\n1:08:30 Programming Proverb: Rob Pike on Data Structures\n1:09:00 Programming Proverb: Fred Brooks\n1:09:55 Programming Proverb: Mike Acton\n1:10:08 Bills Programming Process and the benefits of taking a walk\n1:12:44 Surprise features in Odin that had large impact\n1:15:00 Odin 1.0 is coming\n1:16: 32 On learning compiler and language development\n1:19:40 Book recommendation for students and learners.\n1:22:00 Advice: Understand one level lower than you work (Baking analogy)\n1:24:00 Closing Words and Shout outs\n\n►...

0. Time travel debugging with the rr debuggerClick to find out more!

0. A Brief Introduction to Computational Geometry In this lesson I give a lecture on computational geometry. This is an introduction that I gave at my university, with the purpose to introduce some high level problems that we think about in geometry and some of the primitives that we use. This lesson does not include any code, but will provide pointers to a few of the more interesting problems that we can solve.\n\n►...

0. CppCon 2015: Kate Gregory “Stop Teaching C\Click to find out more!

1. CppCon 2018: Matt Godbolt “The Bits Between the Bits: How We Get to main()”Click to find out more!

2. C++ Code Smells - Jason TurnerClick to find out more!

3. CppCon 2017: Bjarne Stroustrup “Learning and Teaching Modern C++”Click to find out more!

4. Keynote: SOLID, Revisited - Tony Van Eerd - [CppNow 2021]Click to find out more!

5. CppCon 2015: Greg Law \" Give me 15 minutes & I'll change your view of GDB\Click to find out more!

6. CppCon 2014: Mike Acton \"Data-Oriented Design and C++\Click to find out more!

7. \"Performance Matters\" by Emery BergerClick to find out more!

8. Software Engineering Principles with Titus WintersClick to find out more!

9. CppCon 2019: Conor Hoekstra “Algorithm Intuition (part 1 of 2)”Click to find out more!

10. CppCon 2019: Conor Hoekstra, “Algorithm Intuition (part 2 of 2)”Click to find out more!

11. code::dive conference 2014 - Scott Meyers: Cpu Caches and Why You CareClick to find out more!

0. [Dlang Series Teaser] Dlang versus Python speed comparison (Matrix Multiply) Teaser for a new series on D Programming - DLang!\n\n►...

1. Dlang versus Python (Matrix Multiply) #shorts series intro Teaser for a new series on D Programming - DLang! Note, that this is the same trailer as before, but the YouTube shorts version. Let me know in the comments which you like best! #Shorts\n\n►...

2. [Dlang Episode 1] The D Programming Language - dlang An introduction to the series and the D Programming Langauge. This series is for folks of all programming experience who want to learn the D Programming language and many of the features that it has to offer. In this video I provide a high level overview of the language and why I am excited about bringing this series to you!\n\n►...

3. [Dlang Episode 2] D Language - setup on Linux (dmd, gdc, and ldc2 shown!) In this lesson I'll show you within the first about two minutes how to get started with DMD. That said, there are multiple compilers available (and that's a very good thing for a programming language to have multiple implementations!), and I want to show you how to get setup with each of them. As I install each compiler, I will also show you how to compile the 'hello world' in each of the compilers, so get ready to follow along!\n\n►...

4. [Dlang Episode 3] D Language - setup on Mac (Shown on Mac M1, DMD and LDC2) In this lesson I'll show you within the first about two minutes how to get started with DMD on the Mac platform. I'll be testing on a Mac M1 to show you how to get started. There are multiple compilers available (and that's a very good thing for a programming language to have multiple implementations!), and I want to show you how to get setup with DMD and LDC2 (GDC is another option as well!). As I install each compiler, I will also show you how to compile the 'hello world' in each of the compilers, so get ready to follow along!\n\n►...

5. [Dlang Episode 4] D Language - DMD command line and Visual D for Visual Studio (DMD and LDC2) In this lesson I'll show you how to get started with DMD on the command line. The most common use case however, is probably to use the Visual D plugin, which has a nice installer and integrates with Visual Studio (note: Visual Studio is different than Visual Studio Code). I personally would recommend Visual Studio with Visual D if you are focused solely on windows development, it's a very clean experience!\n\n►...

6. [Dlang Episode 5] The Anatomy of a Hello World Application In this lesson I'll show you how to write a hello world application in D. Hello world is the classic application that you write in most all programming languges! That said, we'll want to understand a little bit about the different components of hello world, such as 'import' and what 'standard' libraries are.\n\n►...

7. [Dlang Episode 6] rdmd - Faster iteration times, use DLang like a scripting language In this lesson I show you a tool that comes with the install of DMD called rdmd. This tool allows you to execute your D language files essentially as 'scripts', such that the code does not need to go through two steps to compile and run (those steps are packed into one step behind the scenes). You can use some other flags with dmd (such as dmd -run hello.d) as well for this functionality. For quick iteration of small programs, I really enjoy this feature!\n\n►...

8. [Dlang Episode 7] D Language - Getting help learning D In this lesson I show you a few other key resources for learning the D programming language. If you can believe it, you'll want to be able to navigate a few other resources other than these videos to help master the D programming language. The DLang tour itself is a great starting place, followed by the Programming in D textbook (freely available online). Finally, the forums are friendly for folks with questions, so go ahead and join!\n\n►...

9. [Dlang Episode 8] D Language - Built-in Basic Data Types In this lesson I show you the built-in data types in the D programming language. The built-in types in D are very nice because we have guarantees that they will be a specific size. I'll also show you how we can look at the properties of these built-in data types, by accessing properties on the types.\n\n►...

10. [Dlang Episode 9] D Language - The ‘auto’ keyword In this lesson I show you how to use the 'auto' keyword which allows you to 'infer' the type. Auto can actually be used in many scenarios, and can be quite powerful when it comes to using templates and mixins in the D programming language. That said, it's worth knowing about early along your D journey, and to also be a little bit careful if you really need to control the precision of your data types with the basic data types.\n\n►...

11. [Dlang Episode 10] D Language - Static and Dynamic Arrays In this lesson I will show you two out of the four array types that are built into the D programming language - static and dynamic arrays. Static arrays are fixed size, while dynamic arrays can be automatically expanded or contracted. I'll also show you some useful features such as 'slicing' of arrays that make arrays in D quite wonderful to work with.\n\n►...

12. [Dlang Episode 11] D Language - Strings Part 1 - Representation and Basic usage In this lesson I show you how to use the string type in the standard library (Phobos) in the D programming language. Strings in Dlang are immutable by default, which is a nice default to ensure that strings can be used in concurrent applications safely.\n\n►...

13. [Dlang Episode 12] D Language - Strings Part 2 - Unicode and Multi-line In this lesson I show you the support that Dlang has for working with unicode. This lesson just barely touches the surface, but I at least want to expose you early on that you can use different character sets, and that DLang has available support for things like wide character strings(wstring, being one of three built-in strings (the other two are string and dstring)). Enjoy this quick lesson, with a little bonus on handling multi-line strings :)\n\n►...

14. Invited Speaker Ali Cehreli, Introduction to Dlang In this special lesson, guest speaker Ali Cehreli (author of https:\/\/ddili.org\/ders\/d.en\/index.html ) presents a wonderful tour of the D Programming language. Enjoy this talk!\n\n►...

15. [Dlang Episode 13] D Language - Control Flow - Conditionals, Switch, Ternary and Safety! In this lesson I show you a few of the ways to allow you to make decisions in your program! D like many other languages supports if\/else if\/else. D also allows ternary expressions, and switch\/case statements. Dlang by default also has some safety features to stop you from assignment in a conditional as well as fall through behavior in swtich\/case statements.\n\n►...

16. [Dlang Episode 14] D Language - Control Flow - Loops (do-while, while, for) In this lesson I show you three of the looping constructs in the D programming language. While loops, do-while loops, and the classical for-loop. For experts, you probably know most of what I'm tallking about here, but if you're newer to programming, this should get you familiar with the language. I'll also show you how to use 'break' (we saw earlier in the series with switch statements) and the 'continue' keywords to control the control flow of the loop.\n\n►...

17. [Dlang Episode 15] D Language - Guessing Game Project (random numbers, std.conv, and readln) In this lesson we are going to put together all of the different topics that we have learned thus far in this series. This is also a great lesson for those new to the D programming language to see how we work in the D programming language. We may revisit this project again as we learn more features in the future as well -- and with that said, start your guessing!\n\n►...

18. [Dlang Episode 16] D Language - Control Flow - foreach loop In this lesson I show you how to use 'foreach' loops in Dlang. Foreach is similar to 'ranged-based' loops in C++ or other languages like Python which allow you to iterate through all of the elements in a loop. In addition to foreach, there is also foreach_reverse in the language which changes the direction that you iterate through a collection. It's important to note, that foreach is applying operations to 'copies' of elements by default, so we'll also get an introduction to the 'ref' keyword to learn about reference semantics.\n\n►...

19. [Dlang Episode 17] D Language - Associative Arrays In this lesson I show you a fundamental built in data structure in the D Language - associative arrays (sometimes known as dictionaries or hashtables in other languages). An associative array allows you to decide the type as a key (that does not have to be an unsigned integer), and a value as the information stored. In this lesson I'll show you how to iterate through the keys and values stored. Importantly, associative arrays are a 'reference type' in DLang, which we'll touch on in future lessons, but this lesson will introduce briefly what that means. \n\n►...

20. [Dlang Episode 18] D Language - Functions - Part 1 of n - Introduction In this lesson I talk about an introduction to functions in the D programming language. Likely you have already seen functions, and in fact we have used some (e.g. writeln, readln, and main!) -- but I want to in this lesson tease you with some features and also give us a vocabulary for working with functions in the D programming language.\n\n►...

21. [Dlang Episode 19] D Language - Functions - Part 2 of n - main() and program arguments (std.getopt) In this lesson I talk about a special function, the main function! I'll start by showing you the ability to use void or 'int', how to handle arguments, and what to do with exit codes. Then I'll show you how to handle program arguments in a more advanced way using the std.getopt library.\n\n►...

22. [Dlang Episode 20] D Language - Functions - Part 3 of n - Function Overloading In this lesson I show that D has support for function overloading. Function overloading allows us to use the same name for a function, allowing for often a more consistent api (Languages like C for instance do not support this feature). Most of the time the compiler is smart enough to find an exact match, or do implicit conversions to the correct type. However, sometimes we can have ambiguity with which function to call.\n\n►...

23. [Dlang Episode 21] D Language - Functions - Part 4 of n - Function Default Parameters In this lesson I show you how D supports default arguments in functions. This allows you to avoid specifying all of the arguments, or otherwise can be a tool to extend the functionality of functions that your legacy code relies upon.\n\n►...

24. [Dlang Episode 22] D Language - What happens when you call a function? In this lesson I take a little step back and discuss what exactly happens when you call a function. D is a systems programming language, so it's important for us to understand just a little bit more about how the language works (in fact many programming langues do this), by understanding the 'program stack' and how it is divided into a 'heap' and 'stack' region. We'll talk specifically about the call stack in this lesson, and how the return address, locals, and parameters are copied.\n\n►...

25. [DLang Episode 23] D Language - The ampersand &(address of) and more on stack\/heap memory In this lesson I talk about the ampersand operator which I think of as 'address of'. It's a useful tool for understanding where exactly memory is placed. For folks with C and C++ experience, you'll understand that we will talk about pointers later on in this series. For those using D as your first programming language, the & is a very handy way to figure out exactly what data you are accessing.\n\n►...

26. [Dlang Episode 24] D Language - Functions - Part 5 of n - ref parameters and pass-by-value In this lesson I discuss the 'ref' parameter in the D programming language. In order to truly understand how ref works though, we'll have to take a look at pass-by-value (or pass by copy-value) and pass-by-reference semantics. Towards the end of the video, I'll leave you with a little teaser that in the D programming language, we have to think about value and reference types.\n\n►...

27. [Dlang Episode 27] D Language - lvalue and rvalues In this lesson we are going to talk about lvalues and rvalues. You may have heard these terms before in other languages like C and C++, or otherwise see these terms in error messages in D. So in this lesson I want to help you understand what it means, and the basic idea is that anything with a location (i.e. an address) is an lvalue. lvalue can for example be passed by both copy and reference ('by reference' because we have a location). rvalues on the other hand, we need to understand (for example the expression \"4 + 5 \") cannot be passed in as a 'ref parameter' in a function, because there is no address to look at (Note: We can set a parameter with an 'auto ref' when we learn about templates, so the rvalue \"4 + 5 \" could be used and passed by copy in a function template, and we'll see this later). \n\n►...

28. [Dlang Episode 28] D Language - Value and Reference Types (Understanding the Semantics) In this lesson we are going to talk about value and reference semantics. We'll revisit this topic throughout the series, but as an introduction I will show you how structs are treated as value types (similar to how we use basic types like 'int', 'double', 'char', etc), and how classes are treated as reference types. This distinguishment between a struct and a class may be new for folks coming from a C++ background -- but I will argue this is a nice thing to think about up front when creating a new data type. Why it matters to understand the difference, is so that you understand when you pass a value type or a reference type in a function, reference types will by default be 'passed by reference' -- thus you can change the type. Note: We'll talk more about 'ref' with reference types in the next video.\n\n►...

29. [Dlang Episode 30] D Language - Revisiting foreach with ‘ref’ (and also accessing index in foreach) In this lesson I show you two new things with the foreach loop. The first is how to use the 'ref' keyword to modify elements in a foreach loop -- by default the elements in a foreach loop are otherwise created by copy. This copy could potentially be expensive, thus why we may want to allow modifications using 'ref'. Second, I just show you another trick that probably isn't worth an entire video, but the idea that we can pass in a second variable in our loop to capture the index. Note: With associative arrays, when we pass in two variables, we retrieve the 'index' as the key.\n\n►...

30. [Dlang Episode 29] D Language - Passing Reference Types with ‘ref’ in a function In this lesson I do a bit of a deep dive to show you what happens when you use a Reference Type and pass it with the 'ref' keyword. The idea is that with a reference type, whether passing by reference or passing by value, you can change the underlying data. When passing a 'reference type' with 'ref' qualifier in a function, you can change where that underlying data is stored when creating a new allocation.\n\n00:00 Introduction\n00:45 Review of previous lesson\n04:00 What 'ref' does and does not do to reference type parameters\n06:10 Experiment with & operator to retrieve addresses.\n07:10 Exploring addresses in our functions\n10:00 Printing where underlying data lives, to show new memory location\n13:48 Illustration on whiteboard of new allocation.\n19:00 Summary and Conclusion\n\n►...

31. [Dlang Episode 25] D Language - Debugging with GDB (Linux demonstration) In this lesson we take a brief step back, and I show you how to debug DLang using the GDB debugger. GDB is a wonderful free debugger, and I'll demonstrate the usage on Linux. I have many more resources on using GDB otherwise you can check out on courses.mshah.io if you find useful.\n\n00:00 Introduction\n01:45 Compiling with -g flags\n02:42 Starting gdb\n03:50 Finding a segmentation fault\n06:40 Fixing our segmentation fault\n07:15 Interactively debugging from _Dmain\n09:50 Setting a breakpoint at _Dmain -- our program entry\n11:55 GDB Text User Interface (tui)\n14:00 Breakpoints at functions in a D module\n17:44 focus on src and focus on cmd window\n19:03 Conclusion\n\n►...

32. [Dlang Episode 26] D Language - Debugging with lldb (Mac demonstration with LDC2 and DMD) In this lesson we take a brief step back, and I show you how to debug DLang using the lldb debugger. lldb is a wonderful free debugger, and I'll demonstrate the usage on Mac with both LDC2 and DMD (though I prefer LDC2). I have many more resources on using GDB otherwise you can check out on courses.mshah.io if you find useful.\n\nfile - load program\nlldb -- program arguments\nrun from within lldb\n\nbreakpoint set --name main\nb s -n main\nb list\nb del 1\n\nShow help\nhelp frame\nframe info\nframe variables\nfr v\n\np\nbt -- backgrace for current thread (thread backtrace)\n\nimage lookup --type int\nimage lookup -r -s main (scroll to top)\n\nq to quit\n\n00:00 Introduction\n00:35 Downloading and setting up DMD and LDC2\n02:53 Compiling LDC2 with debug symbols \n04:51 Starting lldb with ldc2\n06:45 Setting a breakpoint at main\n08\"30 Starting from _Dmain (b _Dmain)\n10:15 next, step, bt, and exploring main interactively\n17:40 Using DMD with lldb\n19:01 Conclusion\n\n►...

33. [Dlang Episode 31] D Language - ctags with dscanner for VIM (and ctags with phobos demonstration) In this lesson I show you some more tooling with the D programming language. We will be setting up ctags to assist with finding function and data structure definitions in our project. As a little bonus, I'll also show you how to find functions and data structures in the phobos library by setting up a tags file for phobos.\n\n►...

34. [Dlang Episode 32] D Language - Functions - Part 6 of n - auto as a return type (and std.variant) In this lesson I show you how to use 'auto' to automatically deduce the return type. auto needs to be able to determine the actual type however if there are multiple return types, and if it cannot implicitly convert from all of the types to a common type will fail. That said, if you do need to return lots of different types, then you can use something like a union, or more conveniently std.variant. Variant is one of several different ways in D (including VariantN, and SumType) which allows you to return a collection of values depending on the currently held value.\n\n►...

35. [Dlang Episode 33] D Language - Functions - Part 7 of n - ref functions In this lesson we revisit the 'ref' keyword, but this time as a return value. When we use 'ref' with a return value, we are stating that we want to be able to return an actual location in memory, and not something that will be otherwise a 'copy' of a temporary (i.e. rvalue). We can use 'auto ref' to deduce the value in cases where we might return multiple types.\n\n►...

36. [Dlang Episode 34] D Language - Raw Pointers Introduction In this lesson we learn about raw pointers in the D programming language. D is a systems programming language, which means we have low level access to pointers and memory (and manual memory allocation if we choose). The reality is we can probably use D without even thinking about pointers, especially for smaller projects. That said, when it comes to using features of the D language, and for working with lower level functionality (or even reading error messages), it's useful to know what they are and the benefits.\n\n►...

37. [Dlang Episode 35] D Language - Pitfalls of Pointers and Memory and @ safe in dlang In this lesson I discuss some of the pitfalls of pointers and introduce the @ safe function attribute for writing safer code. @ safe function code can help many of the memory safety bugs from a language like C for instance, and serve as documentation for how code should be treated.\n\n►...

38. [Dlang Episode 36] D Language - Manual Memory Allocation and @ safe in dlang In this lesson I show you how to use malloc and free from the C library for manual memory allocation. While D is a garbage collected language by default, on occasion you may have special needs for writing your own allocators. Of course, one must consider the trade offs, but it is good to know that it is always an option in the D language to have lower level control.\n\n►...

39. [Dlang Episode 37] D Language - @safe, @trusted, and @system function attributes for safer D Code In this lesson I show you how the function attributes safe, trusted, and system work together to allow for safer code checks at compile-time. Each of the function attributes also serve as important documentation for how a function should be treated, and what operations are allowable.\n\n►...

40. [Dlang Episode 38] D Language - @live - ownership\/borrowing system early preview in D In this lesson I show you a preview of the ownership and borrowing system being developed in the D language. At the time of this writing, it's just a preview feature, but it shows some of the capabilities that are being planned for the D language to write safer code. The live attribute can be used to verify that one resource is owned by one pointer (or otherwise there are several read-only pointers (thus non-owners) of a resource).\n\n►...

41. [Dlang Episode 39] D Language - Functions- Part 8 of n - arrays as function parameters(fat pointers) In this lesson I show you how to pass arrays into functions. The truth is, there is nothing too complicated, we just need to remember that D uses reference types (for arrays), and that we have the ability to access the length and the ptr within the array. This makes it also easy to interface with C code.\n\n►...

42. [Dlang Episode 40] D Language - const type qualifier - A contract not to change In this lesson I show you how to use the 'const' qualifier that exists in D just like other languages. If you're coming from a C and C++ background, the ability to choose whether the pointer is mutable or not also comes into play, and D makes that easy by carefully organizing the parenthesis around the const declaration. We'll also take a sneak peek at immutable, which is a similar idea to const before closing this lesson.\n\n►...

43. [Dlang Episode 41] D Language - immutable type qualifier - A STRONGER contract to not change In this lesson I show you how to use the 'immutable' qualifier that exists in D which may be new to you coming from other languages. immutable is a type qualifier that is stronger than const, and it does not allow us to store references to data that may change. In this lesson I'll show you how to use idup as well when you need to pass immutable data into functions.\n\n►...

44. [Dlang Episode 42] D Language - enums - another immutable (named) type In this lesson I show you another immutable 'named type' known as an enum. Enums are ways to group together related constants that do not change, but we can otherwise create variables of the enum type. I have found enums useful to check for things like error state or to iterate through to make sure I handle various 'states' a program could be in. In this lesson, I'll also briefly show you std.traits which is a useful part of D to introspect the different enum members.\n\n►...

45. [Dlang Episode 43] D Language - Functions - Part 10 of n - local functions In this lesson I introduce you to the ability and idea of creating local functions. The purpose of this video is to show you this is possible, as many beginners do not think about nesting functions. A larger idea however of different ways to use functions (lambdas, delegates, function pointers) is teased, and we'll be discussing those ideas further in the series.\n\n►...

46. [Dlang Episode 44] D Language - Reading from files In this lesson I do a bit of a deep dive into the D programming language on reading files. We'll first learn about different path types (relative versus absolute) and then understand that files are collections of bytes that we can iterate through. I'll show you how to open a file and check for its existence, and then several ways to move through the data.\n\n►...

47. [Dlang Episode 45] D Language - Writing to files (text and binary) In this lesson I show you how to write data to files both text and briefly show how to write binary data and read it back to text files. I'll also show you some different file modes that you should consider, and talk briefly about the idea of a file descriptor.\n\n►...

48. [Dlang Episode 46] D Language - Writing and reading json files In this lesson I show you how to load and parse json files which is built in directly to the D programming language. I'll show you a trick or two for reading a file into a string as well. We'll iterate through a portion of the json values, and then I'll show you at the end how to update a value.\n\n►...

49. [Dlang Episode 47] D Language - Casting with ‘cast’ In this lesson I show you how to use the 'cast' operator in dlang to interpret bytes as the needed type. Cast can also be useful for telling us if conversions between types was successful. I'll also show a useful example of casting parts of a byte stream to the intended type which is often useful in networked applications. Finally a teaser for the next lesson using std.conv will be shown.\n\n►...

50. [Dlang Episode 48] D Language - conversions with std.conv (e.g. to!string and castFrom) In this lesson I show you how to use the 'to' and 'castFrom' to perform conversions from the std.conv library in dlang. to!some_type is your one stop shop for conversions, while castFrom allows you to be even more explicit about the types that you are converting from. The latter (castFrom) can be especially useful if you are doing code refactorings in your codebase.\n\n►...

51. [Dlang Episode 49] D Language - Functions - Part 11 of n - Shortened Function Syntax In this lesson I show you a very nice feature that allows you to write short and quick functions. This can be useful if you have lots of 'getter' or 'setter' member functions or otherwise small functions that you want to put in your program We'll later talk about lambda functions in this series, so stay tuned after learning about the shortened function syntax!\n\n►...

52. [Dlang Episode 50] D Language - Functions - Part 12 of n - UFCS - Universal Function Call Syntax In this lesson I show you a really nice feature of the D programming language that I think is a **MUST** for any modern programming language. UFCS (Universal Function Call Syntax) allows you to 'chain' together successful function calls. It works by allowing you to take out the first parameter of a function and then chain together the function names. With a series of function calls, thus we can chain together the resulting value. At the end of the day, the compiler will then rewrite the function for you to otherwise write a function from inside-out when calling. I'll argue that UFCS allows for more easy reading of code, easier refactoring, and overall just makes working with code more pleasant.\n\n►...

53. [Dlang Episode 51] D Language - Functions - Part 13 of n - Function pointers In this lesson I show you what a function pointer is in the D programming language. Just like in other languages like C or C++ with pointers, we can point to functions and store a functions address in D. This can be useful, because we can change the function that we point to at run-time in our programs.\n\n►...

54. [Dlang Episode 52] Functions - Part 14 of n - Passing Function pointers in Functions (and alias) In this lesson I show you how to pass a function pointer as a parameter, which is one way of enabling 'higher order functions' in the D programming language. This can be a very powerful idea, and it allows us to write more reuseable code where we can change the behavior of our programs based on the parameters. I'll show you how to also use this with default parameters, and otherwise create an 'alias' to make this a bit easier on the eyes.\n\n►...

55. [Dlang Episode 53] D Language - structs - Part 1 of n - Introduction In this lesson I introduce you to struct's in Dlang. If you are coming from a C or C++ background these will be quite familiar, however structs in D have some different capabilities that are quite nice. I'll show you the very basics of how to work with a struct, and how to use them as a way to create a new user defined type (UDT) to aggregate related pieces of data (i.e. fields). We also have member functions which can act on data. Each individual instance of a struct is an 'object'. Finally at the end of this video, I'll tease some of the introspection capabilities of D that are quite neat for analyzing structs.\n\n►...

56. [Dlang Episode 54] D Language - structs (Value Type) - Part 2 of n - Introduction In this lesson I talk about an important semantic difference in DLang versus other languages -- structs are value types! This means that they are default allocated on the stack. We can of course heap allocate our structs, but it is otherwise useful to observe that they are stack allocated. Structs also cannot take advantage of inheritance or interfaces, but that is again an advantage as you make a design decision up front about how a type should be used (or not used) in your program. Finally, structs (whether heap or stack allocated) still use the '.' symbol to access fields, which makes it easy to swap between heap and stack allocated data.\n\n►...

57. [Dlang Episode 55] D Language - structs - Part 3 of n - struct creation without constructors In this lesson I continue our discussion on structs, this time showing you some different ways to initialize a struct. The important takeaway from this lesson is that we probably want to set default values for structs, and we will probably want to more heavily rely on constructors if we have more complicated types. That said, struct literals and named initialization can be useful techniques!\n\n►...

58. [Dlang Episode 56] D Language - structs - Part 4 of n - struct creation with constructors In this lesson I continue our discussion on structs, showing you the syntax for constructors and how to access member variables (fields) within our constructor. Note that when we create our own constructors, we lose the ability to have struct literals or initialization of named fields. Constructors are useful when we have non-trivial types where we need to perform some initialization.\n\n►...

59. [Dlang Episode 57] D Language - structs - Part 5 of n - Delegate Constructors In this lesson I show you a neat feature in constructors to reuse code -- delegate constructors. Delegate constructors allow you to call other constructors (marked with 'this') from other constructors. This is a nice way to ensure that initialization code does not need to be duplicated, and it also helps your clients of your struct from avoiding calling other 'init' functions accidently.\n\n►...

60. [Dlang Episode 58] D Language - structs - Part 6 of n - Deterministic Destruction In this lesson I show you how to use struct destructors in the D programming language. Destructors operate similar to other languages like C++ (and allow for Resource Acquisition is Initialization (RAII)), in that they provide a deterministic way for us to destroy objects when their lifetime ends.\n\n►...

61. [Dlang Episode 59] D Language - structs - Part 7 of n - struct creation with copy constructors In this lesson I show you how to use struct copy constructors to perform necessary deep copies when we have fields that are reference types (or really any heap allocated memory). I'll show you by example what happens when a copy constructor (that the compiler generates automatically) performs for us can cause trouble!\n\n►...

62. [Dlang Episode 60] structs - Part 8 of n - copy constructors cont (disable, typeof(this), perf) In this lesson I show you a nice trick for copy constructor function signatures with 'typeof(this)'. Then we go into a performance experiment to show you the impact copies can have on performance. If copying is unwelcomed in your data type, I show you how to disable copy constructors completely.\n\n►...

63. [Dlang Episode 61] D Language - structs - Part 9 of n - static members In this lesson I show you how to create static member fields and static member functions (static methods) in a struct (and the same applies for a class). The static attribute allows you at compile-time to allocate storage that is shared across all instances of a struct or a class. Finally, I'll show you one neat trick for otherwise 'bookkeeping' all the objects that you allocate.\n\n►...

64. [Dlang Episode 62] D Language - structs - Part 10 of n - bitfields In this lesson I show you how to use structs (also applicable to classes and unions) as bitfields for more efficient storage. In Dlang there are two ways, either using mixins with bitfields, or otherwise performing a more c-style bitfield (use -preview=bitfields if you have an older compiler).\n\n►...

65. [Dlang Episode 63] D Language - structs - Part 11 of n - struct alignment (align, offsetof) In this lesson I show you how to use the 'align' attribute in structs in D in order to pack bytes together. Examples of where you might need this feature are when you are working with networked data or streams of bytes that need to fit a specific format.\n\n►...

66. [Dlang Episode 64] D Language - structs - Part 12 of n - struct visibility attributes In this lesson I show you how to use visibility attributes to help write safer software. Visibility attributes are part of the idea of 'encapsulation' which D allows us to do at the module level, struct, and classes. In this example, I'll show you how public and private work, and we'll look at other visibility attributes in the future.\n\n►...

67. [Dlang Episode 65] D Language - tuples (brief look at std.csv) In this lesson I show you another way to create aggregate data types through the 'tuple' (pronounced 'tup-l' or 'two-pool'). If you need to return multiple pieces of data this can be a great choice! They allow for you to also name the fields which may make your code readable if you're working with csv data as well. \n\n►...

68. [Dlang Episode 66] D Language - unions In this lesson I show you how to use unions in the D programming language. Unions are a powerful and often forgotten way to structure data in an efficient representation where overlapping storage is 'shared'.\n\n►...

69. [Dlang Episode 67] D Language - anonymous structs and anonymous unions In this lesson I show you how to use anonymous unions and anonymous structs. This is a powerful feature that can be useful when implementing your own 'tagged unions' or otherwise structuring data. I might actually recommend that you use a std.variant which is built-in, but nonetheless it's a useful feature to use, and if you're limited to not being able to use the Phobos library, you'll want to know how to construct the types yourself.\n\n►...

70. [Dlang Episode 68] D Language - Functions - Part 15 of n - pure functions In this lesson I show you how to use the 'pure' function attribute to write safer code (especially when later using concurrency) in the D programming language. Some functional programming languages (e.g. Haskell) are pure by default, avoiding state mutations. In D lang, we can specify to avoid mutations (and document to our users) how a function is to be used with 'pure'.\n\n►...

71. [Dlang Episode 69][Tools] D Language - VSCode - code-d plugin In this lesson we setup visual studio code for working with the D programming language. We'll install the 'code-d' plugin, which does a nice job with auto-completion, integration with dub (not yet covered in this series), and much more! Try it out!\n\n►...

72. [Dlang Episode 70] D Language - scope guard statements (for safer programming) In this lesson I show you how to use 'scope guard statements' in the D programming language. scope(exit) for example is a way to safely ensure that blocks of code will execute. I find they are quite useful when interfacing with C like interfaces, or otherwise interfaces where there is no deterministic destruction.\n\n►...

73. [Dlang Episode 71] D Language - [tools] run.dlang.io - Share your code Snippets - Understand D Lang In this lesson I show you a useful tool for working with and learning the D programming language - run.dlang.io! This is a handy way first and foremost to share you snippets -- whether you've just done something cool, or have something you need help with, it can be a great way to share your executable code on a forum or chat. The other neat thing is that run.dlang.io makes it easy to see what's going on within the D compilers (i.e. assembly output or lowering of code). While you can do things like this with the compiler, I think it's sometimes nice to quickly have the view side by side of your code snippets.\n\n►...

74. [Dlang Episode 72] D Language - [tools] dfmt - automatically format your code In this lesson I show you a useful tool for formatting your code automatically -- dfmt! This tool can be useful for working in a team, or otherwise running automatically before you check your code into a source repository. You can disable dfmt with '\/\/ dfmt off' and '\/\/ dfmt on' comment blocks if you do need a specific style of code.\n\n►...

75. [Dlang Episode 73] D Language - Functions - Part 16 of n - scope parameters In this lesson I show you a function parameter that can help you write safer code -- that is 'scope'. The scope qualifier for function parameters ensures that for reference types it is not possible to have a function indirectly (e.g. a return or a global variable) have the functions lifetime be extended. The current escape analysis runs on 'safe' code, and is a feature of dip1000. Make sure to use the -dip1000 flag.\n\n►...

76. [Dlang Episode 74] D Language - Functions - Part 17 of n - return scope parameters In this lesson we continue with showing another safety feature with 'scope' as a function parameter -- that is 'return scope'. This allows you to allow escapes through the return type. Make sure to use the -dip1000 flag.\n\n►...

77. [Dlang Episode 75] D Language - Functions - Part 18 of n - ‘in’, function parameters In this lesson we discuss a newer feature of the D programming language which is a function parameter qualifier for 'in'. In effectively makes the parameter 'const scope' which means that it is not open to modification, and should not escape (in safe code). You may need to use the '-preview=in' flag depending on which version of the D language you are using. In general, I recommend using the 'in' qualifier for parameters that are not meant to be modified.\n\n►...

78. [Dlang Episode 76] D Language - Functions - Part 19 of n - ‘out’, function parameters In this lesson we learn about the 'out' parameter qualifier for function paramaters. The 'out' parameter is not used in all other programming languages, but you may have stumbled upon it. In D, the 'out' parameter effectively makes the parameter a 'ref' parameter, with one slight modification. The modification is that any incoming variable will be set to its default value (i.e. the .init value). \n\n►...

79. [Dlang Episode 77] D Language - Functions - Part 20 of n - ‘inout’ parameters In this lesson we learn about the 'inout' parameter which is a way to save you time and make sure your 'constness' of the functions (whether mutable, const, or immutable) is matched. This can be very useful for library writers in terms of providing various functions and providing the correct return type value.\n\n►...

80. [Dlang Episode 78] D Language - Functions - Part 21 of n - lazy versus eager evaluation of arguments In this lesson we talk about getting lazy! Well, lazy evaluation that is. Lazy evaluation is a technique to avoid 'eager' evaluation which is what we typically do. You have seen short-circuit evaluation which is one form of avoiding 'eager evaluation', and thus saving us cpu cycles. We'll find that lazy evaluation hides effectively behind a delegate, and it can also be useful for memoization. Lazy evaluation is a common technique in functional programming languages -- another wonderful feature of D is the support of multiple programming paradigms.\n\n►...

81. [Dlang Episode 79] D Language - Memoization (std.functional) In this lesson I show you the built-in std.functional feature for memoizing a function. This is a really neat way that works best with pure functions. The idea is, if we have a function that generates the same output with the same set of inputs, we can store that value in a hash table. Memoization is a powerful technique in computer science for otherwise trading some space for potentially large speed ups.\n\n►...

82. [Dlang Episode 80] D Language - map -- thinking functionally (std.algorithm) In this lesson I show you the Phobos standard library function for map found in std.algorithm. 'map' is found in many functional programming languages, and is quite frequently used in DLang when you want to evaluate and potentially save the result of operations applied to elements in a container. Map also can be somewhat trivially parallelized in some libraries, so it is a nice and clear construct for what is going on. It is frequently used with 'filter' and 'reduce' as well.\n\n►...

83. [Dlang Episode 81] D Language - filter (and filterBidirectional) (std.algorithm) In this lesson I show you the Phobos standard library function for filter (and filterBidirectional) found in std.algorithm. 'filter' is found in many functional programming languages, and is quite frequently used in DLang want to process data. You can additonally 'chain' together ranges and filter data from infinite ranges. Filter also allows you to 'save' your results as needed with the .array functionality.\n\n►...

84. [Dlang Episode 82] D Language - reduce (std.algorithm) In this lesson I show you the Phobos standard library function for reduce (and the equivalent fold briefly) found in std.algorithm. 'reduce' is found in many functional programming languages, and is quite frequently used in DLang want to process and creating one final value from a container. \n\n►...

85. [Dlang Episode 83] D Language - Generic Programming In this lesson I introduce to you the idea of generic programming. We'll soon be talking about templates, but it's important to first understand the basic ideas of generics.\n\n►...

86. [Dlang Episode 84] D Language - Template Code Blocks - Part 1 of n - Generic Programming Basics In this lesson I will introduce the idea of a 'template block' -- which is a bit more powerful than specifying per function\/class\/struct the template parameters. The idea is to understand that all the template parameter is doing, is a textual substitution of the generated code per unique template instantiation.\n\n►...

87. [Dlang Episode 85] D Language - Function Templates - Part 2 of n - Generic Programming In this lesson I will introduce function templates. Function templates allow us to reuse functions with different types. The D language uses ()'s before our paramter list and the the '!' for instantiating each function template. D is smart enough to 'deduce' using implicit function template instantiation (IFTI) in many cases the data types to further save us from writing out all the details (in fact, this is what writeln very frequently does for us!)\n\n►...

88. [Dlang Episode 86] D Language - Templates - Part 3 of n - value parameters, and alias and typeof In this lesson I we will continue discussing templates, but revisiting some previous concepts. I will introduce the idea of a 'value parameter' (i.e. a 'string') that can be evaluated at compile-time and then templated. We'll then look at arrays as a template type, and also using the 'typeof' operation to deduce the type for us as a template argument. Finally, we'll look at using 'alias' that is useful for defining a common instantiation of a template.\n\n►...

89. [Dlang Episode 87] D Language - Templates - Part 4 of n - Struct Templates In this lesson I we will continue discussing templates, this time showing you how to work with 'structs'. Templates really shine when creating data structures or records that you can use with different types. Later we'll get into cool stuff with 'template mixins', but for now the basics of setting up a struct with a template is very similar to a function. Similar tools also exist for using 'alias' for common types.\n\n►...

90. [Dlang Episode 88] D Language - Templates - Part 5 of n - Variadic Templates (i.e. Seq Parameters) In this lesson I show you how to use variadic templates. Variadic templates are a powerful tool for doing computation at compile-time. Variadic templates pragmatically are also the mechanism that allows you to specify any number of arguments without having to define many variations of the same templated user defined type or function. In this lesson, I'll also provide a little bit of a sneak peek into some compile-time features of the D language that work quite nicely with templates.\n\n►...

91. [Dlang Episode 89] D Language - Compile-Time Programming - Part 1 of n In this lesson I introduce an awesome capability of the D programming language, which is compile-time programming -- or otherwise the ability to evaluate code at compile-time. In this introduction I show you a simple example of how you can sort an array at compile-time from the homepage, and a pragma for retrieving information at compile-time (similar to writeln). We'll dive more into compile-time programming in the future, but it's an awesome capability in which D will try to evaluate as much as possible at compile-time to save the user time!\n\n►...

92. [Dlang Episode 90] D Language - Compile-Time Programming - Part 2 of n - String Mixins In this lesson I introduce the idea of a mixin -- specifically a 'string mixin'. This is a simple but powerful feature of the D programming language, which can be used with compile-time programming and the idea of generating code. A string mixin is nothing more than a literal 'string' that is known at compile-time that is valid D code. What makes this interesting is when you either import strings, or otherwise compose functions to generate code. String mixins are a powerful feature combined with templates to get the compiler working for you. In this lesson I'll also show you a little trick with the '-mixed' flag to help debug mixins. \n\n►...

93. [Dlang Episode 91] D Language - Templates - Part 6 of n - Template Mixins In this lesson I introduce the idea of a 'template mixin' a powerful feature that combines what we have learned about in regards to both templates and mixins. Templates in D are parameterized code blocks that generate blocks of code at compile-time based on which are used. Combine that with the idea of a mixin, which allows us to mixin templated code 'as a string', and we get a really powerful feature. I've seen folks use this for things like serialization and deserialization, and we'll take a basic look at writing a 'getter' function for a struct as a template mixin. Let me know otherwise if you have found some pragmatic uses of this powerful feature.\n\n►...

94. [Dlang Episode 92] D Language - Compile-Time Programming - Part 3 of n - Variadic Template structs In this lesson I show you how to make use of several of the topics that we have been discussing in regards to compile-time programming. We'll take the idea of a variadic template and apply it to a struct using mixins to generate a struct at compile-time. This is again a very powerful idea, and will lead us into understanding how the AliasSeq concept (shown in the next lesson) enables variadic templats and powerful compile-time sequence programming. As always, share your use cases and cool examples for how you use these tools!\n\n►...

95. [Dlang Episode 93] D Language - Compile-Time Programming - Part 4 of n - AliasSeq and aliasSeqOf In this lesson I introduce the idea of a compile-time sequence -- often known as a compile-time tuple or otherwise named as an AliasSeq in the language (among many other names). The AliasSeq is a fundamental building block for working with data that is generated or otherwise will be iterated through at compile-time. It can also be very useful to use with the std.traits library for introspection of types. We'll also see another building block 'aliasSeqOf' which returns an AliasSeq from iterable types (i.e. something that you can usually put in a 'foreach' loop). As always, share your interesting use cases with the community in the discussion below!\n\n►...

96. [Dlang Episode 94] D Language - Templates - Part 7 of n - Template Constraints In this lesson I show you the idea of a template constraint (known as a concept in C++) that allows you to constrain what functions, structs, classes (or anything in a template block really) get generated. This is a really powerful way to provide other overloads or versions of functions that execute. We'll get another preview of the 'traits' feature and std.traits library as well which is useful for template constraints. Note that traits provide 'compile-time reflection' in the D programming language. As always, share your interesting use cases with the community in the discussion below!\n\n►...

97. [Dlang Episode 95] D Language - ‘is’ expression (is keyword) In this lesson I show a new keyword that we have not yet highlighted -- 'is'. IsExpressions can be very useful for checking if two of the underlying types are equivalent, if the type is implicitly convertible, if the type is a subtype, and otherwise for deducing template arguments. It's important to note that 'is expressions' are evaluated at compile-time -- though we can do a 'writeln(var1 is var2)` check at run-time. In this lesson I'll also try to showcase how 'is' can be combined with 'template constraints' which we otherwise looked at in the previous video. As always, share your interesting use cases with the community in the discussion below!\n\n►...

98. [Dlang Episode 96] D Language - Typedef and TypedefType - Type Constructors In this lesson I show how to use the 'TypeDef' type constructor from the std.typecons library. This can be a more secure way to work with types that have the same underlying value, but otherwise you may be trying to prevent an error. For things like conversions (e.g. currencies) this can be especially useful, and you could probably build on top of this feature for things like 'units'. As always, share your interesting use cases with the community in the discussion below!\n\n►...

99. [Dlang Episode 97] D Language - assert In this lesson I show you how to use assert expressions. 'asserts' are a key tool for testing the correctness of your program. However, asserts are really tools for developers as a 'contract' to ensure that during development time, things that most always be true are indeed true. We should use asserts liberally to test our programs, then we can use 'release' and '-check=assert=off' to remove asserts when deploying to clients. As a best practice, asserts should not contain state changes, but only test a true or false condition of the state of a program at a given time. We'll later look at how asserts and 'static asserts' at compile-time can also be used. As always, share your interesting use cases with the community in the discussion below!\n\n►...

100. [Dlang Episode 98] D Language - static assert - catch errors at compile-time In this lesson I show you how to use asserts, but this time at compile time with 'static assert'. 'static asserts' are yet another key tool for enforcing a 'contract' of how our program executes, but this time at compile-time. These are again tools for the developers who are compiling software to try to catch pesky bugs or situations for any computation at compile-time -- the best time to catch a bug! As always, share your interesting use cases with the community in the discussion below!\n\n►...

101. [Dlang Episode 99] D Language - version (for conditional compilation) In this lesson I show you how we do conditional compilation in the D programming language. If you're coming from a C background, then you're probably use to using the preprocessor with #if\/#define\/#endif and other related ideas. D does not have a preprocessor, because it can compute so much at compile-time, and often this ends up making the language much cleaner. So in this lesson I introduce 'version' which can be used to control conditional compilation, whether for specific features or platforms. I'll show a few examples, and one real world use case where I use this in my code. As always, share your interesting use cases with the community in the discussion below!\n\n►...

0. [C++ Quick Start Part 1\/4] Quick First Time C++ Introduction to iostream and vector in 23 minutes This is a quick introduction to C++, and showing two important libraries, and providing some functions that I have found useful for folks to know about.\n\n►...

1. [C++ Quick Start Part 2\/4] Classes and Compiling multiple files (program structure) in 25 minutes This is a quick introduction to C++ in which I show you how to create a class, and how to structure your project to have a separate file for your classes implementation(.cpp) and interface(.hpp file).\n\n►...

2. [C++ Quick Start Part 3\/4] Read, write, and parse files(fstream, string, & stringstream) in 31 min. This is a quick introduction bringing data into your C++ programs as well as writing out data to your C++ programs. I also spend a little bit of time on parsing the data that you read in your programs using stringstream.\n\n►...

3. [C++ Quick Start Part 4\/4] References, Pointers, and Dynamic Memory Allocation in 30 minutes This is a quick introduction to understanding how references, pointers, and dynamic memory allocation work in C++. I will first show you what a 'reference type' is, which allows you to access another location in memory by an alias. References are convenient and the preferred way to work in C++. Then I will show you a more generic structure known as a pointer, which allows us to 'store memory locations' in a variable. We can dereference pointers to retrieve a pointer to retrieve the value that is pointed to. Finally, the new and delete (delete[]) operators allow us to request memory at run-time. We use a pointer to point to the start of the allocated memory.\n\n►...

0. [Not a VLOG 1] Game Developers Conference 2022 - Short Highlights Reel Fun video I put together from my experience at the Game Developers Conference 2022. In part, the video is practice for capturing some clips, working on cut, transitions, and flow. Editing time was quite a bit (probably 3 to 4 hours) for one clip, so it would have been worth it to storyboard a bit more, as I only had a vague idea in my head as to what I wanted to put out (I also did not want to record any sessions beyond a few photographs, as I was trying to pay attention to the actual talks :) ). \n\nAs for the conference, it was a great experience for me. I would recommend folks attend conferences in their domain of expertise in order to continue learning as much as possible. At the very least, it's motivating to be around other motivated folks.\n\nMusic from the Youtube Audio Library: Stasis by Track Tribe.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. [Not a VLOG 2] SIGGRAPH 2022 - #shorts Highlights Reel A highlight reel of some of the experience hall and expo hall technologies shown off at SIGGRAPH 2022, the Special Interest Group on Computer Graphics. Editing probably took close to 10 hours for this 1 minute clip, so enjoy! As always, I have a vague idea for a storyboard, and then the music drives a lot of the cuts. Technical sessions unfortunately cannot be recorded, so you'll have to find those elsewhere. As always, I recommend that folks attend conferences to learn the latest and greatest.\n\nMusic from the Youtube Audio Library: Glass - Anno Domini Beats\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. [Not a VLOG 3] 2022 YouTube Wrap up A wrap up of the year of 2022, with some highlights at the end of some of the videos and playlists created.\n\nMusic from the YouTube Audio Library: Lightning Bugs - Geographer\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. [Not a VLOG 4] Corecpp visit 2023 A fun and brief recap of Corecpp 2023 with a few highlights in short form. #shorts \n\nMusic from the YouTube Audio Library: Anno Domini Beats - Better\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. [Not a VLOG 5] SIGGRAPH 2023 - Computer Graphics Pioneers Some inspiration from pioneers in the computer graphics field at SIGGRAPH 2023 in Los Angeles. #shorts \n\nMusic by: David Cardona\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. [Not a VLOG 6] SIGGRAPH 2023 - 50th Year Highlights A few clips of SIGGRAPH 2023 in Los Angeles in the exhibition, electronic theater, and more! #shorts \n\nMusic by: Anno Domini Beats - Pray\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. [Not a VLOG 7] Dlang - DConf 2023 - D Language Conference A few clips of from the recent DConf in London in 2023.\n\nMusic by: Anno Domini Beats - Skylines\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. [Not a VLOG 7] 2023 YouTube Wrap up A wrap up of the year of 2023, with some highlights at the end of some of the videos and playlists created. Thank you for your support through the year -- more to come!\n\nMusic from the YouTube Audio Library: Lightning Bugs - Geographer\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. [Developer Tools] Introduction to tmux In this lesson I show you 80% of all of what you will need with a tool like tmux to split your terminal. This lesson is ideal for beginners and folks working on unix-based systems or terminals where you want to increase your productivity.\n\n00:00 Introduction and motivating question\n00:40 Installation of tmux and manual page\n1:30 Starting tmux\n2:00 Issuing commands with ctrl+b\n2:35 Navigating window panes with ctrl+b and then arrowkeys\n3:04 Splitting window with \" for a horizontal split\n3:24 Percent sign for a vertical split\n4:50 [ (left bracket) to scroll through a pane, and then q to quit\n5:50 Resizing panes with ctrl+b and then ctrl+arrowkey direction\n6:20 Ctrl+b and then alt+number to set a nice layout (tiled view is alt+5 )\n7:50 Viewing different layouts\/sessions with 'w'\n8:30 Creating a new session in command mode (ctrl+b then ':', then 'new')\n9:40 Revisiting a previous session\n10:05 Conclusion and wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. C, C++, obj-c Intellisense and autocomplete setup in Vim (Coc, ccls, bear, compile commands) **READ Below** and watch the video for some notes.\n\nI struggled to get something to work for a long time (without using CMake or an IDE), so I hope this will help you folks!\n\nThe main tools you'll need are Coc, ccls, and Bear to complete this lesson.\n=========================== Coc =======================\nRepo: https:\/\/github.com\/neoclide\/coc.nvim\n\nYou can follow the general directions provided in the repository. Make sure that you have version 8.1 or later for vim (test with vim --version)\n\nI use Vim-plug (https:\/\/github.com\/junegunn\/vim-plug) to install this plugin.\n\nThen follow the guide on the CoC github for setting up your .vimrc, and then installing clangd, and also setting up the CocConfig.\n=========================== ccls =======================\nHere's a note on install 'ccls' tool: https:\/\/snapcraft.io\/install\/ccls\/ubuntu\nYou could otherwise build it from source following: https:\/\/github.com\/MaskRay\/ccls\n\nHere is the 'CocConfig' I used.\n{ \n\"languageserver\": {\n \"ccls\": {\n \"command\": \"ccls\",\n \"args\": [\"--log-file=\/tmp\/ccls.log\", \"-v=1\"],\n \"filetypes\": [\"c\", \"cc\", \"cpp\", \"c++\", \"objc\", \"objcpp\"],\n \"rootPatterns\": [\".ccls\", \"compile_commands.json\"],\n \"initializationOptions\": { \n \"cache\": {\n \"directory\": \"\/tmp\/ccls\"\n },\n \"client\": {\n \"snippetSupport\": true\n }\n }\n }\n },\n \"clangd.path\": \"~\/.config\/coc\/extensions\/coc-clangd-data\/install\/14.0.0\/clangd_14.0.0\/bin\/clangd\"\n}\n\n=========================== Bear ============================\nRepository: https:\/\/github.com\/rizsotto\/Bear\/blob\/master\/INSTALL.md\n\nIt's possible you may have to update your default g++ when compiling bear to a modern version.\n\nHere's an example of updating your g++ to a later version (First do: sudo apt-get install g++-10)\nsudo update-alternatives --install \/usr\/bin\/g++ g++ \/usr\/bin\/g++-10 10\nSee this article for more: https:\/\/linuxconfig.org\/how-to-switch-between-multiple-gcc-and-g-compiler-versions-on-ubuntu-20-04-lts-focal-fossa\n\nOne other additional dependency I was missing was libssl (I already had openssl, but you'll need to the developer libraries): sudo apt-get install libssl-dev\n\n\n00:00 Introduction and motivating question\n00:57 Lack of a good C language intellisense in VIM\n1:44 Conquer of Completion VIM plugin\n2:30 Setting up our vimrc using vim plug\n4:53 vimrc for Conquer of Completion (Coc tool)\n6:03 diagnostics of errors\n6:33 Setting up extensions for C++ (clang diagnostics)\n9:42 Installing the Code completion engine for C (ccls)\n10:30 language server setup (:CocConfig)\n11:00 snap install for ccls\n12:32 Compilation Database explanation\n13:00 First attempt installing and running bear\n14:50 Building 'bear' from source to get latest version\n17:05 CMake with bear\n20:00 Running bear to generate a compile_commands.json\n21:05 Successful compilation databse\n21:44 Successful intellisense\n23:40 Recap of what we did\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. First Day learning the C Programming Language - Crash Course in C Programming In this series of lessons I provide you with a crash course in the C programming language. I will introduce the language to you from your very first program, and then introduce you to the other features of the C language. One of the benefits of the C language, is that it is relatively small, and a majority of the language and syntax can be learned from this series of lessons.\n\n00:00 Introduction\n1:00 Hello World Example\n4:17 Understanding the compilation process\n8:56 Variables (Primitive variable types)\n14:17 Arrays (Fixed-size arrays)\n18:52 For Loops \n22:17 While Loops\n24:00 Handling Bugs (Tips and bug fixes)\n26:45 Block Scope (Variable lifetime)\n29:33 Functions (Declaration and definition)\n36:50 Recursion \n39:35 Assert (and being careful with data types)\n42:33 Condition Statements (if, else, elseif)\n45:25 Reading user input with scanf\n47:00 address of (& operator)\n51:21 Pointers (Creating pointer and dereferencing)\n58:33 Malloc and Free (Dynamic Memory Allocation)\n1:05:44 Pass by value Semantics in C\n1:11:00 C-Strings and String Literals\n1:18:25 structs (user-defined composite data types)\n1:28:48 Linked List\n1:36:18 Conclusion\n\n►...

1. Your Second Day in C (Understand .h header and .c source files) - Crash Course in C Programming In this series of lessons I provide you with a crash course in the C programming language. In this lesson I will show you the difference between a .h file, and a .c file. This will lead us into a small discussion and demonstration of how to structure a C project. We'll also be reviewing several of the topics from the first video in the playlist linked above.\n\n00:00 Introduction\n00:40 Discussion of header versus implementation files\n3:40 Creating a main.c file.\n4:00 The vector struct that we are creating.\n5:20 The header and implementation for our math library\n7:00 Sketching a vector 'Add' function.\n8:45 Including files is a copy and paste by the preprocessor\n10:20 Header Guards discussion and usage\n11:40 Implementing the functions in our header file in our .c file.\n12:40 Refactoring our 'Add' Function\n15:00 const parameters\n15:57 Using our Math Library\n17:00 Different ways to include files\n20:25 Successfully running our program.\n20:53 Review of what we have done.\n24:14 Review of compiling multiple files in C\n26:00 Conclusion and wrap up\n\n►...

2. Your Third Day in C (Understanding stack and heap memory) - Crash Course in C Programming In this series of lessons I provide you with a crash course in the C programming language. In this lesson I will discuss the difference between stack (short lived and automatically reclaimed memory) and heap memory (long lived, larger allocations, and memory that you have to manually manage with malloc\/free).\n\n00:00 Introduction\n1:15 Understanding working memory (RAM)\n4:55 Reviewing block scope and local variables\n9:00 Stack based memory allocation (i.e. automatically managed memory)\n12:30 Stack operations push and pop\n14:25 The stack frame (How memory gets allocated on the stack during a function call)\n19:00 Heap Memory - For long-lived memory\n20:40 malloc function reminder\n22:26 void* - A generic pointer (This is what malloc returns)\n24:00 malloc example for allocating memory on heap (and free, to free memory)\n27:30 Allocating memory on the heap in a separate function\n30:10 Observing heap and stack memory are in different locations\n31:45 Summary of what we have done\n32:39 Wrap up part\n33:30 Conclusion\n\n►...

3. Your Fourth Day in C (Building a Linked List Data Structure) - Crash Course in C Programming In this series of lessons I provide you with a crash course in the C programming language. In this lesson I will show you how to create a data structure in the C programming language, the linked list!\n\n00:00 Introduction\n00:50 Introducing the Singly Linked List\n4:40 Linked List program structure\n5:56 Building node_t\n6:54 Creating the linkedlist_t struct\n8:44 Functions to utilize with the linked list data structure.\n12:14 Adding in header guards\n13:13 Starting the implementation in linkedlist.c\n14:16 CreateLinkedList() implementation\n15:30 AppendToLinkedList implementation\n26:02 PrintLinkedList implementation\n27:40 Bug fixes \n30:00 Testing our partial implementation in main()\n31:48 CreateLinkedListOfFiveItems() implementation\n35:55 Testing out our CreateLinkedListOfFiveItems() function\n37:00 FreeLinkedList() explanation\n40:11 FreeLinkedList() implementation\n43:52 Testing our FreeLinkedList implementation for memory leaks\n45:16 Uncovering the leaked memory!\n48:33 Creating additional unit tests for our linked list\n50:00 Quick Code Review\n51:10 Conclusion and wrap up\n\n►...

4. Your Fifth Day in C (Understanding C Strings) - Crash Course in C Programming In this series of lessons I provide you with a crash course in the C programming language. In this lesson I will discuss how strings are represented in the C language. In addition, I'll also talk about the difference between a C string and a String literal. Throughout this discussion we will learn about some of the important C library string functions, implement two of them from scratch (strlen and strcat), and then wrap up discussion showing why it is important to have a null terminating byte your C strings.\n\n00:00 Introduction\n00:47 C-strings are an array of characters\n01:58 The Null terminating byte\n3:33 Modifying characters in the C-string (i.e. character array)\n5:40 Exercise: Writing a string length function\n8:20 The strlen function in string.h\n9:30 'const' in C\n10:58 size_t datatype in C\n12:35 Working with a dynamically allocated string with malloc (i.e. char*)\n14:55 String Literals in C\n16:30 C puts in the null terminator for string literals\n17:03 String literals are read-only\n21:52 Exercise: Writing a string append function\n31:57 Bug fixes and a refresher on pass-by-value\n34:55 A working ''StringAppend'' function demo\n35:34 Comparing our StringAppend with strcat in C Standard Library\\\n36:36 Refactoring our StringAppend\n40:05 Simplifying our StringAppend with realloc\n44:45 Improving our StringAppend performance with memcpy\n47:20 What happens without the Null Byte?\n50:20 Review on temporary, stack allocated memory\n52:03 Wrap up and Conclusion\n\n►...

5. Your Sixth Day in C (main function arguments and char**) - Crash Course in C Programming In this series of lessons I provide you with a crash course in the C programming language. In this lesson I will discuss how the arguments to the main function are used. For most of this series, the examples have not used any arguments--but it can be incredibly valuable to be able to take a series of arguments as inputs into how our program executes (e.g. file paths to configuration settings, flags for how the program executes, etc.). In this lesson, I'll also describe in a little bit more detail, how the char** works. This is our first time seeing a pointer to pointers (i.e. an array of pointers).\n\n00:00 Introduction\n00:20 The main function\n1:40 Program arguments for main\n4:18 argc - the argument count\n5:50 argv - vector of strings (i.e. variable amount of arguments as strings)\n7:03 Array of Strings (char**) - A pointer to char*'s\n12:42 Converting strings to long int with strtol\n15:29 Add program of any number of arguments.\n19:12 The real power, is the ability to control program behavior and\/or compose programs\n20:25 Conclusion\n\n►...

6. Your Seventh Day in C (Pointer are not arrays, and 2D arrays) - Crash Course in C Programming In this series of lessons I provide you with a crash course in the C programming language. In this lesson I will discuss that arrays and pointers are truly different types in C. A pointer however can act like an array in different concepts, and I will demonstrate how that works, and when an array decays into a pointer. Half way through the lesson, I will show how to build a simple array_t type that retains size information. Finally, I will finish the lesson showing multi-dimensional arrays (2D arrays shown) in C. I will discuss how a multi-dimensional array is structured, and how to access an array with two dimensions, using 1D array math.\n\n00:00 Introduction\n00:50 Review on arrays\n3:07 Simple 1D array example\n4:20 Computing the size of a stack allocated array\n6:00 Assigning a pointer to an array\n8:48 Computing the size of our pointer\n10:50 Writing a function with an array parameter\n12:55 Array parameter decays to pointer\n16:18 Passing 'size' information with arrays in functions\n17:00 Passing a struct with 'size' information with an 'array_t' data structure\n23:00 Two dimensional array introduction\n28:20 2D arrays are still contiguous blocks of memory\n30:00 Defining the 'pitch' of an array\n31:25 Printing a 2D array using 1D array conversion\n36:50 Allocating a 2D array on the heap\n39:30 Conclusion and wrap up\n\n►...

7. Your Eighth Day in C (Function Pointers Part 1) - Crash Course in C Programming In this series of lessons I provide an introduction to function pointers in the C language. The main thing that you need to know, is that functions in the C programming language have addresses. Because functions have addresses, we can store those addresses in pointers. Our ability to reassign a function pointer, then allows us to write 'more dynamic' programs that can change their behavior at run-time, by reassigning a pointer.\n\n00:00 Introduction\n00:58 Seeing where a function is stored in assembly\n2:36 Seeing where a function is stored using objdump\n4:00 Using address of operator (&) to see address of function\n4:29 Defining a function pointer\n6:22 Example of creating and using a function pointer\n9:38 Changing what a function pointer points to\n11:00 Understanding visually how to define a function pointer\n12:10 A more convincing example to show off function pointer usage\n15:55 Wrap up and conclusion\n\n►...

8. Your Ninth Day in C (Object Oriented Programming in C) - Crash Course in C Programming In this lessons I show you how you would program in an 'object-oriented' style in the C programming language. C as a general purpose language allows you to build 'language' features from scratch if you need them, or otherwise understand the programming paradigm. I think this lesson will show more of an appreciation of other languages, and otherwise understanding how language features are built from scratch can help give you more command over the language.\n\n00:00 Introduction and code walk definition\n1:20 Observing array_t data structure\n2:20 The self and function pointers in array_t\n3:15 Get and Set function and passing in struct as a pointer\n5:12 The constructor or 'factory function' for creating array_t\n7:30 Setting up our function pointers\n9:20 Destructors to destroy our array_t\n10:44 Using our array_t\n12:40 A quick review again of array_t\n14:24 The equivalent C++ code\n20:01 Conclusion\n\n►...

9. Your Tenth Day in C (Bit shifting and bit fields) - Crash Course in C Programming In this lessons I show you some bit manipulation techniques in C. I first will show you the left and right shift operators as a technique for multiplying and dividing. It also turns out that if you are multiplying and dividing by two, this can be a simpler instruction and quick optimization in your code. Once you know how to bit shift, you can also compacting move information inside of data type as well, so I will also show you how we can pack information into a pixel.\n\nIn the next part of the lesson, I show you how to create a bit field, and why it is more efficient than using data types in a struct. This can again be another large optimization for saving space.\n\nOne thing NOT discussed in the video however, is when to make these kinds of optimizations and use these tricks. It's probably worth noting that you should only optimize when you know you need more performance--at least when you are first learning how to program. That said, now you know these techniques exist!\n\n00:00 Introduction\n00:40 Bit shifting introduction \n2:42 Bit shifting (left shift) example code for multiplication\n4:18 right shift operation for division\n6:00 Packing data into an integer\n15:18 Bit fields motivating example\n18:05 Experimenting with struct sizes\n23:49 Conclusion\n\n►...

10. Your Eleventh Day in C (Unions in C) - Crash Course in C Programming In this lessons I show you how to use a 'union' in the C programming language. At this point in the series, we'll have covered most of the major language C programming features that a C programmer would see in most C texts. Unions are not intuitive at first, because it is weird to see how a collection of bytes can be treated differently (sort of like casting, but unions provide more information into 'what types can we treat these bytes as'). \n\nI'll start this example showing how a union works with a simple example. Then I'll show where unions are used in the real world. Finally, unions can often be used as a way to 'address' bytes in different ways which I'll show as an example at the end.\n\n00:00 Introduction\n00:40 Definition of Unions and difference from structs\n2:35 First example of a union\n6:40 Understanding behavior of unions \n9:45 Example of unions used in SDL2\n11:12 matrix_t example with a union\n19:54 Wrap up\n\n►...

11. Your Twelfth Day in C (Floating Point Comparison) - Crash Course in C Programming In this lessons I show one of the key problems in programming, regardless of programming language--floating point comparison error! Unfortunately, computers cannot represent every possible number, so floating point (whether single or double precision) provides a close enough approximation for most use cases. However, some numbers (e.g. 1\/3) or after a series of mathematical operations (i.e. lots of multiplications of floating point numbers) may cause imprecision to accrue. In order to deal with this, we often use an epsilon value to approximate if two floating point numbers are equal when performing a comparison.\n\n00:00 Introduction\n00:31 Demonstration of floating point precision\n2:06 Floating point comparison error with == operator\n3:52 Trying to add more precision with a double\n4:50 Using 'fabs' and an epsilon value to check for equality\n7:30 Wrap up\n\n►...

12. Your Thirteenth Day in C (enums and switch statements) - Crash Course in C Programming In this lessons I show you how to use 'enum' which is a way to create a new datatype of related values. The values themselves are signed integers by default, and in C there is nothing otherwise special about them. That said, your compiler (or other tools) can help you by using the enum information in switch statements. In addition, using enums can make your code more readable by grouping related items together.\n\n00:00 Introduction\n00:23 Motivation and creation of an enum\n2:10 Understanding enum values\n4:22 Using enums in switch statements\n6:13 Enabling warnings with -Wall\n8:47 Reviewing some limitations of enums in C versus C++\n10:30 Wrap up\n\n►...

13. Your Fourteenth Day in C - static (with bonus usage of objdump) - Crash Course in C Programming In this lessons I show you how to use the 'static' keyword in the C programming language. The 'static' variable has to deal with the lifetime of a variable, and ultimately the storage of the variable in memory in the binary. I'll show you also how to find your static variables using the objdump tool (on linux)\n\n00:00 Introduction\n00:26 Pop quiz on local (stack) variables\n2:21 Introduction to static\n4:30 Scope of static variables\n5:45 Understanding where static variables live with objdump\n8:44 Wrap up\n\n►...

14. Your Fifteenth Day in C - void* pointers (void* to function pointer) - Crash Course in C Programming In this lesson I show you how to use the void* pointer in C. void* is a very powerful feature that allows us to do generic programming. With void* we have to use extra caution however, to make sure we dereference to the proper type that we point to however. In this lesson I also show you how to point to function pointers as well, and then call the function. This is very useful in more 'event-driven' applications, or otherwise if you'd want to write a function that can take any type of function as a parameter for example. Finally, I'll show you that you have been using void* all along in malloc.\n\n00:00 introduction\n00:24 Pointer review\n1:40 void* (Generic Pointer introduced)\n3:12 void* to variable\n5:15 void* to a void function with no arguments\n9:00 void* to a function with a return value\n10:20 void* to a function with a return value and arguments\n11:50 malloc as an example returning void*\n12:45 Conclusion\n\n►...

15. [Day 16] - Static and Dynamic Libraries (ar, objdump, ld, ldd) - Crash Course in C Programming In this lesson I show you how to create both static and shared libraries on linux. Static and shared libraries are both ways to allow for code reuse, and another way to break large projects into smaller more manageable pieces. Using libraries can also have advantages in our build systems, by allowing for separate compilation for instance.\n\n00:00 introduction\n00:50 ldd tool usage\n2:28 Physical structure of project\n3:12 Header guards\n5:08 The include directory (-I)\n6:30 Building individual .o object files as static library\n10:10 Creating two .o files.\n11:50 Compiling with two .o files\n12:18 The advantage of separate compilation of our .o files\n13:55 The archive (ar) tool.\n17:00 The advantage and use case of shared object (.so) files\n18:10 Building a shared library with position independent code\n20:30 Understanding include and linking errors (undefined reference)\n22:48 Understanding format of how to link libraries with -l (lowercase L)\n25:40 LD_LIBRARY_PATH to utilize our shared libraries\n27:40 Summary\n31:26 dlopen preview\n32:11 Conclusion\n\n►...

16. [Day 17] - pointer arithmetic (addition and subtraction) (and a warning with sizeof!) In this lesson I show you how to use pointer arithmetic in the C language. In fact, we have already been using it quite a bit when accessing information in arrays. I'll show you that when we use arithmetic, we are actually offsetting the number of bytes of the underlying type. In addition, I'll show you subtraction (hah!), and something to be a little careful of as well with the memory allocator.\n\n00:00 introduction\n00:36 Setup and explanation of array memory layout\n2:22 Brackets dereference, and the offset is the pointer arithmetic.\n5:35 Using sizeof to find our types size\n7:00 Experimenting with sizeof -- just size of stack variable!\n11:06 Pointer subtraction to show you allocation boundary\n16:20 Conclusion\n\n►...

17. [Day 18] - memset, memcpy, strcpy, memmove In this lesson I show you how to use some of the most common functions found in the string.h library regarding memory. In C we often think in terms of blocks of memory or bytes of memory, so these operations can allow you to manipulate your data at a very low level.\n\n00:00 Introduction\n00:22 Why I suspect memory operations are in string.h\n1:22 Test program overview\n4:04 memset example (with an array)\n7:20 memset example to zero initialize a struct\n8:47 memset visualization on drawing board\n11:08 memcpy introduction\n11:50 memcpy visualization\n12:46 memcpy example - creating a copy\n14:23 memcpy example - copying to smaller region of memory\n16:51 strcpy introduction and comparison with memcpy\n18:02 strcpy example\n18:52 memcpy example with a struct\n21:14 memmove demonstration and visual\n22:12 memmove code example\n24:49 Conclusion\n\n►...

18. [Day 19] - calloc, realloc, and alloca In this lesson we are going to be learning about three more useful memory allocation functions in the GNU C Library: calloc, realloc, and alloca. calloc is a function that is very similar to malloc, the difference is that it is going to zero initialize the memory. Note that with calloc, the calling interface is slightly different from malloc so that each element can be zero initialized. Next we'll look at realloc, which is a useful function for resizing already allocated data into a larger or smaller sized chunk of memory. Finally we'll talk about alloca, which is a special purpose allocator for managing memory on the stack. alloca will reclaim memory automatically for us outside of the block scope however, so it's quite fast if we otherwise have a small enough allocation that can fit on the stack (see limit and ulimit -a for example)\n\n00:00 Introduction\n00:30 calloc man page\n01:43 calloc example\n05:00 realloc visual explanation\n09:15 realloc code example\n10:35 alloca \n11:00 limit and ulimit -a to find stacksize\n11:58 alloca example\n15:51 Conclusion\n\n►...

19. [Day 20] - structs and unions (anonymous structs and unions with C11) In this lesson I am going to show you how to use a combination of unions and structs together. We'll make use of a feature known as an anonymous struct (and we also have anonymous unions as a feature available in C11 compilers) to help add context to our data structures. This can be a really useful way to work with data structures and show their intent.\n\n00:00 Introduction\n00:44 vec2_t example and review of union\n03:32 Depending on how we use type, use different fields to add context.\n04:40 Code example\n8:47 Conclusion\n\n►...

20. [Day 21] - C Compiler Optimization Fundamentals (and brief performance experiment) In this lesson we are going to discuss compiler optimizations and what the compiler can do for you. This \nis a relatively deep subject, and I want to merely expose you to a few popular compiler optimizations tha\nt most compilers support. It's also useful to know about compiler optimizations and how they effect the '\ndebugability' of your code when they are on. Finally, I'll do a very brief performance experiment, though\n this is probably best served with an actual profiler to see where we spend time in our code.\n\n00:00 Introduction\n00:50 Optimization levels\n04:44 Example optimizations \n05:10 Function Inlining\n07:30 Constant Folding\n08:09 Dead Code Elimination\n08:34 Compiler Explorer i.e. Godbolt.org\n12:40 Loop Unrolling\n16:20 Strength Reduction\n18:00 Brief Performance Experiment with 'time'\n24:13 Conclusion\n\n►...

21. [Day 22] - Typedef (An alias for a new type) In this lesson we revisit the 'typedef' keyword that has showed up a few times in our series. typedef is a way for us to create an alias for new types, so we'll see how that can simplify and potentially make our code easier to use (and is a better tool than say define)\n\n00:00 Introduction\n00:50 typedef introduction\n01:52 Example with define and preprocessor\n04:00 typedef usage for a new alias of data type\n05:40 dangerous example with define for substituting a type\n08:20 Using typedef for pointer types\n9:59 typedef with structs\n13:24 typedef with function pointers\n16:04 typedef with struct revisited\n17:30 Review of lesson\n18:45 Conclusion\n\n►...

22. [Day 23] - Fixed width types and bool in C In this lesson we look at fixed-width types in the C programming standard library, which allows us to use types that have a gaureenteed minimum number of bytes to support a range of values stored in the type. The reality is, an 'int' can be different sizes on different architectures otherwise. Later on in this lesson, I'll also show you that along with the fixed-width types, there is also a 'bool' type in stdbool.h so we can have 'true' and 'false' in C.\n\n00:00 Introduction\n00:40 Discovering the different sizes of 'int'\n02:00 Programmatically finding sizeof 'int' on our architecture\n03:18 Finding the limits (range) of different ints\n04:05 stdint.h for fixed-width integers\n07:00 stdbool.h for 'bool' type\n09:10 Conclusion\n\n►...

0. [New Camera Upgrades] Quick Comparison for my 2022 videos (Sony ZV-1 versus Logitech Brio 4k) **See in the description below some of the actual equipment**\n\n**Answers to which camera is which is in the description**\n\nOn the 'left' side of the video is using the webcam. On the right side is using the Sony ZV-1. I'm using a Magewell capture card (shown below) to send the output of the camera from my Sony ZV-1. It's **IMPORTANT** to note that the magewell capture card is what worked on my linux machine (The Elgato camlink I sort of got to work, but not at full resolution).\n\nIf folks want a full tour of my setup, perhaps that can be done in the future! Here is otherwise the main pieces of equipment I am using.\n\nAmazon Affiliate Links to equipment:\n1. Logitech Brio 4K Webcam: https:\/\/amzn.to\/3Ftx7nO\n2. Sony ZV-1: https:\/\/amzn.to\/3GzCrXK\n3. Magewell Capture Card: https:\/\/amzn.to\/3I2G49k (Works on Linux, Windows, and Mac)\n4. Elgato Cam Link: https:\/\/amzn.to\/3fiuPNG (Works on Windows and Mac, and sort of works on Linux if you want to really hack around)\n5. Blue Yeti USB Microphone: https:\/\/amzn.to\/3ngjxhd\n6. Elgato Stream Deck: https:\/\/amzn.to\/3Fm1igu\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. [Mike's Advice] Should you build your dream projects from scratch or leverage preexisting tools? In this video I provide a few thoughts on the trade offs of building software from scratch or using other tools. The type of software I am talking about, is usually a 'dream project', that project that first got you into programming.\n\nMy general advice is to just go ahead and try it--don't worry about the failure. More often than not, folks will discourage you from building your dream project--but you have to go through that process yourself to figure out what steps you''ll need to learn that project. So more pragmatically, I think you'll learn something by trying to build the software from scratch.\n\nThat said, plenty can be learned by looking at other preexisting tools that exist. You'll see how that software is structured, what the API looks like, and hopefully get some insights into what your next steps would be in learning, if you were to revisit that project and build it from scratch.\n\nAnyways, I hope this is helpful or provides some inspiration to go for it!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. [Mike's Advice] The Five Programming [Languages\/Paradigms\/Styles] You Should Explore In this video I provide a few thoughts on which programming language you should learn. You will quickly observe that the specific language actually does not matter--the important part is using the right tool for the right job. Often you'll want to identify the right 'paradigm' to solve the problem in. That said, I'll toss a few programming languages that I think are useful to learn, or at least have been useful to me in my career so far.\n\n- Scripting languages (Python, Ruby, Lua, Bash, etc.) for example offer a quick way to prototype (whether to sketch out an idea, or perhaps to use to your advantage by shipping software more quickly). \n- Systems languages (C, C++, DLang, Rust, Go, Zig, Swift, etc.) offer the ability to access different layers of the hardware, or otherwise focus on optimizations. \n- Web languages (HTML\/CSS,) offer the ability to layout information that internet browsers can interpret and execute. And you'll often need a frontend language (e.g. JavaScript) and a backend language (of which you can use almost anything) to complete a 'web 2.0' style website. I also toss in SQL as something programmers should learn, and then they can choose another database language for their needs.\n- Functional languages (OCaml, Kotlin, Scala, ML, Haskell, Scheme, Lisp) allow you to often most elegantly solve the actual problem you are trying to solve without additional noise in the syntax.\n- And finally the last language is up to you to learn and master. Think of this as your 'fun' language that you would program in if you had no choice. Sometimes that language is determined by your domain, and sometimes this is just a language you enjoy mastering.\n\nAnyways, I hope this was a fun video, and for beginners you are getting exposure to lots of other languages. You'll learn and use many different languages and paradigms in your career!\n\n00:00 Introduction\n2:05 Scripting Language\n3:09 Systems Programming Language\n5:05 Web Programming Language\n7:07 Functional Programming Language\n8:48 Your choice of a programming language!\n9:40 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. [Mike's Advice] (To Students) Breaking into the Game Industry, building your portfolio In this video I provide some of my advice that I like to give to undergraduate and graduate students on breaking into the industry. Often times, folks are not sure where to start in this competitive industry. The reality is, building a portfolio and having projects to showcase to employers can give you an edge (You'll also learn a ton doing it -- again that's the point -- learn and make games!).\n\nAs always, take my advice as one opinion, and hopefully it will help many of you break into the game industry! Here's a link to the GDC Vault powerpoint I showcased: https:\/\/www.gdcvault.com\/play\/1024411\/Get-Noticed-Get-Hired-Upgrading\n\nAdditional links:\n- https:\/\/www.gamedevmap.com\/\n- https:\/\/www.unrealengine.com\/en-US\/students\n- https:\/\/unity.com\/learn\n- https:\/\/github.com\/turanszkij\/WickedEngine\n\n00:00 Introduction on breaking into the Game Industry\n2:21 Building a Resume (finding a template)\n3:33 Building a Portfolio\n4:27 Analyzing other portfolios to learn how to build a portfolio\n11:00 What to write in your portfolio\n12:22 Building a webpage - Getting Started\n14:57 Having a GitHub presence\n16:52 Immersing yourself in the game development community\n18:40 Learning Resources for Unreal and Unity\n20:20 Game Jams\n21:40 Taking more courses\n22:20 Game Industry Events\n24:40 Closing Thoughts and where to find jobs\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. [Mike's Advice] On finding a career path - TRUST your gut In this video I provide some of my advice on finding a career path for you. There is no one path, but I hope to provide a few pragmatic steps you can take for otherwise finding some inspiration on a career path for you. As always, take my advice as one opinion, and hopefully it will help many of you.\n\n00:00 Introduction and Question\n01:10 Follow your gut and write things down\n03:50 Build projects on the side\n05:15 Pragmatically, have some savings\n06:11 Where to find vision and inspiration\n07:10 Think two or three years ahead.\n08:10 Don't underestimate how much you can learn in a year\n08:59 Throw a few darts on the dart board.\n10:10 Summary and thank you\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. [Mike's Advice] Negotiating Salary (Software Engineers) In this video I provide some of my advice on negotiating salaries as you navigate some of your first software engineering roles. Note: One other thing that I forgot to add was to negotiate for relocation expenses if that is not already included -- it's common, but make sure to ask if you are moving for the job!\n\n00:00 Introduction\n00:40 Base Salary\n01:30 Levels as a tool for finding salary range\n03:28 Salary Increase Calculator\n06:24 Internship and Co-op Salary Range\n07:42 Negotiating on Bonus\n09:10 Stock Options (Public companies and startups)\n13:40 Negotiate based on how much leverage you have.\n14:28 Less Common things to negotiate for\n17:40 Conclusion and wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. [Mike’s Advice] Breadth versus Depth - When Studying Computer Science In this video I provide some of my advice on how to approach whether to favor a breadth of study versus a depth of study. The reality is, you'll build your foundations first, and then do a deep dive into a few specific areas in your career. \n\n00:00 Introduction\n00:45 Start with Fundamentals First\n02:35 Teach Yourself CS Resource\n03:20 Start exploring after your foundational courses\n05:20 Start a deep dive, working on a difficult problem over time\n10:30 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. [Mike's Advice] Acquiring your First Software Internship In this video I provide some of my pragmatic advice about preparing for your first software engineering internship\n\n00:00 Introduction\n00:35 Proofreading and setting up your resume\n03:20 Career Fairs\/Job Expos\n05:40 Applying Early\n08:20 Building Projects\n10:00 Applying to lots of companies\n12:10 Practice\n13:22 Review and Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. [Mike's Advice] Tips on Being a Successful Software Engineering (SWE) Intern In this video I provide some of my pragmatic advice about what to do after you have earned an internship and have started working.\n\n00:00 Introduction\n00:30 Show up on time\n01:52 Schedule a 1 on 1\n03:11 Try to see things from managements views\n04:10 Shadow other engineers and interns\n05:22 Level up your skills\n06:10 Be social, join your team for lunch\n06:54 Join in on the internship or local activities\n08:00 Write a thank you note if you had a good experience\n08:42 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

8. [Mike's Advice] Should you do an accelerated bachelors\/masters (Plus 1) program (SWE Focus) In this video I talk about accelerated masters program in which (at least in the United States) you can complete a masters degree in 1 year after you bachelors (most often at the same university). There are some pros and cons to consider, but overall I hope this brings you some awareness to think about this as an option!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

9. [Mike's Advice] Academic Advice to High Schoolers preparing for college (from a Professor) In this video I provide a few thoughts on college selection and things to be thinking about if your in the high school and thinking about starting your university path.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

10. [Mike's Advice] What Software Project Should I Build? In this video I answer a common question I get about what are some good projects to try. In general, find something you are interested in, or perhaps recreate something that you are familiar with. I generally encourage folks to 'remove friction' when it comes to thinking, so you can get into practicing your engineering. Here's the link to Austin Henley's original post: https:\/\/austinhenley.com\/blog\/challengingprojects.html\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

11. [Mike's Advice] Hackathon and Game Jam Advice In this video I I provide a little bit of advice when it comes to hackathons -- in short -- do them! They're a great way to get started and pushing yourself to take that first step to developing a project. After you do a few hackathons however, I recommend you think about being intentional\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

12. [Mike's Advice] Balance, School Clubs, and Do Not Underestimate Yourself! In this video I reflect back on a few pragmatic things that I tried to do in my college career related to balancing myself out. This involved being involved in a mix of academic and non-academic activities, trying to attend useful events, and making sure to reflect on my own personal growth.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

13. [Mike's Advice] Note Taking for Programmers In this video I provide a response to a user on a few pieces of advice to students and other practitioners learning how to program on note taking. Note: In the thumbnail, this is a bit of an Easter Egg -- in that John Carmack famously would writer in his home directory at id software various notes that folks could see -- that is another example of a frictionless system! The screenshot and the plan files are from https:\/\/github.com\/oliverbenns\/john-carmack-plan\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

14. [Mike's Advice] How to Choose that First Job (SWE) -- a few thoughts In this video I provide a few thoughts based on conversations I've had with recent graduates trying to decide between which job offer to take (or otherwise, which career path to pursue when interviewing). The point is to think carefully about your offers, try to choose something that puts you on a future that you are excited about, and try to choose a path that helps you grow.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

15. How to Improve your Github Readme [Mike's Advice] In this video I provide a few thoughts on how to improve your github readme page. Now I fully understand not all projects are meant for consumption, but in the instance that you want to draw in collaborators, or get more 'stars' or 'favorites' on a public code repository -- this applies to you! Some sample repositories can be found here in the video: \n\nhttps:\/\/github.com\/horde3d\/Horde3D\nhttps:\/\/github.com\/panda3d\/panda3d\nhttps:\/\/github.com\/redagito\/NeoELF\nhttps:\/\/github.com\/turanszkij\/WickedEngine\nhttps:\/\/github.com\/craflin\/libnstd\nhttps:\/\/github.com\/gnunn1\/tilix\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. [Episode 1] Learning OpenGL - Modern OpenGL Welcome to a brand new series on the OpenGL API! In this series, we will be learning OpenGL from a beginners point of view and implementing examples in the C++ programming language. I look forward to working with you in this series, make sure to like the video to show your support, and subscribe so you don't miss any new videos!\n\n►...

1. [Episode 2] What is OpenGL (The Specification and Some History) - Modern OpenGL In this lesson I discuss some of the history of OpenGL, and also try to accurately describe OpenGL as a 'specification'. It's important for folks to know this information so that you can understand what purpose OpenGL serves, and who the stakeholders are.\n\n►...

2. [Episode 3] A Short OpenGL History Lesson - Modern OpenGL In this lesson I discuss more of the history of OpenGL with the emphasis on learning 'Modern' OpenGL.\n\n►...

3. [Episode 4] [Theory] The Programmable Graphics Pipeline (Interview Question) - Modern OpenGL In this lesson I discuss at a high level the graphics pipeline-- the journey of a vertex from 3D data to your 2D screen--as I'd like to say! This lesson is intended to be a high level overview to help you understand that geometry passes through multiple stages of a pipeline on your GPU. Some of the terminology on this video is going to be new, but that's okay, as we will continue later on in the series to deeper content.\n\n►...

4. [Episode 5] [Code] Setup SDL2 and OpenGL and first OpenGL function (glGetString) - Modern OpenGL In this lesson I show you step by step how to create an SDL2 window, setup an opengl context, and ultimately call your first OpenGL function. This is a longer lesson, but should be useful in helping you put together all the information you need to get started with OpenGL programming.\n\n►...

5. [Episode 6] [Theory] Triangles, Vertex Array Object (VAO) and Vertex Buffer Objects - Modern OpenGL In this lesson I am going to answer the question of 'why triangles'. Then I'm going to move on to talk about some of the 'OpenGL' objects that are used to program in OpenGL -- Vertex Array Objects (VAOs) and Vertex Buffer Objects (VBOs). It can be a little confusing at first, but taking the time now to understand these objects will help make sense of when we actually start writing code.\n\n►...

6. [Episode 7] [Theory] How Shaders are used in the pipeline - Modern OpenGL In this lesson I take a moment to talk about what happens after we specify vertices in our graphics pipeline-- the next step is to build the graphics pipeline, which includes the vertex and fragment shaders. Vertex shaders execute once per vertex, and fragment shaders execute once per fragment.\n\n►...

7. [Episode 8] [Help] Docs.gl, the Spec, and the OpenGL man pages - Modern OpenGL In this lesson I provide a few helpful tools to have by your side while programming in OpenGL -- documentation! In particular I appreciate docs.gl, because it is very searchable.\n\n►...

8. [Episode 9] [Code] First OpenGL Triangle - Modern OpenGL In this lesson I continue our code from episode 5, and add the OpenGL code for our vertex specification (a vertex array object and vertex buffer object), and then also add functions for compiling our shaders. Additionally, I'll start setting up the OpenGL state needed for our graphics scene, and we'll issue our first draw call (glDrawArrays) that activates our graphics pipeline.\n\n►...

9. [Episode 10] [Code Review] First OpenGL Triangle - Modern OpenGL In this lesson I review our code from episode 9. I've added a few lines of code for error logging, and additional comments so you can further understand the actual code. This should be a nice checkpoint to determine if you should proceed further in the series, or go back and review the prior video materials.\n\n►...

10. [Episode 11] OpenGL Objects, Context (through Mesa), and State Machine - Modern OpenGL In this lesson I help you understand the 'C-based' nature. We'll then look at the Mesa source code which is an actual implementation of OpenGL to better understand how OpenGL is structured. Finally, there is a wonderful demo at webgl fundamentals (search webgl fundamentals state diagram) that can walk you through how OpenGL is working.\n\n►...

11. [Episode 12] Loading a Shader from a File (Improve workflow on shader code) - Modern OpenGL In this lesson we are going to write some code to load our shaders from a file instead of embedding them as strings in our program. This has the advantage of allowing us to not have to recompile our C++ code if we are only making changes to the glsl code (Because the glsl itself will be compiled at run-time).\n\n►...

12. [Episode 13] Drawing a colored triangle (using multiple vertex buffer objects) - Modern OpenGL In this lesson I show you how to use multiple vertex buffer objects (VBOs) to add color to your triangles. We will be modifying our vertex specification to now store position and color information in order to make this change. In this lesson you will also see me use the 'layout' specifier in the glsl shaders for the first time.\n\n►...

13. [Episode 14] Drawing a colored triangle (using single vertex buffer object) - Modern OpenGL In this lesson we'll revisit our previous lesson, but this time we will only use one vertex buffer object in order to add color into our scenes. Their are some pros and cons that would have to be empirically measured with having multiple buffers (anecdotally one buffer may perform better), so it is good to know both strategies, and understand also how our attribute pointers work in this lesson.\n\n►...

14. [Episode 15] Rendering a Quad (And Understanding Winding Order) - Modern OpenGL In this lesson we learn how to draw a quad by adding an additional set of vertices to our vertex buffer object. Something important we also learn about is the 'winding order' of the vertices. That is, the order that we lay out the vertices, such that the front face is known to us, so it can be visible.\n\n►...

15. [Episode 16] Rendering a Quad Again! (More efficient Indexed-Buffer Strategy) - Modern OpenGL In this lesson we again return to our quad, but this time we use an index buffer object to more efficiently reuse vertex buffer object data. The index buffer (or sometimes called element buffer) allows us to use an array of unsigned integers to access three vertices at a time (assuming we render with GL_TRIANGLES). In this lesson I'll also show you some mistakes to be careful of as well when rendering. Note, we will be using glDrawElements, which is another new command for drawing using the index buffer (as opposed to glDrawArrays).\n\n►...

16. [Episode 17] glError - Debug errors in OpenGL State Machine - Modern OpenGL In this lesson I show you a quick way to debug your OpenGL applications when there is an error. Usually you only know when an error occurs when 'nothing shows up' on the window. But in this lesson, I will give you the tool available on all version of OpenGL - glGetError() for detecting errors in the OpenGL state machine.\n\n►...

17. [Episode 18] OpenGL Math - Introduction to the GLM Library - Modern OpenGL In this lesson I show you how to install the GLM library for mathematics. We'll look at how to get setup, and I'll show you how to explore the documentation, make a few mistakes, and how to fix them along the way. We'll look at a more advanced look at the library, and how to use the swizzling feature as well.\n\n►...

18. [Episode 19] OpenGL Math 1 - Vectors, Dot Product, and Cross Product (with code demonstration) In this lesson I will be showing you with GLM some of the fundamental math primitives (vectors, dot product, and cross product) that we are going to need to proceed further in this series. I'll show you the glm mathematics library for how to use the mathematics as we learn them.\n\n00:00 Introduction and recap\n1:06 Cartesian coordinate system\n1:53 vec3 as a point\n2:37 vec3 as a vector - with magnitude and direction\n5:00 vector length (i.e. magnitude)\n9:33 unit vectors\n13:16 vector addition and subtraction\n14:15 vectors equivalence\n15:02 Vector dot product (how similar are two vectors)\n16:40 Demonstration of dot product with light\n18:05 Dot Product code example\n19:15 Normalizing Dot Product and retrieving angle\n25:50 Cross Product\n32:09 Lesson Summary\n33:16 Conclusion\n\n►...

19. [Episode 20] OpenGL Math 2 - Matrix Transformations (with GLM code demonstration) - Modern OpenGL In this lesson I continue to show you a little bit more of how to use the glm mathematics library by showing you 4 of the special matrices we use in computer graphics: identity, scale, translation, and rotation (which has 3 versions). I'll also provide a little bit of intuition as to why we need a 4x4 matrix due to the use of the 'w' coordinate. If you can remember w=1 when working with points, that will be useful, and w=0 for working with vectors, that will get you quite far. Eventually you'll want to derive these matrices yourself as an exercise, but hopefully the intuition after this lesson is there.\n\n00:00 Introduction and recap\n1:21 Representing a point in 3D with glm::vec4\n3:00 The 'w' coordinate\n4:55 Vectors have a '0' for w. points have w=1\n6:30 Creating a 'model' matrix to transform from local to world space.\n7:55 What is a matrix\n11:20 Reading a matrix\n12:20 Scale, translation, and rotation matrix references\n13:49 First code example -- scaling using glm::scale\n16:04 Trick for printing out matrices neatly\n17:20 model * vertex (transforming a vertex to world space)\n18:40 glm::rotate example\n21:57 glm::translate example\n23:20 Applying multiple transformations (right-to-left) - ORDER MATTERS!\n26:44 Review of what we covered\n27:35 Conclusion\n\n►...

20. [Episode 21] OpenGL - Putting it all together (SDL2+glad+glm) - Modern OpenGL In this lesson I show you how to link in the glm library to our previous graphics infrastructure. You now will have all of the components that you need to start doing exciting work in OpenGL.\n\n00:00 Introduction\n00:47 project structure overview\n1:30 moving glm into a 'common' folder\n2:19 Compiling our project\n2:52 Updating the compiler Include path to include glm\n5:04 Testing out glm compilation\n5:50 Code Review and Review on whiteboard of all the components of our application\n10:45 Conclusion\n\n►...

21. [Episode 22] OpenGL - glsl uniform variables (Second mechanism to send data to GPU) In this lesson I show you the second mechanism for transferring data to the GPU from the CPU -- uniform variables. The value stored in the uniform variable is shared at all stages of the pipeline (i.e. vertex and fragment shader if we have two shaders in our pipeline), and the value cannot be modified in the GPU code. Every frame we can otherwise query for the uniform variable (or at least one time if our shader does not change), and then update the value that we want to set in GPU memory.\n\n00:00 Introduction\n00:30 Review of Vertex Buffer Object (VBO)\n1:35 Review of 'locations' and 'layout' of VBO\n2:40 Uniform variable introduction\n3:36 Creating a uniform in vertex and fragment shader\n4:20 prefixing variable with 'u' for style\n5:30 Offsetting vertex (u_Offset)\n6:30 Creating a 'cpu' variable for offset (g_uOffset)\n8:54 Adding interaction with g_uOffset using SDL Keyboard\n10:23 Setting the value of a variable using 'glUniform'\n11:58 'glGetUniformLocation' to retrieve location of variable we want to set.\n12:38 Understanding 'uniforms' in graphics pipeline\n15:54 When querying uniform name, the textual name must match exactly (case and spelling)\n18:18 Error checking when retrieving uniform variable\n19:29 Setting the uniform value on the GPU (vert.glsl) from our CPU (.cpp) code\n21:18 Working example!\n22:00 Recap of what we did and using uniform in our fragment shader\n24:28 Wrap up and some additional things you can do with uniforms\n\n►...

22. [Episode 23] From Local to World Space (Model Matrix Transformation) In this lesson we look at translating our object again, but instead of modifying directly the vertices in the vertex shader, we are going to do so by modifying the object by passing in a special transformation matrix -- specifically a translation matrix. By multiplying in this translation matrix, we are transforming the vertices from 'local space' into 'world space'. (And the inverse of the worldspace matrix would put us back into local space -- i.e. our original vertex x,y,z positoins in the vertex buffer object).\n\n00:00 Introduction\n00:26 Review of code and compilation\n03:00 Local and world Coordinates\n4:36 Model Matrix Setup\n6:12 glm::translate in the matrix_transform header\n08:15 Setting up glUniform to pass a 4x4 matrix.\n10:18 Fixing a spelling error\n10:57 Fixing an error in our fragment shader with undefined uniform variable\n12:18 Using our Model Matrix in our vertex shader (and one subtle bug)\n13:40 Casting a vec3 to a vec4\n15:51 A working model matrix transformation\n16:25 Review and Conclusion\n\n►...

23. [Episode 24] Projection Matrix and glm::perspective In this lesson we fix a problem where we could not properly move our object in the 'z' direction. We certainly could try, but we would not be able to get a correct perspective projection in our code example. In order to properly render, we need to multiply each of our vertices by a 'projection matrix' (specifically a perspective one in this lesson) in order to 'squish' our 3D positions into the appropriate place on a 2D screen to give the illusion of 3D.\n\n00:00 Introduction\n00:30 The problem -- no perspective projection\n00:57 Blender3D perspective versus orthographic projections\n01:59 perspective projection example with railroad tracks\n02:56 Perspective Projection Matrix\n03:48 glm library perspective matrix\n04:48 lack of perspective in our code.\n05:28 Adding perspective matrix uniform\n09:47 Fixing a few errors\n11:20 Program compiles, but not quite working perspective\n13:06 Adding in the 'w' component for correct perspective divide.\n14:20 Review on our transformation spaces\n15:44 Code Review and quick refactor on naming\n18:10 Conclusion\n\n►...

24. [Intermission] OpenGL and ChatGPT #shorts Fun little #short here as an intermission in our OpenGL series. Enjoy!\n\n►...

25. [OpenGL Episode 25] Rotation Matrices (using glm) In this lesson we look at some of the special transformation matrices that allow us to 'rotate' geometry. We are rotating each vertex, in each dimension by a vector (i.e. one of the columns in the 4x4 matrix) in order to transform it to its final spot.\n\n00:00 Introduction\n00:42 Review on graphics pipeline\n02:12 Rotation matrices and special transformations\n03:59 How to read a 4x4 matrix as columns for y-axis rotation\n05:37 glm API Documentation for rotate\n06:54 Quick code review for where to apply our rotation\n09:22 Performing the rotation\n16:48 Conclusion\n\n►...

26. [OpenGL Episode 26] Scaling Matrices (glm::scale) In this lesson we look at another special transformation matrices effectively multiples each of the vertices x,y, and z points along an axis. In doing this, we can uniformly (or non-uniformly) scale our objects to be larger or smaller.\n\n00:00 Introduction\n00:35 Scaling Transformation \n04:22 GLM Documentation (glm::scale)\n05:07 Adding in a scale transformation\n08:42 Conclusion\n\n►...

27. [OpenGL Episode 27] Matrix Transformation Order Matters (Think Concatenation) In this lesson we put together a series of transformations to understand an important lesson -- order matters! We want to think about matrix multiply as concatenation, as opposed to a commutative (e.g. addition) operation. I'll show you how you can compose rotation and translation in different orders to create different effects in this example.\n\n00:00 Introduction\n00:045 Recap of Transformations and an experiment on transformation order\n04:00 Recap of code\n05:10 Order of Operations Experiment\n10:22 Think of Matrix operations as concatenation\n11:11 Wrap up and conclusion\n\n►...

28. [OpenGL Episode 28] [Theory] Gimbal Lock In this lesson I introduce you briefly to the idea of 'gimbal' lock. This is the idea that we lose a degree of freedom (i.e. an axis that we can rotate about) when two axis line up. A solution is to add another axis (e.g. using a different system, like quaternions, which we then convert to a 4x4 matrix).\n\n00:00 Introduction\n00:34 Gimbal Lock\n3:24 Wrap up and conclusion\n\n►...

29. [OpenGL Episode 29] Quick Fix and Quick Recap In this lesson I do a quick little fix to our support code, and brief recap (since it's been a little while), before we move onto adding the next view matrix.\n\n00:00 Introduction\n00:20 Recap of transformations (order matters)\n01:24 Code Review\n03:28 Vertex Array Object Review\n05:14 Bug fix, removing the rebind to VBO -- already done in VAO\n05:55 Recap of Input and transformations with uniforms\n08:14 Review of Vertex shader and connection with uniforms (and some common errors)\n10:10 perspective review\n11:42 Conclusion\n\n►...

30. OpenGL [Episode 30] [Theory] The View Matrix In this lesson I discuss the view matrix and what its purpose is in OpenGL for creating a 'virtual camera'. I also introduce the idea of the 'lookAt' function in glm that will help us use the eye, center (or view direction), and upVector to create our camera matrix.\n\n00:00 Introduction\n3:24 Wrap up and conclusion\n\n►...

31. OpenGL [Episode 31] Building The View Matrix with glm::lookat (and moving forward and backwards) In this lesson we introduce a small abstraction for creating a camera using glm's lookAt matrix. We then implement the ability to move forward and backwards in our camera. I leave you at a cliff hanger to think about how to otherwise implement first person camera.\n\n►...

32. OpenGL [Episode 32] Camera -- first person mouse look In this lesson I introduce the ability to do a proper first person camera where you can use the camera to rotate to the left and right. We'll thus update our viewDirection correctly, and be able to move forward and backwards based on our current view direction.\n\n►...

33. OpenGL [Episode 33] Camera -- first-person movement with right vector In this lesson I show you the ability to move left and move right properly with the updated view direction. This is useful when you are performing movement in a first person camera, but also generally shows one nice use case of the cross product.\n\n►...

34. OpenGL [Episode 34] GL_FLOAT enum vs GLfloat type bug fix In this lesson I show go back and do a few bug fixes on our original code, as I had made a mistake with the GLenum versus the OpenGL type. We tend to use the OpenGL types because on the platform they will be set to the right number of bytes. On occasion, we get lucky that the 'enum size' (which is an integer) matches the type, and we'll want to correct those bugs to be 100% certain our code works. Finally we'll add the ability to 'escape' from SDL with the escape key, just as a little quality of life improvement. As always, feel free to join the discussion!\n\n►...

0. C++ Video Series Introduction | Modern Cpp Series Ep. 1 Welcome to this series on Modern C++ programming. I hope you are excited to learn with me in this series. In this series, I take you on a comprehensive look a the C++ programming language, including the most basic features, to the more advanced features of the language.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. C++ Workflow in a Compiled Language | Modern Cpp Series Ep. 2 In this lesson I want to bring to attention to programmers coming from scripting languages (e.g. Javascript, Python, Ruby, etc.) the idea of compilation. We'll talk more in-depth in the future about this, but it's important that you know that every time we make a change to our source code, we need to rebuild our application (i.e. compile to machine code), before executing our program to observe the changes made.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. [Setup Video] Linux Setting up C++ | Modern Cpp Series Ep. 3 In this lesson I am going to teach you how to get the g++ (and the directions are the same for clang++) compiler. I recommend going through your package manager if you're just getting started.\n\nFor those extra curious, here's a related video on how to build gcc from scratch: https:\/\/www.youtube.com\/watch?v=QfPpT0O9m2k&list=PLvv0ScY6vfd9OxOzvroGivi0Q_0UtFzk1&index=1\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. [Setup Video] Setting up C++ on Mac (Shown on Apple M1) | Modern Cpp Series Ep. 4 In this lesson I show you how to setup clang++ on the command line for C++ development on my Apple Mac with M1 processor. Note the instructions will work on Intel-based Macs as well.\n\nI also go a little further and show you how to obtain g++ on brew if you'd prefer that as an option, or perhaps if you prefer using IDEs, I'll show you how to quickly compile a 'hello world' application within XCode.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. [Setup Video] Visual Studio Setup for C++ | Modern Cpp Series Ep. 5 In this lesson I show you how to get setup with Microsoft Visual Studio full Integrated Development Environment (IDE). I'll show you how to create a project from scratch, and how to run some C++ code so you can continue learning. I'll then take a little dive into some of the 'project settings' so you can control how your C++ projects are built. Finally, at the end, I'll show you how you can also debug your programs.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. Hello World in C++ | Modern Cpp Series Ep. 6 In this example I teach you about how to write your first C++ program--the infamous 'hello world' example. I'll show you how to get the standard library setup, and then how to use the 'cout' objects. The cout object allows you to write text to the standard output (which is usually your terminal or console window).\n\nOne technicality in this video that I'll address later on, is that \"hello world!' is really type which is -- \"const char*\", but if you're coming from another language we can just think of this as a 'string'.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. [Advice] Making mistakes, make small changes when learning | Modern Cpp Series Ep. 7 In this lesson I provide just a few key pieces of advice and some programming habits that I've tried to reinforce within myself over my programming career, especially when learning something new!\n\nSome key pieces of advice are shared in this video.\n1.) Start fixing errors from the first error or warning from the quote.\n2.) Make small changes to your code, save, recompile, and then run your program.\n3.) Treat warnings as errors with -Werror compiler flag\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. [Info] A quick tour of the different versions of C++ | Modern Cpp Series Ep. 8 In this lesson I clarify a bit what 'modern c++' means. What is important to understand is that C++ is a language (just like a spoken language) evolve over time with new features--and this is a good thing!\n\nA good way to see the features of iterations of the c++ language is to take a look at the cppreference website.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

8. [Info\/Advice] C++ Websites to help you while learning | Modern Cpp Series Ep. 9 In this lesson I show you two key websites for supplementing C++. I like cplusplus.com for the tutorial to help folks get started quickly, and the reference is pretty good for providing quick examples. The more definitive reference (cppreference) is something that we are going to grow into. cppreference tends to have the most up to date and is much more technical in the documentation (and more accurate than other websites I have seen). A cool feature of cppreference is also the ability to execute some of the examples in the browser.\n\nAs a bonus, the isocpp website also has great current event news, book releases, conference information, and more.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

9. C++ Primitive Data Types | Modern Cpp Series Ep. 10 In this lesson I introduce some of the C++ primitive types that are built in to the language. I also distinguish between std::string (which is not built into the language), but is otherwise included in the C++ Standard Library--which we'll talk about soon enough!\n\nAnother important feature of this lesson is to learn about the 'sizeof' operator, which tells us how big our data is.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

10. const in C++ - The first use | Modern Cpp Series Ep. 11 In this lesson I show you how to make data 'read-only' (a.k.a immutable) by using the 'const' keyword built into the language. 'const' has several uses, but in this use we'll learn that we can make variables values unchangeable during the duration of the program. I'll also tease the idea of 'constexpr' for evaluating expressions at compile-time, and we'll revisit this idea later on.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

11. C++ Block Scope | Modern Cpp Series Ep. 12 In this lesson I teach you that the curly braces {}'s that we are using actually define the 'block scope' of our variables. Utilizing scope helps our machines be more efficient in how they allocate memory, but from a pragmatic perspective they allow us to reuse symbol (i.e. variable) names. In this lesson, you'll also learn that having 'no scope' is what creates a global variable, and they tend to NOT be good for design in our programs.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

12. Raw Arrays and std::array in C++ | Modern Cpp Series Ep. 13 In this lesson I teach you our first data structure in this series, the array! Arrays are very simple but frequently used data structures. They allow us to store a collection of data in a contiguous block of memory. In modern C++ we also have the std::array container, which provides additional power and error-checking mechanisms for our array.\n\nAs a teaser, I also show you how to initialize an array using a loop, as well as with std::iota which lives in the numeric library..\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

13. For-loop, ranged based for-loop, while, do-while, and std::fill | Modern Cpp Series Ep. 14 Loops are our tool to build algorithms and work with data in any programming language! In this lesson I teach you about the different kinds of loops available in the C++ language. I also show you a neat way to initialize arrays (statically initializing the array with a brace-enclosed list, and also using std::fill--which is just a loop!). \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

14. continue and break | Modern cpp Series Ep. 15 In this lesson we introduce two keywords in C++: continue and break. Each of these keywords allows us to control how loops execute in C++. It is likely you may have seen these in other languages, and they should function the same.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

15. Writing Functions in C++ | Modern Cpp Series Ep. 16 In this lesson we learn about how to write a function in C++. I will also provide you some rules about writing functions, making sure that the declaration occurs prior to the use of the function, and that you eventually 'define' the function body somewhere in the source file (or an external source file).\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

16. Recursive Functions in C++ | Modern Cpp Series Ep. 17 In this lesson I show you a recursive function in C++, primarily to show that recursion is allowed in the language. However, there is a limit to the number of recursive calls that can be made. The reason for this limit, is that you only have so much 'stack memory'. Some of the information stored in stack memory, is what is stored in the 'stack frame' of each function call. The call stack thus canot grow too large, and when making recursive calls, we sometimes have to be careful with this.\n\nNote: In the future we will revisit 'stack memory' as a concept beyond the idea of a call stack shown here.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

17. Address of operator & | Modern Cpp Series Ep. 18 In this lesson I teach you about the ampersand (&) operator. The & will retrieve the address of a variable so you can figure out where it lives in memory (though we don't necessarily know if it is from stack or heap without a little bit of further introspection). I often use '&' to help debug and understand which piece of memory (i.e. which variable) I am modifying.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

18. C++ Functions - Understanding Pass by Value Semantics | Modern Cpp Series Ep. 19 In this lesson we talk about how arguments are by default passed into functions in C++ using 'pass by value' semantics. This means that a copy of the value stored in the functions stack frame when the function is called, and the copy will be modified, and then eventually when we leave the functions scope, the 'temporary copy' (that was passed into the argument) will be gone.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

19. References in C++ (Another use of the & symbol) | Modern Cpp Series Ep. 20 In this lesson we learn about what a reference type is in C++. Simply put, a reference is an 'alias' for another named symbol (e.g. a variable) in C++. We will use them most frequently as arguments in functions, though on occassion we will also use them when we talk about classes to return values.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

20. C++ Functions - Understand Pass by Reference (&) Semantics | Modern Cpp Series Ep. 21 In this lesson we take a look at 'pass by reference' semantics which allows us to mutate (i.e. change the value) of a variable, as well as more efficiently pass data around. Pass by reference behind the scenes is using something called a 'pointer', which we will learn about later. Pass by reference tends to be one of the preferred ways to pass data around in functions when we need to share data in a function, as it is efficient, and generally more safe.\n\nNote: You'll observe we are spending more time in 'sys' (i.e. system time) in the video allocating memory for the copies. This becomes even worse if you have multiple programs running at once competing for system resources (i.e. memory allocation)\n\nNote 2: As noted, we tend to not pass by reference primitive variables (e.g. an int) as the performance could be slightly more to pass by reference (which is passing a pointer behind the scenes).\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

21. Functions in C++ with const parameters and why (bonus std::is_const) | Modern Cpp Series Ep. 22 In this lesson we learn about a second use for 'const', and that is qualifying the parameters of our functions. This ensures that data passed into our function cannot be mutated, which is something we may want to protect against when using pass-by-reference, to ensure we can efficiently pass data into a function, without the worry that it will be modified.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

22. What is a pointer, dereferencing, and the point of pointers? | Modern Cpp Series Ep. 23 In this lesson we introduce a data type known as a 'pointer'. Pointers store addresses in C++ to a specific data type (e.g. integer pointer, floating pointer, etc.). In order to retrieve the value from a pointer that is stored at an address, we 'dereference the pointer'.\n\nNote: The asterisk (or sometimes called 'star') is used in many places now.\n\nPointers allow us to refer to the same piece of data, and thus 'share' the values, and while only having one actual update in one place in the program. Pointers will also allow us to build data structures.\n\nLink to a full video on pointers from start to finish: https:\/\/www.youtube.com\/watch?v=2R5cjpi9Fzw&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=7&\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

23. Check Your Understanding: Dereferencing a pointer | Modern Cpp Series Ep. 24 In this lesson I am giving you a quick pop quiz to check your understanding on dereferencing and how pointers work. I also want to provide you a tip for drawing your pointers on paper\/tablet\/computer to help check your understanding. \n\nLink to a full video on pointers from start to finish: https:\/\/www.youtube.com\/watch?v=2R5cjpi9Fzw&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=7&\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

24. Dynamic Memory allocation with new and delete (and delete[]) | Modern Cpp Series Ep. 25 In this lesson we learn about heap memory, and how to allocate memory on the heap with 'new' and 'delete' operators. We need heap memory so that we can acquire resources at run-time, especially if we do not know how much of a resource (i.e. how big of an array to allocate) we need. Additionally, memory that we allocate on the heap is 'long-lived' and lives longer than the block-scope of stack memory.\n\nKeep in mind, this is one of the powers of C++, the ability to manage our memory. That said, we also need to responsibly delete our memory in C++ when we are done with the resource.\n\nLink to a full video on pointers from start to finish: https:\/\/www.youtube.com\/watch?v=2R5cjpi9Fzw&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=7&\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

25. Pointer Arithmetic, Array Offsets, and exposing how brackets dereference | Modern Cpp Series Ep. 26 In this lesson we learn about pointer arthmetic. It's important to understand that when we increment (or decrement) a pointer, we are moving in memory to the address that is the sizeof the pointer type. I demonstrate in this video how to move through an array (which is a contiguous block of memory) to the next item, by offsetting the memory location. Finally, I uncover that the brackets (i.e. []'s ) are actually a shorthand for us as programmers to offset and dereference a particular memory location in an array.\n\nLink to a full video on pointers from start to finish: https:\/\/www.youtube.com\/watch?v=2R5cjpi9Fzw&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=7&\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

26. Misunderstanding the use of sizeof | Modern Cpp Series Ep. 27 In this lesson I provide a bit of a cautionary tale on the misuse I have seen by students, programmers, and myself on the sizeof operator. Sizeof returns the size of a data type, or otherwise the size of a stack allocated array. This can be misleading, as folks often want to use sizeof to tell them 'how many elements' are in a data structure--WHICH IS INCORRECT! Hopefully this video will help save you from making that mistake :)\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

27. Passing arrays into functions(array decay to pointer)- prefer std::vector | Modern Cpp Series Ep. 28 In this lesson I show you what happens when you pass in an array into a function--the array is decayed (i.e. turned into automatically) a pointer. We lose some information about our array (if it was stack allocated) regarding its size when this happens, and often need to pass in another argument for the size. While we have the option of creating a std::array for more power, I further recommend that we instead use a std::vector that can be dynamically sized, and is overall implemented quite well. As always, in your arguments, consider if you can pass by reference and if it is read only, to make it const! Note, we'll later cover 'span' in the series here: https:\/\/youtu.be\/OQu2pZILjDo\n\nProps to the very cool website: https:\/\/cppinsights.io\/ \n\nLink to a full video on pointers from start to finish: https:\/\/www.youtube.com\/watch?v=2R5cjpi9Fzw&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=7&\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

28. Pitfalls of Pointers (and using address sanitizer and gdb to find them) | Modern Cpp Series Ep. 29 In this lesson we look at four of the memory errors that can be caused by pointers: 1. nullptr (dereferencing a nullptr) 2. memory leak (forgetting to delete or delete[] memory) 3. Dangling pointers (accessing memory that is out of scope--usually returned from a function) 4.) Double free (deleting memory twice).\n\nIn this lesson I also show you how to use the address sanitizer as part of the compiling process to help detect these problems. For Linux users, I also show valgrind (pronounced val-grinn, like the name 'Val' and a grine like a smile).\n\nLink to GDB Masterclass: https:\/\/www.youtube.com\/watch?v=MTkDTjdDP3c\nDebugging a Segmentation Fault with GDB and valgrind: https:\/\/www.youtube.com\/watch?v=8JEEYwdrexc\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

29. Function pointers, typedef a function pointer, and std::function | Modern Cpp Series Ep. 30 In this lesson I show how to create a variable that can store a function address--this is called a function pointer. One common use of function pointers is to be used for 'callback' functions that can be reassigned at run-time to change the behavior associated with some object (e.g. in a graphical user interface when you press a button).\n\nLater on in the video I'll show a few easier ways to work with function pointers, including using a 'typedef' (which you'll often see in C codebases), as well as the more modern std::function, which uses a much more forgiving syntax.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

30. lvalue, rvalue, lvalue references and an introd to rvalue references | Modern Cpp Series Ep. 31 In this lesson I am going to talk about something that is not so much a 'language feature' but rather something that is part of the semantics of modern C++. At the least, you should leave this lesson understanding what an 'lvalue' and 'rvalue' error means from your compiler. We'll also talk a bit about lvalue references (which you already know as int&), and then briefly introduce rvalue references. rvalue references will be further motivated, and we'll start to look at why they may be useful for performance in a later video.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

31. Introduction to std::move in C++ | Modern Cpp Series Ep. 32 In this lesson I am going to talk to introduce std::move and the idea of move semantics. Move semantics allows us in modern C++ to transfer ownership (i.e. steal a resource) from one object to another. This allows us to avoid copies when we truly want to transfer a resource. The implications of this, is that we can potentially increase performance, when we want to transfer ownership, and then avoid unnecessary copies. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

32. std::unique_ptr - A scoped smart pointer | Modern Cpp Series Ep. 33 In this lesson I show you how to use a std::unique_ptr. I will show you why we might want to use this smart pointer versus a raw pointer, and how to create this pointer. While we haven't covered classes yet in this series, it's important to realize that this smart pointer is essentially a 'wrapper' around a raw pointer that calls the destructor to free memory when the pointer leaves scope.\n\nNote: Something not covered in this lesson is the idea of a 'custom deleter' which can be useful.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

33. std::shared_ptr - A reference counted smart pointer | Modern Cpp Series Ep. 34 In this lesson I show you how to use a std::shared_ptr. Shared pointers are the second of three types of smart pointers introduced in C++. They are a wrapper around raw pointers, that allow you to ensure that a resource stays alive while an object points to it. The mechanism for this is by using reference counting, and a special 'control block' does the book keeping for your smart pointers. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

34. std::weak_ptr - A non-owning smart pointer | Modern Cpp Series Ep. 35 In this lesson I show you how to use a std::weak_ptr. Weak pointers are probably the most strange of the 3 types of smart pointers introduce in modern C++, in that they work with shared_ptr's. The idea is though, that the reference count is not increased, so that it is possible you can point to memory that has been freed. However, this can help solve some problems relating to simplifying ownership, breaking cycles, or 'more safely' being able to check for 'expired' memory. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

35. Interface (.hpp) versus implementation (.cpp) files (and why they exist) | Modern Cpp Series Ep. 36 In this lesson I discuss the difference between an interface (.h, .hxx, or .hpp) file in c++ versus an implementation file (.cpp or .cxx). Header files (.hpp) give you a high level overview of the programming interface you have in the library. The implementation file (.cpp) however, provides the implementation (i.e. the actual details and algorithms to get work done). \n\nIn this lesson, we also discuss header guards (So you can include files safely), what happens when you include a file too many times (multiple definition error), and the purpose of why we separate our code (make project more easy to manage, and to speed up compilation).\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

36. C++ Classes part 1 - Introduction to C++ class | Modern Cpp Series Ep. 37 In this lesson I introduce the 'class' keyword and some ideas in object-oriented programming. Object oriented programming (OOP) allows us to think and model our software in terms of objects that closely reflect how we often think in the real world. Object oriented programming can also provide benefits such as 'information hiding' that is not available (easily) in other languages like C that do not support by default object oriented programming. \n\nIn this lesson I'll also show you how to create a new user defined type 'Student' and how to separate out the interface from the implementation. We'll discuss the class scope operator (::) so you can understand how member functions get associated with a class when in the implementation file.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

37. C++ Classes part 2 - Default Constructor, default destructor, and more! | Modern Cpp Series Ep. 38 In this lesson I show you that C++ provides a default constructor and a default destructor. Very often we will override the defaults by providing our own. In fact, we can override the default constructors, as well as provide additional constructors that take in any amount of arguments that we like.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

38. Classes part 3 - Copy Constructor, Copy Assignment(Deep and Shallow Copy) | Modern Cpp Series Ep. 39 In this lesson I cover the copy constructor, and copy assignment operator. I start by showing how the compiler gives you these two special functions for classes for free, using the compiler generated ones. Unfortunately, this is not sufficient, as when we have to dynamically allocate memory, the trivial copy can result in problems like double frees or unwanted sharing of data. Next I show you how to avoid making these 'shallow' copies, and write your own copy constructor and copy-assignment operators to perform a deep copy.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

39. Classes part 4 - The Rule of 3 (and the lesser known Law of the Big Two) | Modern Cpp Series Ep. 40 In this lesson I introduce the Rule of 3 (Law of Big Three) and the Law of the Big Two. Often times I see beginners confused as to when they should write a custom constructor, custom destructor, or a copy constructor, and this video will hopefully provide some clarity regarding the Law of Big Three or the Law of the Big Two.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

40. Classes part 5 - Avoiding copies(Delete, copy ctor and pass by ref) | Modern Cpp Series Ep. 41 In this lesson I show you where the copy constructor is called, showing the two most common scenarios. Often times folks forget about where copies are being made with pass by value when using user defined types. This can be very expensive from a performance standpoint, and just because we have recently learned about copy constructors, does not mean we should forget about things like pass-by-reference.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

41. Classes part 6 - Operator overloading | Modern Cpp Series Ep. 42 In this lesson I show how to perform operator overloading in C++ so that you can use your objects with operators like +, -, *, \/ , etc. In fact, you can even use other common operators like the stream operators, brackets, new, and delete. Whether or not you should use operator overloading is a style question, and general guidelines I have heard recommend against using operator overloading for anything other than mathematical types where it makes the code more intuitive. That said, occassionally it is useful to overload somethings like the less than comparison operator for use in std::sort, or the == operator for comparisons.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

42. Classes part 7 - Member Initializer Lists | Modern Cpp Series Ep. 43 In this lesson I show you a feature introduced in C++ 11 for member initializer lists. Using member initializer lists is a way to optimize and clean up your code when constructing your objects. I'll show you an example as well as to why you should pay careful attention to initialize your member variables in the order that they are laid out in memory.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

43. Classes part 8 - Structs in C++ | Modern Cpp Series Ep. 44 In this lesson I explain a common interview question I would get for C++ positions -- what is the difference between a struct and a class? It's probably a good question for you to warm up with, and the difference itself is only one thing related to the default access level of member functions and member variables. \n\nThat said, by convention folks will often use 'structs' to match what they are in C--plain old data types (PODs) that just hold fields. It may be important for you when working as an engineer to observe the convention used in your companies codebase.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

44. Classes part 9 - Resource Acquisition is Initialization (RAII) Ep. 45 In this lesson I discuss an acronym that you might have heard in the C++ world, RAII -- Resource Acquisition is Initialization. This programming concept of RAII is as simple as acquiring resources in the constructor, and releasing any resources that were acquired in the destructor. Understanding that using the lifetime of an object to prevent resource leaks and otherwise handle exceptions is the importance of this concept for writing code that can scale through the lifetime of a project.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

45. Classes part 10 - Rule of Five - Have fun reducing memory allocations! | Modern Cpp Series Ep. 46 In this lesson I discuss the rule of five (otherwise known as the law of 5 or the big 5). I first will recap a simple class data structure recapping the big 3 (constructor, destructor, and copy constructor), and showing where these special member functions are invoked. Then I will remind you of the idea of move semantics (i.e. the transfer of resources from one object to another). When used appropriately, move semantics can save significantly on performance by avoiding copies. Towards the end of the lesson, I will show you how copies are often made, and sometimes unknowingly (like in the case of a vector when it is getting resized as you add elements), and how move semantics can help significantly improve performance by reducing allocations.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

46. Classes part 11 - friend functions (and why you should probably avoid) | Modern Cpp Series Ep. 47 In this lesson I discuss the 'friend' keyword in C++ and why you should probably avoid using it because it breaks encapsulation in C++ classes and structs. The friend keyword allows (in a one-way relationship) functions to access private variables of a class. The friend keyword can also (in a one way relationship) allow classes to access all of the private member variables of another class.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

47. Classes part 12-Explicit ctor and list initialization to avoid conversions| Modern Cpp Series Ep. 48 In this lesson I show you two tips to make your C++ a little bit safer by avoiding conversions. The 'explicit' keyword avoids implicit conversions when constructing single parameter objects. Using curly braces (list initialization) can also be used when instantiating new instances of objects to avoid narrowing conversions of your object.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

48. Classes part 13 - Introduction to Inheritance | Modern Cpp Series Ep. 49 In this lesson I introduce you to a powerful idea in Object oriented programming--inheritance. Inheritance allows you to create a new user defined type that is derived from an existing type. This is beneficial for code reuse, but the real power is to be able to redefine how objects that 'are-a' certain type behave at run-time.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

49. Classes part 14 - Inheritance - public, private, protected access levels | Modern Cpp Series Ep. 50 In this lesson I show the difference between the different access modifier levels in C++. I will show you how the member variables (and member functions) are accessible from a derived class, as well as how those member variables are accessible outside of the class in the main program.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

50. Classes part 15 - Inheritance calling different constructors | Modern Cpp Series Ep. 51 In this lesson I show you how to call specific constructors from base classes for your derived classes. The syntax and the errors can often be confusing, so I hope this will help make clear what is going on when the compiler is trying to resolve what constructor to call. Finally, I hope that this video also shows a little bit of a warning of how confusing code can be, if you have very deeply nested inheritance hierarchies. Extending your codebase often makes a programmer have to make many decisions or possibly many modifications if you have deep inheritance hierarchies.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

51. Classes part 16 - Virtual Functions (Dynamic dispatch) | Modern Cpp Series Ep. 52 In this lesson I show you how to ensure that the correct member functions are called when instantiating objects at run-time. Inheritance-based polymorphism (i.e. the ability to decide what the object type is at run-time, from any type in your inheritance hierarchy) is a powerful tool. That said, with great power comes great responsibility to ensure the right member functions are then called from the instantiated type. The keywords 'virtual' and 'override' in C++ (override being available in modern C++) enable 'dynamic dispatch' (the ability to choose the correct member function at runtime) to work.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

52. Classes part 17 - Virtual Destructors (Make base class destructor virtual)| Modern Cpp Series Ep. 53 In this lesson I show you why you have to make your base classes in an inheritance hierarchy virtual. In order for a derived class to call all of the appropriate destructors in the inheritance hierarchy, the base class destructors must be marked as virtual. This ensures that proper RAII practices are being used, and that resources are properly freed in each of the base classes from the derived class.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

53. Classes part 18 - Understanding the vtable (Popular interview question) | Modern Cpp Series Ep. 54 In this lesson I show you what exactly the vtable is in C++. The vtable is the data structure which holds information about which member functions to call for an instance of class when the presence of 'virtual' exists in inheritance. Understanding a little bit about this data structure, will also give you some intuition about a small performance cost (i.e. storage for the pointer, and following a pointer to call a function) about virtual functions as well.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

54. Classes part 19 - Interfaces in C++ (Pure virtual functions) | Modern Cpp Series Ep. 55 In this lesson we learn about pure virtual functions in C++. Pure virtual functions are functions that must be implemented in the derived class. C++ itself does not have an 'interface' or 'abstract' keyword like other languages, so a looser way to create an abstract class (or interface) is through pure virtual functions. I'll show you an example of how I have used interfaaes in the past in this lesson.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

55. Classes part 20 - CAUTION Multiple Inheritance (and example of using it) | Modern Cpp Series Ep. 56 In this lesson I show you how multiple inheritance works in C++. In general, we try to avoid multiple inheritance, especially when you have deep hierarchies of custom defined user types. That said, using multiple inheritance to add a specific behavior (or policy) can sometimes be helpful when used with care. That said, with all features, use carefully!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

56. cppman | Modern Cpp Series Ep. 57 In this lesson I show you a cool tool to help you with quickly finding out information in C++ when you are on the road!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

57. Classes part 21 - ‘const correctness' with member functions | Modern Cpp Series Ep. 58 In this lesson I show you the third use case of the 'const' keyword in C++. const again is used to make variables 'read-only' (sometimes referred to as immutable, meaning you can only initialize a value one time). By making your code 'const correct' and thinking about how variables should be used, you can often write much safer code.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

58. Classes Part 22 - Curly brace versus parenthesis and std::initializer_list| Modern cpp Series Ep. 59 In this lesson I show you three different ways to initialize a variable (the fourth would be to perhaps not initialize the variable which is bad practice). In C++ there is a difference between using curly braces and parenthesis. Parenthesis will call the constructor and setup any arguments. Curly braces may also call the right constructor, but will also prevent narrowing (i.e. conversion of types). In addition, using curly braces to initialize an object will use a constructor with an std::initializer_list if one is defined.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

59. Classes part 23 - Composition (and aggregation) versus Inheritance in C++ | Modern Cpp Series Ep. 60 In this lesson I discuss the concepts of composition, aggregation, and how they differ from inheritance. Understanding when to use each is important when designing classes. The preference tends to be to avoid deep inheritance chains, and prefer composition when possible. Part of making that decision means understanding when an object should 'have-a' type as part of it, versus the type having a 'is-a' (inheritance) relationship to truly represent a subclass.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

60. Classes part 24 - Multiple Inheritance Revisited (Virtual inheritance) | Modern Cpp Series Ep. 61 In this lesson we revisit multiple inheritance, an often frowned upon technique. That said, there are legitimate use cases, and you will see multiple inheritance used in large codebases. One technique to manage the shared (or duplicate) variables in inheritance hierarchies, is to use 'virtual inheritance'. Virtual inheritance 'merges' shared variables that are the grandparent of the current derived class. This essentially creates a 'diamond' inheritance pattern in the hierarchy. As always use caution, but in some scenarios this can be a useful tool to deriving new objects. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

61. Classes part 25 - Classes Practice Interview -- Jeopardy Edition | Modern Cpp Series Ep. 62 In this lesson we are taking a break from adding new content and are going to play a game! Ideally, if you are preparing for an interview in C++, this could be a good review for you (But of course, many more lessons are still coming in the series!). Many of the questions I am going to ask are sourced from actual interviews I had, so go ahead and have some fun in this lesson, and let me know your score in the comments below!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

62. Classes Part 26 - Value Initialization (Zero-Initialization of Members) | Modern Cpp Series Ep. 63 In this lesson I show you a little trick to zero initialize your variables when creating a class. This is probably the 'right' thing that you want to do when creating a new object that does not have a constructor for instance. In order to perform value initialization that zeroes out the member variables (i.e. zero-initialization), you use the {}'s. As long as the class does not have a constructor defined, this will work.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

63. Classes Part 27 - In-Class Initializer | Modern Cpp Series Ep. 64 In this lesson I show you a few more techniques for initializing your variables. Using an in-class initializer to set defaults can help make your classes more safe. You can of course override these default in a constructor as I will demonstrate in this lesson.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

64. Classes Part 28 - Delegating Constructors - Avoiding Repeating yourself Ep. 65 In this lesson I am going to show you how to leverage multiple constructors to avoid repeating yourself. The DRY principle (Don't Repeat Yourself) is a good guideline for avoiding errors. Often times, it can be tempting to write helper functions in classes (e.g. init) when you have multiple constructors, but those could be accidentally used by users of your interface. Instead, you can prefer to use constructors to provide a more consistent way to instantiate objects.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

65. Classes Part 29 - Class Data Layout (Optimizing for size) | Modern Cpp Series Ep. 66 In this lesson I show you the importance of how you lay out your member variables in your classes and structs. C++ Compilers align member variables to powers of 2, in order to make it easier to access fields. That said, this can cause waste depending on the order in which you list your member variables in classes. As a general guideline, you can list the larger member variables first, and then the smaller variables after to prevent internal fragmentation.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

66. Classes Part 30 - pIMPL (pointer to implementation) - More Stable APIs| Modern Cpp Series Ep. 67 In this lesson I talk about an important idiom that allows us to hide our implementation details in our classes. The pointer to implementation (pIMPL) idiom stores private data members and member functions in a class, while also limiting the pIMPL class's scope. This can be a way to create a more stable ABI for your applications, and even save compile times. The cost may be an additional level of indirection, and managing code in a .cpp file. In general, I would urge folks who have long lived codebases to consider this idiom.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

67. Classes Part 31 - The ‘this’ keyword - Modern Cpp Series Ep. 68 In this lesson I talk about the 'this' keyword in C++ and how it is used. Primarily, the this keyword is used to make it unambiguous as to which variable (or member function) is being used within a class. 'this' itself is a pointer to the memory in which the object was allocated.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

68. The ‘static’ keyword - understanding static vs stack vs heap memory - Modern Cpp Series Ep. 69 In this lesson I talk about the 'static' keyword in C++ and how it is used to specify the duration of the storage of a variable. Static can be used to allocate a variable in memory, within a scope (function, class, or file) throughout the duration of a program.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

69. Classes Part 32 - static member variables and functions in classes - Modern Cpp Series Ep. 70 In this lesson I show you how to use static within a class. The static keyword used with member variables in a class limits their scope to 'class scope'. Effectively, the variables are working the same as with static in our other example, just that they are available from a class scope, and not tied to a specific instance of a class. Static member functions are similar in that they are not tied to a specific instance of a class, and can otherwise only make use of static member functions in their body (i.e. they cannot use 'this' within the static member function).\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

70. Generics in C++ 1 - Templates Introduction | Modern Cpp Series Ep. 71 In this lesson I introduce you to templates in C++. Templates are a powerful feature in C++, and they allow us to avoid 'copy and paste' when we need to implement similar functionality on different data types. I'd like you however to think of templates as a tool for helping compilers generate the necessary code that we need. In this lesson we'll do a brief motivation of just one of the types of templates C++ provides, and then revisit some more features of generic programming (i.e. called templates in C++) in future lessons.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

71. Generics in C++ 2 - Template Functions (Abbreviated function templates) | Modern Cpp Series Ep. 72 In this lesson I introduce to you the anatomy of creating a function template. I will show you how to use the typical template syntax, as well as an additional way using 'abbreviated function templates' by using the keyword auto. One thing to keep in mind as well as our 'vocabulary' related to templates, and I'll show you what it means to instantiate a template.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

72. Generics in C++ 3 - Multiple Template parameters, non object-type params | Modern Cpp Series Ep. 73 In this lesson I discuss passing in multiple template parameters and non-object type parameters into the template. An example like std::array is used to demonstrate where we may want to use non object type parameters. In addition, I give a little bit of a warning that we can easily generate lots of code -- this is both a really good thing sometimes for the code we can generate, but also something we sometimes have to mindful of from a 'code size' perspective (and also for build times).\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

73. Generics in C++ 4 - Template Functions Full and Partial Specialization | Modern Cpp Series Ep. 74 In this lesson I discuss template specialization with function templates. This technique can also be used for class templates, but the motivating example will show you why it may be important to sometimes write specific code for handling specific types. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

74. Generics in C++ 5 - Variadic arguments and Variadic Function Templates | Modern Cpp Series Ep. 75 In this lesson we are going to look at creating a function template with a variable number of arguments. We are going to create a function template using a parameter pack to have an arbitrary number of arguments. This has an advantage of being type safe and also avoids any run-time checks versus using va_args in the stdarg.h header. I'll show in this lesson an example of how to properly create and use a Sum function with variable arguments, and one thing to watch out for.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

75. Generics in C++ 6 - Improving our Function Template (Review) | Modern Cpp Series Ep. 76 In this lesson we are going to write another function template, but this time as a review of what we have learned so far for some things in the C++ series. Additionally, I am going to show one thing that you need to think about, regarding the return type when we have a template that has multiple parameters that may be different.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

76. Generics in C++ 7 - Template Classes Introduction | Modern Cpp Series Ep. 77 In this lesson we are going to be creating your first class template. Class templates are similar to function templates that we have been learning about in this series, except we are using templates to generate new types based on the template parameter list. We can specify as many types as we like in the template parameter list (either class types or non-object types like 'ints). I'll also show briefly an example of a templat class for an array type similar to the STL.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

77. Generics in C++ 8 - Template Classes with Static Data Members | Modern Cpp Series Ep. 78 In this lesson we continue looking at class templates, this time adding in the static member variable. We'll look at how the compiler generates one copy of a static variable for each template, and how to properly setup a static member variable.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

78. Generics in C++ 9 - Class Template Argument Deduction (CTAD) | Modern Cpp Series Ep. 79 In this lesson we make use of a useful C++ 17 and beyond feature known as CTAD - Class Template Argument Deduction. This is similar to the abbreviated function templates we previously learned about, in that the types can actually be deduced. The compiler needs to be sure of the types, so it won't always work, but otherwise we can use this technique to clean up our code.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

79. Use -Weffc++ with g++ to write effective modern C++ | Modern Cpp Series Ep. 80 In this lesson I show you a cool trick to write better C++ code with the -Weffc++ flag in g++. This allows the compiler to run a static analysis on your C++ code, and suggest fixes based on Scott Meyers Effective C++ texts.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

80. Generics in C++ 10 - Templates Class default parameters | Modern Cpp Series Ep. 81 In this lesson I show you a feature that has actually been around for quite some time (though improved as of C++17 and beyond) -- default template parameters. Providing good default values can simplify your code for the common use case. However, it's also important to note that most of the STL data structures we have been use to using have at least one default we've been taking advantage of!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

81. Revisiting std::unique_ptr and Custom Deleters | Modern Cpp Series Ep. 82 In this lesson I show you what a custom deleter is for unique_ptr. It's more so important in this lesson that you know it exists and is available for you. It is particularly useful if you are working with legacy codebases and need to ensure a series of checks is made before reclaiming memory.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

82. Unions | Modern Cpp Series Ep. 83 In this lesson I show you how to use Unions in C++. You might be familiar with them in the C language, and C++ is backward compatible with unions in C. That said, you can also have member functions if you can find a compelling reason to do so in C++. Unions are a great way to more compactly store data, and we'll look at an example in SDL (SDL_Event) where they are useful. Finally, we'll look a the actual assembly in this lesson, to prove unions really are just a compact set of bytes.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

83. std::variant (tagged unions, write safer code) | Modern Cpp Series Ep. 84 In this lesson we are going to take a look at 'tagged unions' which are implemented as std::variant in C++17 and beyond. This is a way to create more type-safe unions in C++ by checking the field that you are accessing. Beyond the scenes, we're really creating a 'struct', so we do not however get the compactness of a regular union, thus trading space for safety.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

84. A brief look at c++ code style guides | Modern Cpp series Ep. 85 In this lesson we are going to do a very brief look at a few coding style guides. This lesson unfortunately is not going to have a single answer as to what the best style or coding standards are, but rather encourage you to follow one (or the one your team is going to use). Following good style is going to help your teammates help you, make it easier to read your code, and can in some cases help prevent bugs.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

85. Introduction to constexpr | Modern Cpp Series Ep. 86 In this lesson I will show you how to use constexpr to 'suggest' expressions that could be evaluated at compile-time. This can save your performance by evaluating results at compile-time, reduce code size, and even help you catch bugs at compile-time! constexpr does have a few quirks however, meaning that you'll have to be careful with floating point. A more detailed cppcon talk dedicated and inspiring this video can be found here https:\/\/www.youtube.com\/watch?v=fZjYCQ8dzTc\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

86. Write secure code with assertions (assert and static_assert) | Modern Cpp Series Ep. 87 In this lesson I will show you one way to catch bugs at run-time, and one way to catch bugs at compile-time. The assert statement (from C) is available to us in C++. Assertions serve as contracts of thing that must absolutely be true, and if they're not, the safest thing to do is for our program to terminate. In modern C++ we have available to use static_assert which can check boolean-constexpr expressions to see if they pass the test, and catching bugs at compile-time is often much easier on us in the long run!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

87. auto in Modern C++ | Modern Cpp Series Ep. 88 In this lesson I show you one of the more exciting features that was initially added to C++ 11, the repurposing of 'auto'. 'auto' is a placeholder for a type specifier, and allows the compiler to deduce the type for you. This can be handy for cleaning up your code, though I will have a warning that it does not always do what you may expect, so you do have to be a little careful with auto.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

88. Circle, Carbon, Cppfront, Val, DLang oh my! (Language Evolution) | Modern Cpp Series Ep. 89 In this lesson I talk about some of the evolution and exciting experiments going on around the C++ ecosystem. It's too early to know how some of these are going to develop, but worth knowing they exist and seeing how they might change the direction of the C++ language.\n\nC++ 23 https:\/\/en.cppreference.com\/w\/cpp\/23\nCircle Lang https:\/\/www.circle-lang.org\/\nCircle Talk from C++ Now 2022 https:\/\/www.youtube.com\/watch?v=15j4bkipuAg\n\nCarbon https:\/\/github.com\/carbon-language\/carbon-lang\nCarbon C++ North Talk https:\/\/www.youtube.com\/watch?v=omrY53kbVoA\n\nCpp Front https:\/\/github.com\/hsutter\/cppfront\nCpp Front talk (may get updated later) https:\/\/youtu.be\/CzuR0Spm0nA?t=14619\n\nVal Language https:\/\/www.val-lang.dev\/\nC++ Now talk https:\/\/www.youtube.com\/watch?v=4Ri8bly-dJs\n\nDLang interface to C++ https:\/\/dlang.org\/spec\/cpp_interface.html\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

89. API Design - Two Tips: pimpl idiom and ‘struct Options’ | Modern Cpp Series Ep. 90 In this lesson I show you two of my favorite tips for building a better API in C++ code. They're neat little hacks that should hopefully make your application interface more stable to the clients who are consuming them. They aren't perfect for every situation, but should be a good starting point to thinking about how to design code that is future proof.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

90. C++ Casting - Part 1 - Types, conversions, and C-style casts | Modern Cpp Series Ep. 91 In this lesson I talk about one of the best features of C++ design -- the fact that it is a statically typed language! This itself can help build safer and more scalable software. That said, on occasion, we need to treat data as different types in order to evaluate correctly our results. One thing we have to take care of is the 'runtime cost' of the cast, as well as if we are going to lose precision as well!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

91. C++ Casting - Part 2 - What could go wrong? Use -Wall cmp_greater (C++20) | Modern Cpp Series Ep. 92 In this lesson I talk about one of the things we often have to keep in mind when comparing data types, signed versus unsigned comparison. The actual bit representation of an unsigned number is often using a twos complement representation, thus the values may appear 'bigger' at the bit level than what we would expect as programmers. In order to fix this, we can use -Wall to warn us of such conversions, or otherwise use a C++ 20 feature like std::cmp_greater in the utility header (and associated comparisons) to write more stable code.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

92. C++ Integer and floating suffixes and using the single quote for clarity | Modern Cpp Series Ep. 93 In this lesson I talk about a simple trick to help make your code more clear by using suffixes on your numbers. Suffixes will avoid the compiler from having to guess the type, and this becomes especially important when using the keyword 'auto'. Finally, I also show how to use the single quote in order to make your numbers slightly more clear to read.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

93. C++ Casting - Part 3 - static_cast and dynamic_cast (mega lesson) | Modern Cpp Series Ep. 94 In this lesson I talk about the four keywords that were added to C++ 11, focusing primarily on static and dynamic cast. These named casts are generally more safe to use, easier to grep for, and can help you cast your data more safely when you absolutely must cast your data. I'll walk through several examples with a class hierarchy, and hopefully convince you that the named casts better show your intent of the code, and are much better than the C-style cast (which essentially is trying all of these named casts).\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

94. C++ Casting - Part 4 - static_cast vs dynamic_cast (Interview Question) Ep. 95 In this lesson I give you one of my interview questions on static versus dynamic casts. See how you'd answer, and watch my review of our previous lesson! Again, my recommendation is to try to avoid casting when you can, and I would probably default to more 'safe' casts (i.e. dynamic_cast), so hopefully this video will help you understand why. For this particular lesson, I think it's important to try the code, and play around with it like I did, so you can see where the casts 'might work' (i.e. compile) -- but in many cases give you the wrong behavior!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

95. C++ Conference Talks - Feed Your YouTube Algorithm more C++ | Modern Cpp Series Ep. 96 In this lesson I give you a list of some of my favorite C++ conference talks that I think a wide audience can benefit from. Here's the link! https:\/\/www.youtube.com\/playlist?list=PLvv0ScY6vfd-fxDQiicYsjqAhJqZkkRH-\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

96. C++ Casting - Part 5 - reinterpret_cast | Modern Cpp Series Ep. 97 In this lesson we continue our discussion of casting, this time using reinterpret_cast. Again, I've found the uses for this cast far and few between, but I'll show you where it be useful to read in one chunk of data at a time and just treat the data as a specific set of bytes.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

97. Classes Part 33 - Nested Classes | Modern Cpp Series Ep. 98 In this lesson we are going to learn a little bit more about class design -- this time with a simple feature that's been around for quite some time, nested classes\/structs. This i another way we can encapsulate code, and show our intent for what clients should easily have access to, or otherwise for keeping functionality private within a class. This technique could also be combined with other idioms like the pImpl idiom as another technique for information hiding.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

98. Functors() - Function objects - functions with state | Modern Cpp Series Ep. 99 In this lesson we learn about a concept that probably sounds scarier than it really should be -- functors. These are 'function objects' in which we can 'hold state' (because they are a class), but use exactly like a function. Where functors() really shine is by allowing us to compose or partially compose results, and we're soon going to find out that lambda's (unnamed functions) are essentially functors behind the scenes, but both lambda's and functors are incredibly useful tools for using with the STL.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

99. C++ Lambdas Part 1 - Unnamed function objects (closures) in C++ | Modern Cpp Series Ep. 100!!! In this lesson you are going to get an introduction to lambda's -- a powerful tool for building more composable programs and taking advantage of other building blocks like the algorithm library in the STL. I'll also show you that lamabda's are 'unnamed function objects' (not just unnamed functions), and it is important to have that distinguishment so you understand the implementation, but also that lambda's can capture state -- just like function objects!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

100. Classes Part 34 - mutable keyword to override const and the M&M rule| Modern cpp series Ep. 101 In this lesson you are going to learn a new keyword introduced in modern C++ 'mutable'. mutable allows us to override the 'const' keyword of member variables in a class. There are a few specific use cases where this goes together, and I'll introduce one called the M & M rule when used with mutexes for instance for creating thread safe classes.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

101. C++ Lambdas Part 2 - ‘The capture’ | Modern cpp series Ep. 102 In this lesson we continue our journey talking about lambda's this time focusing on the 'capture'. We can capture by reference and by value when using lambdas. Note that when capturing by value, by default variables are 'const' and we need to use 'mutable' if we want to change those objects. I'll also show you at the end a little bit more on the actual implementation of lambda's using cppinsights for those who are interested.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

102. C++ Lambdas Part 3 - Capturing ‘this’ (Using lambda’s in member functions)|Modern cpp Series Ep. 103 In this lesson I show you how to capture 'this' when using lambda's within a member function of a class. We can capture by reference and by-value as before. One note is that some of the syntax for capturing by value using '=' has been deprecated in C++20, so be sure to use *this explicitly when capturing by value.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

103. C++ Handling Program arguments (argc, argv, env) | Modern Cpp Series Ep. 104 In this lesson we learn how to handle taking in program arguments. I'll show you the basics of what you need to know, and even show you how to handle environment variables that may also be useful in configuring your programs execution.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

104. The ‘using’ keyword (using namespace and alias declarations) | Modern Cpp Series Ep. 105 In this lesson we take a look at the 'using' keyword which you'll occasionally see on old tutorials. In the case of modern C++ however, 'using' is not only used for resolving namespaces, but it is also used as a replacement for 'typedef'. 'using' however has more power, in that it can work and preserve template arguments.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

105. C++ Book Recommendations | Modern Cpp Series Ep. 106 One of the most frequent questions I get is what books to read. Here's a quick video sharing a progression of texts that you can read to learn C++. Of course, otherwise, you can follow this series to get a relatively linear progression of topics as you use C++ in a personal project.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

106. C++ Macros, defines, __LINE__, and std::source_location (C++ 20) | Modern Cpp Series Ep. 107 In this lesson I show you how to use macros in C++. While some of you may have seen my video on the compilation process (https:\/\/www.youtube.com\/watch?v=ksJ9bdSX5Yo), it's useful to review in this tiny lesson some of the different things you can do with macros. In fact, you can create lots of handy functions that expand and wrap around your functions. I'll also show you how to use 'define' from the command line so you don't have to litter your code or make source changes to change behavior. Finally, I'll show you some handy macros like __LINE__ and __FILE__, and how in modern C++ we can instead use std::source_location.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

107. Functions with default arguments | Modern Cpp Series Ep. 108 In this lesson I wind us back a little bit in time and show you how to use default arguments in functions. This is something I've skipped over, but is important to know and supported in many programming languages. Default arguments are often useful for ABI stability, as well as just making it easier for users of your API to make to choose reasonable defaults.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

108. Function Inlining in C++ | Modern Cpp Series Ep. 109 In this lesson I talk about an important topic in optimization which is function inlining. This optimization can enable other optimizations by embedding the code from a function call directly at the call site, and otherwise avoid the overhead of setting up a function call (through the activation context or 'frame'). That said, there is a trade-off which it comes to the code size, as well as the debugability of a program. Compilers will take the 'inline' keyword as a hint, and otherwise do their best to inline code where performance may be improved. Again, function inlining often enables code optimizations, but should be used cautiously -- though I will show you how to force inlining if you are certain with compiler attributes in this lesson.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

109. inline variables (C++ 17 and beyond) | Modern Cpp Series Ep. 110 In this lesson I show you a useful c++ 17 feature to help you write cleaner code -- inline! This time it has to deal with how we can inline static member variables within a class (or also a namespace). Again, this is useful for a header-only library, or otherwise for making sure we only link in one copy of the variable.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

110. Standard Template Library (STL) Short Overview | Modern Cpp Series Ep. 111 In this lesson I give you a little bit of history and a brief overview of the standard template library (STL). The STL in my mind makes a key contribution by providing algorithms, containers, and iterators as building blocks for generic programming. Understanding this idea in C++ can help give you a model for computation and programming in the C++ programming language.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

111. STL std::string, char*, const char*, and string literals in C++ | Modern Cpp Series Ep. 112 In this lesson I show you how to get started with the std::string in the STL. std::string is something we have used before, but it is actually a specialization of basic_string. By understanding how string works, you'll actually see how many of the containers and data strutures in C++ work.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

112. STL std::string_view and when to use it versus std::string | Modern Cpp Series Ep. 113 In this lesson I show you how to use STL string_view to provide a faster way to access strings (especially when only performing read-only operations). \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

113. STL std::array (Since C++11) | Modern Cpp Series Ep. 114 In this lesson I show you how std::array is really the same thing as the C-style arrays we have previously used, but with better type safety. std::array takes advantage of templates to store the size of the array with the array, and better member functions to more consistently query things like size or access elements. std::array's do not thus decay to pointers, which can be a source of confusion for beginners.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

114. STL std::span | Modern Cpp Series Ep. 115 In this lesson I introduce another efficient way to pass around data structures in a non-owning way, the std::span added in C++ 20. std::span is a 'view' into a container and does not own the elements. Just like string_view, it is an efficient way to pass data around and think about the 'range of computation'.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

115. STL std::vector | Modern Cpp Series Ep. 116 In this lesson I give you a full look at one of the most popular data structures, the vector. std::vector is a dynamic array (nothing to do with vectors in linear algebra!), and it dynamically resizes as you add elements into the data structure, and also has the ability to shrink. Because vectors are contiguous data structures, they also are generally very perform very well.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

116. Commenting the 'why' in your C++ code | Modern Cpp Series Ep. 117 In this lesson I give you my opinion on writing comments in your code. The bottom line is that you should document the 'why' in your code. You should also have in your 'code review' a process to check that your comments match the 'why' of the code, and the 'purpose' of adding in abstractions.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

117. STL std::list | Modern Cpp Series Ep. 118 In this lesson I give you an introduction to the std::list data structure. Lists are node based data structures using pointers behind the scenes to help you achieve fast insertion and removal at the trade-off of random access.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

118. STL std::forward_list | Modern Cpp Series Ep. 119 In this lesson I give you an introduction to the std::forward_list data structure which is a singly linked list in the STL in C++ 11 and beyond. forward_lists are very lightweight linked lists, designed primarily to 'push_front' and occupy the minimal amount of memory for a linked data structure.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

119. STL std::deque | Modern Cpp Series Ep. 120 In this lesson I give you an introduction to the std::deque (pronounced \"deck\") data structure which is a double ended queue. deque's are particularly useful if you want the same functionality as a vector, but know you are going to primarily do lots of insertions at the front or end of the data structure. I'll cover how the data structure might be implemented as well in this video.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

120. STL std::set | Modern Cpp Series Ep. 121 In this lesson I give you an introduction to the std::set data structure which is an ordered data structure for adding unique elements. Sets are typically implemented as a tree structure (rb-tree) for insertion and removal operations. Sets can also be merged together to transfer elements into another set. The key is to use this structure to check for existence of data.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

121. STL std::unordered_set (std::algorithm generate_n for creation of sets) | Modern Cpp Series Ep. 122 In this lesson I give you an introduction to the std::unordered_set data structure which is an unsorted data structure storing unique elements. The advantage is in this case the ability to have average time constant lookup, insertion, and removal. I'll spend some time introducing the concept of a hash table at the start of the lesson, and then I'll also show you how to generate sets using the stl algorithm generate_n.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

122. STL std::multiset (And how to compare non-trivial types) | Modern Cpp Series Ep. 123 In this lesson I give you an introduction to the std::multiset data structure which is an ordered data structure like the set, but it allows for duplicate elements. This data structure typically uses a red-black tree for logarithmic time operations for lookup, insertion, and removal. I'll spend some time also showing how to implement a custom comparison using less than operator overloading and a functor for a less trivial data type.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

123. STL std::unordered_multiset( C++11) (and custom hash function) | Modern Cpp Series Ep. 124 In this lesson I give you an introduction to the std::unordered_multiset data structure which is an unordered data structure , but it allows for duplicate elements. This data structure typically uses a hash table for average case constant time operations for lookup, insertion, and removal. I'll spend some time also showing how to implement a custom hash function for a custom type in this lesson, and we'll observe how to print out the buckets in the data structure using iterators.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

124. STL std::pair (and also a peek at std::ref and std::get) | Modern Cpp Series Ep. 125 In this lesson I give you an introduction to the std::pair data structure which is a special case of std::tuple. std::pair you will see often come up when talking about key\/value pairs -- and soon we are going to be talking about std::map, std::unordered_map, and more! Finally, in this lesson I'll show you how we typically work with pairs (when iterating through collections), and a neat inference capability with std::make_pair and a compile-time check with std::get.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

125. STL std::map | Modern Cpp Series Ep. 126 In this lesson I give you a tour of the std::map. std::map is an associative and ordered container for storing keys and values. In general you will get logarithmic performance using this data structure for insertion, removal, and updates. I'll show you how to iterate through the map several different ways, some tips on 'using' for creating your maps, and how to create a custom comparator if you use a custom key.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

126. [News] Upcoming C++ Conferences for 2023 | Modern C++ Series Ep. 127 In this lesson we take a brief detour and I show you some of the C++ conferences that are coming up this year. Conferences are a great way to network and gain knowledge if you are able to attend. And at the least, knowing these conferences exist and that a lot of the content is later available on YouTube can help supercharge your career. Here's a recap of some of my favorite C++ Conference talk videos for the reference here: https:\/\/www.youtube.com\/watch?v=xxoQKQbZEXY\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

127. STL std::multimap (ordered, stable, multiple keys -trick with equal_range)|Modern Cpp Series Ep. 128 In this lesson I will show you how to use the multimap which is very similar to map. The difference with this data structure is you can have more than one key in the data structure (similar to multiset versus set). I'll show you how to use a few other functions like find, erase, and insert, as well as how to retrieve all of the keys using lower_bound, upper_bound, and a more efficient equal_range.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

128. STL std::unordered_map (C++11) | Modern Cpp Series Ep. 129 In this lesson I will show you how to use the unordered_map which is very similar to map but offers average-cast constant time insertion lookup, and deletion.. The difference with this data structure (versus a std::map) is that the underlying data structure is a hash_table (similar to unordered_set versus set) versus a red-black tree. I'll show you how to use a few other functions like find, erase, and insert, as well as how to write your own hash function and quality operator if you use keys that are not part of the STL or otherwise trivial.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

129. STL std::unordered_multimap (C++11) | Modern Cpp Series Ep. 130 In this lesson I will show you how to use the unordered_multimap which is very similar to unordered_map but this time allowing for duplicate entries. I'll show you how to find all of those entries using equal_range, and different member functions like count, erase, insert, and why the operator[] cannot be used since we can have multiple entries.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

130. C++ STL std::stack (a container adaptor) | Modern Cpp Series Ep. 131 In this lesson I will show you a fundamental data structure -- the stack! Stacks have two key operations, push and pop in computer science. The STL organizes stack such that each operation does exactly one thing, and push, pop, top, and empty for example are as they sound. I'll also describe what it means to be a container adaptor, and that the stack data structure itself enforces a policy, while the underlying data structure has impacts on performance. Finally, I'll show you a use case of stack with an undo and redo system.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

131. C++ STL std::queue a container adaptor | Modern Cpp Series Ep. 132 In this lesson I will show you a fundamental data structure -- the queue! Queues have two key operations, push and pop in computer science. The Queue is a FIFO (first in, first out) data structure as opposed to the stack which is a LIFO (Last in, First out) data structure. The STL organizes queue such that each operation does exactly one thing, and front, back, push,pop, and empty for example are as they sound. I'll also describe what it means to be a container adaptor, and that the qeue data structure itself enforces a policy, while the underlying data structure has impacts on performance. Finally, I'll describe to you a use case of queue as it's used for handling events.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

132. C++ STL std::priority_queue (a container adaptor) | Modern Cpp Series Ep. 133 In this lesson I will show you the last of the container adaptors, the priority_queue data structure! Priority queues follow a different ordering than queues, by taking the 'highest' (by default) element and that is the first element to be removed. I'll show you in this lesson how to use a different comparator function for custom data structures, as well as talk about the complexity of the priority queue.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

133. STL C++ Container High Level Review | Modern Cpp Series Ep. 134 In this lesson I will review all of the C++ containers that we have previously covered! This lesson serves as a quick review, and you can go back to the playlist and see any data structures that you may need to freshen up on.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

134. STL C++ Iterators - Introduction | Modern Cpp Series Ep. 135 In this lesson I provide you an introduction to iterators in the C++ standard template library (STL). Iterators allow us a uniform way to move through data structures, and can often express the intent clearly in our code. Range-based for loops use iterators behind the scenes to also make our code more concise.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

135. STL C++ Iterators - Categories | Modern Cpp Series Ep. 136 In this lesson I go through the different iterator categories to help you make sense of reading the c++ documentation. It's useful to understand the different categories so you know the capabilities of each container.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

136. STL C++ Iterators - Range Access (non-member functions-begin,cbegin,etc) | Modern Cpp Series Ep. 137 In this lesson I show you some of the generic functions available for first retrieving iterators (as opposed to calling the member functions), and then we'll look at a few functions (data and size) that may be available for your container. The advantage of using these, is in my opinion, the readability and ease to swap.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

137. STL C++ Iterators - Writing an iterator from scratch | Modern Cpp Series Ep. 138 In this lesson I show you how to write an iterator from scratch that is compatible with range-based for-loops. We'll set the stage for how to also make this iterator compatible with several std::algorithm STL algorithms as well!\n\n00:00 Introduction\n00:58 Iterators review and use\n03:50 Example of STL vector and usage with iterators\n05:40 Cpp insights view of ranged-based for loops and iterators\n08:00 Swapping STL data structures\n08:45 Figuring out which member functions we need for iterators\n09:41 Example data structure explanation\n11:40 Adding 'begin' and 'end' stubs and 'iterator' struct\n14:00 Adding 'struct iterator'\n14:40 Design Decision on our iterators bookkeeping strategy\n15:25 iterator Constructor\n16:12 Idea that we can have multiple iterators to same container\n17:20 Cleaning up our iterator, inspired by STL design\n18:30 Placeholders for distance (ptrdiff_t)\n19:40 Placeholder for iterator category\n21:40 Filling out 'begin' and 'end'\n23:28 'end' is beyond the data structure\n24:58 Implementing pre increment and post increment\n29:07 Dereference operator\n31:00 Adding arrow operator\n32:53 Implementing \"operator==\" and \"operator!=\"\n35:20 Fixing bug with pre increment\n36:00 WORKING iterator -- very cool!\n37:40 Review of our implementation\n40:30 Wrap up and thank you to our members and subscribers\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

138. STL C++ Iterators - Writing an iterator from scratch (Code Review) | Modern Cpp Series Ep. 139 In this lesson we do a code review of the previous iterator video. I will discuss some high level ideas on how to learn to write iterators and the requirements, as well as show the full source code for you to learn by example.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

139. STL C++ Iterators - Iterator Invalidation | Modern Cpp Series Ep. 140 In this lesson I talk about the idea of iterator invalidation, this idea that the iterators that you have could become invalid if you modify the shape (i.e. by adding or removing an element) of a data structure. We'll look at an example where 'erase' and push_back may (or may not -- in the case that we do not discover it) cause problems.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

140. C++ STL algorithm - Brief Introduction | Modern Cpp Series Ep. 141 In this lesson we are introduced to the standard algorithm library. We will be looking at algorithms in the STL which are templated functions that can work with the containers and iterations in the STL. These serve as well-tested building blocks for performing work (i.e. algorithms) in our code, and are often quite expressive. There is also a path to parallel performance with the execution policies that may be of interest as well!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

141. C++ STL algorithm - generic design and advice on using member functions | Modern Cpp Series Ep. 142 In this lesson I help us navigate the algorithm library. In some cases we might find that there appear to be repeats of some algorithms as well! We should prefer the member function of the data structure as it knows of the internals. However, this brings up an important discussion of the design of the algorithm library to be generic, and that once we know these algorithms exist, they can help us write more expressive code.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

142. C++ STL algorithm - search (find, find_if, search, adjacent_find) | Modern Cpp Series Ep. 143 In this lesson I show you the non-modifying sequence algorithms for searching. We'll work through several examples using find, find_if, search, and adjacent find. These algorithms (i.e. function templates) do not modify the data structure, but typically take a pair of iterators (the range to search) and a value or range to search for. I've found they can be helpful in string search or image processing applications personally.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

143. C++ STL algorithm - std::mismatch | Modern Cpp Series Ep. 144 In this lesson we discuss the mismatch algorithm which reports back the first pair of mismatches. When comparing two sequences, if they are not the same size, then their is some undefined behavior, so we'll right a little helper function to deal with that. This is a nice example of how the algorithm building blocks can help us write safer code and code that is more resilient.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

144. C++ STL algorithm - comparison with std::equal | Modern Cpp Series Ep. 145 In this lesson we learn to use the handy std::equal algorithm. Effectively we equal will iterate through two sequences and do a comparison using the == operator. Of use in this video however, I'll show you how binarypredicate works, and an instance where when comparing strings we might want to use it for handling case-sensitivity.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

145. C++ STL algorithm - comparison with std::lexicographical_compare | Modern Cpp Series Ep. 146 In this lesson I show you how to use lexicographical_compare, which is a way to compare sequences using 'dictionary ordering'. Most often this is useful when comparing strings as I will show by example. However, we can also use this for other sequences like vectors, and potentially there may be interesting use cases with a priority_queue perhaps. The operator less_than sign can be overloaded to provide the orderings you need.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

146. C++ STL algorithm - counting (all_of, any_of, none_of)| Modern Cpp Series Ep. 147 In this lesson I show you some of the counting algorithms available -- all_of, any_of, and none_of. These are useful for querying about sequences. Generally speaking, these could be easy functions to write, but they are very nice self-documenting functions, and additionally a predicate can be supplied as needed. I think an interesting use case is to perhaps swap in predicates, which is a nice use case of the algorithms library.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

147. C++ STL algorithm - counting (count, count_if)| Modern Cpp Series Ep. 148 In this lesson I show you how to do more counting with count and count_if. I'll show you a more pragmatic example where you might want to do something beyond counting an occurrence of some value. By supplying a predicate you can count properties of particular objects who have some property (e.g. in a game, how many enemies still have health left) for example.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

148. C++ STL algorithm - std::copy | Modern Cpp Series Ep. 149 In this lesson I show you how to use std::copy to copy elements into another sequence. In this example I also run a little performance experiment so you can think about how these algorithms are implemented in your standard library (performance thus may vary!)\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

149. C++ STL algorithm - std::copy_if and std::copy_n | Modern Cpp Series Ep. 150 In this lesson I show you copy_if and copy_n which are two new forms since C++11 in the algorithms library. These algorithms document more clearly the intent of the code, and are otherwise useful in copying a subset of data or a subset of data-based on a predicate (note copy itself can be supplied a predicate as well, but copy_n is more explicit in how many elements as a maximum to copy).\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

150. C++ STL algorithm - std::fill and fill_n | Modern Cpp Series Ep. 151 In this lesson I show you fill and fill_n which replaces a 'loop' that we often write to initialize our data structures. Generally speaking it may be a good idea to initialize your data structures if you know the exact number of elements that they will contain. Fill is a bit less error prone when it comes to setting the boundaries, as it will just fill the data structure for however many elements you've requested.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

151. C++ STL algorithm - std::generate and generate_n | Modern Cpp Series Ep. 152 In this lesson I show you generate and generate_n which are useful algorithms for populating sequences (i.e. containers) with data. This is related to iota for those who know, but more generic in the type of data that is generated. We'll look at an example for generating integers, but we can really generate any type of value to populate our data structures as we need.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

152. C++ STL algorithm - std::reverse and reverse_copy | Modern Cpp Series Ep. 153 In this lesson I show you the reverse and reverse_copy STL algorithms. These are useful generic functions for reversing containers. Note that some containers have their own member functions which should be preferred, or otherwise must be used -- I'll show forward_list as an example which has it's own reverse member function.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

153. C++ STL algorithm - erase-remove idiom -- std::remove(_if, _copy_if) | Modern Cpp Series Ep. 154 In this lesson I show you how to remove elements from a container! This is the popular erase-remove idiom that will actually remove elements from a data structure (a common search on stack overflow!). Note that we'll look at 'erase_if' in a later video as well.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

154. Easier removal with container std::erase(non-member function)and erase_if| Modern Cpp Series Ep. 155 In this lesson I show you some nice additions to the C++ 20 standard library containers, with erase and erase_if. These non-member functions make life a bit easier, such that you don't have to do the two step erase-remove idiom.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

155. C++ STL algorithm - sample algorithm| Modern Cpp Series Ep. 156 In this lesson I show you a neat algorithm for taking samples from other collections. It is available in C++ 17 and beyond and called 'sample'. The trick is that it uses a random number generator to get a uniform distribution and push out the result to another data structure.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

156. C++ STL algorithm - rotate algorithm | Modern Cpp Series Ep. 157 In this lesson I show you a neat algorithm rotating a collection, which is a fundamental way to think about computation. 'That's a rotate' is the famous saying as well from Sean Parent's famous talk C++ Seasonings (https:\/\/www.youtube.com\/watch?v=W2tWOdzgXHA) which I highly recommend. In this video, I'll show you how to even perform insertion sort from the cppreference site, and if you're familiar with the insertion sort algorithm, it's a fun way to think about how quickly you can put together this sorting algorithm with the STL. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

157. cppman - round 2! (in 2023) | Modern Cpp Series Ep. 158 In this lesson I revisit a cool tool for helping you work on c++ on the road. This is another version of my previous video, but specific to answering a user question. Thank you to my supporters! The previous video is here: https:\/\/youtu.be\/5Z2AXSWLx8o\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

158. C++ STL algorithm - shuffle algorithm | Modern Cpp Series Ep. 159 In this lesson I show you the 'shuffle' algorithm in the STL. Shuffle will rearrange the elements in a container such that they move into a random position. Note that shuffle is the preferred STL algorithm to use over 'random_shuffle' which used the previous implementation of std::rand in order to randomly distribute elements -- in C++11 there exist other random distributions that can be used.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

159. C++ STL algorithm - unique and unique_copy algorithm | Modern Cpp Series Ep. 160 In this lesson I show you the 'unique' and 'unique_copy' STL algorithms for removing adjacent elements that are found to be equal (using the operator==). This is a handy way when you are filtering data for instance. One thing to be careful of, is since unique is removing elements, we need to use the remove-erase idiom that we previously learned.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

160. C++ STL algorithm - transform algorithm | Modern Cpp Series Ep. 161 In this lesson I show you a popular STL algorithm -- transform! Transform is effectively 'map' in other programming languages (but in C++ we have a data structure already called 'map'). Transform is very similar to for_each, but does not necessarily gaureentee elements will be executed one after the other. Transform can also take in multiple collections and a binary predicate to perform the transformation as well.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

161. C++ STL algorithm - std::partition, std::is_partitioned | Modern Cpp Series Ep. 162 In this lesson I show you the is_partitioned and partition algorithms. If you have ever implemented quicksort, then you'll be happy to find these algorithms available! Again, these are very much fundamental algorithm building blocks in computer science, and the STL has you covered!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

162. C++ STL algorithm - std::partition_point, std::partition_copy | Modern Cpp Series Ep. 163 In this lesson I show you how to return the partition point and then copy the left and right sides of the partition to new collections. These functions can be useful for finding if you have a good partition for exapmle. This video puts together several things we have learned about in the STL as well (including std::partition, std::is_partitioned, std::distance, std::back_inserter, and vector.reserve ideas).\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

163. C++ STL algorithm - stable_sort, sort | Modern Cpp Series Ep. 164 In this lesson I show you how to use the sort and stable_sort algorithms in the STL. These use an 'introsort' algorithm (in some implementations) to perform sorting in nlogn time. It's important to note that this is for containers that allow for random access, but containers like 'List' have their own member function for sort(). I'll also show you how to sort a custom data type and write a compare function for usage with sort and stable_sort.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

164. C++ STL algorithm - is_sorted, is_sorted_until | Modern Cpp Series Ep. 165 In this lesson I show you how to use is_sorted and is_sorted_until. is_sorted is implemented in terms of is_sorted_until, but provides a simple bool value, while is_sorted_until provides an iterator to the element not sorted. This algorithm runs in linear time, and may be useful to do a check before a more expensive sort operation. I'll also at the end show you how to use this at compile-time on a std::array with static_assert for fun!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

165. C++ STL algorithm - nth_element and partial_sort()(median filter use case)|Modern Cpp Series Ep. 166 In this lesson I show you how to use nth_element which is useful for various applications related to 'partitioning' data. I'll show you a real world use case with a median filter briefly for image processing. The combination of nth_element with partial_sort can also be useful for finding the 'nth largest' values for a partition. I've found these two algorithmic building blocks very useful for thinking about computation.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

166. C++ STL algorithm - std::inplace_merge, std::merge | Modern Cpp Series Ep. 167 In this lesson I show you how merge and inplace_merge work in the STL algorithms library. Most folks are familiar with 'merge' in mergesort (which is actually best implemented with inplace_merge). Both merge and inplace_merge work with already sorted collections. Merge will generate from two sorted collections a new sorted collection, while inplace_merge will sort inplace in the same collection that consists of two independent consecutive sorted sequences.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

167. C++ STL algorithm - lower_bound, upper_bound, binary_search | Modern Cpp Series Ep. 168 In this lesson we look at the binary_search, lower_bound, and upper_bound algorithms which are building blocks for search. Many containers have a 'find' already built-in that may be logrithmic. However, binary_search is useful for again returning a bool value, searching partial ranges, flattening a data structure, or otherwise used with lower_bound and upper_bound for queries on where to perform potential insertions.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

168. C++ STL algorithm - includes (for finding subsequences) | Modern Cpp Series Ep. 169 In this lesson I show you the 'includes' algorithm for searching for subsequences between containers. I'll show you how to use it for a basic vector, a custom type, and even mixing containers! This data structure follows the mathematical 'include' test you would otherwise perform on two sorted sequences.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

169. C++ STL algorithm - set_union, set_intersection | Modern Cpp Series Ep. 170 In this lesson I show you the 'set_union' and 'set_intersection' algorithm for generating a new sequence. Note that the functionality of set_union is slightly different than std::merge, avoiding generating all of the elements that show in both (thus perhaps the 'set' name.. I'll show you how to use it for a basic vector and write out to a new list data structure, and discuss why you may consider using these building blocks.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

170. C++ STL algorithm - set_difference, set_symmetric_difference | Modern Cpp Series Ep. 171 In this lesson I show you the 'set_difference' and 'set_symmetric_difference' algorithms for working with containers. Both of these operations are useful for subtracting or otherwise 'taking the non-intersection' of two containers data. I could imagine using these if you're detecting some pattern, or otherwise for processing data\/queries.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

171. C++ STL algorithm - make_heap, pop_heap, sort_heap | Modern Cpp Series Ep. 172 In this lesson I show you the 'make_heap' operation to 'heapify' your contiguous data structures. I'll also show you how to work with a custom comparator, to otherwise work with custom types. You might have also observed that previously we have covered a priority_queue (a container adaptor in the C++ standard library), which makes use of the make_heap building blocks. Finally, I'll show you how to 'heap sort' by popping off elements, or you can otherwise use the sort_heap function as well.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

172. C++ STL algorithm - min, max | Modern Cpp Series Ep. 173 In this lesson I show you the 'min' and 'max' functions in algorithm. They are actually a bit more powerful than comparing two values, and generally more type safe than using a macro (i.e. with a #define MAX(A,B) type of operation). min and max can both take initalizer lists, and they can also both take custom comparators for your objects. I'll show you a fun example of passing in different comparators to return different 'max's based on some operation. If you do decide to implement your own min and max functions, do take care if you return a value or reference.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

173. C++ STL algorithm - min_element, max_element | Modern Cpp Series Ep. 174 In this lesson I show you the 'min_element' and 'max_element' functions in algorithm. They are similar to 'min' and 'max' from a previous video, but allow you to instead search a range or container. Both min_element and max_element return iterators to the minimum value -- and then you can decide how to process the data afterwards (e.g. dereference to return the value, or otherwise modify the original container). I'll show you a fun example of passing in comparators for a custom type as well in this lesson.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

174. C++ STL algorithm minmax, minmax element | Modern Cpp Series Ep. 175 In this lesson I show you the 'minmax' and 'minmax_element' functions in algorithm. These functions return a std::pair with the min and max elements respectively. Both versions of these functions can be composed effectively to create interesting behaviors as I will show. As a bonus, I'll show how to use a 'structured binding' to return the pair and clean up your C++ code.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

175. C++ STL algorithm - std::clamp | Modern Cpp Series Ep. 176 In this lesson I show you the 'clamp' function. Clamp is a function that you may often find yourself writing -- but never fear, we have that function is available in the C++ STL! Clamp is useful for processing data, and it comes with 'const' for the parameters so that you return the value that you want. In this video I'll show you a little example for doing image processing, in which we might want to store values between 0 and 255 in a range. We'll also review some things like templates and .reserve in vectors for efficiency.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

176. C++ STL numeric - std::midpoint -- Interview Question! | Modern Cpp Series Ep. 177 In this lesson I show you the 'std::midpoint' function in C++. Implementing midpoint at first may seem quite trivial -- and perhaps it is. However, did you consider overflow? What about rounding for integers? Or maybe an overload for finding the midpoint of a contiguous data structure. Lucky for us, the STL handles these cases in a safe implementation in the numeric library.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

177. C++ STL numeric - std::lerp | Modern Cpp Series Ep. 178 In this lesson I show you the 'std::lerp' function in C++ for linear interpolation (fun name!). Implementing lerp at first may seem quite trivial -- and perhaps it is. However, did you consider overflow? What about other issues for large exponents of floating point numbers? In this lesson I'll show you the safer STL version of lerp, and we'll discuss a few examples of where you may also use lerp in a game or application.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

178. C++ STL numeric - std::iota | Modern Cpp Series Ep. 179 In this lesson I will try to show you why you might care at least one iota more about std::iota. This is a function that effectively populates a range with a successive call of ++ on the object. It can be a simple way to run a version of std::generate that fills a container with successive elements. For fun, I'll also show you how to implement a 'range' like function in Python to clean up your range-based for loops.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

179. C++ STL numeric - adjacent_difference | Modern Cpp Series Ep. 180 In this lesson I will show you the handy adjacent_difference algorithm -- which seems to show up so frequently in leetcode questions. That said, adjacent_difference can be very useful for data analysis tasks, image processing, and optimization functions. We'll look at two ways to output the data, in-place, or otherwise with a back_inserter to write to a new container.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

180. C++ STL numeric - partial_sum | Modern Cpp Series Ep. 181 In this lesson I will show you the handy partial_sum numeric algorithm -- which could be handy for something as simple as summing the area under the curve. I'll also show you how this function can be used for computing a factorial by providing a 'multiplies' functor, and finally one other fun example by performing a 'cummulative sum' (another way to think of partial_sum) with a custom object to represent dice rolls in a game.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

181. C++ STL numeric - inner_product (map reduce)| Modern Cpp Series Ep. 182 In this lesson I will show you the handy inner_product numeric algorithm can be used for more than just the sum of products (i.e. scalar dot product for my graphics folks). The inner_product introduces the map reduce paradigm style of programming, which is a functional paradigm. Understanding inner_product (and its parallel implementations) can greatly simplify your code and reduce loop computations.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

182. C++ STL numeric - std::accumulate (fold) | Modern Cpp Series Ep. 183 In this lesson we take a look at std::accumulate -- which has been around since C++ 98. This is a powerful algorithm also known as 'fold' for summing up, or otherwise performing a 'fold' operation using some binary operation. One gotcha is to make s sure the initial type matches your result (as this is determined at compile-time by the template parameter type). I'll show in this example how to think about 'fold' operations, and shortly we will talk about a related operation known as 'reduce'.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

183. C++ STL numeric - reduce (parallel fold) | Modern Cpp Series Ep. 184 In this lesson we take a look at std::reduce -- which has been around since C++ 17 and improves upon std::accumulate. This is a powerful algorithm that allows us to get the benefits of accumulate (i.e. fold) but also provide an execution policy for potential parallelism. Two 'gotcha's' remain 1. make s sure the initial type matches your result (as this is determined at compile-time by the template parameter type) 2. Make sure the default value for the constructed type is what you want it, if you choose the overload that omits 'init'. I'll show in this example how to think about 'parallel fold' operations.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

184. C++ STL numeric - transform_reduce | Modern Cpp Series Ep. 185 In this lesson we take a look at std::transform_reduce -- which combines what we have learned in transform and reduce operations. Again the advantage of this algorithm has to do with being able to potentially being able to transform and reduce the data in one step, as well as potentially do that step in parallel (as opposed to doing all transforms first, and then a second reduction step). This is a powerful algorithm that I have frequently observed in high performance computing and image processing. Two 'gotcha's' remain 1. make s sure the initial type matches your result (as this is determined at compile-time by the template parameter type) 2. Make sure the default value for the constructed type is what you want it, if you choose the overload that omits 'init'. Note that you may have also heard of this algorithm as 'map-reduce'.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

185. C++ STL numeric - exclusive_scan, inclusive_scan | Modern Cpp Series Ep. 186 In this lesson we take a look at std::inclusive_scan and std::exclusive_scan which are similar to the previous std::partial_sum variations that we have seen. The difference however is that we are able to parallalize the operations with the functions described in this video, which are generally referred to as 'scans' or 'parallel scan' building blocks in the family of algorithms. I'll also link to some useful resources such as (https:\/\/developer.nvidia.com\/gpugems\/gpugems3\/part-vi-gpu-computing\/chapter-39-parallel-prefix-sum-scan-cuda and https:\/\/www.cs.cmu.edu\/~guyb\/papers\/Ble93.pdf) for use cases of these algorithms.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

186. std::format Introduction (C++20) - C++ Utilities | Modern Cpp Series Ep. 187 In this lesson we take a look at std::format which was introduced in C++ 20. This was a big innovation for allowing safer and easier access to formatted strings (and by many benchmarks, even more performant!). In this lesson I'll show you how to get started and formatting strings. We'll cover the basics, using positional specifiers to arrange arguments, format specifiers, fill, alignment, and precision! This is an action packed lesson, and I hope you enjoy it! As always, feel free to bring up any questions and discuss what you've learned!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

187. std::format with STL Containers - C++ Utilities | Modern Cpp Series Ep. 188 In this lesson we take a look at std::format again this time with containers! Note that this is a C++ 23 feature that requires the latest version of currently the clang compiler which supports printing out formatted STL containers. We'll talk more about printing out custom types later on in the series. As always, feel free to bring up any questions and discuss what you've learned!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. Installing Python on Linux - Learn Python 3 in a Weekend In this lesson I show you how to install Python 3 on Linux.\n\nsudo apt-get install python3\nsudo apt-get install idle3\n\nWe want to make sure we install Python 3 or later for our system. If you have further questions, feel free to post in the comments.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. Installing Python on Mac - Learn Python 3 in a Weekend In this lesson I show you how to install Python 3 on Mac.\nWe want to make sure we install Python 3 or later for our system.\nIf you have further questions, feel free to post in the comments.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. Installing Python on Windows - Learn Python 3 in a Weekend In this lesson I show you how to install Python 3 on Windows.\nWe want to make sure we install Python 3 or later for our system.\nIf you have further questions, feel free to post in the comments.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. Installing wxWidgets stable 3.0.5 from source on Ubuntu Linux and hello world C++ app with wx-config In this lesson we build the GTK version of wxWidgets following https:\/\/docs.wxwidgets.org\/3.1\/plat_gtk_install.html\n\nThis version uses configure to build a linux version of wxWidgets, and I complete the 'hello world' application.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. Building and Running Hello World wxWidgets 3.1.5 on Ubuntu Linux with CMake In this lesson I show folks how to compile and build wxWidgets from scratch, and to execute the 'hello world' example on a Linux machine.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. Building wxWidgets 3.1.5 for Mac (M1 Apple Silicon) from source | Setup and Hello World Example In this lesson I show folks how to compile and build wxWidgets from scratch, and to execute the 'hello world' example on a Mac with an M1 processor. I will use CMake to build the source code, make to compile, and then finally run a 'hello world' program.\n\n00:00 Introduction to building wxWidgets on Mac from source\n1:12 Documentation for building\n2:10 Using cmake to build\n3:05 Generating our makefile from cmake\n4:40 Doing a parallel build with make\n6:02 Completed build of libraries and wx-config tool\n7:03 Using wx-config to find include and library paths\n8:24 Building the hello world application\n10:15 Successful build and demo of application\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. wxWidgets - Running the included samples including the Advanced User Interface (aui) with wx-config In this lesson I show you how to build some of the samples from the command line that are included from wxWidgets. I hope this will help you evaluate whether the library is for you or not, and otherwise show off some of the cool features of wxWidgets.\n\n00:00 Introduction to learning from the wxWidgets samples\n1:50 Building the treelist examples\n3:46 Running the drag and drop (dnd) sample\n4:32 Running the Advanced User Interface (aui)\n6:30 Making sure to include specific wxWidgets libraries\n7:45 Successful execution of the AUI sample\n\nFor reference, here was my compilation command for building the aui demo: \ng++ -std=c++17 auidemo.cpp -o prog `.\/..\/..\/linuxbuild\/wx-config --libs std,aui --cxxflags`\n\nSome note on wx-config: https:\/\/wiki.wxwidgets.org\/Wx-Config\nSome notes on the wxAUI: https:\/\/wiki.wxwidgets.org\/WxAUI\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. wxWidgets hello world application explained In this lesson I spend some time walking through the hello world example explaining what the code is doing. I'll show you how to navigate the wxWidgets documentation, and we'll even dive into the source code so you can see that there is no magic behind the scenes of wxWidgets.\n\n00:00 Welcome and introduction\n00:55 Rebuilding the hello world example and review of wx-config\n2:30 Running the hello world example\n3:10 Hello world library includes and finding classes\n4:20 wxApp is our main application\n6:14 wxFrame understanding how to build our window\n8:10 enum and the idea of unique identifiers for events\n9:23 Diving into wxWidgets source to understand wxIMPLEMENT_APP\n13:00 OnInit and the setup of our application\n14:08 The parameters of wxFrame constructor\n15:24 Creating a user interface one object at a time\n16:06 Binding events to make action happen\n17:30 Where to go next for understanding wxWidgets\n19:30 Wrap up and conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. Building wxWidgets Legacy OpenGL sample (Shown on Mac M1) In this lesson I show you how to compile one of the included openGL examples for wxWidgets 3.1.5. The key to this example will be to make sure to include the 'gl' library and the 'std' library using wx-config. You will see me in this example walk through step by step, and how I fix the errors that you may encounter in order to get the example up and running.\n\nNote: If you are a linux user, you may also have to add '-lgl' to link the opengl library.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. The what and the why of concurrency | Introduction to Concurrency in Cpp In this lesson I'll introduce some of the ideas behind concurrency, how it is different than parallelism, and why on today's hardware we'll need to learn how to write concurrent code to maximize our performance.\n\n00:00 Introduction to the series\n00:40 What is concurrency\n1:53 Sequential software that we write\n2:59 Performance is our currency\n4:00 Parallelism versus concurrency\n6:00 Why concurrency is necessary\n7:20 Orchestras and dinner tables as an example of concurrency\n8:28 Hardware and concurrency support\n9:07 Moore’s Law\n11:23 Dennard Scaling\n12:31 Some hardware architecture examples\n13:49 Wrap up of our introduction\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. First thread with std::thread | Introduction to Concurrency in C++ In this lesson we learn about creating our first modern C++ threaded application. We learn about how to launch a thread and properly join a thread. The 'join' is a way to synchronize how the threads execute, and which thread will be blocked. A visual explanation is also provided to help comprehend how a thread is executing.\n\n00:00 Introduction to thread-based concurrency\n1:40 High level view of a thread.\n3:13 When should we use thread based concurrency\n4:28 std::thread in c++\n6:10 First C++ thread example\n9:17 Linking in a thread library, pthread\n9:47 Fixing a core dump by joining a thread.\n11:27 Corrected thread program execution\n12:36 Visual guide to how our thread executes along the main thread\n15:00 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. std::thread with a lambda in modern c++ | Introduction to Concurrency in Cpp In this lesson we'll refactor some code to launch a thread from a lambda instead of a function call. This can be an elegant way to launch a thread, especially if it is a short lived task that can be done in isolation.\n\n00:00 Using lambda’s in c++\n0:30 refactoring our threaded program with a lambda\n1:43 Threads can be launched with a callable\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. Launching multiple std::thread in C++ | Introduction to Concurrency in Cpp In this lesson we learn about creating our first modern C++ threaded application. We learn about how to launch a thread and properly join a thread. The 'join' is a way to synchronize how the threads execute, and which thread will be blocked. A visual explanation is also provided to help comprehend how a thread is executing.\n\n00:00 Launching multiple threads from a vector\n1:50 returning the executing thread id\n3:26 Sequential execution as a result of bad join\n4:50 Launching threads for parallel execution\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. jthread std::jthread in C++ 20 | Introduction to Concurrency in Cpp In this lesson we learn about a C++20 concept know as the jthread, which can be a cleaner way to ensure that if we by default want to join on our threads destruction (wherever that scope may be).\n\n00:00 Introducing the jthread\n1:24 RAII and how it ensures join on destruction\n2:59 jthread is a c++20 feature\n3:23 Successful execution of our program\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. std::mutex and preventing data races in C++ | Introduction to Concurrency in Cpp In this lesson show you how a primitive structure known as a mutex can be used to prevent data races.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. Preventing deadlock with std::lock_guard in modern C++ | Introduction to Concurrency in Cpp In this lesson we learn about deadlock, why it happens, how to prevent it, and why we may want to use RAII based locks (i.e., lock_guard) to help prevent us forgetting to release a lock.\n\n00:00 Being frozen in time, deadlock\n0:50 Creating a deadlock intentionally\n1:27 Visual of what it means to forget to unlock\n2:30 Why lock and unlock is not enough\n3:00 try\/catch and forgetting to unlock\n4:24 Introducing the lock_guard\n5:06 Refactoring with lock_guard for RAII\n6:33 Conclusion and notes on other locks\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. Using std::atomic in modern C++ to update a shared value | Introduction to Concurrency in Cpp In this lesson we learn how to use std::atomic to avoid using any locks or other primitives to update a shared value.\n\n00:00 Simplifying our update of a single value\n1:12 Updating our code with atomic\n2:02 Viewing atomic operations overloads available\n3:20 Atomics work with simple data types\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

8. Example Data Parallel C++ Program using multiple threads in SFML| Introduction to Concurrency in cpp In this program I show you how you can structure a program to utilize multiple threads based off of what we have previously learned. We are now understanding the idea of having a 'worker thread' perform some task or computation, while our main thread performs the actual rendering of our graphical scene.\n\nNote: I use the SFML library here and have some videos available here if you are curious on using the library: https:\/\/www.youtube.com\/playlist?list=PLvv0ScY6vfd95GMoMe2zc4ZgGxWYj3vua\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

9. Condition Variable in Modern cpp and unique lock | Introduction to Concurrency in C++ In this lesson I teach you about how to use a condition_variable in C++. This is a relatively old concept that is useful for making sure that cpu time is not wasted attempting to constantly 'try' to acquire a lock.\n\n00:00 Synchronization of threads with locks\n1:20 Wasted cpu cycles waiting\n1:58 Introduction to condition variable\n3:20 What is needed for condition variables\n4:21 Worker and reporter thread idea\n5:00 Implementation of condition variable\n5:45 Setting up condition variable\n6:30 Setting up our 2 threads\n7:20 Setting up worker thread\n8:07 Using a unique_lock\n9:20 Doing work in reporter thread and updating condition\n10:50 notify with condition variable\n11:58 Setting up reporting thread\n12:46 Condition variable wait\n13:20 wait blocks a thread\n14:04 notify wakes up a thread\n14:34 Syntax fixes\n15:08 Logic fixes\n15:40 Successful execution of program\n16:10 Explanation again of what we have done\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

10. std::future and std::async in Modern cpp | Introduction to Concurrency in C++ In this lesson I teach you std::async and the idea that it returns a future. We block on the futures result if we need to compute the result, and otherwise std::async is an easy way to launch threads.\n\n00:00 Introduction to std::async\n1:11 What is a future\n2:02 Creating a std::async function\n3:27 Retrieving result with get\n4:00 What is the point of async?\n5:29 Waiting on a futures result\n6:00 Progress is made in background on a task\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

11. std::async in cpp with background thread loading data example | Introduction to Concurrency in C++ In this lesson I show you an example with std::async and how you can use it to load data in a background thread. We also discuss the policies that exist for how to launch a std::async, and look at the futures library to get the status of our future.\n\n00:00 Return to async\n00:20 Real world example with Youtube\n1:45 Program design with background thread\n2:50 Starting our program\n3:37 Discussion of std::async policies\n4:50 Setting up our background thread\n5:50 Understanding future_status\n6:30 The main program loop\n8:45 Checking status of future\n10:02 Implementing our background thread\n12:00 Compilation and bug fixes\n12:40 Successful execution of the program\n14:50 Conclusion, like, and subscribe!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

12. Example of gcc and clang thread sanitizer to detect data race - Introduction to Concurrency in C++ In this lesson I show you how to use the thread sanitzer provided in both gcc and clang compilers. Using the thread sanitizers can help save you time debugging programs at scale for thread related errors.\n\nSome helpful links to documentation:\n1. https:\/\/gcc.gnu.org\/onlinedocs\/gcc\/Instrumentation-Options.html\n2. https:\/\/clang.llvm.org\/docs\/ThreadSanitizer.html\n\n00:00 Recap on threaded code with a data race\n1:39 Introduction to thread sanitizers\n3:14 g++ thread sanitizer usage\n5:20 clang thread sanitizer usage\n6:10 Conclusion, use your tools!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

13. Using a trylock | Introduction to Concurrency in C++ In this lesson I show you the difference between calling 'lock' on a std::mutex and something known as a try_lock. The try_lock will immediately return depending on if the lock was able to become successfully acquired or not, allowing threads to continue their execution.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. Design Patterns - Command Pattern Explanation and Implementation in C++ In this lesson I teach you one of the most powerful behavioral design patterns, the command pattern. This pattern models objects to act as a command, and it is one of the most convenient ways to store a series of 'commands' or actions that happen throughout your program. I will show you a use case of using the pattern to store commands as a queue, and this pattern could be used to elegantly implement and undo\/redo system.\n\nFree resource: https:\/\/gameprogrammingpatterns.com\/command.html\n\n00:00 What are Design patterns\n00:30 Behavioral Design Patterns\n1:00 Command Pattern\n1:30 Command Patterns uses\n1:59 Design Pattern Resources\n2:50 Conceptual Understanding of command pattern\n4:00 A game controller example\n4:40 Utilizing inheritance for is-a relationship\n5:20 Key idea of what a command does\n5:50 C++ explanation of virtual\n6:30 Enqueing commands in some data structure\n7:40 Undo commands in our history\n9:10 Starting our command pattern in C++\n10:15 Creating our command class\n10:45 Creating our interface member functions\n11:25 A simple use case for our command pattern\n12:40 Creating a Move, which is a type of Command\n13:50 Showing how pure virtual functions must be implemented\n15:00 Creating a character\n15:45 Passing our character as an argument\n17:02 Preparing our character to move\n18:25 Adding some output to see what is going on\n20:00 Our characters first command\n20:40 Storing multiple commands in a queue\n23:00 Managing lifetime of our commands with pointers\n24:40 Undoing our commands\n25:30 How do we know it is working?\n26:00 Storing position data for our character in move\n29:35 Verifying our execute and undo work\n31:30 Using a different data structure to perform undo\n32:12 Final code walk through\n34:10 Closing\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. Design Patterns - Singleton Pattern | Explanation and Implementation in C++ In this lesson I show you how to implement a creational design pattern in C++ known as the singleton. This is a controversial pattern to many in that it can be misused, however, the pattern itself can be useful when we truly need only 1 point of access for a specific class (e.g., a file system or logger). This lesson will also refresh you on the idea of 'static' which is a clean way to implement the singleton pattern.\n\nUseful resource on understanding static https:\/\/en.cppreference.com\/w\/cpp\/language\/storage_duration\n\n00:00 Design Patterns are not perfect\n00:58 Creational Design Pattern\n2:25 Sample Logger Class\n4:10 Creating multiple instances of an object\n5:15 Utilizing access modifiers of class for constructor\n6:06 Idea of a GetInstance member function\n7:06 The static keyword\n7:50 static function example\n10:22 Practical use case of static in a class\n11:00 Initializing static member variables\n13:30 A static pointer to instance of our class as member variable\n15:40 Utilizing a member function from our single instance\n16:50 Creating a static member function\n17:37 Implementing our logger class\n19:10 Allocating memory for our pointer\n20:50 Adding messages to our logger\n22:18 Careful with returning pointers to member variables\n24:20 Design to protect your clients of your API\n25:10 Create the static variable within GetInstance\n27:30 Other design considerations and closing\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. Design Patterns - Factory Method Pattern Explanation and Implementation in C++ In this lesson I teach you about a creational design pattern to have a single point in which you allocate objects at run-time. This is the factory method (or factory function), which takes advantage of inheritance based polymorphism to create the correct object at run-time and return it to the user.\n\n00:00 Factory method and definition\n1:25 Goal of the factory method pattern\n2:37 Inheritance based polymorphism\n3:40 Start of implementation with interface\n4:50 Creating derived classes\n5:58 Creation of our factory\n9:15 Confirming the factory works in GDB\n10:50 Refactoring our factory arguments with enum class\n14:35 Returning a smart pointer from our factory\n16:12 Confirming no memory leaks with valgrind\n17:30 Recap of source code and pattern\n18:00 Pros and cons of the pattern\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. Design Patterns - Factory Method Pattern Adding More Power to Count Allocated Objects in C++ In this lesson I present a few ideas on how you may decide to add more power to the 'Factory Method' pattern. \n\nIf you'd like to review singletons, you can do so here: https:\/\/www.youtube.com\/watch?v=eLAvry56vLU&list=PLvv0ScY6vfd9wBflF0f6ynlDQuaeKYzyc&index=2\n\n00:00 Recap of previous lesson\n00:55 Wrapping the factory into a singleton\n1:40 Our motivation is for book keeping\n2:20 Refactoring our function into a class\n4:50 First test after refactoring\n5:46 Counting object types that were created\n7:50 PrintCounts function implementation\n9:00 Discussion on counting active objects\n10:27 Sketch of using adapter to count objects\n12:25 Other idea to use weak pointers to count active objects\n\nNOTE: You will have to think a little bit about solution you would like to implement, and as always, there are tradeoffs depending on how much power you want, how many layers of abstraction you may choose to use (and if this may cost you space or time), and how simple (i.e. readable) you want your code to be.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. Design Patterns - The Extensible Factory Pattern in C++ | Register Objects at Runtime In this lesson I present to you an even more powerful version of the factory, in which you can extend and register objects at run-time in your factories. This makes your factories even more powerful, as clients can derive objects from your base classes, and then register them so they are created from the same factory you provide.\n\nIf you'd like to review a previous iteration of the factory pattern, you can do so here: https:\/\/youtu.be\/VVsvhA_FdXU\n\n00:00 Introduction and refresher on factory pattern\n1:10 Utilizing run-time polymorphism for factory\n2:10 Extensible Factory allows you to add objects at runtime\n3:20 Refresher of IGameObject\n4:05 The Create Function in derived types\n5:10 Example of a user created type derived from IGameObject\n6:15 The Extensible Factory Interface\n7:35 Using a callback function as a parameter in a map\n8:33 Map storing how to create types\n10:30 Implementation of Extensible Factory\n12:17 Registering new types\n13:00 Using our factory\n14:25 GDB walkthrough to show working extensible factory\n16:40 Conclusion and wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. Design Patterns - Iterator Pattern Explanation and usage with STL in C++ In this lesson I present to you the behavioral pattern for the iterator. Iterating through code is something you are likely familiar with, but using iterators is useful for clearly showing the intent in the code for how you traverse a data structure. Additionally, iterators provide a uniform way to traverse a data structure if you need to make changes in multiple places.\n\n00:00 Introduction to the Iterator Behavioral Pattern \n2:00 C++ iterators for STL\n2:50 A series of trivial Iteration examples\n6:00 Built-in iterator examples\n8:36 const_iterator\n9:56 reverse iterator\n11:04 std::next and std::advance to control iterator\n12:59 Ranged-based loops\n14:08 Iterators in an unordered_map\n16:48 Wrap up and conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. The Observer Design Pattern in C++ - Part 1 of n - A simple implementation In this lesson I present to you the basics of the Observer Design pattern in C++ with the theory and a first implementation. We will implement the most naive version of the observer pattern so that you understand from scratch exactly how to create this pattern. I'm going to do this in an object oriented manner, but it need not be limited to just object oriented programming.\n\n00:00 Introduction\n01:00 Theory of where to use Observer Pattern\n10:20 Implementation of Observer Concrete Class\n12:30 Implementation of Subject Concrete Class\n16:30 Creating a simple test\n20:30 Review of our simple implementation\n21:53 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. The Observer Design Pattern in C++ - Part 2 of n - Extensibility and Abstraction In this lesson we continue our discussion of the Observer pattern, this time improving it with abstraction and creating an interface.\n\n00:00 Introduction\n00:27 Recap of previous lesson\n03:05 Adding an interface to our subject and observer overview\n05:30 Code walk through of what we are going to build.\n06:52 Code Implementation of IObserver and Watcher\n11:56 Code implementation of ISubject and SomeSubject\n14:25 Test case of observer pattern\n16:30 Review of what we coded\n17:12 Pros and cons of current implementation\n19:15 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

8. The Observer Design Pattern in C++ - Part 3 of n - Registration and Lifetime In this lesson we are going to refactor our code yet again, this time to more safely register (add\/subscribe) and unregister (unsubscribe\/remove) observers to their subjects. Note that this lesson builds off of the previous two in this series.\n\n00:00 Introduction\n00:45 Recap of the previous lesson.\n02:40 Demonstrating the problem with our observers\n05:00 Utilizing RAII with our Concrete Observer (Watcher) class to register\/unregister\n08:14 Creating a test case in our main\n09:48 Separating our project into separate files so we have concrete types\n13:33 Demonstration of our new Watcher class preventing lifetime errors.\n15:10 Review of the key insight from this lesson.\n16:24 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

9. The Observer Design Pattern in C++ - Part 4 of n - Notify Specific System In this lesson we are going to refactor our code yet again, this time to more safely register (add\/subscribe) and unregister (unsubscribe\/remove) observers to their subjects. Note that this lesson builds off of the previous two in this series.\n\n00:00 Introduction\n00:30 Review of Previous Lesson\n01:53 Design of our next Observer Implementation\n07:10 Modifying our Subject with 'Message Types' and map data structure\n10:39 Implementation of 'AddObserver' with different 'Message Types'\n15:08 Modifying our 'IObserver' to register with as a specific 'Message Type'\n19:45 Modifying our 'NotifyAll' to iterate through entire map\n21:10 Modifying our Observer to store 'Message Type'\n24:06 Modifying our 'RemoveObserver'\n27:48 Review and Design decision to consider on Add\/Remove Observer\n29:28 Implementing Notify for specific 'Message Type'\n31:10 Example demo of our system\n33:15 Review on Pros and Cons on our system\n36:10 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

10. The Observer Design Pattern in C++ - Part 5 of 5 - Review and Next Steps In this lesson we wrap up with our design pattern. I will do a summary to show you what we have accomplished in this series, and then talk about some of the next steps for taking the observer pattern further.\n\n00:00 Introduction\n00:27 Code Review of what we have built\n5:38 Observer Pattern used in open source projects\n08:42 Some ideas to improve the pattern\n14:19 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

11. C++ Visitor Design Pattern - Part 1 of 4 - Programming Paradigms In this lesson we take a look at different programming paradigms. The purpose is to better understand how we work with data and behaviors, and how different paradigms force us into these designs.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

12. C++ Visitor Design Pattern - Part 2 of 4 - Object Oriented Hierarchies In this lesson we introduce a real world problem, and think about the data and the object-oriented hierarchy of objects. The object-oriented solution otherwise provides the solution to how we have to add new behaviors to our object directly into the object structure.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

13. C++ Visitor Design Pattern - Part 3 of 4- Coding the Visitor In this lesson we code from scratch the visitor pattern in C++. I will show you how we can create a second hierarchy to implement behaviors. The idea is that we can pass in 'Monsters' to one side (they 'visit' a visitor), and the 'Monster' can otherwise accept behaviors (Anything in the 'Monster Visitor Hierarchy'). We'll end the video talking about some of the trade-offs otherwise of the visitor pattern.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

14. C++ Visitor Design Pattern - Part 4 of 4 - std::visit and std::variant version In this 'bonus lesson' we'll wrap everything up, and I'll show you another version of the visitor pattern in a more 'functional' style approach. The point of the first visitor pattern video, was to introduce different programming paradigms to you, so that you can think about code and data. So to wrap things up, I'll show you a version of the visitor pattern using std::visit and std::variant.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

15. C++ Strategy Design Pattern - Part 1 of 2 - Changing Algorithmic Behavior In this lesson we talk about how to change algorithmic behavior at run-time by using inheritance for use in the strategy pattern. We typically choose to create a inheritance hierarchy when we have a family of related algorithms that could be called based on some condition at compile-time or run-time. In this video, we'll try to motivate the strategy pattern, and further understand where we may use the strategy pattern in applications. Stay tuned to the next video for an implementation!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

16. C++ Strategy Design Pattern - Part 2 of 2 - C++ Implementation In this lesson implement the strategy pattern (a behavioral design pattern) from scratch in Modern C++. This is a small example that otherwise shows the fundamental ideas and tradeoffs of the strategy pattern.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

17. Flyweight Structural Design Pattern in C++ - Part 1 of 2 - Understanding the Pattern In this lesson we understand the flyweight pattern, which is a structural design pattern. The flyweight can be used to improve your performance significantly by sharing 'common' (often immutable) components of data. In the next lesson, we'll look at implementing the flyweight pattern.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

18. Flyweight Structural Design Pattern in C++ - Part 2 of 2 - Implementation (with factory) In this lesson we do a quick review of the structural design pattern the flyweight pattern, and then we dive into an implementation. I will show you how to create a basic flyweight object, and then we will also create a factory, and ultimately use a shared_ptr in a map to share our objects. There are several ways to structure a flyweight, and we'll hope to understand the trade-offs at the end of the video when we finish. As always, please share your thoughts and any interesting use cases you have found for the flyweight!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

19. Component Pattern in C++ - Part 1 of n - Identifying Components In this lesson we are going to begin introducing the component design pattern. This is a type of structural design pattern that has gained extra popularity in the gaming domain. We'll start this first lesson by first just identifying objects and components in a system, and thinking about different ways to organize them. This series will then continue in the next few days -- so stay tuned! As always, feel free to leave comments discussing your idea of how to build a 'root' or 'base' object (i.e. A 'GameObject' in this example)\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

20. Component Pattern in C++ - Part 2 of n - Component Pattern Basics In this lesson we are introduce our component design pattern, and contrast it with the 'monolithic object' design we previously had. Fundamentally, the component design pattern is just replacing our data members with a vector of data members. This adds a layer of indirection for the flexibility of being able to 'resize' and 'change' the functionality of a game object (which just holds components). We'll later discuss how this can be improved further by building an entity-component system for those who are trying to squeeze out even more performance. As always, feel free to leave comments discussing your ideas on the component pattern. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

21. Component Pattern in C++ - Part 3 of n - Component Pattern Implementation In this lesson we write a simple implementation of the component pattern in C++. I use a map and constrain us to one component per game object. You may further think about how to support multiple components, and otherwise how to use unique_ptr's and resource managers to otherwise manage the components (e.g. texture components may be something that is better shared and looked up from a resource manager). As always, feel free to leave comments discussing how to improve the implementation and use cases of the component pattern. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

22. Component Pattern in C++ - Part 4 of n - Component Pattern, Data Oriented Design Discussion In this lesson we discuss one strategy using a more 'data-oriented' approach for accessing components in flat arrays. This moves us more towards a 'entity-component system' style of design which is frequently used in games for performance. We'll discuss this style and provide a brief discussion of a 'cache' and 'memory hierarchy'. As always, feel free to leave comments discussing Entity-Component Systems. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. New SFML 2.0 C++ Series Introduction! A brief welcome and introduction to the SFML library. Be sure to check out the SFML web page to get excited about some of the materials we will be learning!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. [Setup] SFML Setup on Linux (Shown on Ubuntu 18.04) In this lesson I will show you how to setup libsfml-dev (i.e. the sfml libraries and header files) using the Ubuntu package manager.\n\nUnderstanding compilation tutorial: https:\/\/www.youtube.com\/watch?v=ksJ9bdSX5Yo&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=4\n\n00:00 Introduction\n00:35 Installing sfml using apt package manager\n1:54 Testing our installation\n2:30 Compiling our code\n2:50 Fixing 'undefined reference' errors (i.e. make sure to link libraries)\n3:30 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. [Setup with Brew] Compile SFML on Mac on the command line (Shown on Apple M1) -- No XCode In this lesson I teach you how to compile SFML with Mac using only the command line and the brew package manager. No need to use XCode or any other fancy IDE for this lesson. That said, it can be a little tricky to get the compile options correct, so I hope this video will help!\n\n00:00 SFML Web Resources\n1:08 Brew setup and installation\n1:38 Install SFML with brew\n2:10 Finding SFML installation directory\n3:15 Sample SFML Program \n3:40 Including header files and library files\n5:37 Successfully running our SFML program\n\nUnderstanding compilation tutorial: https:\/\/www.youtube.com\/watch?v=ksJ9bdSX5Yo&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=4\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. [Compile from Source] Compile SFML From Source on Linux (Fix dependencies, and learn how to link) In this lesson I teach you how to compile SFML from the github repository from source code on Linux. I'll show you how to fix some dependency errors, compilation errors, and how to link to get a hello world application running.\n\nUnderstanding compilation tutorial: https:\/\/www.youtube.com\/watch?v=ksJ9bdSX5Yo&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=4\n\n00:00 Introduction\n00:30 Purging any previous installation\n00:50 Download from github repository\n1:30 Using CMake\n2:30 Fixing a missing dependency\n3:00 Using apt-cache to find the missing library\n3:30 Installing missing dependency\n3:50 Building SFML\n4:50 Hello SFML Tutorial\n5:30 Including the appropriate header files\n6:45 Compiling with C++17\n7:10 Linking in the correct libraries\n8:10 Missing path for runtime libraries\n10:30 Successfully running SFML application\n11:30 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. [Compile from Source] Build and Compile SFML from source on Visual Studio with CMake on Windows 11 In this lesson I teach you how to compile SFML from the github repository from source code using Visual Studio. I'll also show you how to fix some dependency errors, compilation errors, and how to link to get a hello world application running on Visual Studio.\n\nUnderstanding compilation tutorial: https:\/\/www.youtube.com\/watch?v=ksJ9bdSX5Yo&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=4\n\n00:00 Introduction\n00:40 Visual Studio Download\n1:00 CMake Download\n1:20 SFML Download from github\n2:40 CMake GUI to build our build file\n3:50 CMake Target Project\n4:40 Generating a build file\n5:30 Navigating Visual Studio Project\n6:00 Building the SFML webpage\n7:00 Sample 'hello world' SFML code\n7:30 Creating a new visual studio project\n8:10 Setting up x64 build\n8:55 Fixing 'include' paths in Visual Studio Project\n10:00 Setting C++ Language version to C++17 or greater\n10:55 Fixing Linker errors by setting up Linker path\n13:07 Moving dlls into executable path\n14:30 Successful application of our SFML program!\n15:00 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. [Compile from Source] Building SFML from Source on Apple M1 Mac (And fixing common build errors) In this lesson I teach you how to compile SFML from the github repository from source code using a Mac on the command line. I'll show you how to fix common errors, make sure the code is configured properly with CMake, and ultimately how to build the hello world application in SFML from a version of the library you built from source.\n\nUnderstanding compilation tutorial: https:\/\/www.youtube.com\/watch?v=ksJ9bdSX5Yo&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=4\n\n00:00 Introduction\n00:40 Getting started with prerequisites\n1:25 Downloading SFML\n2:00 Getting started with CMake\n5:00 Building the SFML libraries with Make\n5:50 Creating a 'hello world' sfml application\n6:30 Fixing our Include Paths\n7:30 Fixing the standard version of C++ used\n8:40 Fixing linking errors\n10:40 Fixing 'built for newer macOS version' error.\n11:40 Fixing 'Library not loaded @rpath' error.\n14:00 Successfully building project\n14:38 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. SFML Hello World Explanation, and exploring the API documentation In this lesson I walk through the sample hello world application in SFML. We'll take a look at the different parts of the hello world application, citing the official documentation. I'll also spend some time talking about the general architecture of multimedia applications. One key component is the 'update' portion, in which we handle sf::events. \n\n00:00 Introduction\n00:30 Review of last time\n1:00 Opening the API documentation\n1:40 The five modules in SFML\n2:13 The common SFML Application architecture\n3:25 sf::RenderWindow\n4:03 sf::CircleShape\n5:23 The Application Loop (i.e. Infinite Game Loop)\n7:52 Example sf::event for closing the application\n8:40 Rendering order of operations explanation\n9:52 Cleaning up our application\n10:15 Conclusion and Homework\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. SFML Detecting Mouse events and keyboard key press events In this lesson I am going to show you how to use the SFML Documentation to get an idea of what an 'event' is, and how to then perform key presses and mouse clicks. We'll learn by exploring the documentation, such that this way you do not have to rely on tutorials in the future once you get a hang of navigating the docs!\n\n00:00 Introduction\n00:50 Opening up the documentation\n1:20 Discussing sf::event\n2:30 Handling MouseButtonPressed\n3:35 Handling Key presses\n5:10 Detecting a specific key press\n8:00 Discussion of other sf::Event\n8:40 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

8. SFML Mouse and keyboard static member functions In this lesson I am going to show you how to use the public static member functions in sf::Mouse and sf::Keyboard to detect mouse and key presses anywhere in your code (i.e. outside of your event loop). I'll also show you how to handle the difference between holding your mouse down and detecting one click, versus holding your mouse down and detecting a constant series of mouse clicks.\n\n00:00 Introduction\n00:40 What if we want to press a key and the mouse at the same time?\n1:20 Static Public Member functions for sf::Mouse\n4:50 Handling only one mouse button press with isButtonPressed\n7:00 sf::keyboard public static member functions for checking key press\n8:40 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

9. SFML Introduction to Sprites and Textures In this lesson we are going to be learning about sf::Sprite and sf::Texture. Textures are pasted on top of sprites, and allow us to move images around. Note that a texture is different than a image, in that a texture lives in memory on our graphics card (We don't have to think about how the pixels are transferred to the GPU, as sfml takes care of that). Finally in this lesson, I'll show you how to transform the sprite to make our scene a bit more dynamic.\n\n00:00 Introduction\n00:30 What is a Sprite\n1:00 What is a texture? (And why it's different than an image)\n2:40 Creating a Sprite\n3:40 Creating a texture\n4:45 Acquiring the Mona Lisa\n5:50 Displaying our sprite, exploring sf::Drawable\n7:55 Successful application running\n8:33 Transforming (i.e. scaling) our sprite\n9:12 Moving our sf::Sprite\n11:00 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

10. SFML Introduction to Fonts and sf::font In this lesson we learn how to load a custom font and display text to our screen. Another subtle part of this lesson, is to note that the drawing order is very important for us to consider--this is known as the painters algorithm.\n\n00:00 Introduction\n00:47 Exploring sf::Text a type of sf::Drawable\n1:17 The sf::font class\n2:20 Downloading a true type font\n3:15 Creating and loading our sf::font\n4:06 Creating our sf::text\n4:46 Drawing and positioning our text\n5:33 Thinking about the order of rendering, painters algorithm\n6:33 Repositioning and resizing our text\n7:14 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

11. SFML Framerate (FPS) calculation and frame rate limiting In this lesson I show you how to calculate the framerate for an application. I talk about the problem with not limiting the framerate from our previous application (i.e. the sprite will move too fast on different machines), and we see how to correct it using SFML's built-in frame limiting function. You will also understand after this lesson how to compute and limit the framerate yourself, if you'd like to build your own utility.\n\nNOTE: It's probably worth providing an assertion to ensure currentTime does not return 0.\nNOTE: If you also do not see a change in framerate with the setFramerateLimit function, you may have to disable vertical sync.\n\n00:00 Introduction and framerate defined\n1:00 Illustrating the problem--demo\n1:54 Framerate calculation explanation\n4:00 sf::clock and sf::time classes in SFML\n4:40 Elapsed time calculation\n5:40 Implementation of calculating frames per second calculation\n9:00 Limit frame rate (setFramerateLimit)\n11:57 Conclusion \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

12. MONSTER lesson on Game Entities and Entity Component System in SFML In this lesson I show you how to build a simple game entity class and the start of a game entity component system. I'll talk about some of the design considerations that you need to make, and why I make them. There will be more to iterate on, and your entity systems capabilities will change depending on if you are making a specific game, or an engine (and that will further evolve your software architecture). By the end of the lesson, we will build a simple 'screensaver' effect with some 'ghosts' that I have provided, to make this a MONSTER lesson.\n\n00:00 Introduction \n1:00 Game Entity and Components idea\n2:12 Code structure review and restructuring\n4:30 Starting to create a Sprite2DComponent\n10:50 Test of Sprite2DComponent\n13:10 Discussion of different types of components\n14:45 Creation of the Game Entity 'holder' class\n20:40 Creating a base class for our components\n23:50 Utilizing inheritance-based polymorphism for our components\n28:00 First iteration of Game Entity\n29:15 Moving our game entity\n32:25 Creating multiple game entities\n36:00 Moving our game entities\n42:00 First test of moving entities\n42:50 Improving the movement of our game entities with rand()\n44:40 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

13. SFML Building an Entity Manager from Scratch Using Factory In this lesson I show you how to build an entity manager from scratch. You'll be utilizing data structures like an unordered_map and two design patterns (singleton and factory) to build your entity manager. Having all of your entity creation located in one place can be very useful for logging, resource management, and making your game framework more usable by clients.\n\nFactory Method Pattern Video tutorial: https:\/\/www.youtube.com\/watch?v=vAmDQKeC99g&list=PLvv0ScY6vfd9wBflF0f6ynlDQuaeKYzyc&index=3&\nSingleton Pattern Video tutorial: https:\/\/www.youtube.com\/watch?v=eLAvry56vLU&list=PLvv0ScY6vfd9wBflF0f6ynlDQuaeKYzyc&index=2\n\n00:00 Introduction \n1:10 Entity Manager Class Design using a factory and singleton\n3:25 Review of previous project structure\n4:50 Start of Entity Manager implementation\n7:46 Discussion and rationale of unordered_map to store our entities using smart pointers\n12:40 Instance() function to access our entity manager\n14:20 Recap of how to compile SFML project with build.sh\n15:06 Creating entities (A basic factory pattern)\n16:26 First test of our Entity Manager\n18:05 Storing our created entity in the unordered_map\n20:40 Retrieving entities from our Entity Manager\n22:45 Rendering all of our entties from our entity manager\n26:15 Refactoring our project to render entities from our entity manager\n31:20 Successful run of our application\n32:06 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

14. SFML 2.6.0 is released! [News piece] In this lesson I give you an exciting update that a new release of SFML version 2.6.0 is out! This release offers a few new features, many bug fixes, and sets up for roadmap for the future SFML 3 relesae.\n\n00:00 Introduction \n00:10 The news! \n3:18 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. [Ep. 1] What is the Simple Directmedia Layer (SDL) and how to get started | Introduction to SDL2 Welcome to the introduction to a series on learning the Simple DirectMedia Layer (SDL2) in C++. This series will show you how to use the C-based SDL2 API, and I will be using the C++ language. Most of the lessons I will be building from scratch or showing code how to utilize various features. This series will skew towards folks who want to make games or other graphics applications.\n\nUnderstanding compilation tutorial: https:\/\/www.youtube.com\/watch?v=ksJ9bdSX5Yo&list=PLvv0ScY6vfd8YRjgGvXKJRAMZQAxNypcH&index=3\n\n00:00 What is SDL2\n1:00 SDL2 website, and why it’s a good choice\n2:30 SDL2 Wiki and documentation\n3:10 Github Repository for this series\n3:55 First SDL2 program\n5:04 Linking in SDL2 explanation (in C and C++)\n6:45 First SDL2 program from scratch\n9:40 Attempt to compile without linking\n10:13 Fixing linking errors\n11:41 SDL2 Documentation to SDL_Init\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. [Ep. 2] [Setup] SDL Linux command line setup with Glad and OpenGL | Introduction to SDL2 In this lesson I show you how to setup SDL2 for Linux, and how to build a program from the command line. Many folks will also be interested in how to setup OpenGL alongside SDL2, so I will show that in this series as well for how to connect to an OpenGL context.\n\nCheckout this video if you want to see the source code for setting up OpenGL: https:\/\/www.youtube.com\/watch?v=LJItKy96tN8&list=PLvv0ScY6vfd-p1gSnbQhY7vMe2rng0IL0&index=12\n\n00:00 Introduction\n00:34 GLXInfo to query your OpenGL features\n1:22 Using lspci to see your PCI hardware\n3:00 Using apt search to install SDL2 libraries\n4:40 Downloading sample OpenGL SDL2 application\n5:24 Attempting to compile source code\n5:55 Fixing include paths for GLAD\n6:14 Fixing linker errors \n7:11 Linking in SDL2 library\n7:51 PATH variable\n8:26 Linking in dl library\n8:50 Successful SDL2 Window compiled and linked\n9:47 Recap of what we have learned\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. [Ep. 3] [Setup] SDL Windows Setup with Mingw and Simple OpenGL Application | Introduction to SDL2 In this lesson I will show you how to setup the SDL2 library using a C++ compiler on windows. We'll be using the Mingw compiler, which is a 'gcc' port to the windows platform.\n\n00:00 Goal to Setup MinGW\n1:00 Downloading Mingw\n1:35 Installing Mingw tools\n3:20 Setting up Windows Command Prompt for g++\n4:43 Modifying Environment variables\n5:40 Downloading Git\n6:38 Downloading sample SDL2 project from Git\n7:33 Installing SDL2 for minGw\n9:16 Copying files from SDL2 into minGw\n10:38 Including and compiling glad\n13:00 Linking in SDL2\n13:22 Linking in mingw32\n14:08 Modifying the sample code\n14:52 Installing Python\n\nCheckout this video if you want to see the source code for setting up OpenGL: https:\/\/www.youtube.com\/watch?v=LJItKy96tN8&list=PLvv0ScY6vfd-p1gSnbQhY7vMe2rng0IL0&index=12\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. [Ep. 4] [Setup] SDL Mac (Including M1) Setup with Simple OpenGL Application | Introduction to SDL2 In this lesson I will show you how to setup SDL2 on the Mac operating system using the clang++ compiler. I'll intentionally make a few mistakes so you can see each step of the build process and setup your executable. Additionally, we'll setup OpenGL for use on the Mac. Note that Mac has deprecated OpenGL to a maximum version of 4.1.\n\nCheckout this video if you want to see the source code for setting up OpenGL: https:\/\/www.youtube.com\/watch?v=LJItKy96tN8&list=PLvv0ScY6vfd-p1gSnbQhY7vMe2rng0IL0&index=12\n\n00:00 Goal to Setup SDL2 on command line for Macs\n00:43 Downloading SDL2\n1:13 Installing the SDL2 Framework\n2:13 Obtaining a sample SDL2 and OpenGL program\n2:48 Using clang++\n3:36 Setting up the Include path to SDL.h\n4:45 Fixing the header path to SDL.h\n5:23 Setting up Glad\n6:10 Fixing linking errors by compiling glad.c\n6:55 Linking in SDL2\n7:36 Successfully running our SDL2 program\n8:06 Naming our binary executable\n8:42 Querying your GPUs on your system\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. [Ep. 5] [Setup] SDL2 Windows Setup with Visual Studio 2017 Setting up SDL 2 on Windows 10 with Visual Studio 2017.\nI got some tips on how to setup SDL through code from this resource: http:\/\/lazyfoo.net\/tutorials\/SDL\/01_hello_SDL\/index2.php\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. [Ep. 6] [Setup] SDL2 Windows using Visual Studio with Glad Visual C++ setup for my graphics course. Glad helps us use modern OpenGL by managing the extensions.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. [Ep. 7] Helpful Tip on Navigating the Wiki | Introduction to SDL2 In this lesson I want to show you how to navigate the help system in SDL2 from the website documentation.\n\n00:00 Searching the SDL2 Docs\n00:40 API By Category\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. [Ep. 8] Exploring the SDL source code | Introduction to SDL2 In this lesson, I want to show you a few tricks for exploring an unfamiliar API. In the worse case that the documentation does not have specific information, you may have to work through the source code--so I hope this will help!\n\n00:00 Finding the documentation\n00:30 zlib license and github source download\n1:10 Grepping for specific functions\n2:22 Exploring SDL_Init\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

8. [Ep. 9] Creating a Window in SDL | Introduction to SDL2 In this lesson I show you how to create a window after initializing SDL2. We'll then add a slight delay to keep the window open for a few moment so you can observe your work.\n\n00:00 SDL_CreateWindow in the Documentation\n1:57 Creating an SDL2 Window\n3:10 Call to SDL_CreateWindow\n4:47 SDL_Delay function\n5:33 Running our program with a Window\n6:22 Review of the code\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

9. [Ep. 10] Application loop and Event Queue with SDL PollEvent | Introduction to SDL2 In this lesson I talk about how SDL2 and how to handle events. SDL2 handles this like many other event-driven applications, in which it will poll for events that are put onto a queue, and then those events can be handled individually.\n\n00:00 Introduction\n00:30 Explaining an Event Queue\n2:20 Creating the main application loop\n3:20 SDL_PollEvent and our event loop\n4:40 Handling SDL_QUIT Event\n6:39 Reviewing the Event Queue and Documentation\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

10. [Ep. 11] Understand SDL Event with Mouse motion, key presses, keycodes and scancodes | Intro to SDL2 In this lesson I show you how to handle key press events, and how to handle specific key presses on the keyboard.\n\n00:00 SDL_Event documentation and usage\n1:40 Handling event.type\n4:02 Handling SDL_KEYDOWN\n5:00 Handling specific key presses\n6:30 SDL_KeyboardEvent\n7:07 SDL_Keysym\n8:02 Handling a keypress for SDLK_0\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

11. [Ep. 12] SDL keyboard input with GetKeyboardState | Introduction to SDL2 In this lesson, I show you how to handle keypresses by handling scan codes. Scancodes and keycodes differ, in that keycodes map to the physical keyboard and return a specific scancode. Some information can be found specifically here on the difference: https:\/\/wiki.libsdl.org\/CategoryKeyboard\n\n00:00 GetKeyboardState to find all scan codes\n1:25 Using SDL_GetKeyboardState to detect keypresses\n3:48 SDL_SCANCODES\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

12. [Ep. 13] First SDL OpenGL Window with GLAD fully explained | Introduction to SDL2 In this lesson I provide a detailed instruction on how to setup OpenGL. In this lesson I will be using the GLAD library to setup the function pointers for OpenGL, and I'll show you how to set that up from scratch as well. I'll show each of the steps along the way for including the needed libraries as well as handling linking in the libraries needed.\n\n00:00 Setting up SDL2 for graphics\n1:00 How to initialize OpenGL Context\n2:29 How to load OpenGL library\n3:05 The GLAD Library\n3:35 Generating our version of OpenGL\n5:00 Core vs compatibility profile\n6:00 Exploring glad structure\n7:50 Finding and including glad header\n10:33 Revisiting SDL_CreateWindow for OpenGL\n11:42 SDL_GL_SetAttribute to setup OpenGL Context and Version\n15:27 Creating OpenGL Context (SDL_GLContext)\n16:29 First attempt at OpenGL Function calls\n17:25 Linking error, forgetting to load gladLibrary\n18:20 Compiling in glad.c library\n18:54 Using dlopen to load library, linking dl\n19:54 Segmentation Fault — still haven’t initialized glad library\n20:40 gladLoadGLLoader and SDL_GL_GetProcAddress\n21:47 glViewPort — sizing OpenGL Graphics window\n22:24 Double Buffered Window\n22:40 SDL_GLSwapWindow\n23:40 Successful OpenGL Window\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

13. [Ep. 14] SDL Surface, GetWindowSurface, and SDL LoadBMP | Introduction to SDL2 In this lesson I am going to show you how SDL stores pixels from images in their internal data structure the SDL_Surface. We'll talk a bit about the components of an image so you understand what exactly is stored. Finally, we'll display that image to the screen.\n\n00:00 Revisiting our SDL_Window\n1:36 SDL_Surface for holding raw pixels\n2:12 Image formats that exist\n4:04 Components of a pixel\n4:43 pitch of an image\n6:24 Creating an SDL_Surface\n7:04 SDL_GetWindowSurface\n8:05 SDL_LoadBMP to load bmp image to SDL_Surface\n8:51 SDL_BlitSurface to update surface through copy\n10:26 SDL_UpdateWindowSurface to refresh our window\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

14. [Ep. 15] (Live Code) Learn with me how to modify SDL Surface in realtime | Introduction to SDL2 In this lesson, I'm going to do a little bit of live coding, and setup some code for us to modify pixels and 'paint' on an SDL_Surface. At the end of this lesson, you'll have some foundation for creating a little painting application.\n\n00:00 Project goal\n00:33 Handling SDL_MouseButtonEvent\n1:24 Handling Left mouse button\n2:00 How to modify SDL_Surface\n2:45 SDL_LockSurface\n3:42 SDL_memset to modify all surface pixels\n4:47 Updating the window surface in main application loop\n5:34 Successfully modified window SDL_Surface\n6:50 Retrieve relative mouse position\n9:12 Thinking about how to change one pixel\n9:33 SetPixel Helper function\n12:26 Modifying components of a specific pixel\n18:21 Modifying SDL_Surface though not correctly yet\n19:33 Mouse click not quite working\n20:23 Revisiting concept of pitch in an image\n21:49 Fixing our x offset for bytes per pixel\n23:17 RGB is not the only color format\n25:42 Success and recap\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

15. [Ep. 16] SDL RenderDraw lines and rectangles using SDL Renderer | Introduction to SDL2 In this lesson, I am going to introduce to you the SDL_Renderer and the structure of the Renderer. I'll show you a few of the key functions so you can draw primitives like rectangles so you can do 'immediate' mode style rendering directly to the SDL window.\n\n00:49 2D Accelerated Rendering API\n01:30 SDL_RenderDrawLine\n2:09 Looking at SDL_Renderer\n3:00 SDL_CreateRenderer\n3:45 SDL_RendererFlags\n4:22 Creating our SDL_Renderer in C++\n5:20 Understanding the graphics application loop\n6:15 Input, Update, Draw loop\n6:36 RenderClear and RenderPresent\n7:50 SetRenderDrawColor\n9:34 Fixing the blank screen\n10:33 Drawing a rectangle with SDL_RenderDrawRect\n12:33 We have immediate mode graphics!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

16. [Ep. 17] Textured Rectangles with SDL Texture and SDL RenderCopy | Introduction to SDL2 In this lesson I am going to show you how to create a textured surface. Textures differ from surfaces in that the memory of a texture exists on the GPU, so we can truly take advantage of hardware acceleration.\n\n00:00 Recap of how we have drawn our scene\n1:35 Loading image with SDL_Surface\n2:06 What is a texture\n3:18 SDL_CreateTextureFromSurface\n4:33 Resource Management with FreeSurface\n5:05 SDL_DestroyTexture\n5:40 Texturing our Rectangle\n6:20 SDL_RenderCopy\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

17. [Ep. 18] SDL Transparent Pixels and Color Keys No more boring rectangles | Introduction to SDL2 In this lesson, I am going to show you how transparency works. In fact, I am taking advantage of transparency with all of these videos filmed (i.e., the green screen!). The technique I am going to show you is how to use color keying to essentially 'ignore' pixels of a specific color on a texture.\n\n00:00 What is a green screen\n00:30 Drawing textured rectangles\n1:15 PNG images have transparent pixels\n2:18 Loading images with alpha data\n2:40 Debugging transparency \n3:37 What if we do not have transparent pixels in our image format\n3:52 Color Keying idea\n4:40 SDL Color Key with 24 bit image\n5:18 Using SDL Color Key\n6:22 SDL MapRGB helper function\n7:22 A working 24 bit transparent texture\n7:42 One last thing\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

18. [Ep. 19] Where was SDL installed in Linux (mac and windows) | Introduction to SDL2 In this lesson, I am going to show you a quick trick for finding out how to find header file paths using your compiler. It's a little trick that can help reduce the 'magic' in what is going on during the compilation process.\n\n00:00 Where was my actual header file found\n00:43 Using find for a brute force search\n1:05 Using your compiler to find header file paths\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

19. [Ep. 20] Texture Blending and handling mouse events | Introduction to SDL2 In this lesson I show you how to perform texture blending with textures, and in addition we control the different blend modes using the mouse--thus revisiting events again!\n\n00:00 Introduction and Review on Textures\n3:00 Creating a second textured rectangle\n4:00 Adding mouse motion events\n5:30 Fixing mouse motion bug\n6:58 Moving second rectangle with mouse successfully\n8:00 SDL SetTextureBlendMode explanation and application\n9:25 The different blend modes\n10:30 Using mouse buttons to change blend mode\n14:32 Change blend mode with mouse buttons test\n14:57 Color key is part of the state of blending modes\n16:12 Demoing all of the blending modes\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

20. [Ep. 21] Super Mario Sunshine (like) Water effect in SDL with scrolling textures | Intro to SDL2 In this video I prepare a fun yet convincing effect of two textures scrolling on top of each other to create water. The effect was inspired from a breakdown of how water is rendered in the game Super Mario Sunshine. I hope this is a fun lesson and also inspires you to investigate or try to implement your favorite effects in games--you've got the tools to do so! :)\n\n00:00 Showing the Super Mario Sunshine Water Effect\n00:55 The basic idea of water\n1:20 Mipmapping to create more depth in water\n2:00 Demo of the created effect\n3:13 Finding a seamless water texture\n4:00 Making a seamless image in GIMP\n4:40 Explaining why we need a seamless texture\n5:30 Sample water textures and caustics\n6:13 Review of the code\n7:40 The main trick using four scrolling rectangles\n10:50 Main loop code review\n11:46 Quick Hack to slow down rendering\n12:12 Scrolling the textures logic\n12:50 Rendering order matters\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

21. [Ep. 22] True Type Fonts (ttf) in Simple DirectMedia Layer | Introduction to SDL2 The example here is shown on an Ubuntu Linux 18.04 system for how to load True Type Fonts (TTF).\n\n00:00 TrueType fonts\n00:40 Picking your favorite font\n1:10 Downloading SDL2 ttf library\n2:43 main code file\n3:18 SDL2 ttf documentation walkthrough\n4:00 Sample code walk through\n8:18 Remembering to link our library\n8:50 Successful rendering\n9:10 Text rending challenges\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

22. [Ep. 23] Load PNG (and more formats) into Simple DirectMedia Layer with SDL2 Image | Intro to SDL2 In this example I show you how to download, include, and link the SDL Image library. Using the SDL Image library will enable you to use more formats beyond bitmap (bmp) images.\n\n00:00 Gettting pixel data to SDL_Surfaces\n00:50 SDL_Image 2.0 library\n1:35 Installation on linux\n2:50 Recap of base code\n3:52 SDL Image documentation, including, linking, and compiling in library\n6:51 IMG_Init with SDL Image\n10:07 IMG_QUIT to destroy our library\n10:31 IMG_Load for a png image\n13:10 Creating a texture to render to\n13:50 Free our surface and destroy our texture\n14:30 Render our texture to the screen\n15:45 IMG_LoadType_RW and SDL_RWops discussion\n17:48 Conclussion and final demo\n\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

23. [Ep. 24] Textured Rectangle Class abstraction in C++ with some discussion | Introduction to SDL2 In this lesson I wrap a few SDL structs into a single C++ class. There are many decision decisions to start making at this point, which could be one of the difficulties of Object-Oriented programming. That said, a good abstraction can also help prevent user error.\n\nView the previous Textured Rectangle video if you are completely new to this: https:\/\/www.youtube.com\/watch?v=75yEVx8iXYQ&list=PLvv0ScY6vfd-p1gSnbQhY7vMe2rng0IL0&index=18\n\n00:00 Introduction \n00:56 Recap of a previous SDL lesson\n2:06 Start of the implementation\n2:30 Useful Documentation reminder\n3:02 Rule of 3 as a best practice.\n3:30 Refactoring code into the class\n4:50 Thinking about the constructor\n5:45 Careful with number of function parameters\n6:36 Creating update and render\n7:02 Setting Rectangle properties and getters and setters conversation\n8:26 Passing in SDL Renderer as a parameter\n9:20 Careful with pass by value for performance\n10:18 Setting up member variables\n10:45 More considerations on SDL Render as a parameter versus holding a reference\n12:16 Bug fixes after first compile \n13:00 Testing one textured rectangle with new class\n15:00 Checkpoint one, it works!\n15:30 Further discussion on design decisions\n17:00 Moving class to a separate interface file.\n18:29 Separating out the implementation file\n20:00 Future work to comment your interface file.\n20:25 Updating class scope and fixing bugs\n21:13 Updating our compilation to include our cpp file.\n22:07 Fixing spelling mistakes\n22:50 Success, now to create more rectangles (speed up 3x speed)\n24:36 Hmm, nothing showed up! What happened!?\n24:57 Strange, why did it not work?\n26:02 Careful with ownership of memory, using shared ptr\n29:00 Rendering out all of our rectangles\n29:25 Slight adjustments to layout\n30:04 Recap of the lesson\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

24. [Ep. 25] Organizing the physical structure of a Simple DirectMedia Layer project in cpp | SDL2 In this lesson I discuss how to organize the structure of a source code project in general. There's no 100% correct way to do so, but it is worth thinking about the physical structure (i.e, thinking about the files and directories) of a project. This makes it easier for teams to collaborate, for you to split files, and then also to think about integrating testing and build frameworks into your project.\n\nAnother important component of this video is the idea that we will use a shell script to have consistent builds. In the future I will show how to use makefiles or cmake for other possible project configurations.\n\nIt may be worth visiting the previous lesson where we built a Textured Rectangle class here: https:\/\/www.youtube.com\/watch?v=nORrPBg-Q1U&list=PLvv0ScY6vfd-p1gSnbQhY7vMe2rng0IL0&index=24\n\n00:00 A recap of our SDL2 code project structures\n1:20 Inspiration from other successful projects\n3:10 A sample project structure for us\n4:15 Updating our project structure\n6:46 A simple build shell script for consistent builds\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

25. [Ep. 26] Building a Resource Manager to efficiently and more quickly load assets | Intro to SDL2 In this lesson I show you why it may be worth your time to implement a resource manager. Implementing a resource manager can ensure that you do not reallocate memory redundantly for structures that already exist in your program. Resource managers however come with some responsibility in that you will have to think about how to structure the manager, and then when you want to free a shared resource. In this lesson, I'll show you how to get started with the foundational idea.\n\nNote: It may be useful to use std::shared_ptr instead of raw pointers in your resource manager in order to more reasily free resources.\n\nIf you need a refersher on singletons, you can find a resource here: https:\/\/www.youtube.com\/watch?v=eLAvry56vLU&list=PLvv0ScY6vfd9wBflF0f6ynlDQuaeKYzyc&index=2\n\nYou may find it helpful to look at an unordered_map data structure for this lesson\nhttps:\/\/en.cppreference.com\/w\/cpp\/container\/unordered_map\/insert\n\n00:00 Introduction to a resource manager\n1:00 recap of project structure\n1:50 Observing the redundant work with loading the same 'large' resource\n3:50 Showing the repeatedly loaded image\n4:50 Resource Manager high level ideas\n6:20 Starting the creation of the resource manager interface\n8:12 Getting an instance of our resource manager (GetInstance)\n9:10 Returning a surfcace from Resource Manager (GetSurface)\n10:10 Setting up a map with key and value\n11:40 Creating the implementation (.cpp) file\n12:15 Fixing compiller errors\n14:05 Implementing GetInstance\n15:45 Preparing to implement GetSurface\n17:40 Implementing GetSurface and review of unordered_map\n22:50 Using our resource manager\n25:07 One quick bug fix and successful use of resource manager!\n26:35 Proving to ourselves the manager works\n27:30 Recap and some future design decisions\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

26. [Ep. 27] Animating Sprites in Simple DirectMedia Layer with a simple sprite class | Intro to SDL2 In this lesson I teach you how to perform sprite animation in SDL 2. This relies on us being able to select a portion of a sprite sheet (i.e. an image that contains multiple frames of the same character or object) and then being able to cycle through a specific set of frames. \n\nNote: Sprite sheets are likely more efficient than having to load several images and maintain them, we would rather have all of the data in a single texture.\n\nAt the end of the video, I also discuss the content asset pipeline to further add power to your API.\n\n00:00 Animating sprites like a flip book\n1:15 Understanding a simple sprite sheet\n2:15 Example of how to modify a sprite sheet to a grid\n4:40 Review of file structure and new files\n5:25 The Animated Sprite interface (i.e. header) file\n6:25 Understanding how to play a single frame\n8:25 Using SDL_RenderCopy to copy a portion of texture to screen\n9:40 Looping animation over multiple frames\n10:40 Successful demo of animation and SDL_Delay\n11:45 Discussion of Content Asset Pipeline\n12:45 Thank you!\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

27. [Ep. 28] (Live Code) Rectangle Collision in Simple DirectMedia Layer (SDL2) | Introduction to SDL In this lesson I teach you how to perform collision between two rectangles. I'll be adding this as part of our TexturedRectangle class from previous lessons so you can see how this works, and how to incorporate a raw 'collision' between two objects.\n\nIdeally, you'll want to create some sort of 'collision component' class to handle these sorts of events. For now, this will be enough to get you started with making games!\n\n00:00 Introduction and Code Review of Sample Code\n1:15 Capturing mouse positions to move our object\n2:10 The build script and demo of current program\n3:00 Theory behind rectangle collision\n5:32 SDL_HasIntersection built into SDL2\n6:15 Modifying our TexturedRectangle with IsColliding function\n9:40 Helper function for returning SDL_Rect\n10:54 Fixing some compile errors\n14:20 Fixed bugs\n15:14 Handling Collision\n17:16 Wrap up and review of what we learned\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

28. [Ep. 29] Building an Object Oriented Abstraction over SDL for a game framework | Intro to SDL2 In this lesson I teach am going to show you a walk through of taking the SDL code that we have been primarily cramming into the main.cpp file, and build an object-oriented abstraction around it. This abstraction will allow us to create an SDLApp, and clean up overall how the client uses our game framework. This will also make it easier for us to build more interesting demos and applications in the future.\n\n00:00 Introduction to our new abstraction design\n2:10 Creation of SDLApp\n3:47 Adding in callback functions\n8:45 Refactoring SDLApp and creating a single instance of app\n15:19 Successful refactoring of application\n15:49 Moving .hpp code into separate .cpp file\n17:21 Wrap up and conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

29. [Ep. 30] SDL Game Object (Game Entity) class design and implementation in c++ | Introduction to SDL2 In this lesson we are going to create a GameEntity (sometimes called GameObject) class. This will be the object that holds various components of entities (the player, objects, lights, cameras, etc.) in our game. There are many design decisions to consider, so I'll hope to provide some intuition into our design to make it extensible, and a reasonably easy data structure to maintain. There are some performance considerations when designing these types of objects, so do take time to look into data-oriented programming and other entity component systems in the future.\n\n00:00 Introduction to Game Objects with References\n2:20 Game Object or Game Entity Sketch\n3:25 Review of previous abstraction\n4:19 Game Entity Interface\n6:22 TexturedRectangle as a component of each GameEntity\n7:16 Game Entity Constructor design\n9:26 Update and Render member functions\n10:27 Game Entity class overview\n11:33 Recap of what we have and refactor to use Game Entity\n15:20 Design decision about how to set position and dimensions\n19:26 Retrieving a Textured Rectangle component from Game Entity\n23:40 Refactor and a few bug fixes and a working Game Entity\n27:30 A working game object and conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

30. [Ep. 31] SDL Frame Capping implementation in c++ | Introduction to SDL2 In this lesson we take care of a long time issue of capping our frame rate. This prevents our game from updating at a rate that is too quick to observe or to reasonably interact with the game.\n\nNOTE: In this video I set the frame rate in terms of 'milliseconds' delay. You could instead have the user specify the frame rate in the function (e.g. 60), then just do 1000\/60 at the top of your function. I would probably clean that up in the future, or otherwise provide in the API a way to specify either way.\n\n00:00 Introduction to frame rates\n1:15 Setting up a moving object to demo how fast our app is\n4:20 Updating our SDLApp with dimension getter and setter functions\n8:45 Demo of application moving way too fast and too slow\n10:10 Calculating 60 frames per second in milliseconds\n11:03 using sdl_delay and SDL_GetTicks\n11:38 Frame capping algorithm\n14:25 Frame capping implementation\n17:00 Writing a setter function for the frame rate cap\n21:00 Example of working application\n22:45 Conclusion and wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

31. [Ep. 32] (Live Code Colliders part 1) SDL2 Collider Component implementation in c++ | Intro to SDL2 In this lesson I do some live coding to create a box collider component. We'll call this collider2D. The idea is that we now have a smaller set of components that we can add to our gameentity class in order to build different combinations of 2D objects in our scene (e.g. User interface, sprites, etc.).\n\n00:00 Introduction and goals\n00:40 Review of code and Game Entity\n1:10 Idea of multiple collision\/collider components\n2:20 Quick design review and refactor of GameEntity\n7:20 Pulling out coupled collision code\n8:50 Creating Collider2D\n11:38 Adding Collider2D to our Game Entity class\n14:50 Buf fixing and first test\n16:40 Careful with how many includes you have\n18:20 Refactoring collision detection code in main\n20:24 Fixing segmentation fault\n22:50 Adding member functions to collider2D\n27:10 Getter and Setter functions to TexturedRectangle\n31:42 Adding an 'update callback' function to our SDLApp\n37:40 Working collision\n38:18 Adding a debugging box for our collider\n43:40 Working implementation of collider with debug bounding box\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

32. [Ep. 33] (Live Code Colliders part 2) SDL2 Multiple Collider Components in c++ | Intro to SDL2 Review lesson on color key if you want a reminder on how transparency works: https:\/\/www.youtube.com\/watch?v=-SpT8FH5ORQ&list=PLvv0ScY6vfd-p1gSnbQhY7vMe2rng0IL0&index=18&\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

33. [Ep. 34] (Colliders part 3) Automatic Bounding Box and improved Entity Abstraction| Intro to SDL2 In this lesson I am going to show you some improvements to our abstraction as I start thinking about handling multiple colliders types and using inheritance to do so. Then I show you how I wrote a simple bounding box algorithm to automatically wrap around an object by ignoring the transparent pixels. Finally I show two helper functions to set the position and dimension of our game entity, as well as all of the components that are a part of the game entity.\n\n00:00 Introduction and Review of previous lesson\n1:10 Adding an ICollider2D Base class\n2:20 Automatically setting up a bounding box\n4:11 Finding sprite boundaries\n7:53 A new Vector2D struct\n8:57 Improving GameEntity API\n11:30 Use of our new bounding box member function\n13:00 Conclusion and wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

34. [Ep. 35] Simple SDL Audio API tutorial (Not using SDL Mixer) | Introduction to SDL2 In this lesson I demonstrate how to use the Sound API in SDL. You will hear the playback of a 'collision' sound when the mouse is clicked and two objects are colliding. The SDL_Audio API overall is quite low level and gives you lots of power over how sound is played back. The one disadvantage I can immedietely think of is that it only loads WAV by default, so eventually we may need a future lesson utilizing different formats. :)\n\n00:00 Introduction to Sound\n00:30 Sound APIs available\n2:10 Quick explanation of how sound works\n3:30 Sound sampling rate\n5:00 Lossless versus lossy format\n6:15 SDL Audio API\n6:52 SDL_INIT_AUDIO\n7:20 SDLApp Updates to initialize sound system\n9:15 Our Sound Interface (Start of code tutorial)\n11:40 Code walk through (.cpp implementation)\n14:40 Documentation references for sound\n20:16 Main program (usage of our API)\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

35. [Ep. 36] Creating Sound effects for your SDL2 games with Bfxr | Introduction to SDL2 In this lesson I slightly diverge away from SDL2, and introduce a synthesizer for making sounds in our SDL2 projects. I think this lesson will be useful for folks just starting their game development journey who want to quickly add sounds to their game development projects. \n\n00:00 Introduction and review of Sound API\n1:30 Bfxr Introduction\n2:20 Brief Demo of Bfxr tool\n4:22 Closing remarks\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

36. [Ep. 37] (Live Code) SDL2 Building a Dynamic Text class with SDL2 TTF | Introduction to SDL2 In this lesson I demonstrate how to build a 'dynamic text' class. That is, I use the SDL_TTF library to write text to the screen that can be updated each frame. While this is somewhat inefficient, I hope it demonstrates how to build a useful component for your SDL2 games. Comment below if you think you can make some improvements, or otherwise if you build a useful StaticText class for the community!\n\nLink to true type fonts video: https:\/\/www.youtube.com\/watch?v=ltNTI9m_Vg0&list=PLvv0ScY6vfd-p1gSnbQhY7vMe2rng0IL0&index=22\nLink resource manager: https:\/\/www.youtube.com\/watch?v=_DGIRmHUtwQ&list=PLvv0ScY6vfd-p1gSnbQhY7vMe2rng0IL0&index=26&\n\n00:00 Introduction\n00:46 Recap of working with Fonts\n2:20 Updates to build script to include SDL2_ttf\n3:54 Obtaining a .ttf font file\n5:00 Creating our initial Text Class\n14:28 Refactoring the Text code member variables\n18:30 Committing to DynamicText code design\n24:30 Using our DynamicText class in main.cpp\n25:00 Rendering text after our other Game Entities for layering\n26:44 Fixing compilation errors\n28:40 First successful demo!\n33:03 Final working demo\n34:20 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

37. [Ep. 38] (Code Walk) Pong from scratch | Introduction to SDL2Click to find out more!

38. [Ep. 39] (Live Code) Design and implementation of Pong | Introduction to SDL2 In this lesson I build Pong from scratch using the framework we have built using the game framework we have built in the previous lessons. I go over the code, interface, design decisions, and you can watch me struggle as I work out bugs :)\n\nMy overall 'learning objectives' for you in this lesson is:\n1.) To make a game\n2.) See how making a game will help shape your framework (we'll see in this video how handy it may be to have some classes and functions available to us)\n\nComment below if you watch the whole thing (even if you watch it at 2X speed that counts!)\n\n00:00 Introduction\n1:51 Pong Design Document\n5:55 Physical file structure\n6:28 Start of code implementation\n1:50:25 Completed implementation and wrapup\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

39. [Ep. 40] SDL2 Mixer introduction tutorial (Learn how I learn) | Introduction to SDL2 In this lesson I show you how to install and use the SDL2 Mixer library. We'll create a simple wrapper class called 'Music' for you to then use in your games.\n\n00:00 Introduction\n00:40 Review of Assets\n1:18 Installing SDL2_Mixer Development library\n3:20 Looking at the old Sound library\n4:00 New Music Library class\n5:45 Quick look at the documentation\n7:40 Mix_OpenAudio to setup the library\n9:54 Mix_LoadMUS to load a music file\n12:20 Playing and Pausing Music\n16:30 Mix_VolumeMusic to set the music volume\n17:50 Setting up our music track in main.cpp\n19:10 Fixing some bugs\n21:00 Successful Demo!\n21:45 Conclusion and wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

40. [Ep. 41] Build SDL2, SDL2 Mixer,and SDL2 ttf from source (Shown on Apple Mac M1) (using sdl2 config) Hi Folks, this is a lesson today requested from our commentators, and that's specifically how to build SDL2 on Mac's with an M1. That said, this lessons will show you how to use the 'configure' tool to build SDL2 on any platform (windows, linux, mac, etc.). Follow along, or take a peak in the SDL2 repository to see how it's done!\n\nNote: The '-D MAC' preprocessor definition is not needed, but it still may be useful so you know what platform you are building for.\n\nNote: SDL2_ttf has moved to github here: https:\/\/github.com\/libsdl-org\/SDL_ttf\n\n00:00 Introduction\n00:40 Download SDL2, SDL2_ttf, and SDL_Mixer\n2:59 Running configure and building SDL2 with make\n4:52 sdl2-config usage\n7:57 SDL2 TTF Library build\n10:39 SDL2 mixer library install\n12:25 Successful build\n13:20 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

41. [Ep. 42] A simple shell script for compiling projects on multiple platforms | Introduction to SDL2 Hi Folks, this is a lesson today requested from our commentators for building on multiple platforms. In this lesson I provide a shell script (.\/build.sh) that allows you to compile for Mac, Windows, and Linux platforms. Check out the respository for the actual script. \n\nThe purpose of a build script is to allow for consistent builds across multiple platforms. Eventually we'll want to graduate to something like 'make' so that we have a more intelligent build system that only recompiles files that have been changed--this is important if the project grows in size (Once we start compiling 10,000+ lines of code let's say).\n\nNote: You may have to run chmod a+x build.sh in order to give execute permissions to the script to execute with .\/build.sh.\n\n00:00 Introduction\n00:50 Bash Shell script walk through\n4:50 Making our script executable\n6:50 Wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

42. [Ep. 43] Introduction to SDL2 Timer | Introduction to SDL2 In this lesson I show you how to use SDL2 timers to execute a callback function after a specific duration of time. The code could be extended further if you wanted to create a 'recurring timer' or otherwise create events that occur and handle them in your event loop.\n\nIf you want to learn more about 'threads' and asynchronous programming in C++, you can check out my playlist here: https:\/\/www.youtube.com\/playlist?list=PLvv0ScY6vfd_ocTP2ZLicgqKnvq50OCXM (Watching the first few on 'threads' will at least help you understand what a thread is doing while the program executes.\n\n00:00 Introduction\n00:30 Timers execute asynchronously\n1:22 The Timer API in SDL\n2:00 SDL_AddTimer function\n2:50 Abstraction and Implementation walk through\n7:15 Demo\n7:40 Wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

43. [Ep. 44] (Design Patterns Applied) A simple Entity Manager class for creating objects| Intro to SDL2 In this lesson I show you how a simple Entity Manager class that I have implemented to handle the creation of our game objects. I am using the factory and the singleton pattern in order to implement it. In the future, I may refactor out the singleton, but it works nicely for this small game framework.\n\nIf you need a refresher on the Singleton or factory, checkout the playlist here: https:\/\/www.youtube.com\/playlist?list=PLvv0ScY6vfd9wBflF0f6ynlDQuaeKYzyc (The first singleton or the first factory video should provide a solid refresher)\n\n00:00 Introduction\n1:00 Review of the old way we created objects\n1:45 Point of the Entity Manager\n3:50 Overview of EntityManager interface\n5:00 The unordered_map key\/value data structure\n5:45 Explanation of shared_ptr\n6:30 Change to GameEntity to give it a name\n7:10 Singleton Pattern\n7:40 How to create and remove an entity\n9:10 How to 'Get' an entity from our EntityManager\n9:50 Update and Render All of our entities\n10:30 Usage of EntityManager\n12:30 Cleanup with our Entity Manager\n13:00 Use of 'GetEntity' member function\n13:50 Writing a 'free function' to 'type less' code.\n15:30 Looking at OGRE3D for inspiration on their manager classes\n16:30 Wrap up off lesson.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

44. [Ep. 45] (Live Code) Building a layering system (discussion on painters algorithm) | Intro to SDL2 In this lesson I explain to you the painters algorithm. The algorithm itself isn't perfect, but the idea comes in understanding the order in which we draw things. We can build a layering system in our abstraction to help support and make much easier the development of our games in our little game framework.\n\n00:00 Introduction\n00:25 Painters algorithm explanation\n2:26 Adding a 'court' background image to our pong game\n6:50 Demonstrating error of painters algorithm\n8:26 Talking through design of layering in EntityManager\n8:54 Creating Layer.hpp file\n10:40 Adding layer attribute to GameEntity\n15:15 Creating our entities and assigning their layers\n16:10 Rendering individual layers\n20:29 Rendering All the layers\n22:00 Working system!\n23:00 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

45. [Ep. 46] (Live code) Compiling SDL2_ttf and SDL2 from source (linux) | Introduction to SDL2 In this lesson I answer a user question on building the SDL2 ttf library from scratch. More generally, this is a walk through to see how I build software from scratch. You will see me struggle, google, and try to follow the directions needed to install some software :) I'll also try to confirm that the install works as well. While this lesson is in linux, I think the principles should help folks out on Mac and perhaps on Windows as well. Building from source is a good skill to have, and as you will see, it's not always trivial, so some practice is always good.\n\n00:00 Introduction\n00:48 Installing SDL2 ttf\n1:40 Review of SDL2 ttf\n4:30 Building SDL2 ttf\n6:00 Running configure and building SDL2 from scratch\n9:12 make install for SDL2\n9:50 Wrestling with configure and aclocal\n16:20 Dependencies (deps) directory for automake\n20:02 Knowing when to restart from scratch\n22:40 Successfully running the demo\n23:30 (Extra) Confirming we have the correct libraries linking\n29:30 (Extra) Linking directly to the directory in usr\/local\/lib\n31:40 Conclusion and wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

46. [Ep. 47] Controlling your SDL2 window on multiple displays | Introduction to SDL2 In this lesson I show you how to query for information about your window.\n\n00:00 Introduction\n00:37 Navigating to functions available for Display\n1:16 Code Review of multiple displays\n2:43 Getting the Display Bounds\n5:05 Compiling and running a demo\n6:00 playing with your display settings\n7:15 Demo shifting windows\n8:02 Final review of functions available in SDL2 API\n8:42 Wrap up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

47. [Ep. 48] Parallax Scrolling in Simple DirectMedia Layer | Introduction to SDL2 In this lesson I show you how to create a parallax scrolling effect in SDL. This is a classic effect used in many games based on the idea of layering, and scrolling the foreground at a faster rate than background layers..\n\n00:00 Introduction\n00:40 Wikipedia on Parallax scrolling effect\n01:35 Parallax Scrolling Concept\n03:19 Creating artwork for the parallax scrolling effect\n04:18 Code walkthrough\n11:16 A note on SDL3 SDL_RectF coming in the future\n11:36 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

48. [Ep. 49] Creating a Tile Map in SDL | Introduction to SDL2 In this lesson I show you how to create a tile map in GIMP as well as how to render different tiles in SDL. The trick is to just break the tile into equal pieces (though they need not be), and then to lay out the tile data across your window. Relatively simple trick that is the key to so many 2D platformer games!\n\n00:00 Introduction\n00:40 Tile Assets\n01:12 Creating a tile map from scratch\n03:00 Creating tile texture in SDL\n05:40 Creating a simple tile map data structure\n09:00 Selecting a tile to draw to the screen\n10:40 Successful demo and fun experiments\n12:11 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

49. [Ep. 50] Scrolling in a Tile Map in SDL | Introduction to SDL2 In this lesson I continue to build off of the tile map data structure and show you how to use it for scrolling. As a homework assignment you can otherwise start to abstract around this data structure and think about scrolling up and down additionally.\n\n00:00 Introduction\n00:38 Scrolling a tile map description\n01:38 Review of the previous lesson and retrieving keys\n03:10 Adding code to handle key presses and offsetting the tile map.\n07:57 Implementing scrolling\n09:50 Decision decision on handling empty tiles\n11:26 Discussion on rendering large tile map data with heap\n12:52 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

50. [Ep. 51] Simple procedural tilemap generation in SDL | Introduction to SDL2 In this lesson I continue to build off of the tile map data structure this time showing you how to randomize the tile map. We'll look at randomized tile maps, smoothing, and a random walk to help create tilemaps that you can use as a starting point, or perhaps the final product for your games! Here's the blog article from Unity3D https:\/\/blog.unity.com\/technology\/procedural-patterns-you-can-use-with-tilemaps-part-i\n\n00:00 Introduction\n01:12 Review of what we will be building today\n02:02 Review of previous lessons code\n04:55 Conceptual overview of procedural algorithm\n06:12 Randomized heights algorithm\n14:12 Smoothed randomized height algorithm\n18:00 Random Walk algorithm\n23:28 Conclusion and wrapup\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

51. [Ep. 52] SDL3 is coming! SDL3 is coming! Every decade or so the hard working folks at SDL make some major updates. For SDL3 we can expect some great updates in stability, mouse motion, a 3D graphics API, Support for High DPI displays, and thread safety.\n\n00:00 Introduction\n00:29 Upcoming SDL3\n5:00 Conclusion and wrapup\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

52. [Ep. 53] SDL VSync (SDL_RENDERER_PRESENTVSYNC) | Introduction to SDL2 and SDL3 SDL3 is coming! Every decade or so the hard working folks at SDL make some major updates. For SDL3 we can expect some great updates in stability, mouse motion, a 3D graphics API, Support for High DPI displays, and thread safety.\n\n00:00 Introduction\n00:33 Fixing the SDL_Delay hack\n01:55 Setting up the renderer\n02:28 SDL 2 and 3 VSync functions\n04:45 Setting up SDL_RendererFlags and SDL_RendererInfo\n07:50 The simple solution with vsync renderer flag\n08:44 Understanding info.flags from renderer\n12:17 SDL_render.h enums (and understanding C APIs)\n15:40 Quick Review\n17:06 Conclusion and wrapup\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

53. [Ep. 54] Bitmap Fonts - No external dependencies | Introduction to SDL In this lesson I show you how to create a bitmap font. Similar to the techniques we have been learning about in the tilemaps, we can also create 'tiles' for individual text characters. This technique can thus be used to represent text (with various pros and cons), or other User interface (UI) elements.\n\n00:00 Introduction\n00:47 Basic idea of Bitmap Font\n01:33 Pros and Cons of bitmap fonts\n04:40 Creating a bitmap font in GNU GIMP\n10:30 Writing from scratch our program\n13:15 Displaying our font as a texture\n15:40 Displaying a first character from font texture\n17:20 Brief aside on performance\n17:55 Creating the BitmapText class\n25:30 Understanding ASCII mapping to our bitmap font\n27:30 Finishing off our BitmapText class to draw any of 26 characters.\n29:40 Adding positioning of text\n30:30 Using color keying for transparent text\n34:20 Final Code Review\n35: 30 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

54. [Ep. 55] Rotating Textures | Introduction to SDL In this lesson I show you how to rotate a texture in SDL 2 and in SDL 3. It is important to note that rotating a texture however, does not effect the collision test with rectangles however (i.e. the rectangles are not rotated -- only the texture in video memory is rotated).\n\n00:00 Introduction\n00:50 Brief Code Review of project setup\n02:40 Adding a second intersecting rectangle (SDL_IntersectRect)\n04:20 Displaying the intersection of the two rectangles\n05:22 Adding in a rotating texture\n11:01 Understanding the center of rotation (SDL_Point)\n13:15 Flipping the rectangle (SDL_FLIP_HORIZONTAL)\n14:20 Conclusion\n\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. A 15 Minute Briefing for Getting Setup and Navigating Linux in Virtual Box In this lesson I show you how to get started in a Linux environment using the terminal. We spend the first few minutes showing you how to obtain a linux operating system if you do not have one, and emulating the Linux environment. In the latter portion, I show you a few of the fundamental ways to navigate using a terminal in this introductory lesson.\n\n(1) Download Ubuntu: https:\/\/ubuntu.com\/#download\n(2) Download a virtual machine to run Linux.\n- Virtual Box: https:\/\/www.virtualbox.org\/wiki\/Downloads\n- (For newer Mac M1's) UTM: https:\/\/mac.getutm.app\/gallery\/\n- QEMU: https:\/\/www.qemu.org\/\n- VMWare: https:\/\/www.vmware.com\/\n\n0:00 Motivation for Terminal\n1:33 Downloading Ubuntu Linux\n2:11 Virtualization\n4:29 Virtualization Options for Linux\n6:55 Starting Virtual Machine\n7:57 Introduction to Linux \n9:11 Terminal Introduction and Navigation\n14:47 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. The 23 Minute Introduction to Git and Github In this introduction I get you started using git with the webhost github.com\n\nCommands Shown:\ngit add - Prepare our changes for specific files to be saved to a snapshot\ngit commit - Save a snapshot of our repository locally\ngit push - Push our changes to the web (when cloned from github.com)\ngit status - Track changes that have or need to be made\ngit checkout FILE - revert changes\ngit help add - shows us help about the command.\n\n0:00 Introduction\n0:27 Motivation to use Git\n3:17 Github.com\n3:57 Creating a Repository\n5:24 Cloning repository from Github\n7:54 First git add, commit, and push\n10:52 Understanding Git Workflow\n16:13 git status\n18:57 git log\n19:20 git checkout\n21:07 git help\n22:08 gitk\n22:33 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. In 54 Minutes, Understand the whole C and C++ compilation process I've seen enough folks struggle with compiling in C and C++ that it is time for a full video to understand the process. As a result of understanding the compilation process, you can understand why a project should be split into smaller components, and how that makes your code faster to compile, easier to debug, and dare I say...more fun to work with!\n\n0:00 Introduction\n0:35 High Level Overview of Compilation\n6:17 Simple Project Setup\n10:10 Compiling\n12:09 Preprocessor output\n13:29 All functions are extern\n14:02 Syntax error versus linking error\n15:33 successful compile of multiple sources\n17:02 Redefinition errors\n18:30 Header Guards\n20:20 Compiler at a high level\n22:57 g++ syntax tree visualization\n24:53 Assembly Overview and Output\n28:24 Outputting object file (.o)\n30:00 Compiling Files Individually\n31:10 Linking o files together\n32:05 objdump\n34:22 Dynamically linked libraries\n35:30 ldd dynamially linked shared libraries\n36:35 Summary and Recap\n39:36 Practical Example with SFML Library\n40:45 Compiling without linking libraries error\n41:54 Linking in the correct libraries\n43:16 Using the -L flag to find library\n44:42 PATH and environment variables for default search paths\n45:58 Include Path\n50:00 Fixing Include Path Errors\n51:07 What your IDE is hiding from you.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. A 50 minute Introduction to C++ and your next steps! C++ is one of the most popular languages, and getting started can be tricky. Let's just dive in and get started with C++!\n\nSome helpful references\nhttp:\/\/www.cplusplus.com\/doc\/tutorial\/\nhttps:\/\/en.cppreference.com\/w\/\nhttps:\/\/www.sfml-dev.org\/\n\n0:00 Introduction\n1:38 Operating System and IDE Options\n2:28 Hello World\n4:53 Completion of first C++ program\n5:14 C++ is a compiled language\n8:00 Classic Guessing Game\n9:33 IOStream\n10:42 Start of guessing game\n12:00 std explanation\/namespaces\n12:52 Compiling with g++ on terminal explanation\n13:34 Getting input from user\n14:00 integer variable\n14:41 output a variable\n15:10 data types\n16:10 random numbers\n21:22 Control flow - loops\n24:28 Fixing a compile bug - order of variable declaration\n26:15 Always initialize your variables\n27:23 if- statements\n30:22 Functions\n31:55 for-loop\n33:26 containers - vector data structure\n41:00 Idea of a class in C++\n42:51 Review of what has been covered\n44:44 Quick introduction to C++ graphical programs with SFML\n45:50 Installing SFML\n46:30 Linking libraries in C++\n49:30 Next Steps and Conclusion\n\nNOTE: cout is not a 'function' as I mentioned, but really an 'object' with the angled brackets overloaded. You can learn about operator overloading to see exactly how that works. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. Learn the lldb debugger basics in 11 minutes | 2021 (Also works on M1 Apple Silicon) Note: One other very useful command is 'display' which I did not cover. You can inspect symbols in scope and see their value.\nHere's a mapping of GDB to lldb commands if you are more familiar with gdb: https:\/\/lldb.llvm.org\/use\/map.html\n\n00:00 Introduction to LLDB debugger\n00:55 LLDB website \n1:26 Sample code for the lesson\n1:51 Compiling with debugging symbols\n2:40 creating a target process\n3:00 help in lldb\n3:27 Finding our bug\n4:08 creating a breakpoint\n5:16 stepping to next instruction and moving to next command\n6:40 Viewing the backtrace, i.e., our call stack\n7:40 Navigating the graphical interface\n8:48 relaunching our process and running through GUI\n10:14 Fixing our segmentation fault\n10:58 Wrapping up\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. Learn and understand (almost) everything about the fundamentals of C++ pointers in 96 minutes Pointers are a difficult topic for beginners. In this video, I am going to try to demystify what pointers are, the syntax, how they work, why you would use them, and why access to pointers make them a powerful language feature (and not something to be scared of). Note, this video is primarily targeted at a C++ audience, though C programmers will find a lot of the content useful as well for understanding pointers.\n\n00:00 Introduction about pointers\n1:00 Code available\n1:40 How I understood pointers today\n3:50 What is a pointer\n6:40 Running our first pointer example\n7:26 Visualizing pointers\n10:15 Pointer step by step animation\n11:10 Visualizing your memory\n13:00 Storage size of variables\n14:50 Storage size of a pointer\n17:00 Dereferencing a pointer\n19:50 Review of pointer syntax so far\n22:20 Dereferencing pop quiz\n25:55 Pointer to a pointer example\n35:00 Power of pointers with sharing data\n41:30 Arrow syntax of pointers to dereference\n42:00 Passing Pointers into functions\n42:50 Pass by value\n44:40 Pass by pointer\n48:24 Pointers and arrays\n53:10 Pointer Arithmetic\n54:40 Array Offset, dereference, and the bracket notation\n57:10 Array Decay to Pointer\n1:00:26 Pointers as parameters\n1:03:00 Dynamically allocated arrays and pointers usage\n1:07:05 nullptr in modern C++ for type and memory safety\n1:08:28 segmentation fault with null pointer dereference\n1:09:50 The pitfalls of pointers\n1:10:30 Memory Leaks with pointers and dynamic memory allocation\n1:12:50 Dangling pointers and returning local addresses\n1:14:10 Double free errors\n1:15:48 isocpp best practices with memory management\n1:16:10 Wrapper class for pointers\n1:17:00 Smart pointers in modern C++\n1:19:00 unique pointers in c++ - unique_ptr\n1:25:20 shared pointers in C++ - shared_ptr\n1:26:39 weak pointers in C++ - weak_ptr\n1:27:40 Do not use auto_ptr\n1:28:30 Function pointers, usage and their syntax\n1:31:29 Modern C++ std::function\n1:32:20 Other topics related to pointers\n1:33:10 A linked list example code\n1:33:50 wrap up of topics\n1:34:40 Pointer analogies\n1:35:30 Thank you and conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. In 6 Minutes - One idea to automate your edit, compile, run cycle this year (entr) In this lesson, I show you some quick tricks to avoid having to context shift and constantly switch between panels when you have to compile and edit your code. There's actually a huge list of other tricks you could do (e.g. building make files, integrations into IDEs, or a combination of each), but one trick I learned was to just run automatically the compilation of your source files as they change using 'entr'.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

7. VMWare Fusion - Run Linux (Ubuntu) on Apple Silicon (m1 and m2) In this lesson I will show you how to run Ubuntu on an arm-based Mac using Apple Silicon on VMWare Fusion.\n\n00:00 Introduction\n00:50 Downloading Ubuntu\n01:30 Downloading VMWare Fusion\n03:25 First attempt installing the WRONG Ubuntu image architecture\n04:42 Installing SUCCESSFULLY Arm-based Ubuntu image.\n05:40 Setting up Ubuntu to install applications and graphics applications\n09:30 Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. [Blender3D] [2.92] Crash Course Making a Sword for first time users of Blender3D A quick tutorial for Blender 2.92 on creating a sword. Shows a simple technique for box modeling.\n\nDefault Blender Shortcuts:\n\nMouse wheel -- Zoom in and out\nMouse wheel -- Hold to orbit\nHold Shift to pan view with middle wheel pressed\n\nCtrl+z to undo\ndelete to delete objects\n1-9 on numpad to move around.\n1-3 in edit mode to change selection (vertex, edge, face)\ng for moving vertices in edit mode\ngg to slide vertices\nHold shift to select multiple vertices\nExtrude with 'e'\n's' to scale\nWhen extruding with 'e' you can ctrl+click to quickly model\nUse the 'alt' key to get alternative ways to do things (e.g. alt+e) \n\n0:00 Introduction\n0:30 Downloading Blender\n0:51 Preferences to Change Display\n1:46 Entering Edit Mode\n2:22 Scene Collection Navigation\n3:02 Selection in Edit Mode\n3:27 Moving Vertices\n4:32 Panning the camera\n4:46 Editing\n5:32 Extruding\n6:30 Transforms\n7:02 Box Modeling with Extrude\n9:12 Extruding with a click\n10:57 Bevel\n11:36 Subdivide\n12:59 alt-e for alternatives\n\n►...

1. [Blender] [2.93] A speedy introduction for first time users of Blender3D A quick tutorial for Blender 2.93 on creating a tree. Shows a simple technique for box modeling, though the primary use of this tutorial is to show you how to navigate Blender3D for the first time user.\n\nDefault Blender Shortcuts:\n\nMouse wheel -- Zoom in and out\nMouse wheel -- Hold to orbit\nHold Shift to pan view with middle wheel pressed\n\nCtrl+z to undo\ndelete to delete objects\n1-9 on numpad to change camera view.\n1-3 in edit mode to change selection (vertex, edge, face)\nGrow selection with ctrl+ (the plus on the numpad) or shrink with ctrl- (the minus on numpad)\ng for moving vertices in edit mode\ngg to slide vertices\nHold shift to select multiple vertices\nExtrude with 'e'\nm to merge vertices\nalt+e to get alternative functions (i.e., extrude along normal)\n's' to scale\nWhen extruding with 'e' you can ctrl+click to quickly model\nUse the 'alt' key to get alternative ways to do things (e.g. alt+e) \n'i' for inset\n\n0:00 Introduction\n0:28 Downloading Blender\n1:07 Preferences to Change Scale of interface\n1:46 zoom\n2:03 delete with 'delete'\n2:28 Different workflows in Blender3d\n3:03 Moving around in scene\n3:30 Numpad for changing views\n4:05 panning with shift and middle mouse\n4:33 object and edit mode with tab\n4:58 moving geometry with g\n5:30 one,two, and three key to change selection\n6:07 extruding with e\n7:33 undo\n7:48 grow selection with ctrl+ and shrink with ctrl-\n9:04 extrude along normals\n9:56 ctrl+e to extrude at mouse\n10:29 scale with 's' key\n11:03 create additional meshes\n12:00 hiding geometry\n12:23 inset geometry\n12:48 merge vertices\n13:15 gg to slide geometry\n13:52 closing notes and exporting model\n\n►...

2. [Blender3D] [2.9.3] An introduction to texturing and uv mapping in Blender3D In this lesson I talk about using blender3D to add a texture material as well as to perform uv unwrapping of a simple cube.\n\n0:00 Introduction and Navigation reminders\n0:50 Shading Tab and modifying base color\n1:30 Downloading a cube image\n2:08 Adding a material node\n2:40 Downloading a wood texture\n3:40 High level idea of uv mapping\n4:30 uv editing tab and selecting geometry\n5:10 moving geometry in uv editing tab\n6:00 rotation of geometry\n6:26 Selecting vertices, edges, and faces\n6:56 Warning on distortion\n7:48 Aligning texture coordinates on uv map\n9:00 Cleaning up our edges\n9:22 Example of texture stretching\n9:50 exporting .obj geometry file\n10:22 examining material file and texture coordinates\n11:30 Default objects are already unwrapped\n11:55 clearing seams\n12:16 adding seams to our scene\n12:46 uv unwrap\n13:50 unwrap\n14:16 adding a material\n15:00 Careful with scaling to avoid distortion\n16:00 Different uv mapping projections\n\n►...

3. [Blender3D 3.0+] Beginner Crash Course - Modeling and Texturing a Spaceship A quick tutorial for Blender 3.0 on creating a space ship. I'll use a technique known as box modeling to show you how to create an object and get started in Blender3D.\n\nDefault Blender Shortcuts:\n\nMouse wheel -- Zoom in and out\nMouse wheel -- Hold to orbit\nHold Shift to pan view with middle wheel pressed\n\nCtrl+z to undo\ndelete to delete objects\n1-9 on numpad to move around.\n1-3 in edit mode to change selection (vertex, edge, face)\ng for moving vertices in edit mode\ngg to slide vertices\nHold shift to select multiple vertices\nExtrude with 'e'\n's' to scale\nWhen extruding with 'e' you can ctrl+click to quickly model\nUse the 'alt' key to get alternative ways to do things (e.g. alt+e) \n\n0:00 Introduction\n00:20 Blender3D download from blender.org\n1:00 User Interface Navigation\n3:00 Blender3D Object Transform\n5:00 Different Workflows in Blender3D\n5:20 Shading Edidtor\n8:55 UV Editing\n12:18 Box modeling the spaceship (extrude, inset, scale, etc.)\n23:18 Just for fun, lighting our scene.\n24:59 Conclusion\n\n►...

4. [Blender3D 3.0+] Beginner Crash Course - Modeling a Low Poly Humanoid A quick tutorial for Blender 3.0 on creating a space ship. I'll use a technique known as box modeling to show you how to create an object and get started in Blender3D.\n\nBlender3D Shortcuts:\n\nMouse wheel -- Zoom in and out\nMouse wheel -- Hold to orbit\nHold Shift to pan view with middle wheel pressed\n\nCtrl+z to undo\ndelete to delete objects\n1-9 on numpad to move around.\n1-3 in edit mode to change selection (vertex, edge, face)\ng for moving vertices in edit mode\ngg to slide vertices\nHold shift to select multiple vertices\nExtrude with 'e'\nctrl+r to do a loop cut\n's' to scale\n'r' for rotate\nWhen extruding with 'e' you can ctrl+click to quickly model\nUse the 'alt' key to get alternative ways to do things (e.g. alt+e)\n\n►...

0. [pybind11] Setup with Ubuntu A brief example of setting up pybind11 with Ubuntu.\nI also show how to debug one common problem of not having the correct version of the python3-dev package.\n\nDownload pybind 11 with: pip3 install pybind11\n\nThe command line that I used to compile was: \nclang++ -shared -fPIC -std=c++11 -I.\/pybind11\/include\/ `python3.6 -m pybind11 --includes` pybind.cpp -o mymodule.so `python3.6-config --ldflags`\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. [pybind11] Setup on Windows with Mysys2 A brief example of setting up pybind11 with Windows.\nI also show how to debug one common problem of not having the correct version of the python3-dev package.\n\nDownload pybind 11 with: pip3 install pybind11\n\nThe command line that I used to compile was: \ng++ -std=c++14 -shared -fPIC -static-libgcc -static-libstdc++ -I.\/include\/ -I.\/pybind11\/include\/ `python3.6 -m pybind11 --includes` *.cpp -o mymodule.pyd `python3.6-config --ldflags` -lmingw32 -mwindows -L libwinpthread-1.dll\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. [pybind11] setup with Mac A brief example of setting up pybind11 with Mac (Big Sur is what I tested on).\nI also show how to debug one common problem of not having the correct version of the python3-dev package.\n\nDownload pybind 11 with: pip3 install pybind11\nI also recommend downloading Python with brew (brew install Python3) and using Python3+\nIn order to use the clang++ compiler, you likely need to also install XCode and the command line developer tools.\n\nThe command line that I used to compile was: \nclang++ -std=c++11 -shared -undefined dynamic_lookup -I.\/pybind11\/include\/ `python3.9 -m pybind11 --includes` pybind.cpp -o mymodule.so `python3.9-config --ldflags`\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. [pybind11] Embedding the Interpreter In this video I show how to embed the python interpreter in a C++ project. This is something really cool that for a long time I wondered how to do. In this way, you can expose you could expose a game or game engine to run scripts entirely in python. \n\nAnother neat thing you might try to do is to write specific scripts for game objects that could execute. I would recommend writing some sort of 'manager' class that manages the execution of the game objects scripts, but hopefully this first example helps folks get started. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. [pybind11] using templated functions In this lesson I show you how to use templates functions using pybind11 and C++.\n\nHere was the handy command I was using to show the functions template instantiations: \n\nclang++ -Xclang -ast-print -fsyntax-only template.cpp\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. [pybind 11] using templated classes Another video this time with a templated class. I provide an easy solution to getting your templated classes from C++ into Python. Depending on your interface this may be acceptable. If folks have more clever solutions, I will follow up with another video of how to do this with less manual labor :) ...

6. [pybind11] wrapping SDL2 classes for use in Python In this lesson I show you how to wrap the SDL library in order to make use of SDL functions (as objects) within your python code.\n\n►...

1. Preview: Hands on Debugging in C and C++ In this course you'll learn the skills needed to program in GDB. Each lesson is a hands on lesson teaching you the skills you need. See the full course or explore my channel for more debugging resources.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. Preview: Introduction to the Terminal In this course you'll learn the skills needed to work in the terminal in Linux, Mac, or Windows. Each lesson is a hands on lesson teaching you the skills you need.\n\nIf you do not want to pay, check out the free lesson linked above that teaches about 25% of the skills learned from the course. \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

3. Preview: Python in a Weekend In this course you'll learn the skills needed to program in Python 3 as a first time programmer or if you are learning the language for the first time. Each lesson is a hands on lesson teaching you the skills you need.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

4. Vim - Official Promo (courses.mshah.io) In this course you're going to learn the essential skills to learning VIM from the start. The goal of this course is to provide a linear path for learning essential skills in VIM, so you can continue to develop your VIM skills further throughout your career.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

5. A working example in GDB [Free course lesson preview] This is a free lesson from my course, showing you some of the features of GDB that you will become comfortable with.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

6. Compilers cannot read our minds [Free course lesson preview] This is a free lesson from my course, showing you how even simple logic bugs enter our program, even though they may be syntactically correct.\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. VIM Beginner Masterclass A quick introduction to VIM showing you the basics all VIM users should know. The full course linked at courses.mshah.io provides another 70%+ more material broken down into smaller lessons and exercises.\n\nSome of the things that we learned:\n-Opening (e), saving (w), and exiting (q) vim\n Understanding their are different modes in VIM\n The four most common modes that you will use:\n - insert mode (i)\n - normal mode (esc)\n - command mode (colon)\n - visual mode (v)\n moving around in VIM (h,j,k,l and arrowkeys)\n undo\/redo of changes (u and Ctrl+r)\n visual mode (v)\n yank (y)\n cut (x)\n paste (p)\n delete (d)\n block mode (Ctrl+V)\n Line Navigation\n w,e,b,0,$,o\n Screen navigation\n zz - center cursor\n Ctrl-u, and ctrl-D\n Shift+(H,M,L) to move to the sreen\n Search and replace text\n \/s\/foo\/bar\/g\n \/phrase_to_search\n Splitting Windows\n :vsplit and :split\n Getting help in VIM\n :h or vimtutor \n\n00:00 Introduction\n1:22 Starting vim\n2:22 Creating and saving a new file (insertion mode)\n5:20 Navigation in VIM (In normal mode)\n7:00 Visual Mode\n8:10 Quick Navigation\n10:00 Text replacement (visual mode and command mode)\n11:55 'zz' to center around your cursor\n12:50 More quick navigation tips\n14:30 Visual block mode for text replacement\n16:05 Splitting the vim window\n19:00 Getting help in VIM\n20:20 vimtutor\n21:00 undo and redo and Conclusion\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

1. GDB Beginner Masterclass A quick introduction to GDB showing you the basics all GDB with some simple examples. The full course linked at courses.mshah.io provides another 70%+ more material broken down into smaller lessons and exercises.\n\nSome of the things that we learned:\n- gdb .\/prog to start the program\n- gdb and the file .\/prog to reload a program after changes\n- 'n' or 'next' to move to next line\n- 'l' or 'list' to list source code.\n- 'Ctrl+x 1' to enter the TUI mode.\n- 'Ctrl+x o' to shift between windows\n- 's' or 'step' to step into the source code.\n- 'br' or 'break' to set a breakpoint followed by a line number or function name\n- 'c' or 'continue' to continue from a breakpoint.\n- 'set var=value' to set a varaible value.\n- 'p' or 'print' followed by a variable. Note: You can also dereference a variable (e.g. print *px) to see the dereferenced value.\n- 'bt' or 'backtrace' to get the stack frame.\n- 'f' or 'finish' to execute a function to completion.\n- 'info args' to get information about the incoming function arguments' \n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

2. Terminal Beginner MasterclassClick to find out more!

3. Python Beginners Master ClassClick to find out more!

4. Git Beginner MasterclassClick to find out more!

5. Why I'm Still using Vim in 2024 - A Brief Introduction and Demo A quick introduction to VIM motivating you to learn VIM. The full course linked at courses.mshah.io provides step-by-step lessons to get started in VIM.\n\nSome of the things that we learned:\n- saving (w), and exiting (q) vim\n Understanding their are different modes in VIM\n The four most common modes that you will use:\n - insert mode ('i' is one way to enter)\n - normal mode (esc)\n - command mode (colon)\n - visual mode (v)\n moving around in VIM (h,j,k,l and arrowkeys)\n undo\/redo of changes (u and Ctrl+r)\n visual mode (v)\n yank (y)\n cut (x)\n paste (p)\n delete (d)\n block mode (Ctrl+V)\n Line Navigation\n w,e,b,0,$,o\n Screen navigation\n zz - center cursor\n Ctrl-u, and ctrl-D\n Shift+(H,M,L) to move to the sreen\n Search and replace text\n \/s\/foo\/bar\/g\n \/phrase_to_search\n Splitting Windows\n :vsplit and :split\n Getting help in VIM\n :h or vimtutor \ntabe: opens the tab editor\nsplit and vsplit\n\n00:00 Introduction\n00:34 Launching VIM (Vi IMproved)\n01:55 Insertion Mode \n02:37 saving and exiting VIM\n03:42 VIM quick demo of a few features\n13:17 Wrap up and more motivation for Vim\n\n►YouTube Channel: https:\/\/www.youtube.com\/c\/MikeShah\n►...

0. Building GCC-9.1.0 from Source A video on how to build GCC 9.1.0 and additional compilers(e.g. Dlang) from scratch. This video should also be helpful for downloading later versions of GCC.\n\nSome skills we look at:\n- Using wget to download a tar\n- Using the tar tool\n- Exploring a man page (and navigating with '\/')\n- Using Ubuntu's 'apt' tool.\n\nI found this website also helpful for this particular task: https:\/\/solarianprogrammer.com\/2016\/10\/07\/building-gcc-ubuntu-linux\/ \n\n►...

1. Using Valgrind to detect a bug Short lesson on using Valgrind to find bugs\n\n►...

2. Using Valgrind to fix bug Short lesson on finding bugs in Valgrind--enjoy!\n\n►...

3. Using Valgrind and GDB together to fix a segfault and memory leak In this lesson I show you how to use Valgrind and GDB together to find bugs. This is a nice review of some of the tools that we have learned, and a reminder that you can combine as many of the tools that we learn together in order to help debug!\n\n►...

4. Compile from Source - Build Latest GDB and Binutils on Linux In this lesson I show you how to build GDB (GNU Debugger) 12 and the associated bin utils from scratch on Ubuntu Linux 18.04. I will show you how I resolve dependency bugs, and how I generally navigate building Linux build errors as I encounter them.\n\nThe total install time running on one core on a relatively new system (Intel I7 10th generation) takes around 30 minutes. \n\nNote: You can speed things up by using: make -j 8\nIf you run into trouble, I recommend doing a single core build however.\n\n00:00 Introduction\n00:50 Finding the Git Repository and log\n2:20 Navigating our files\n3:00 Running configure\n3:40 Attempting to make in the source directory\n4:30 Fixing a first dependency error\n5:10 Warning on doing parallel builds\n5:40 Installing Bison and Flex\n6:30 Googling our dependencies\n7:10 Build your software in a separate directory\n8:00 make distclean to clean up our old build attempt\n8:40 Yet again, another missing dependency\n9:15 Luckily make is a smart build tool\n9:36 Success now where are our files?\n10:30 Running gdb\n11:02 Fixing our install path\n12:40 Success\n\n►...

5. Building GCC 11 (and beyond) from Source (git repository) | (Front ends for C, C++, dlang (gdc)) \nThis is an updated video on how to build large source projects, specifically the gcc compiler for version 11. I build for the C, C++, and Dlang frontend programming languages and show you how to fix few dependencies errors and install the missing dependencies. In total, it took around 80 minutes for me to figure out how to build from scratch (including the time to compile the software from scratch). \n\nNote: I probably should have run 'sudo make install' in order to creating the correct links to default to gcc-11 for instance.\n\n00:00 Introduction\n00:48 GCC 11 updates\n1:35 Downloading GCC from git version control system\n3:30 Checking out the version of GCC we want to build.\n5:30 Understanding the build process\n6:58 Build instructions\n9:50 Running configure\n10:59 Building dependencies and some tips\n15:15 download_prerequisites script to find all dependencies\n16:55 Running 'make'\n17:50 Thirty-two (32) minutes to a successful build!\n18:50 make install\n19:30 Testing our installation\n21:14 Conclusion\n\n►...

6. Using Leaks (the valgrind equivalent) on Mac (Shown on M1) to detect memory leaks In this lesson I show you how to use leaks to to detect memory leaks on the Mac. Leaks is the equivalent tool that will run on Mac machines (including M1).\n\n00:00 Introduction\n00:37 Example Faulty Program Overview\n2:00 Introduction to Leaks\n2:52 Running Leaks\n\n►...

7. Building GCC 13.1 (and beyond) for C and C++ \nThis is an updated video on how to build large source projects, specifically the gcc compiler for version 11. I build for the C, C++, and Dlang frontend programming languages and show you how to fix few dependencies errors and install the missing dependencies. In total, it took around 80 minutes for me to figure out how to build from scratch (including the time to compile the software from scratch). \n\nNote: I probably should have run 'sudo make install' in order to creating the correct links to default to gcc-11 for instance.\n\n00:00 Introduction\n00:25 GCC 13 updates\n02:40 Pre-requisites for installation\n03:20 Checking your gcc version\n04:19 Downloading GCC from git version control system\n05:20 Setting up the source and build directory\n07:37 Running configure\n10:59 Building dependencies and some tips\n12:13 Observing and running 'make' (About 35 minutes later)\n13:24 Running make install\n14:30 Running GCC 13 (I mean 14 experimental!)\n15:30 Recap of the steps we ran\n17:20 Wrap up and Conclusion\n\n►...

0. x86-64 Assembly (ASM) 1 - Hello WorldClick to find out more!

1. x86-64 Assembly (ASM) 2 - syscalls and assembly program structureClick to find out more!

2. x86-64 Assembly (ASM) 3 - Call instruction and label (Subroutines)Click to find out more!

3. x86-64 Assembly (ASM) 4 - ascii and ascizClick to find out more!

4. x86-64 Assembly (ASM) 5 - ConstantsClick to find out more!

5. x86-64 Assembly (ASM) 6 - Debugging ASMClick to find out more!

6. x86-64 Assembly (ASM) 7 - InputClick to find out more!

7. x86-64 Assembly (ASM) 8 - How to write out a character?Click to find out more!

8. x86-64 Assembly (ASM) 9 - Thinking about DivisionClick to find out more!

0. Introduction To LLVMClick to find out more!

1. Introduction to ConcurrencyClick to find out more!

2. Introduction to Github ClassroomClick to find out more!

3. CppCon 2018: Mike Shah “Let's Intercept OpenGL Function Calls...for Logging!”Click to find out more!

4. Introduction to LLVM 8 - 2019Click to find out more!

5. Introduction To Clang 2019 06 10 13 02 18Click to find out more!

6. Northeastern+MIT - Introduction to Program Analysis 2019 (Small LLVM Example)Click to find out more!

7. Back to Basics: Design Patterns - Mike Shah - CppCon 2020Click to find out more!

9. Back to Basics: Pointers - Mike Shah - CppCon 2021Click to find out more!

10. Back to Basics: Concurrency - Mike Shah - CppCon 2021Click to find out more!

11. The Factory Pattern - Mike Shah - CppCon 2021Click to find out more!

12. How I Teach Modern C++ One Pixel at a Time - Mike Shah - ACCU 2022Click to find out more!

13. Beginners Guide to C++'s Best Kept Secret -- std::algorithm - Mike Shah - C++ on Sea 2022Click to find out more!

14. DConf '22: Ray Tracing in (Less Than) One Weekend with DLang -- Mike ShahClick to find out more!

15. DConf Online '22 - Engineering a Ray Tracer on the Next Weekend with DLangClick to find out more!

16. Introduction to Smart Pointers and WhyClick to find out more!

17. Back to Basics: Debugging in C++ - Mike Shah - CppCon 2022Click to find out more!

18. The Observer Design Pattern in Cpp - Mike Shah - CppCon 2022Click to find out more!

19. DConf Online '22 Q & A: Mike ShahClick to find out more!

20. Mike Shah :: Running Away From Computation - An IntroductionClick to find out more!

21. itCppCon23 Optimization Design Patterns (Mike Shah)Click to find out more!

22. [CppIndiaCon 2023] Optimization Design Patterns by Mike ShahClick to find out more!

23. DConf '23--A Semester at University: Teaching\/Learning Software Engineering in D--Mike Shah et al.Click to find out more!

24. Getting Started with Scripting in PythonClick to find out more!

25. Introduction to C++ Containers - Know Your Data Structures - Mike Shah - Meeting C++ 2023Click to find out more!

26. Back to Basics: Functions in C++ - Mike Shah - CppCon 2023Click to find out more!

27. ACCU 2024 Session Preview - Interview With Mike Shah by @cppeventsClick to find out more!

28. ACCU 2024 Session Preview - Interview With Mike Shah by @cppevents - RereleaseClick to find out more!

29. The Strategy Design Pattern in Cpp - Mike Shah - C++Online 2024Click to find out more!

30. How DLang Improves my Modern C++ and Vice Versa - Mike Shah - ACCU 2024Click to find out more!

0. 1 Introduction To P5.js | Processing JavascriptClick to find out more!

1. Basic interaction in P5JS part 1Click to find out more!

2. Basic interaction in P5JS part 2Click to find out more!

3. Basic interaction in P5JS part 3Click to find out more!

4. Basic interaction in P5JS part 4Click to find out more!

0. Set Notation - Lesson 1 [Topics in Discrete Mathematics] Learn basic set notation \n\n►...

1. Set Representation - Lesson 2 [Topics in Discrete Mathematics] Learn how sets can be represented and talked about \n\n►...

2. Cartesian Product - Lesson 3 [Topics in Discrete Mathematics] Learn the cartesian product \n\n►...

3. Power Set - Lesson 4 [Topics in Discrete Mathematics] Learn the power set \n\n►...

4. bit strings - Lesson 5 [Topics in Discrete Mathematics] Learn about one way to represent sets in computers \n\n►...

5. prime and coprime - Lesson 6 [Topics in Discrete Mathematics] Learn about prime numbers, co-prime (i.e. relatively prime) numbers. \n\n►...

6. bezout identity - Lesson 7 [Topics in Discrete Mathematics] Learn about Bezout's Identity \n\n►...

7. euclid and extended euclid - Lesson 8 [Topics in Discrete Mathematics] Learn about Euclid for finding the GCD and extended Euclid \n\n►...

8. Multiplicative Inverse (Modular) - Lesson 9 [Topics in Discrete Mathematics] Learn how to divide in modular arithmetic. \n\n►...

9. RSA - Lesson 10 [Topics in Discrete Mathematics] Learn about the RSA algorithm \n\n►...

10. Permutations and Combinations Part 1 - Lesson 11 [Topics in Discrete Mathematics] A lesson on permutations and combinations\n\n►...

11. Permutations and Combinations Part 2 - Lesson 12 [Topics in Discrete Mathematics] A lesson on permutations and combinations continued!\n\n►...

12. Permutations and Combinations Part 3 - Lesson 13 [Topics in Discrete Mathematics] Permutations and combinations continued for part 3.\n\n►...

13. Permutations and Combinations Part 4 - Lesson 14 [Topics in Discrete Mathematics] A fourth part of permutations and combinations.\n\n►...

14. Permutations and Combinations Part 5 - Lesson 15 [Topics in Discrete Mathematics] Round 5 of permutations and combinations\n\n►...

15. Permutations and Combinations Part 6 - Lesson 16 [Topics in Discrete Mathematics] Part 6 of permutations and combinations. \n\n►...

16. MarkovChain - Lesson 23 [Topics in Discrete Mathematics] A lesson on markov chains\n\n►...

17. MarkovChain Part 2 - Lesson 18 [Topics in Discrete Mathematics] A second lesson on markov chains\n\n►...

18. MarkovChain Part 3 - Lesson 19 [Topics in Discrete Mathematics] A third lesson on markov chains\n\n►...

19. MarkovChain Part 4 - Lesson 20 [Topics in Discrete Mathematics] A fourth lesson on markov chains\n\n►...

20. BinarySearch - Lesson 21 [Topics in Discrete Mathematics] A lesson introducing binary search\n\n►...

21. LinearSearch - Lesson 22 [Topics in Discrete Mathematics] A lesson on linear search\n\n►...

0. 01 review - Writing a Hello World in C++Click to find out more!

1. 02 terminal - Quick Introduction to the terminalClick to find out more!

2. 03 comp11 - Providing Files (Specific to Students in Course)Click to find out more!

3. 04 scp file transferClick to find out more!

4. 05 READMEClick to find out more!

5. 06 variablesClick to find out more!

6. 07 stringsClick to find out more!

7. 08 strings 2Click to find out more!

8. 09 strings 3Click to find out more!

9. 10 constClick to find out more!

10. 11 int longClick to find out more!

11. 12 integer divisionClick to find out more!

12. 13 float doubleClick to find out more!

13. 14 mixingtypesClick to find out more!

14. 15 charClick to find out more!

15. 16 boolClick to find out more!

16. 17 type conversionsClick to find out more!

17. 18 castingClick to find out more!

18. 19 auto decltypeClick to find out more!

19. 20 Do Computers ThinkClick to find out more!

20. 21 selection StatementsClick to find out more!

21. 22 selection Statements 2Click to find out more!

22. 23 selection Statements 3Click to find out more!

23. 24 selection Statements 4Click to find out more!

24. 25 iterationClick to find out more!

25. 26 iteration 2Click to find out more!

26. 27 iteration 3Click to find out more!

27. 28 scopeClick to find out more!

28. 29 functions 1Click to find out more!

29. 30 functions 2Click to find out more!

30. 31 functions 3 overloadingClick to find out more!

31. 32 functions 4 templatesClick to find out more!