Відео

Cheers!

Cheers, I'm very happy to hear that!

'operator+' can be thought of as a function, so if you don't specify how to handle that, then the types do not know how to handle add. You can try otherwise and see the compiler errors guide you.

Cheers!

Good suggestion -- some videos I dive in a bit more or show the possible implementation on cppreference. I'll continue to do that more where applicable.

😂

I did not know of Crystal until this series, very nice language

D is powerful 😁 What I really like though is the tools incorporated like: profiler, documentation, unit tests, code coverage, syntax tree, etc. It's a lot to see with all the options, but much better than having lots of external tools/dependencies. It's all there for free to learn over time 😁

C++23 will start appearing later on in the series. Keep in mind this video was posted 2 years ago -- most compilers are most compliant as of this writing with C++ 20 features (though support for modules may be missing other than on MSVC as of this writing). Generally speaking, many of the features I show are fine to use with C++11, and I explicitly set a higher version if needed to show something else -- keep in mind many folks in embedded world do not have available even C++14, as compilers have to be verified.

Are you referring to around 5:29? What is bad style of coding exactly? Classes indeed are private by default for all data members nad member functions.

Based on the documentation (dlang.org/library/std/typecons/safe_ref_counted.html) as you have mentioned I think this is indeed suppose to be similar to make_shared or otherwise a shared_ptr in C++. I need dto dig in a bit further myself before I make a video. I've always otherwise thought of it as a 'smart pointer' that uses reference counting and manages its own heap -- i.e. does not do garbage collection, but perhaps allocates some control structure that is managed automatically for keeping the reference counts. Use cases again are to have another memory allocation style that does not necessarily need garbage collection, but provides memory safety (and I think with dip1000 enabled, should work fine, and *perhaps* even work in @safe code -- at least that may have been the goal)

I can't remember if in that video I elevated my privileges to super user (sudo or su). That may have been necessary, or otherwise is one thing you can try. There's probably a better fix though than to have to get elevated priveleges -- though that is something I'll have to test when I upgrade my Mac.

@@MikeShah Thx a lot, if you will have answer to this issue I would be very appreciate. I'm trying to solve this problem as soon as I'm passing a huge course of C programming and that tool was absolutely magic for me. Everytime I run leaks --atExit-- <progname>, I have that crazy 2185 segmentation fault sudo leaks --atExit-- <Progname>. I was trying to switch off SIP, but it still doesn't work. And it seems that $PATH I have introduce correctly because there is leaks tool in the system which leaks /usr/bin/leaks

@@vkatasonov Worse case if you can use a VM on valgrind that should immediately reveal answers. Otherwise, this may be a helpful post in regards to Mac and Sonoma: forums.developer.apple.com/forums/thread/738804

@@MikeShah I was trying to use VM on UTM but valgrind there doesn’t work. The only solution I see is Docker with Linux or idx from google

Cheers!

I suspect Zig, like many compiled langauges have excellent speed. Fastest often depends on cleverness of algorithm and programmer, so I don't see why Zig would perform any differently than other langauges.. Languages like C, C++, D, Zig, etc. all have compiler options on LLVM based compilers, and can take advantage of many of the same optimizations.

My understanding is Ada projects tend to be long lived. The verbosity is because for long lived projects, you end up reading the code more than writing it, so explicit meanings can be very useful. Ada also wants to provide gaureentees and 'contracts' for code for safety critical applications. Like all langauges, it just takes getting use to and buying into the main principles :)

Cheers! Good idea, I have some examples in my C++ quick start series until then!

Corrext, they're just 'handles' to data allocated elsewhere. All OpenGL really does is validate a bundle of data (by setting various handles) and ships that 'packet of information' to a driver to do the graphics work :)

Cheers! I have another free one here: ua-cam.com/video/e4E6nQpd7Xs/v-deo.html and here's the sales pitch if you want more! ua-cam.com/video/UVb95-ornjs/v-deo.html

Cheers!

Cheers, thank you for your kind words 🙂

Cheers, a great example!

Cheers!

Compiles and reduces i to 23? This could be a result of the compiler running an 'inline' optimization followed by constant expression folding -- i.e. compilers are smart enough to see values 7 and 16 (e.g. return 7 + 16) and just evaluate it. 'constexpr' gives us a tool to try to force the compiler to execute on snippets of code and not rely on optimizer.

What did you have in mind? Could use 'repeat' from std.range 1 import std.range; 2 import std.stdio; 3 4 void main(){ 5 6 auto foo(int x) => x*x; 7 writeln(foo(7).repeat(4)); 8 9 }

@@MikeShah thanks, yes, basically i didnt explain why i had asked... i was recently reading the book 'Starting Forth' by Leo Brodie and from page 11 he creates a couple of words (same as functions basically) in which the 1st function (called star) outputs 1 character (a *) and the 2nd function (called stars) calls that 1st function as many times as the number given on the stack, so if we enter: 35 stars It would output 35 of them, etc etc

Ah got it ​@@thegameoflife9179. This could also be solved recursively if you're printing stars with some input.

@@MikeShah yep, ive no doubt it can be done recursively but i prefer to split into seperate parts like he's done in forth so that they can be reused in other parts of the program... in Common Lisp you could do this... (defun star () (princ '*)) (defun stars (no-of-stars) (loop repeat no-of-stars collect (star))) (stars 35)

None of them really -- each smart pointer is putting some restriction to help you write safer code. A quick summary: shared_ptr is the most flexible, and still saves you from double-frees -- so perhaps this is the closest in some sense. weak_ptr may or may not be valid memory (but you can check, and still allows you to share memory), and unique_ptr is exactly a pointer, except you can only have ownership of one piece of memory (limiting sharing).

