Justified Programming - Reason Parameters That Answer “Why” 

"Programming consists mainly of labor to create a product. But programming is not just labor towards an end product. It is also labor towards making the labor itself easier." - Bisqwit. A beautiful simple, and precise quote to demonstrate the realities programmers go through in life.

I implemented something very much like this for a chatbot with a lot of modules. It had a kind of subsumption architecture where each module would be shown the input message in turn, and if a module thought it could handle the message, it would be the one to respond. This meant the output was sometimes very confusing and hard to debug. So I added a 'why' data structure that every module had to fill whenever they responded to a message. So then if the bot said something weird you could say "bot, why did you say that?" and it would reply using the contents of the 'why' data structure, like "You said 'what is the capital of england?', which seemed to be a geography question, so I asked Wolfram Alpha and it said 'London', so I said 'London' "

Bisqwit, don't beat your Finnish accent up. I'm an American who quite likes Finnish culture, and I find the language particularly fascinating (hence my user name), and I'm sure many people feel the same. Great video as always.

Thank you for being my absolute favorite programming channel!

Totally off topic comment. RU-vidrs usually celebrate subscription count in decimal order. It would be cool to see you commemorating by powers of two. 65K, 128K subs. Or more precisely, 65.536, 131072 subs.

I have no clue what you are saying but i love your voice

This was very educational. I enjoyed the fun examples and exercises you used. I hope you make more of these videos.

This channel is Gold. I’m so glad I found this. Thank you for making these videos. You inspire me. I hope you keep making more videos.

Great video! As a novice programmer, I very much enjoy videos like these that are not so syntax heavy, but rather more conceptual or guideline focused. I hope to see more of this kind from you!

Oh, please more of this. Coding patterns and best practices are totally intriguing to me. :-)

Never been this early on one of your videos, wanted to say I love pretty much all types of videos you put out, keep up the good work :D

One drawback I've often seen in my own code is the state of mind one's into when writing the comment. Imagine you've been embedded into coding for weeks and you comment something in such a way that it looks perfectly clear, because you understand the context (which may span across many source files). Then you quit the code for months to work on something else and when you come back, the comment is anything but clear. It actually seems to make no sense at all! ^_^

Excellent tips for debugging code. These tips should be in the book "Code Complete" due to how useful they are. In most cases we do need to know not just how, but why.

Great video as always Bisqwit! As others have said I like your accent. Your English has always been very good and clear. Anyway, this gives me a video to help my friends "get it" when it comes to the why of programming.

The amount of work put in this video is impressive. Thanks!

Just laughed out loud at code comments at 1:03 It really is a window in the world of professional development.

Many people have this innate repulsion against personalizing computer code (with the notable exception of printf() and comments) as if they think human traces don't belong in computer code or that mere strings will somehow affect code performance. Fantastic video by the way!

Nice work, this reminds me of how an AI decision tree can be used to describe why each step is issued. For example if you ask the AI of a car to drive from A to B the steps might be ReleaseHandbreak-SetGearboxToNeutral-StartEngine-SetGearboxToDrive-ApplyGas-DriveToB-StopEnigine-ApplyHandbreak. You might ask the question why did you set the gearbox to drive and the decision tree will reply because I needed to apply gas.

seems like a legit paradigm to better counter upcoming errors! Thanks!

Really useful tip. More of these please!

Looking forward to your next livestream! I hope it happens soon :)

A little late to the discussion but I wanted to add a useful pattern here is to create a set of reasons why you're program might change state and declare them as a set of extern const char pointers). When the state changes, you pass this parameter. That way you can better predict and control the size of the compiled binary since string literals can get out of hand/overused in larger projects. I observe that Python and Go have this pattern (using error libraries) and C/C++ would benefit from the user doing that kind of work. As always, great paradigm, cheers Bisqwit!

For once a Bisqwit video I understand. I should appreciate documentation more but often what I do (demoscene) just requires visible results as soon as possible and the product only needs to run once for the compo :D

