Bjarne Stroustrup - The Essence of C++ 

papa bless

Thanks, Napat!

Bless you

I shouldn't have to look in comments or description for this type of thing

@@themodfather9382 But you just did xd

vima78 \o/

+vima78 Yeaahhh!!!

+vima78 Thanks. :D

+vima78 Unless you wanna know where the fire extinguishers are, in case of fire :p

Brad Haircut LOL

Maxwell Strange look at what language he started with.

ahk is approachable. Cpp is very not.

Ohm, yes, so damn concerned, that he and the C++ committee did not solve this with a more than 20 year head start.

Yeah I like Bjarne and listen to all his talks.

89888889998889888888

C++ is high level - if you are not using abstraction then you are most likely still using procedural C techniques - I agree man C++ is not easy, it is very challenging and a huge language with huge libraries, and takes years to master good luck bro! - get into Scott Meyers series it's great!

@Calum Tatum Depends. For performance critical tasks, like realtime audio for example, your example languages are just not fast enough. Also, C# is running on a runtime (CLR) that is written in C++. So what do you recommend for the person writing that runtime? C++ is hard, but it's also a really important language.

If you want procedural programming language, try Pascal..very similar to C

@@WouterStudioHD rust go brrrrrr

Does it help?

He invented it but don't be fooled, programming languages are an iterative process and C++ has been around for 40 some-odd years.

Bedroom Pianist More like 30 odd years. In a sense, Objective C beat C++ to market since it was beginning to be used commercially while C++ was still just an internal intellectual curiosity at Bell Labs. One could argue that Objective C isn’t really an entirely new language, but more like C with library and pre-processor extensions.

@@markteague8889 Objective-C sucks. It's a mess of weird syntax and it lacks the generic power of C++.

Wouter I know the original syntax was akin to that used by SmallTalk (maybe the first OO language) which employed the message passing paradigm. As I understand it, modern flavors of Objective C support both styles of syntax for invoking methods against objects.

@Man With No Name he said james bond not dragon ball z

He does have a bit of a Ernst Stavro Blofeld vibe about him

​@@corriedebeer799 No, maybe the old Blofeld though.

If some people would listen to what he has to say and actually take the time to understand his books, not just read, but UNDERSTAND, that wouldn’t be the case. Instead, people just learn C++ at a very basic level as if it’s Python or something, and use every single feature of the language in their projects for no rhyme or reason and then call C++ a horrible language if something goes wrong.

J T Calmdawn computer scientitst

No doubt he's a genius, but the syntax is horrible.

@@jorgebastos2431 The syntax is actually very nice, very 'well defined'. Coder doesn't have much room for 'syntax' mistakes. Compilers catch them. Of course a lot depends from its creators as well... I love the language for classes and possibility to separate interface from implementation... Resource control and the speed of solutions when they e finally ready...

SosukeAizenTaisho C++ isn’t “backwards compatible” with C, it’s a *superset* of C. Big difference.

Menne Kamminga gg

Indeed, it's interesting. He even has a monotone voice delivery. What keeps us listening is the level of precision and relevancy with which he delivers all the information.

He probably thought "English is too simple. Why would they teach such a language as a first one, there isn't enough thinking involved" :D

I see what you did there

hahaha you made my day

lmfaoooooo

we weren't even taught linked lists with nullptr lmao our prof still uses NULL

follow bisquit channel for c++ magic

That's why I learn Rust.

So you think when people use words with more than two syllables in them they are trying to trick you?

not to downplay C++, but C is easily more important than C++

@@joestevenson5568 not to downplay c++ is C

People these days don't respect the past. Sad to see really.

It's an amazingly powerful language, but also gives you the opportunity to shoot yourself in the foot at every step on the way. To use it simply and safely, you'll probably start using smart pointers, copying strings instead of referencing.. undoing its performance potential. Still, you can do everything, including shooting yourself in the foot.

Thank you

Perhaps this is a good time to point out that on RU-vid, if you nest the bold and italic syntax in the wrong way, editing a comment, making no change, and saving it again is not idempotent (it keeps wrapping more and more escape characters-incorrectly-with each additional unchanged save). Man, that takes talent. Broke-the-mold talent. Couldn't get i, j, and k into the correct alphabetical order if your life depended upon it talent.

