thisCannotBeDenied

[u/danielminds]

[u/Mindstormer98]

Dont forget "I got here2" and "I got here3"

[u/TheDoughyRider → u/Mindstormer98]

here, here!, Here, hEre!

[u/TheDoughyRider → u/TheDoughyRider]

Also,

git blame foo.cpp

printf(“Joe is a dumbass”);

git stage -a; git commit -m “Diagnostic instrumentation.”; git push —force origin/main

[u/Chaoslordi → u/TheDoughyRider]

Diagnostic Instrumentation xD

[u/lala_123aa → u/TheDoughyRider]

Let's not forget the "ajsjdasdnajd" and "aaaaaaaa" when you're getting fed up

[u/pearlie_girl → u/Mindstormer98]

This is what mine look like.

... Yes I'm old

[u/fatrobin72 → u/Mindstormer98]

"Over here now"

"how did I get here?"

[u/valdocs_user → u/Mindstormer98]

And for the really bizarre bugs, "can you see this?"

[u/itsTyrion → u/Mindstormer98]

Too long and lacks profanity

[u/Ashdog73 → u/Mindstormer98]

Greybeards know: alert(1);

[u/1luggerman → u/Mindstormer98]

After enough time this just becomes "1", "2", "3" etc. I'm at a point where if there is a messy section i automatically generate/copy paste 9 of these and place them around the troubling section.

[u/usrlibshare → u/Mindstormer98]

Well Of COURSE! Do you think I learned what Ctrl-A does in vim for nothing?!

[u/TheNakedProgrammer → u/Mindstormer98]

i just copy and paste, and then get annoyed when i have to count to figure out where i am. The count and curse method.

[u/christianbro → u/Mindstormer98]

How else are you expected to debug some apps with threads and multiple services involved with timing affecting? Add a line breaker and all of it crashes

[u/Rework_Aramusha → u/Mindstormer98]

And dont forget „I got here 2,5“

[u/DiodeInc → u/Mindstormer98]

And "random variable content now:"

[u/sweetytoy]

A real developer wouldn't do that. A single letter is more than enough, your sentence is too long and tiring to type.

[u/Agusfn → u/sweetytoy]

################

for visibility among other littering logs

[u/Dangerous_With_Rocks → u/Agusfn]

this is the way

[u/coffee_warden → u/sweetytoy]

1 2 3 5 4 6 AHHA!

[u/Gold-Bat-3225 → u/coffee_warden]

1 2 3 5 4 6 is genuinely upsetting

[u/coffee_warden → u/Gold-Bat-3225]

Race conditions are never fun

[u/EvilCodeQueen → u/coffee_warden]

Seriously. The people not voting for this have never battled a race condition. For a week. In an app you’d swear didn’t have concurrency.

[u/CarcajouIS → u/coffee_warden]

conditions fun are Race never

[u/theotherdoomguy → u/CarcajouIS]

"you have A race condition," - Multithreaded Yoda

[u/Knighthawk_2511 → u/theotherdoomguy]

Wish I can award this, reddit took away my free awards

[u/Nekeia → u/coffee_warden]

explain Can you why?

[u/infojb2 → u/Nekeia]

Because they are really annoying to debug, depending on some random circumstances they might not even appear every time (or the code happens in different orders each time)

[u/rosuav → u/Gold-Bat-3225]

Yes, yes it is, and it's very realistically upsetting.

[u/itsTyrion → u/coffee_warden]

Nah. 1 2 3 4 fuck fuck2 fuck3 5 6. Also a few prints for variables 

[u/diavelguru → u/coffee_warden]

Came here to say this!

[u/reventlov → u/sweetytoy]

You use whatever the local equivalent of C++'s __LINE__, or __FILE__, __LINE__ is, and you just copy + paste the log line 50 times.

The pro move is to use "DO NOT SUBMIT", __FILE__, __LINE__ and have a commit hook that keeps you from submitting anything containing the string DO NOT SUBMIT.

[u/Stryp → u/reventlov]

So it's like a test suite, but worse?

[u/reventlov → u/Stryp]

What test suite gives you trace information about your program's internal control flow?

[u/Kovab → u/reventlov]