Please note that all shown mutex examples generate undefined behavior. Locking a mutex multiple times from the same thread without unlocking is UB. std::recursive_mutex would solve this problem in this case. Furthermore, instead of manually locking and unlocking, I'd suggest using std::lock_guard to fully make use of RAII. It also makes sure that the mutex is unlocked even if an exception is thrown between .lock() and .unlock().

idk who this guy is, i dont even know why im watching this, but this has such high production value! subscribed

Really cool! I want more of those kind of videos

this saved me in my most recent program, good thing i remembered this tip

Kudos for your efforts...just perfect ! thanks

A great thing to add to our daily code, i'm sure of it, and never through about something like that, thank you for the idea! But after thinking about it another W add to the What and the Why come to my mind, it's the When. What do you think is the beast approach to set it? Before creating the function? When we have something that "work"? At another time? How do you set it yourself when you use it?

Very cool technique, I don't do this too often but adding extra context parameters to your functions is a fairly solid solution for finding bugs. For debugging this is admittedly it's a lot less time-consuming than doing hex address math on paper, or doing blind breakpoint bisection until finding the bug. I will say though, I think if you do this sort of diagnostic in a hot path of your code in a performance-demanding program like a game or audio mixer, you may want to consider only using const char* or std::string_view (if you're in C++14 or later world), since that will avoid potentially-costly std::string(const char*) construction that can add up as you pass string literals as const std::string& parameters, and this will slightly delay the costs of passing around extra context until the parameters are actually used, while keeping copies off of the normal/success path. Alternatively, maybe having this context parameter behind a #define, so it is discarded unless running in debug or optimized-but-extra-diagnostics executables, would be another way to go. Another way I like is to assert on a failure condition, and use a debugger to break at the failed assertion point. The context is in the stackframe that caused the assertion, and then you can inspect the locals and call stack. This is pretty common to use via assert() or some other similar forced-breakpoint constructs like "__asm int 3" (on x86) etc, but maybe someone out there could use the reminder, as opposed to using printf. The downside to the raw assert method is typically the program aborts after the assert so you can't resume further, and even if you could resume (in the case of __asm int 3 / __debugbreak() / etc) it interrupts the flow of the program if you want to capture some timing-sensitive info multiple times without constant debugger pauses. Also, it mandates having a debugger, whereas the added-context method allows you to potentially share builds with other people and collect logs of all the failures later. I can see the value in that for long-running applications like games, emulators or network applications.

Would it be possible to isolate these reason parameters to debug builds with some template/preprocessor/build system magic? More importantly, could it be done practically?

This was actually really interesting and helpful. It is going to make collaboration alot easier. Thanks.

thank you, your channel is amazing

Awesome video, excellent explanation.

that strchr function looks like one that would benefit from micro optimization, since its the type of function that would be called a lot from many different places

Great video, once again =)

Nice idea! BTW: did you take a look at blender as a video editor yet?

Your videos make me happy.

hey joel, I program on windows 10 using an intel i5 with my code compiled with a recent minGw32 version(I fully installed the complete version in august) and using SDL2, will any code you have posted compile for me, I want to use your code to help me exercise my c++ knowledge, but as long as I can execute it

Also you can use clang's -fsanitize=thread to catch any possible race conditions. It's very impressive.

Why do some programmers use signed int's in situations where the numbers only will go positive? e.g. runtime, counters, etc.

Reason parameters are amazing, instead of having the why in design only, we have the why inside the code itself!!!

Me: *Adds why parameters to all functions.* co-worker: WTF WHAT THE HELL HAVE YOU DONE ARE YOU OUT OF YOUR FUCKING MIND?!?!? AHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

Can this be feasibly implemented in the real world scenarios? The mutex example is a really good usage of this paradigm, I once ended up actually creating something like this when debugging a deadlock on a platform that didn't support pthreads (on Linux or other pthread platform, such deadlock as illustrated will immediately fault and let you know that you attempted to lock a mutex twice in the same thread). I think that forcing a programmer to explain themselves on every state change will cause them to ~~slowly descend into madness~~ stop paying attention to them and write "foo" in each one. This could be a feasible feature, if a programming language implemented it as a core feature, not tacking it onto already oversized C++.

Excelente vídeo!

Is this the bug mentioned in the errata? "The terminating null byte is considered part of the string, so that if c is specified as '\0', these functions return a pointer to the terminator." - strchr(3)