Also, I hope people read carefully enough to realize that I was exactly half serious: half serious because this *does* actually work, half not serious, because it only works for a stubborn iconoclast willing to put up with a certain extreme forms of surface ugliness -and stubborn iconoclasts (like Knuth and Bernstein and every second Haskell programmer) have always managed to write software with orders of magnitudes fewer bugs than competitive endeavors from lower down in the iconoclasm pecking order, so it's really not such a special value add.

@@afterthesmash the problem with avoiding exceptions, is that you are just manually implementing the error handling mechanism already present in the language. you are also wasting the return value which could be used for something more natural. the big advantage of exceptions to me is that you can abstract them away. this way you are left more with code describing task. this is much cleaner, than code checking for errors, with the actual task buried somewhere inside. i'm sure you could make it work like most things, but it looks like it results in a lot of unnecessary code

@@xybersurfer xybersurfer Naturalness only exists in a cultural context. You choose to operate within a software culture with a weirdly enlarged notion of "error". If I tried to sign up on Facebook and I entered my "Allan Stokes" as my preferred username, would the system create me a new account, or would it display an "error" that my username is already taken by some other Allan Stokes of no particular distinction? That counts as an "error" in what sense, precisely? Was it an error that some other Allan Stokes wanted my personal name? Was it an error that I also wanted the same? Was it an error that Facebook did not originally design their social network so that all users were known by a globally unique 128-bit GUID, preventing this kind of land-rush clash for all time? I count _none_ of these things as errors. Not everybody can have everything at the same time in the world we actually live in. Since I'm already a decade or two late boarding the Facebook ark, it's now a hail Mary for me to obtain the simplest rendition of my own name in this sphere. It's for the same reason we send Santa a list, and not just the single item Ferrari Testarossa. Santa might be short on Ferrari's this year, especially in light of the present circumstance in Milan lately. So it's a wise policy to provide Santa with options B through F, as well. Was it an "error" for me to want a Ferrari Testarossa? Or was it merely the first interaction in a distributed algorithm to probe the maximal intersection point between my list of desires and Santa's available merchandise? Likewise, if my algorithm wants 10 GB of DRAM working-space so as to run faster, is it an "error" if my request can not presently be granted by Santa's elves? I don't count that as an error, either. Let's suppose I'm only asking for 256 bytes, and malloc returns NULL. Under those conditions, whatever my subroutine is trying to accomplish is probably not viable. How does the OS know that this is now an error as you see it, because your program design has boxed you into a corner with no recourse but to barf up a White Flag of Surrender message box? The OS does _not_ know this. (Is it a coincidence that "throw" and "barf" are somewhat synonymous? I think not.) What the OS _could_ know for certain is that you just called free on a pointer it can't find on any active allocation list, which is _definitely_ an error. And if your program has just called free on a non-thing (type II error), what confidence do you now have that you haven't previously called free on a thing you intended to continue using (type I error)? Practically NIL. This is now Hunt the Wumpus territory. "It is now pitch dark. If you proceed, you will likely fall into a pit." But this isn't actually defined in the standard as an "error". The standard instead says that free's behaviour is now undefined. And once _any_ function commits undefined behaviour, this condition can not be erased short of exiting the current process (although in theory, attempting to exit your process can now also be undefined)-and now the state of your Unix process tree can potentially also become undefined and it's probably now time to pay homage to CTRL-ALT-DEL. In practice, exit is usually engineered to not depend on much, so it usually won't fail to exit your process, to some number of nines (typically more for BSD with a belt-and-suspenders attitude dating back to the original graybeard; fewer for Linux, which regards too many nines as a type II cultural error that greatly hinders the effective evolution rate). This is the funny thing about error culture in computer science. The unambiguous errors are considered so severe, that the cultural response is "why even contemplate continuing to press forward?" whereas completely foreseeable circumstances-like two people trying to sign up on Facebook with the same username-are reified into the barf loop (aka culturally re-parented into the class of "exceptionable" error events). My personal favourite case study is the Therac-25, a Canadian radiation therapy machine which either killed or badly injured at last six people. It had two beam strengths: regular and lethal (100× beam power). There was a turntable inside to rotate a bullet-proof vest in front of the lethal beam. On striking the bullet-proof target, the lethal beam would kick out some other modality of therapeutic radiation as a byproduct. Patient saved. In Dijkstra's world, you have ONE place in the code which is capable of unleashing lethal beam energy. Under what condition are you not allowed to do this? When the bullet-proof vest has _not_ been rotated into position. Otherwise, the patient experiences an extreme shock and _literally_ runs screaming out of the treatment room (as did a fatally wounded Roy Cox in actual fact). But you see, the software was designed to ensure that the correct turntable position was already activated and properly in place long _before_ subroutine release_the_radioactive_hounds was called upon to do its dirty work. Mechanically, the turntable implemented _three_ separate microswitches to ensure that the software could reliably detect its true position (not just two sets like your microwave oven door). They got carried away with thinking about what the software was trying to _do_ (treat the patient) and forget to think clearly about what the software was trying to _not_ do (kill the patient). There's no excuse on God's green earth for a software culture which accepts _anything_ other than a last conditional statement to check the turntable position (and every _other_ survival-critical precondition, if there were any more) before the ONE line of code capable of unleashing the 100× lethal beam. We were a good 35 years into the software industry before these fatal accidents happened. Dijkstra had completely set this straight already by the 1960s. In ZFS or PostgreSQL-or any other life-critical application (as viewed by the data under storage)-the implementation culture is strongly biased to think first and always about what you simply MUST NOT DO (e.g. create a race condition on flush to disk). Further up the software stack, the culture flips into: call the extremely sophisticated and fast-moving API as best as you can and mostly hope for the best. If a 7'2" Santa Claus with a 30" vertical leap power-blocks your layup attempt, you click you heels through the handy-dandy uncluttered exception mechanism, and return to Kansas, hardly any the wiser, but more or less still alive. Betcha didn't know Santa had that move. Good thing your ruby slippers are maximally topped up on reindeer credits. Only here's the downside: people who live in Kansas begin to develop an extremely muzzy sense of what a true error actually looks like. "Error" becomes a hopelessly muddled class of eventualities where it seems more convenient to click your heels together than to write a robust code block with a clear sense of the hazards it is actually navigating. And then this becomes further reified into what "uncluttered" code ought to properly look like, because we are at the end of the day cultural creatures, who thrive on cultural uniformity

