@kreyren @LordMordred @bwk I am not disagreeing with your OSS argument; my introduction to programming was through OSS and the only reason I am employed today.

This is about the OP saying "I tried programming but I gave up" post that is clearly not asking for help, but some along the lines of "i didn't like movie X" , you make them like the movie.

Also not everyone can make a living writing FOSS projects. Especially if you are not in the first world.

@FrailLeaf @LordMordred @bwk

> This is about the OP saying "I tried programming but I gave up" post that is clearly not asking for help, but some along the lines of "i didn't like movie X" , you make them like the movie.

People usually abandon learning programming as the learning curve to some programming languages is too steep for them to climb.. Usually if they get help from a developer who knows the language then they can learn within hours more than they ever did alone.
So such encouragements are viewed as ethical in computer science if you are willing to invest the time to teach them.

> Also not everyone can make a living writing FOSS projects. Especially if you are not in the first world.

Lol who told you that? People living in a 3rd world country getting hired to work on a FLOSS projects is very common from my experience.. Mostly because they are qualified to do the job and are more economical to hire.

@FrailLeaf @LordMordred @bwk literally everyone.. There are not hard restrictions on who can be hired to work on an open-source projects.

@kreyren @LordMordred @bwk I do not understand why you keep ignoring my point, Not everyone working in software development/engineering are there because they enjoy it, you cannot help them love the job, they do it for the sake of it.

@FrailLeaf @LordMordred @bwk like they can always change an industry.. So what's your point?

@kreyren @LordMordred @bwk What? How does a person working a job, writing absolutely horrible code change the industry?......

@FrailLeaf @LordMordred @bwk

> How does a person working a job, writing absolutely horrible code change the industry?

The gross majority of people working on open-source projects write a horrible code it's by design done this way.

So again the important thing is abstracting and documenting the code preferably writing down what you are doing, how and why

@kreyren @LordMordred @bwk @lupyuen Its great that your experience in life with people learning to code have done well. I'm speaking from experience where the senior-most developers are doing a bad job at it, making no effort to maintain source-level docs, making it a nightmare for me to debug through the large codebase so I can maintain it.

@FrailLeaf @LordMordred @bwk Like footprinting is generally time efficient so what's the issue?

@FrailLeaf @LordMordred @bwk

The practice of figuring out how the software works and why.

My way of doing it is by adding "WTF" comment tags all over the code as comments to things that i do not understand and then commenting out random codeblocks and changing them to see how it affects the outcome to write docs.

e.g.

fn main() {
println!("Hello, world!");
}

fn main() {
// WTF(Krey): what is this supposed to do?
println!("Hello, world!");
}

fn main() {
// WTF(Krey): what is this supposed to do?
println!("Hello, worldSSSSssss!");
}

Oh this block is the one that prints in the console!

fn main() {
// Outputs 'Hello, world!' in the console
println!("Hello, world!");
}

@kreyren @FrailLeaf @LordMordred @bwk The best way to analyze a large unknown codebase is to add logging statements. If you start removing random parts of code, you create so many unpredictable random chaos and failures that any behaviors you see as a result of that are more likely *misleading* rather than actually helpful.

"Experimental Development" is what I call that. Also if you determine your code is correct, because it behaves correctly, that's precisely the same mistake. You can only understand code from the inside, not from the outside, and the best way to analyze the inside is logging. Period. Full stop. There are essentially zero exceptions to that rule.
@clay @LordMordred @bwk @kreyren There's more efficient solution to just leaving logging statements; debugger. It is far more efficient and you can analyze scope at runtime.
@FrailLeaf @LordMordred @bwk @kreyren Debugger is ideal for a precise search for a precise bug, but depending on how complex the code is and what it's doing, sometimes the only viable alternative is logging. Logging is 'repeatable' instantly. Debugging can take hours and hours...and is very labor intensive.
@clay @LordMordred @bwk @kreyren You can capture a lot of stuff you could miss out on logging with a debugger, Set breakpoints and step over/into pieces of code, print out the variable you're analyzing. Its easier to capture many edge-cases this way than logging. With logging, you go back and forth a lot.
@FrailLeaf @LordMordred @bwk @kreyren The debugger is for when you need a microscope. Logging is for when you need a telescope. One is a broad overview and the other is highly detailed.
@clay @LordMordred @bwk @kreyren Okay, but you can choose to turn the microscope into a telescope if need be. You could choose to capture or not. A logging statement is very similar to breakpoint in that sense
@FrailLeaf @LordMordred @bwk @kreyren Sometimes you need to run a scenario a large number of times to collect logging data for post-analysis. When you run into that scenario using debugging approach instead of logging will take you 10 years (i.e. never) to solve certain classes of problems that can be solved easily thru logging approach.
Follow

@clay @FrailLeaf @LordMordred @bwk

If you are ever in a situation where you need to collect a
"logging data for post-analysis" then logging is just about the worst thing to use that for as it has a major impact on the efficiency of the program and you always do this once you understand the code and have established a clean room as without it your logging data will have bunch of noise in them.

Thus the case for benchmark tests preferably using criterion.

@kreyren @FrailLeaf @LordMordred @bwk You don't leave the logging statements in forever, and you only put in as much as you need, but yes performance is the issue if you adjust the firehose to be capturing more than needed for the problem at hand. I agree sometimes the 'firehose' is too much. It's a balance, like everything else.

@clay @FrailLeaf @LordMordred @bwk

So you spend your time writting a logging solution and then remove it?
How is that anywhere near resource efficient?

If you are in a situation where you need to do extensive testing then someone else will most likely be in the same situation in a later date -> You implement the logging permanently on demand preferably without including it in the build binary if the programming language supports it.

@kreyren @FrailLeaf @LordMordred @bwk I do use the debugger too, and I comment out logging statements or even delete many once an analysis is done. My discussion about logging was related to how to understand large unknown codebases, not codebases I already understant. Logging is best way to familiarize yourself with unknown code almost 100% of the time, over logging.
Sign in to participate in the conversation
Qoto Mastodon

QOTO: Question Others to Teach Ourselves
An inclusive, Academic Freedom, instance
All cultures welcome.
Hate speech and harassment strictly forbidden.