why would i myself bark commands at a computer? i can make a program to automate that so i don't have to

Now, I usually hate when people tell me how I should program. But this is actually a good idea!

Cool alternative to standard unit testing. I have couple of questions though Bisqwit. When you create production level code for a company do you follow clean code design methodology do you use macros, and do you use justified programming? Another question I have, which may be a little bit tedious because you have probably heard this before, yet I am curious as to when your next educational video will be released. And, as a final question, can we connect on LinkedIn as professionals?

That is most definitely a Bach piece, although I don't remember its BWV number. I believe it may be a movement of one of the French/English/Italian suites, due to the way it is structured and certain musical elements used in the piece. It is definitely a keyboard piece though.

Bisqwit today I was a little bit worried about my bad documentation habits and there it goes ! A great video that helps me make better documentation, are you a djinn? :^) P.S keep doing what you love bisqwit I really appreciate your hard work

I was just about to ask "why" you locked in both WriteByte and WriteBytes haha. Cool.

The classical piece is Bach's Invention No. 15.

Bisqwit did you ever try object pascal, if yes what do you think about Modern Object Pascal compared to C++?

Don't know if you checked it, but Rust has something similar builtin into standard library with Result and Option. Both have expect function, which does more or less what you explained in video.

How can I get the source code for his code editor? I have the executable, but I would really like to port this code editor so that it can be used in newer versions of Windows.

great video as always, can't wait for the next

Can anyone explain to me why there is a deadlock in the mutex example when there are is only one thread?

First of all, thanks for all the effort you put into your videos -- they're great and enjoyable to watch :-). Have you considered poking a bit into type theory and constructive mathematics? It turns out that there is an isomorphism between writing programs and proving propositions in logic (called the Curry-Howard isomorphism). In essence, it tells us that we can write our propositions as types in a programming language, and any program that inhabits that type is a proof of that proposition. Programming languages such as OCaml make use of this idea to implement something akin to propositional logic, but it is taken to a more of an extreme in proof assistants like Agda and Coq. A middle ground would probably be Haskell, which has a couple of more practical features of such type theories, but doesn't push it to an extreme and aims to be a programming language first. In essence, what this lets us do is express some of the invariants that we want our code to obey and we can check that it's the case statically (modulo implementation bugs, of course!). I'd be quite interested in seeing video from you trying to convey these terms in a simpler way and demonstrating some of the more fun aspects of it :-) (I am more than happy to answer any queries you might have, by the way). Thanks again for all your effort!

Hello, just discovered the channel and i was wondering what tool he was using to auto type the code, i searched for it on his website but didn't find anything Thanks

I want to become chess player but I started chess career at age of 19 but I'm amateur player ....I seen many biography of chess players like Bobby Fischer Carlson anand they started to play chess ..At age of 6 ..I feel confused ...Im helpless please give me a steady mind....And I wanna become programmer but idon't know what to choose ...Im confused I don't know abt programming but u started to play pc ...And operate at 1st grade ...But I'm having interest I can sit in front of pc 24 hrs a day ...I don't know what to do...pls help me....Sorry for my English I don't know English tat much

Bisqwit, I am very interested in learning python since talking to my Father's cousin who is an astrophysicist. She described how the language is quickly being widely used. For instance, she mentioned how NASA is beginning to adopt python and how the language being "modular" is one of its strengths. However, I still do not know the best method to approach learning it. Could you recommend a strategy, or the best resource for learning in your opinion? I love everything you have done on this channel!

thank you!