@@xybersurfer Long ago I attended a pretentious university (Waterloo, Ontario) where the faculty was determined to teach freshman and sophomores the One True Way, which in that year was the Pascal programming language, with a top-down design methodology. Everyone I knew with any talent was conniving to get an account on any machine with a viable C compiler, while the faculty was conniving to keep access to these machines as limited as possible for the sake of "sparing the children". But no high-integrity system is ever designed top down. You mainly work bottom up at first from your core integrity guarantees. And then once you have a coherent API over your core integrity layer, you work top down, but still not as I was originally instructed. The top-down portion is architected from your test and verification analysis. The best modularity is the maximally testable modularity, and not the modularity that produces the least amount or the cleanest amount of code. In particular, your abstraction boundaries only need to be clean enough, rather than conceptually pristine (pristine when you can swing it, but not at the cost of making the full system less testable). The Linux people thought that ZFS had too many layering violations, and that with the benefit of hindsight and some fundamentally better algorithms deep down, they could kick ZFS to the curb with Btrfs. Actual outcome: Btrfs was removed from Red Hat Enterprise Linux 8 (RHEL) in May 2019. Btrfs team: We know pristine (good), we know clutter (bad). ZFS team: We know core coherence layering (hard, but doable with a clear head), we know testability at scale (hard, but doable with sustained cultural pragmatism). From Rudd-O: "ZFS will actually tell you what went bad in no uncertain terms, and help you fix it. ... btrfs has nothing of the sort. You are forced to stalk the kernel ring buffer if you want to find out about such things." That's a guaranteed fingerprint of a click-your-heels-to-return-to-Kansas design ethos. At which point all you can do is emit a somewhat cryptic message to the OS ring buffer. The original inviolable rationale for why top-down-design as I was once taught in Pascal was going to rule the world is that it's fundamentally based on divide and conquer. And what can possibly defeat divide and conquer? We had hundreds of years-if not _thousands_ of years-of history with this technique in mathematics. And it truly rocks in that domain. Because mathematics-of all human things-most excels at abstraction from messy circumstance. By emulating mathematics to the ultimate extent, so too can software _pretend_ to exist in this austere world. The original ZFS design team at Oracle knew how to design the system around their validation framework, because they were _deeply_ immersed in the world of the shit hitting the fan. Before Matt Ahrens proposed ZFS, a typo in the configuration of the Solaris volume manager caused the system to lose all home directories for 1000 engineers. And that was far from the only domain of extreme suffering. Original design principle: to escape the suffering, the administrator expresses intent, not device mappings. Now I'm circling back to the original problem. When you're muzzy-headed about what constitutes a conceptually coherent error class (because you've lumped sick world & sick dog under "click-your-heels" through the underground exception-return expressway) there's barely any possible way to think clearly about application intent. Oh, but you say "the exception return object can be arbitrarily complex to handle this". And right you would be, only there goes your pristine and uncluttered code base, for sure. And now what have you really gained? Because you are already welded into the exception mindset, you're almost certainly going to try to report the damage on first contact with a 7'2" Santa Claus guarding the post. And you're return an object to encode error 666: denied by Giant Black Goliath in a red deerskin vest. I've actually played around with writing code where I would continue to attempt to do all things the code can legally do _after_ something has already gone fatally wrong (fatally wrong meaning there is no remaining chance to achieve your subroutine's mandatory post-condition) and then reporting back _all_ the resources and actions that proved unsuccessful in the quest to accomplish the assigned task. (There is no possible way to implement this coding strategy that you would not decree to be hopelessly cluttered.) And this is interesting, because when you do get six errors at all once (illegal host name, can not allocate memory, no route to host, private key does not exist) then you're immediately pretty sure you entered double-insert mode in vi and there's an extra "i" character somewhere in your application's configuration file. Suppose you tell a human minion: deliver this yellow envelope to 555 Hurl St, last door on the right at the end of the long yellow hallway on the third floor and then grab me a muffin from the bakery downstairs and your minion comes back to report "no such address" (with no muffin) and doesn't point out that while the hallway on the third floor was long, it was orange instead of yellow and you didn't even check whether there was a bakery down below, because unfortunately the hallway was orange instead of yellow, so you didn't even _think_ about completing the rest of the assigned errand. "And there was no bakery down below" would have you checking your street address first of all. "And there _was_ a bakery down below" would have you checking your floor number first of all (while happily munching your hot muffin as a side bonus). Human contingency is _so_ different than code contingency, and I just think this is wrong-headed all around. But modern computer languages really do tend to compel divide and conquer, and I conceded that it's extremely difficult to enact human contingency in a way that's clean and compatible with this reductionist software engineering ethos. I've seen lots of unnecessarily cluttered code. Almost always because of a woolly conceptual foundation, where you're half in one system of coping and half in another system of coping. But I've gradually evolved to where I almost never count clean expression of preconditions or postconditions (all the way down to the level of individual statements) as active code clutter. My eye now regards such code as a somewhat prolix signature of a job well done, no ruby slippers involved.

Yup... and "number" can even be private. People tend to think that private members hide data from other objects, but that's not the goal. The goal is to hide members from people who don't know how Long works internally. Two Long objects share the same code, so they assume that the person who wrote them knows how to handle the two of them interacting. It's when you start interacting with other classes, which are probably written by other people at other times, that private starts to say "Eh... but do they *really* know what Long uses that private field (or method) for?"

rusko dudesko yeah took me a minute to understand the this pointer and how it can point to private data for any new object created

Experienced programmers often write the same code as "this->number += L.number"; it makes it explicit that "number" is a member variable.

@@brianplum1825 yeah... then you can search for this and hopefully get all members... but you can't rely upon it... especially if multiple developers.

The internet is amazing!

Some of the other examples were also missing semicolons.

Tyler Minix "Beautiful" as in "it's what's on the inside that counts," because it's horendeus to look at 😀

Frankly you are insane

It's pretty powerful,but also hard to control

***** what the hell are you doing talking to your fucking self? Or is ***** another person as I have long suspected?

***** Sadly you will never make a programmer with your split personally behaviour. You need your all spanked until your proper Bonobo blue black

***** The answer to what dim wits?

***** Well tell your fucking puppeteer to shove you back in his suitcase.

MScode ™ "I find I can listen to some videos without the sound and learn a lot." How are you able to listen to a video without sound?

its not that deep

@@matthewg1851 oh ok then

okay cool, lets just write all systems software / compilers in Java

Is D still alive? I used it 10 years ago and it was nice, but today I settle for Rust and have more grip on performance.

This only increases the value of C++ programmers

assuming people want C++ programmers@@postmeme44

What did he mean by this comment?

К6🕺🕺🕺😞🕺🕺🗨️🕺🕺🕺😞🕺🕺🕺🕺🗨️🕺🕺🕺😞🕺😞🕺🕺🕺😞🕺😞🕺🕺🕺🕺😞😞🕺🤔🤣🤣😒🤣🤣🤣🐩🐩🐴🏢🏔️🏣🏔️🏕️🏔️🏔️🏔️🏔️🏕️🏔️🏪🏔️🏕️🏔️🏔️🏕️🏔️🏔️🏕️🏔️🏕️🗾🏔️🏕️🏔️🏕️🗺️🏔️🏕️🏔️🏔️🏔️🏪🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏖️🏔️🏛️🏔️🏣🏖️🍋🍋🍋🍋🍋🍎🍋🍋🍋🐂🍋🍈🍌🍐🥑🍍🍍🥑🍍🍍🍍🍍🥖🍍🍍🍑🍍🍍🍍🥑🍍🍑🍍🍍🥖🍍🍍🥖🍍🍍🍍🍐🍍🍍🥑🍍🍍🍍🍊🍊🍊🐘🍊🍉🍉🍉🐹🍉🦒🍌🍍🍍🥐🍌🍏🍌🍐🍌🥐🍌🍌🌶️🍌🍌🦒🦒🥑🦒😀😀🍐🍋🍋🍐🐹🍐🍐🍐🏛️🍐🍐😛🙂😅🏖️🍋🍋🍋🍋🍋🍎🍎🍋🍌🍋🍋🥑🍎🍋🥑🍋🍋🍋🍋🍋🍋🍋🍋🍊🍋🍋🍋🥑🍋🍋🍊🍋🍋🍋🍋🍋🍊🍋🥑🍋🍋🍉🍋🍋🍋🍋🍋🍋🍋🍎🍋🍋🍋🍋🍋🍊🍋🍋🍋🍋🍋🍎🍋🍋🍎🍋🍋🍋🍋🍋🍋🍋🍋🍋🥑🍋🍋🍋🍋🍉🍋🍋🍋🏣😃😃🌶️😃😃😃😃😛🍍🍍🍍🥖🍍🥓🍍🥖🍍🍍🍍🌏🌏🥞🌏🌏🌏🏢🏔️🏔️🏔️🏪🏢🏔️🏔️🗻🏔️🏪🏔️🏢🏪🏔️🌍🥨🌍🌍🍊🍌🥐🍌🍌🍌🍊🍌🍌🥐🏔️🏔️🎉♦️🏑🏑🎽♣️👗🧤🧤🛍️🧤🧤🧣🧣👘🧤🧤👢🧤🧤👘🧤🧤🕶️🧤👢🧤👔👔👖👖🧣🚫🚻🚺🚺🧢🏁🏁🏁🏁↘️🏁🏁📵🚻🚻🚻🚻🛃🛃🚻O:-):-|O:-)O:-):-|O:-):-|🇦🇸:-(🇧🇯:-(🇦🇲🛅🎌🎌🎌⬅️🚺🚻🚻🚩🚩🚻🚻📵🚻🏳️🏁🚻O:-):-|O:-)8-):-P:-|8-):-|8-):-|8-):O:-|:O:-[:-D:-DB-):-|:-|:-D:-[:-[:-D:-|O:-):-|:-|:-|8-):-|:-(:-(O:-):-|:-|8-):-|O:-)8-):-|O:-):-|O:-):-{:-DO:-):-|O:-)🚻🚻↘️🚻:-P🇧🇪:-P🇦🇲:-)🇧🇪:-P:-P:-|:-|🇦🇸♿♿💎🎩👛🎩🚰🚰🚰🚹🚻➡️⚠️⚠️⚠️↔️↘️⚠️👔👔🎳👔♿👛♿🎓🔇👠👡🧣👡🧣🧤🧤🧤🚻⚠️☢️🔇➡️☣️☣️🔕☣️🎙️🚷📱🎶🎈🏔️🏕️🏔️🏪🏛️🏔️🏪🎉🎉🎃🍞🗺️🥑🍍🍐🍑🍈🐖🍈🦍🦍😚🐒😊🐒😚🐒🤐🐵🐺🐐🐺🐄🐺🐺🦄🐄🐺🐄🐺🦍🍊🐫🐗🌳🍇🍇🍇🐙😶🤭🐬🐬🤧🤭🤭🤤🤭🤭🤧🤭🐵🙄🐵🐵😙😙😏😙😜😙😏😪😙😪😋🐙😘😘😜😜🐗🤧😜😜🦄😜😜😜😜😜😜🦄😆😗🤣🍌🍉🍉🍉🍊🍌🍌🍊🍌🍌➡️🚹♿🚹🔈🚰🚰🏳️🇦🇨🏳️🇦🇨🏳️🏳️🇦🇨🏳️🏳️🏳️🏳️🏳️🏳️🇦🇷🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🏳️🎌🎌🎌Любимый человек