Awesome! D really makes them much cleaner to work with :)

I have plans to cover either Erlang or Elixer before I end the series :)

Building an object relational mapping (ORM) sounds like something that you could indeed use this tool for.

I would use the user-defined-attributes for this to make something like spring or EJB in java. on top of that I would use dependency injection and a declarative style to customise the stack at runtime. then you can build the webapp as well as the business code from just a few source files. making use of CTFE removes the requirement for a generational stage during the build.

@@disdroid (User-defined) attributes are another options, yes (however: attributes in D are kind of overused [once w/ @, once w/o @] and not well-defined, IMHO).

@@bsdooby they are extremely versatile - I haven't got round to using them as much as I should. the technique is similar to the variadic struct templates - the client attaches meta-data to their type and it gets parsed by CTFE code that can generate some code inside your type. so you would use the attributes and a mixin instantiation inside your class or struct etc. and this would add your object to the ORM. I can use these attributes to specify the database parameters, as well as things like display style for web pages, in the same file as the object defintion. We wouldn't be forced to use these, they'd be the last part of the library to create. we start out using separate configuration files which we parse at compile time, and when the system is operational we create an API so that users can quickly create a runtime in one file and run it using rdmd. so simple!

here's another idea - the library can generate a tuple from a given declaration set so we just grab that and use "alias this" in our application. we might not need the mixin in this case.

Welcome! Pretty much any video starting with 'C++ Classes' or 'struct' in the title are what you are looking for. Check out the playlist here: ua-cam.com/play/PLvv0ScY6vfd8j-tlhYVPYgiIyXduu6m-L.html

All correct! Don't really need to disable them, as once I've unbinded from the VAO there is no need to disable anything.

@@MikeShahThank you for your quick reply, it is greatly appreciated. I am almost through Episode 19 now, and math is my most difficult challenge. I am 'C' coder and was one for over 40 years. Systems coder. So, the C++ library you recommended 'GLM' is pretty much unusable for me as I much of the syntax is foreign to me. I never learned C++, so I am going to try and write my own math functions in straight 'C' using structures and the SDL math handlers. It will be a great way to learn graphics math, and I look forward to it. I am doing all of this in VS 2022 and so far it has not been a problem. I love SDL2 and use it to code some of the Game JAMS I have entered. I am 71 years old and am looking forward to finishing your wonderful class in hopes it will make clearer the methods I can use to build a procedural forest like Valheim. I have given my self 5 years to finish the project. Thanks again Mr. Shah, you are an inspiration to many programmers, including myself.

@@beebstergames7348 Very cool -- and what a career you have had! Happy to help, enjoy!

Thank you for the kind words! I'll have to explore the Win32 API -- it's been a while since I've done anything beyond opening a window for OpenGL :)

Cheers!

Cheers, thank you for the kind words Andrew!

Indeed!

For me serialization and deserialization is a common use case. This has come in handy for both saving/loading data, and also for cases where I need to pack bytes together to send using the std.sockets API. Folks will also use template mixins to avoid the costs of inheritance (i.e. virtual calls), by just 'adding functionality', rather than having to resort to inheritance and creating an is-a relationship (which may or may not be necessary. I'd say it's necessary to use inheritnace as soon as you need to group objects together in a container as one example). Probably folks can think of other more wild (but useful) examples :)

@@MikeShah Thank you for this excellent response and good use case! much appreciated...

I'm working an idea for a language backend that runs in the compiler. mixin templates are used to represent all the parts of the parse tree. every token represents a mixin template, even the variables and function arguments. a script gets converted into a tuple that you can use in a class or anything at all, wherever you add the mixin to invoke the meta-compiler. or, instead of a tuple it can export a string constant that can easily be written to a file. so it's using template mixins as a middleware between a parse tree and blocks of D code.

@@disdroid What type or kind of language do you have in mind? You seem to know your way round...

@@bsdooby an example would be rule based languages, or things like rdf/owl. We could also make parts of JavaScript happen in the compiler, but not eval of a variable, nor anything to do with async/await or threads. I have an idea for a language that appears more like a script than D - but we can have features such as algebraic classes, so we can say "anything which isn't an InpuRange automatically inherits interface X (although it doesn't - there is no actual interface X, its just a set of mixins). Another point to be made is that inside the compiler mixins we purposely don't import tokens that are part of the language implementation - we require the user to provide implementations for certain symbols. Let's say I'm parsing an expression that uses + and this resolves to a template instantiation called add. If I want to ensure that my code is fully ctfe based I can use the version of add that composes an enum, whereas if I want it to read the current value from a variable every time the expression gets evaluated at runtime, I might choose a version of add that uses lambdas. So before I mixin the compiler I need to "import foo.bar : add = addLambdas;". We can then decide how we treat each token, either enum or lambda usually, but I've just written a small interpreter that mixes in each identifier as a mixin template in scope, and aliases the result, inside an expression, which means that we could create custom behaviour for a particular variable without affecting the grammar or the parser. This hasn't been committed yet - the project is called coregrammars and the module is coregrammars.parsers.expr - look right at the end of the file, the last few unittests do a variety of things with the identifiers in the parse tree. I've got compilation time back to normal at last! Hopefully I will push this code to GitHub today. In actual fact, parameters in mixin templates are unnecessary in respect of adding symbols into scope.

You can supply std::less or std::greater -- but I have otherwise shown how to build 'EdgeCompare' as a functor. std::less and std::greater are simply functions (or functors) that are available in the standard library for any type that already has '<' or '>' defined. en.cppreference.com/w/cpp/utility/functional/less

Cheers!

Cheers!