We think along similar lines, but you address a part of an equation I thought would never be possible... The _"Why"_ In robotics, we'll never have anything less than a chat bot, unless we teach the machine to respond based on it's purpose and proximity to others around itself, and attempt to solve the who, what, when, and where of the person it has come into contact with. Using this algorithm, I hypothetically take it a step further. A virus... The mind is to the human what a virus is to a machine; Who says a virus has to be bad, it's only the purpose for which you use a virus that determines moral intent. I propose the following, if it is at all possible... Game Concept to solve the problem of semi-spontaneous Artificial Intelligence within NPC's in a video game, to relieve the pressure of the master program having to do all the work itself. Artificial Intelligence, in my opinion should be external to the master program, rather than the program controlling dozens of AI's at any given time. Introduction to a limited virus that is quarantined within the confines of the gaming environment, it's only purpose is towards self-awareness, survival, and being aware of it's surroundings. Example Player Harold leases some space aboard a Space Station, and decides to turn that space into a Fast Food burger joint. He furnishes the restaurant, buys a cash register, and a computer for Human Resources related tasks, the only thing missing is the employees. He accesses his computer and goes to the Job Board, clicks on the food industry, and looks at all the possible NPC candidates and the skills they will bring to the job. These NPC's are not yet in the game, but once Harold clicks "hire", the game creates these NPC's and a virus is attached, giving it "life". Each spawned NPC has a "checklist" assigned to it, sort of like a pre-flight checklist in the aviation field. But this "checklist" is for AI's. It starts asking questions... How is my health... Am I hungry, thirsty... What do I want to do... My checklist says I have a job lined up, so I better be on my way, as I do not want to be late on my first day on the job. Per our agreed upon contract, I will be working such and such hours, but after that I am free to do as I please... but while I'm working, my mind must stay focused on the job. With every AI in the game, asking and answering the questions on their personalized check list, we create a game in which the AI's feel spontaneously real. Some jobs AI's take, after the required positions have been filled, may act as stepping stones to bigger and better paying job opportunities, after they've met the prerequisites having worked a lower end job, meaning, some of them have aspirations to rise above their current jobs, to pursue other opportunities, but recognize in order to meet a long term objective, shorter term goals must first be met. My question to you, Mr. Bisqwit, is such a virus possible, and how small can a virus be, if it's only task is to access data from some form of checklist, whatever efficient manner we can come up with to achieve this, as well to figure out path finding in order to reach those locations. There's also the concept of "virtual variables", which are variables in game, that are only visible in scope to AI's based on their training. For instance if an AI is trained in engineering, will not have access or even be aware of medical related events on screen, thus, AI's only have access locally to those events they are qualified for, and that goes for the player as well.

termbin.com/4d6b. What does this code do? Is this supposed to be an easter egg or its just a random IOCCC entry? I pipe random strings into it, it just cuts the 1st 5 letters.

Another name for this approach could be "Reason Driven Development" or RDD for short since we already have TDD etc.

3:41 which program that you used to separate windows?

I have .Ex4 file can you teach me how to remove protection on it. Is it possible ?

"Every fool can write code, which is understandable by the computer. Good programers writes code, which is understandable by humans"

This looks like a pretty good idea, actually. :)

The only problem I have with this style of coding is the runtime cost of doing this. It'd be hard to justify a reason parameter if its used in a situation that is already occupying heavy memory or tight loops that execute 10 million times... but if there was a way to develop this pattern into a compile time removal ( like #DEFINE #IFDEF stuff ), then this might be a interesting pattern to follow.

Clap Clap Clap. This is really impressive. I do want to know why you work as a bus driver while you seem to have more programming knowledge than most programmer i know and maybe the story about your family.