hyqhyp is there any article about it?

Actually, he said he got them to move from Fortran to C and to C++, but still agree with your point...

Making a large company change their primary programming language is a serious achievement.

hyqhyp wth.. he invented one of the most commonly used languages of modern time. What are you smoking?

@@bextract0 He's taking about the guy at the beginning. Not Bjarne. You completely misunderstood his very clear comment lol.

It's really not. The problem is, as the man said, that it's been around a long time, and has been, in a way, several _different_ related languages over the years. Keep in mind how very slow and clunky computers were when C++ was introduced - a lot of the original language relied on the programmer to do most of the heavy lifting. That is, you needed to think about the machine almost as much as the problem you were working on. These days, if you use the right parts of C++, you can offload most of the "thinking about the machine" part to the compiler and just concentrate on the problem you're solving. The compiler itself can be a much larger program than was possible in the early days, and it will compile your modern code in seconds or minutes rather than weeks. Most of this talk was about why it's better to use the newer language features when you can rather than the features that were there so that your steam-and-hamster-powered 4MHz processor with maybe a couple of megabytes of memory (huge for the time) wouldn't choke trying to compile it.

And the Curiosity rover on one of the first Bjarne's slides is actually running software written in C.

FORTRAN WAS COOL (in college) . I DID GOOD IN IT. fun stuff

Best comment on RU-vid.

… seriously I still don’t understand why people get so frustrated with c++…

Yea, but his vocabulary is great and on the other hand his Danish name Bjarne is pronounced wrongly. It is pronounced 'Byarne', where the e is pronounced like e in 'error' :) . Bjarne means Bjørn ('byoern' with an ö like in birn or firn ) , and bjørn means 'bear' . Touche :)

Strange how so many Danish computer scientists have influenced the programming languages...

Shallex ... Well yes quite... but the English ‘Y’ is equivalent to the ‘J’ in all the other germanic languages (Dutch, Flamish, Danish, Icelandic, Faroes, Norwegian, Swedish, German) . So its more like ‘Byarne’, but without saying ‘by arne’ ... cause ‘Arne’ is another Danish male name :)

bc as in basic calculator?