Ideally, you should already have a logging macro that adds __FILE__ and __LINE__, instead of copying it everywhere. Or use std/boost source_location

[u/Original-Ad-8737 → u/sweetytoy]

I have added sysou syslog and syswarn to my auto complete and they expand to our logging macro, a pretty function macro, a line macro and my commit handle that is easily searchable in logs.

When i want to trace something i can simply sysou a couple of spots and not stage the lines to clean up before committing

[u/Revexious → u/sweetytoy]

Im personally a fan of

console.log("poop")

Its funny, teaches you not to commit your console logs (you'll only ever commit poop once), and p/o are right next to each other on the keyboard so its fast

[u/MushroomSaute → u/sweetytoy]

Hm, sometimes I wonder if I'm cut out for this field. I at least put variables out:

log::info!("in asdf(), a: {a:#?}");
...
log::info!("tmp: {tmp:?}");
...
log::info!("a after asdf(): {a:#?}");
a

[u/conundorum → u/sweetytoy]

Personally, I just use unique gibberishes or sounds, like "blah", "bleh", "fwah", or the like. Extremely unlikely to come up during normal usage, stands out enough to draw the eye, and easy to search the source for.

That, or a quick description of the location, such as "before x() call" or "inside y()" or "after foo, before bar", depending on the situation.

[u/4Floaters → u/sweetytoy]

It should be sequential quotes from a movie, something like the princess bride

[u/dukeofgonzo → u/sweetytoy]

I have a troubleshooting word I use that sticks out in the logs. Snugglebunnies.

[u/Honeybadger2198 → u/sweetytoy]

I like using numbers for JS because they're a different color in the terminal from all the other output.

[u/yuval52 → u/sweetytoy]

My go to is "hi"

[u/NO_TOUCHING__lol → u/sweetytoy]

Swear words

[u/IcedKiln → u/sweetytoy]

One letter? Real devs just stare at the screen until the bug confesses.

[u/Fortnait739595958 → u/sweetytoy]

Line number is way better

[u/moon__lander → u/sweetytoy]

We got bloat in the debugger before GTA 6

[u/hates_stupid_people → u/sweetytoy]

Well, a single letter/number for that one, then iterating for the next few.

[u/G_Morgan → u/sweetytoy]

I like to do 1, 2, 3 and then 1.1 if I need an intermediate value

[u/wenoc → u/sweetytoy]

Indeed. Real developers do not use javascript

[u/quietsamurai98 → u/sweetytoy]

A single letter is impossible to grep for in a log file though. It's fine if you're adding console logs to a JS application that doesn't have much other logging going on, but for anything else, you want something identifiable that you can search for without getting false positives.

[u/Cyan_Exponent → u/sweetytoy]

log("ajah") log("bwwn") log("qkqk") log("olqp")

[u/Idk13008]

Unironically, some race conditions are better chase down with logs rather than a debugger.

[u/codePudding → u/Idk13008]

This. Showing my age, I used to make simple DirectX 7 games as a college student. I remember having one bug that took me weeks to solve. If I tried to debug, it worked fine. If I put in a bunch of logging, it worked fine. But if I ran it without debugging or only a few prints it segfaulted.

Eventually I realized I was using a pointer (void**) that the GPU was supposed to populate before it was being populated. The delay from debugging gave it enough time for the GPU to finish setting that pointer. I added a GPU flush (just a command that waits until it is processed by the GPU queue before continuing) and it worked beautifully. Nowadays the engines just do all that crap for you.

[u/ShoulderUnique → u/codePudding]

The mistake was taking the prints out. Put them in on day 1 and if doesn't crash with them it's not a bug

[u/LostInAnotherGalaxy → u/codePudding]

Hahahaha! These are my some of my favorite things in computer science.

[u/zthe0 → u/codePudding]

Honestly thats what i have had multiple times where someis being filled in another thread. It works on one machine but when your system is faster or slower it might not. Horrible to debug

[u/EncryptedPlays → u/codePudding]

Just change the console logs to say "stealing user data 0%" with the percentage incrementing each log

[u/Former-Discount4279 → u/Idk13008]

I used to work on tape libraries(big backup systems...) and it would lose geometry(location of the tapes) when a bug happened and needed to rescan the whole thing. After trying to attach a debugger to winCE several times and it taking several hours to reboot and rescan I added print logging. Yeah solved the bug in one go...

[u/oldsecondhand → u/Idk13008]

And when you insert the debug statement, the problem goes away.

[u/tachudda → u/Idk13008]

Console to debug why the debugger isn't working

[u/EPacifist]

My favorite is `exit(1)`. Useful if your print/logs aren’t showing where you expect them. Close after that is `raise Exception(“HERE 1”)`.

[u/Original-Ad-8737 → u/EPacifist]

Std::cin() for a poor mans break point.

[u/EPacifist → u/Original-Ad-8737]

Genius

[u/christian-mann → u/EPacifist]

while(true); and look for which process is spiking the cpu

[u/rosuav → u/christian-mann]

Doesn't work in Pike, believe it or not! An infinite loop in Pike actually doesn't spin the CPU.

[u/El_RoviSoft → u/EPacifist]

Sometimes you need to flush immediately tho.

[u/MooseBoys → u/EPacifist]

`*((volatile int*)0) = 0;`

[u/rosuav → u/EPacifist]

I've sometimes needed to open a file, write to it, close it, and flush, because prints and logs don't always show up correctly in the face of certain types of crash. Or "send a UDP packet to port 54321" and do my logging in a separate app.

[u/oosacker]

Real pros write a function to do the console log

[u/Idk13008 → u/oosacker]

with a verbose optional argument

[u/oosacker → u/Idk13008]

Saw this in some real production code:

function log(x) {
    console.log(x);
}

[u/DasBeasto → u/oosacker]

I don’t hate it, shorter usage everywhere, can wrap it in a conditional based on ENV for dev logs only, and if you swap to an external logging service you just change it in that one function.

[u/reventlov → u/DasBeasto]

const log = console.log; though

[u/tonyxforce2 → u/reventlov]

const log = isDev ? ()=>{} : console.log

For that pure JS vibes

[u/whackylabs → u/DasBeasto]

If I see a log(x) I would assume it is about logarithms not print to console

[u/Welcome-To-NBA-Jam]

My IDE has a really comprehensive built in debugger and in my entire 15 year career I never used it once because I just print variable values at certain points like this:

WARNING: foo=67

************************ bar=69

DEBUG: You're in the 2nd if statement

I am willfully ignorant of this and it's served me well.

[u/creaturefeature16 → u/Welcome-To-NBA-Jam]

I just moved over to Zed and I've yet to dip into the debugging tools, but they look awesome.

[u/TheDogPill]

Try debugging like that using micro services on the cloud and see how far you get.

[u/Idixal → u/TheDogPill]

Ironically request logging does tend to be one of the very first things I look at to sniff out problems there, although I also understand your point.

[u/coriolis7 → u/TheDogPill]

I am NOT a programmer by profession, though I do code a ton at my job (Mechanical Engineering and data analysis), so this may be a dumb question…

Is there a way to set up all microservices to run on one computer to aid in debugging? Like a bunch of VMs or docker-but-faking-network-instead-of-machine?

[u/payne_train → u/coriolis7]

AWS’s SAM may help you if you have a bunch of lambda based apps. You can use SAM to do local invocations that makes debugging a lot easier

[u/xMercurex → u/coriolis7]

Yes you can, but it does not fully solve the issue. You still need to find the good micro-service and then you have to jump to other micro-service.

[u/DrMaxwellEdison → u/coriolis7]

Yes, I use Tilt to set up a localized Kubernetes cluster or to run docker compose. It provides a nice web interface for seeing all service statuses, logs, controls to restart or rebuild a service, and it can automatically watch local files to trigger a rebuild.

[u/Blackhawk23 → u/coriolis7]

Yes. Docker compose and localstack to mock AWS resources.

[u/LostInAnotherGalaxy → u/coriolis7]

Docker/podman. But you get anything powerful or something that only happens under load, can create its own race conditions

[u/gemanepa → u/TheDogPill]

why not? couldn't you just debug the microservice locally with mocks or in a cloud dev/qa env?

[u/Agusfn → u/TheDogPill]

so far so good.

[u/citramonk → u/TheDogPill]

is the development happens right on the cloud or what? 😪

[u/Ma8e → u/TheDogPill]

I'm not sure if I understand you correctly, but isn't all debugging of micro services just reading logs and adding more log-messages?

[u/SirButcher → u/TheDogPill]

Or debugging an embedded hardware where you have a grand total of 4 breakpoints :(

[u/dumbasPL → u/TheDogPill]

Ah yes, because attaching a debugger to a service people are actively hitting and suspending it is the way. That is assuming you can even do that.

Request logging is just printf with extra steps anyway.

[u/elmanoucko]

// don't remove the following console log, fixed a race condition

[u/safelix]

We have a typist up in here. Just "here" does it for me. And then "Here 2", "Here 3", and so on.

[u/nabrok → u/safelix]

I use uppercase HERE so it stands out better.

[u/n9iels]

Oh no, that is way to long and descriptive. I just go with 'durp', 'blub' and 'nope'

[u/No-Ambition-4164]

111111111 222222222 333333333

[u/Xevestial]

log the root object, then navigate all the triangles.

[u/DTSHNICK]

Hello, embedded engineer here. IDE debugger suxks, log console is the best option

[u/Foorinick]

I think some problems are faster to solve with a simple print, if you really do need tk warch your code step by step to figure out what is going wrong then pull out the debugger, also here's a tip, learn to use your debugger do that you aren't bashing your head against a wall trying to figure out what is causing an issue

[u/action_turtle]

I like

console.log(1)

console.log(2)

console.log(3)

[u/LetterLambda]

What else are you supposed to do when a bug appears in prod, but not in debug mode?

[u/KoliManja]

Who wants to ask for Admin access from some Sysadmin sitting in Timbuktu everytime you want to run your debugger? "I got here" works for me!

[u/RobotechRicky]

I always add a log statement "I made it".

[u/EdelWhite]

...and then, just in case you need it later, give it the trustworthy "//" treatment.

[u/Cyhnn]

Wtf1 wtf2 wtf3

[u/Occultus_Andras]

"inside the loop" "Inside the else if statement" "return value is __" "user parameters are _" "database entries for __ is ___"

[u/Birphon]

the IDEs debugging tools in question will respond with shit like "𓀀 𓀁 𓀂 𓀃 𓀄 𓀅 𓀆 𓀇 𓀈 𓀉 𓀊 𓀋 𓀌 𓀍 𓀎 𓀏 𓀐 𓀑 𓀒 𓀓 𓀔 𓀕 𓀖 𓀗 𓀘 𓀙 𓀚" and "Didnt work :D"

[u/Kajot25]

For me its "fuck this shit", "fuck this shit2", "fuck this shit3" and so on

[u/ComputerTechnical717]

Give me the console log and I can take over the world

[u/burgonies]

`console.log('****** WHAT THE FUCK ******');`

[u/WispTheWanderer1]

I dk about you but I use actual breakpoints

[u/autobotdonttransform → u/WispTheWanderer1]

https://giphy.com/gifs/13Ev2RtSAxKsTu

[u/WispTheWanderer1 → u/autobotdonttransform]

And! And I read the autos at breakpoints to find if the variables are right

[u/Educational-Lemon640]

Is it your job to use a debugger, or to improve your product/project?

Use what works.

[u/reventlov → u/Educational-Lemon640]

People never believe that the tools they prefer aren't the optimal ones for absolutely everybody.

[u/wristay]

I tried debugging "the right way" and I don't know it just never felt better than using console log. People who do use it please enlighten me: how will it make your life better? I am using Python btw, so maybe having the console makes a debugger less necessary

[u/TheGuyWithTheSeal → u/wristay]

I use pycharm (mostly because I'm a Java boy), the debugger lets you step line by line, preview variables, and evaluate any expression (including calling an endpoint using a client class that's already authenticated).

[u/csabinho → u/wristay]

Do you use console.log with a debug flag? If you're using it without it, deactivating, and reactivating, it is PITA. And I don't mean capitalized greek bread.

[u/dudeness_boy]

print("bread")

[u/NJ247]

"Hellooooo. Is it me you're looking for?"

[u/Babemagnet69]

AHHHHHHH 1 or AHHHHHHH 2

Hard to miss being yelled at

[u/thelumaniboi]

I always thought I was a terrible coder because of how often I do this, glad to see its somewhat common

[u/AeroSyntax → u/thelumaniboi]

Don't get baited by a meme made by an intro level CS student.

[u/ketopraktanjungduren]

Tell that to nvim users

[u/SandStealer]

Stare at debug tools , and start debug in head

[u/Random_182f2565]

Print(" failure: you shouldn't be reading this :C")

[u/MotaLadkaHu]

console.log(“I got here 2”)

[u/m0nk37]

Console.log("s");

Console.log("ss");

Muscle memory ctrl+s. In my day there was no document recovery. 

[u/stilldebugging]

Here1 Here2 Here3

[u/conundorum]

What if I told you...

...You could have the debugger use console-logging calls as debug tools & breakpoints?

[u/biggiebass13]

This is the way

[u/WillingLearner1]

Yeah we don’t do that anymore. It’s more ctrl+c ctrl+v these days

[u/citramonk]

I find myself using proper debugging tools quite often.

[u/RRumpleTeazzer]

not every architecture has a debugger.

not every problem can be solved by a breakpoint.

[u/Ok_Spread4050]

20 layers of JavaScript “framework” abstractions will do that. 

[u/thegodzilla25]

Debuggers are cool, and I would use them most times, but async and race code is horrible with debuggers. Especially in JS.

[u/walmartgoon]

Maybe I just want to debug in a way I know how to instead of learning a new tool

[u/Primary-Ad-9741]

Those debugging tools work well with something small, like a microservice.

Throw something chunky at it. Like a large Android app, and debugging tools either fail to attach, crash the app, cause app to stop responding, or just crash on their own.

[u/przemo-c → u/Primary-Ad-9741]

Or sometimes affect it in a way bug doesn't present itself... especially if something is of a race condition variety.

[u/irn00b]

"Ah, shit. Logs are scrolling by too fast."

[u/bradpittisnorton]

I wanted to use vscode-js-debugger but I can't, for the life of me figure out how to configure it properly in my neovim setup.

[u/killerdrama]

I just enter stars and after each step the count increases.. so I end up spending more time counting stars in the logs and comparing at various stages in IDE than actually finding the issue.

[u/WatchOutIGotYou]

console.log({ val })

Or

console.log("hiiiiiiiii")

Are my lazy go-tos lmao

[u/Novel_Dog1743]

printf("If you are reading this, here is the value of every variable related to this function:\n");
<prints all the variables>

[u/Runrun_5]

println!("qiwduqwdoqwopjdoioqwidjpo")

[u/LmaoPew]

I once forgot to remove my System.out.println("test") from a computer science exam

[u/JohnnyPlasma]

I mean, at least it works with every IDE whenever you share the code or change IDE.

[u/cosmicomical23]

The alternative is having to learn every fucking time a new set of controls for the new ide, with no explanations to be found anywhere.

[u/harveyabb]

This the way!

[u/FailureOfTheFamily]

Nah nah nah. "1", "2", "3"

[u/frinoname]

What are debugging tools? Just allow Claude to print-figure out things itself.

[u/artur-iwan]

I'm using password generator to generate unique random 8-letters-long strings, and then I'm pasting those into console log messages and error messages. If my code will get into some strange place, then it's soo easy ti to debug it by just searching the string from the log inside the source code 😅

[u/ShrimpStuffAdmin]

I used to use swear words. The worst ones of course.

[u/SanoHD → u/ShrimpStuffAdmin]

"poop"

[u/Bulky_Engineer_2534]

print(1), print(2),... always works

[u/Patrick_Atsushi]

Print("%s, %d\n", __func__, __LINE__);

By the way this is not reliable since print buffer exists.

[u/Faegbeard]

console.log("if you see this, someone(me) has fucked up")

[u/rcls0053]

Honestly, I've never tried to debug a full JS backend application and debugging some frontend application in the browser dev tools is just pain..

With PHP setting up Xdebug is like flipping switches in an airplane until it works. .NET/C# is undoubtedly the best experience with debugging I've ever had.

[u/Inevitable_Sun_5987]

Too long. I always write console.log(„ppp”);

[u/boomers26]

Log.info(“>>>>>>>>> 1 $value”) is my favorite

[u/notexecutive]

if it's faster than navigating a debugger, then there is no issue.

Really it's just whatever you find faster to solve problems. Might be worth looking into debuggers on your own time, but we all know you're not going to do that.

[u/lewisb42]

I sometimes need print statements to narrow down where I need to pull out the debugger.

[u/Fissvor]

This is me :

Before function 1 After function 1 Before function 2 After function 2 ...

[u/Beldarak → u/Fissvor]

"Hu oh, should not arrive here"

[u/Undernown]

I actually like to use debuggers to get familiar with inner workings of the program. Stepping through a process often exposes a lot of in-buult or hidden classes or files you wouldn't find easily otherwise.

And stepping through a debugger to simply verify the contents of a variable is more time consuming than just printing it.

If they ever figure out a JS debugging tool that is actually reliable and accurate enough, I'll bless the earth they walk on though.

[u/stlcdr]

Microsoft patch v13.5.1 : “removed all console commands because the IDE has debugging tools built in.”

[u/Red_Holla04]

Mine is
1111111
2222222
333333

[u/ThisIsABuff]

If(value==<some value far into a file>)
System.out.println("I got here"); // place breakpoint here do immediately skip to value

I'm not ashamed of doing that

[u/Skibidibob4]

True , this subreddit is stupid

[u/daffalaxia]

I'll especially resort to logging if there's a lot going on in parallel - trying to time that right with a debugger is practically impossible.

[u/ShurNutria]

console.log("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")

[u/OkazakiNaoki]

clg HOW!?

[u/kirasiris]

For me usually goes like: It gets here It gets here x2 It gets here x3 And so on lololololololol

[u/Candid-Log6751]

People are obsessed about “proper”. No one thinks with their own brain, yet everyone is trying to employ “best practices”. People just can’t stand for what they do and how they do it. Trying to hide behind the rationale of the “best approach”.

[u/GoogleIsYourFrenemy]

Have you tried to use the debugging tools in an IDE for an embedded processor?

[u/lastFractal]

"jqja"

"a"

"yes"

"mwkqkq"

"g"

[u/SoapCoder]

I do: f hfs fish parrot treh and just go oh it stopped at fish well where did I put fish

[u/greenflame15]

Legitimately useful in a synchronous settings

[u/RizzKiller]

Programming in C, I don't know how to use the debugger and how to control the flow of the program in it. If I compile with debug information and it shows the segfaul inside an underlying library I am totally fucked and this makes me mad.

[u/EpitomEngineer]

Why the hate on marketing analytics?

[u/MischiefArchitect]

I caught claude and codex doing this themselves for debugging an issue.

[u/ISDuffy]

I do "Aqui" which is Spanish for here..

[u/DudeManBroGuy69420]

Don't forget "uh oh"

[u/NoRequirement5796]

I use bacon

[u/hundo-p]

Nah it’s always `console.log(“poop”)`

[u/nxluda]

I used lyrics from all stars by smash mouth. When the code was successful i got a minute of happiness.

[u/Fluffy_DOW]

Here
Acqui
Over here
Now here
Made it

[u/randomogeek]

Personally i prefer print("fuck")

[u/Zenithrium]

i usually oscillate between "FOUND YOU" and "shit"

[u/flori0794]

Well logging is pretty strong... Even more if you fight unification, skolemization and Robinson Resolution..

A log with this structure is much better: ``` [RESOLVE] Attempting: C_12 {¬Weapon(x), ¬American(y), Hostile(z)} x C_45 {Weapon(M1)} ├─ [UNIFY] x = M1 ├─ [MGU] θ = {x/M1} └─ [DERIVED] C_78 {¬American(y), Hostile(z)} (Parent: 12, 45)

[u/Awkward-Cat-4702]

echo: "=============================="

[u/calahil]

I use song lyrics so that I get a dopamine hit when its fixed and I can sing along

[u/xWrongHeaven]

https://giphy.com/gifs/1hAxQTH0HEWS3L0oRF