I miss you bis;(

Why not use lock guards? Or a variable wrapper with a lock and lock guards? I just recently wrote one myself, tested it against many threads as win10 will let me generate. // Thread safe primitive/object wrapper template class tsafe { public: template tsafe(z val){ var = val; } t get() { std::lock_guard destrMutex(mut); return var; } bool set(t& val) { std::lock_guard destrMutex(mut); return var = val; } void directAccess(std::function func) { std::lock_guard destrMutex(mut); func(var); } // BASIC OPERATOR OVERLOADS // Asingment bool operator =(tsafe val) { std::lock_guard destrMutex(mut); var = val.get(); return true; } template bool operator =(z val) { std::lock_guard destrMutex(mut); return var = val; } // Addition t operator +(tsafe val) { std::lock_guard destrMutex(mut); var += val.get(); return var; } template t operator +(z val) { std::lock_guard destrMutex(mut); var += val; return var; } void operator +=(tsafe val) { std::lock_guard destrMutex(mut); var += val.get(); } template void operator +=(z val) { std::lock_guard destrMutex(mut); var += val; } // Subtraction t operator -(tsafe& val) { std::lock_guard destrMutex(mut); var -= val.get(); return var; } template t operator -(z& val) { std::lock_guard destrMutex(mut); var -= val; return var; } void operator -=(tsafe val) { std::lock_guard destrMutex(mut); var -= val.get(); } template void operator -=(z val) { std::lock_guard destrMutex(mut); var -= val; } // Division t operator /(tsafe& val) { std::lock_guard destrMutex(mut); var /= val.get(); return var; } template t operator /(z& val) { std::lock_guard destrMutex(mut); var /= val; return var; } void operator /=(tsafe val) { std::lock_guard destrMutex(mut); var /= val.get(); } template void operator /=(z val) { std::lock_guard destrMutex(mut); var /= val; } // Multiplication t operator *(tsafe& val) { std::lock_guard destrMutex(mut); var *= val.get(); return var; } template t operator *(z& val) { std::lock_guard destrMutex(mut); var *= val; return var; } void operator *=(tsafe val) { std::lock_guard destrMutex(mut); var *= val.get(); } template void operator *=(z val) { std::lock_guard destrMutex(mut); var *= val; } // COMPARISON OPPERATORS bool operator = val.get(); } template bool operator >=(z& val) { std::lock_guard destrMutex(mut); return var >= val; } bool operator ==(tsafe& val) { std::lock_guard destrMutex(mut); return var == val.get(); } template bool operator ==(z& val) { std::lock_guard destrMutex(mut); return var == val; } bool operator !=(tsafe& val) { std::lock_guard destrMutex(mut); return var != val.get(); } template bool operator !=(z& val) { std::lock_guard destrMutex(mut); return var != val; } private: t var; std::mutex mut; };

Cool to the core

"We spend effort in naming functions, variables, methods and function parameters meaningfully [...] just so we can understand later." You don't know how much you are way too much optimist.

i love you man.. you are of my family

This should be taught at Programming 101.

Hey are you a professional developer these days? I thought you drove buses! Tell me about it, I'm curious :)

Something to think about ! 🤔 Principles always rule.

Well, very good reasons...but in embedded systems....that would cause too much overhead :(

This has what had happened after I let my computer scan a philosophy book.

In my opinion adding a why-parameter feels kind of hacky. If C++ had some kind of way to implement reflection this could be done without burdening the user of the function with the need to pass parameters that are unneeded for the function to actually work. However, as C++ has it's limitations, I guess the why-parameters are a better-than-nothing method for preventing bugs or speeding up bug-fixing.

I don't really think that adding a lot of extra code to explain why is any more helpful than say, adding assertions in most cases.

pair? What?! Also, you're aware std::string is an owned type and you just copy it over the whole prot array, right? Just use a std::string* pointer type (or std::shared_ptr), and set those values to its address. (If scope becomes an issue, push it to a reference-counted reason set, and point at the item there instead!) And, instead of the redundant bool value, just initialize it to NULL :) Either way, I do like the concept! I do not like that it mostly depends on runtime execution aspects, like the stack and function arguments. I would prefer if it were more transparent, so that while it does not affect execution, things like debuggers could easily fetch attached justifications to function calls or expression fragments (akin to how Python attaches docstrings to callables!).

Took me far too long to realize why lock was being called twice.

Will you ever do a video on any of the popular interpreted programming language such as Ruby, JS or Python?

Just make sure your sober or you'll be caught in an ever increasing anger loop.

Where are you bisqwit ?

Drive Ř. What's the story behind that?

yes do this so i can easily debug your work without symbols :0~

i realize that autogen english subtile with NO mistake!

Anyone else expecting to see an esoteric programming language?

Sad, because i could give only one like :(. Thank you so much for this tip

My docstrings justify my commands.

How to convert source code ?

Oh man I wonder what the original 'a bit too pretentious' name was? Was it G0dØfK0D3? Or TheBestFinn?

What did you study in collage?

If anyone wants to take a crack at deciphering the code that borders the video, here is a pastebin of it :) QHJR3kzi

I really thought this was a joke at first.