Also, UFMG university in Brazil has a nice laboratory on compilers, maybe they have a good C++ course and other

I'll look into this, maybe I can found more articles about this kind of topic. this page has a lot of good information and it is helping me a lot. https://www.linkedin.com/company/meeting-cpp/

They are ok Also you can look up CppCon, Jason Turner

And open courses of MIT and other top universities on operating systems, computer science and computer architecture

I thought MIT ended his C++ course.

C++ Move Semantics - The Complete Guide (2022) (Nicolai M. Josuttis)

I have a dos box application

F

I want to deepen my understanding of the type_traits library and the types requirements thing cppreference is good but it's too verbose(being a reference after all) I want to understand why and when to use those components inside the library and the reasoning and logical thinking behind deciding that my foo() should accept only std::is_X_v and alike I'm kinda familiar with the library and how many of its components are implemented(compiler built-in functions, specialisation tricks ..etc) but I feel like I'm missing the practical side Anyway to accomplish that?

Application of c language in PC

Plus there's no use to learn DOS assembly

x86 is still used today

I highly doubt DOS assembly used nowdays, ancient OS and arch

sure it's used :)

Give me the use case then

github.com/akaWolf/LostVikings

Well then, how it can be applicable to modern OS and arch?

you can write in a DOS assembly under modern OS if you want :)

I said how it can be useful under modern OS

well, one use case I give you - reversing legacy soft

Do DOS malware still exist nowdays?

I don't know, I'm reversing the game

Sorry if I'm rude but have you learn about modern OS assembly like Linux or Windows ?

legacy mode will eventually die later

Even i386 will be dropped later, x86-64 is the newest

so what the assembly is still valid, and a decent way to learn it

you still can apply the same principles

Anything but don't learn ancient cpu arch or ancient os

i'd rather teach a beginner 6502 assembly than someone proficient in x86-64 SSE/AVX extensions

Yeah, why teach a skill that is actually relevant, right?

Thankfully no more segmentation on x64

You're missing the point.

https://en.m.wikipedia.org/wiki/Win32_Thread_Information_Block

can you rewrite that sentence please?

Which is?

If someone is interested in how a CPU works, you actually should start with something simple. 6502 is perfectly valid for doing that, so is any other hypothetical machine that helps you learn transferrable knowledge. x86-64 is such a clusterfuck of an architecture that it's basically impossible to teach a beginner how to get the most basic stuff done in a decent amount of time without leaving out important details. (and this would still be leaving out performance considerations, which are imo the most important reason one can have to write assembly.)

Does it has relation with the CPU design like RISC and CISC?

If someone is interested in how a CPU works, you actually should start with something simple. 6502 is perfectly valid for doing that, so is any other hypothetical machine that helps you learn transferrable knowledge. x86-64 is such a clusterfuck of an architecture that it's basically impossible to teach a beginner how to get the most basic stuff done in a decent amount of time without leaving out important details. (and this would still be leaving out performance considerations, which are imo the most important reason one can have to write assembly.)

I have no experience in teaching but couldn't you use risc-v for processor architecture, things like pipelining etc. And could still teach x86_64 to a beginner. At least the instructions, the operand forms, the calling conventions, etc.

I wouldn't use any specific architecture for stuff like pipelining, but rather explain the general concept, once someone understands this, move to the architecture specific details. Your second point is exactly what i meant by "leaving out important details". (You're basically just doing the same thing, teaching the semantics of the most basic instructions & how they're used. But you're basically leaving out all the ugly parts that distinguish x86-64 from anything reasonable) imo Calling conventions aren't something you should explicitly teach when teaching assembly, let your students look at generated code and let them find the patterns that emerge from calling conventions themselves, if you've done a good enough job at teaching before, they will figure it out on their own.

So I still do not get what's impossible. Also what is wrong about removing complexity first then adding it later when teaching? How is it different from teaching them 6052 first?

>How is it different from teaching them 6052 first? You're prepared to be able to answer all questions in a simple fashion.

I wouldn't use any specific architecture for stuff like pipelining, but rather explain the general concept, once someone understands this, move to the architecture specific details. Your second point is exactly what i meant by "leaving out important details". (You're basically just doing the same thing, teaching the semantics of the most basic instructions & how they're used. But you're basically leaving out all the ugly parts that distinguish x86-64 from anything reasonable) imo Calling conventions aren't something you should explicitly teach when teaching assembly, let your students look at generated code and let them find the patterns that emerge from calling conventions themselves, if you've done a good enough job at teaching before, they will figure it out on their own.

If someone is interested in how a CPU works, you actually should start with something simple. 6502 is perfectly valid for doing that, so is any other hypothetical machine that helps you learn transferrable knowledge. x86-64 is such a clusterfuck of an architecture that it's basically impossible to teach a beginner how to get the most basic stuff done in a decent amount of time without leaving out important details. (and this would still be leaving out performance considerations, which are imo the most important reason one can have to write assembly.)