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.
> 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.
@FrailLeaf @LordMordred @bwk like they can always change an industry.. So what's your point?
> 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
@FrailLeaf @LordMordred @bwk e.g. what @lupyuen is doing with https://qoto.org/web/statuses/107793119639236951
@FrailLeaf @LordMordred @bwk Like footprinting is generally time efficient so what's the issue?
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!");
}
@FrailLeaf @LordMordred @bwk Large codebase without documentation is not sustainable so i don't think that this scenario exists in the wild and even if it was it's still time efficient to footprint.. i would say 100K Lines taking <1 hour
>i don't think that this scenario exists
You are saying I'm lying? I work with 3M SLOC ESB system written in Java EE; with no documentation because "a lone developer worked it when the company was small". And another 30 Microservices with source level docs for the same reason.
So what's the issue? footprinting of open-source software is very time efficient..
I do agree that java is a torture instead of a language so i can would imagine that lack of documentation is the least of your problems there.
None of this was ever about Open source software, I have laid it down that this is in Proprietary systems. You fail to understand the context.
"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.
@FrailLeaf @clay @LordMordred @bwk Debugger output will just confuse you most of the time..
When i do footprinting i just fully ignore it.
@clay @FrailLeaf @LordMordred @bwk
Alternatively if you are limited on time resources i usually just add `println!("SSSssssssSSss");` to the codebase at random places to understand the runtime evaluation and then regex it out when i am done.
but yes of course I use the debugger a lot, when I need the microscope.
@clay @FrailLeaf @LordMordred @bwk
If your function is so inefficient that it takes longer then 300 nano seconds per run assuming average personal computer system of 2022 then there is something horribly wrong with your code.
i am aware of this being an ongoing problem with python that most likely won't ever be fixed and if you ever run in that situation on python then you should move your codebase to a better solution as python is not a programming language for data science industry..
@clay @FrailLeaf @LordMordred @bwk
> What if the thing I'm running is doing a merger of all banks in the USA into a theoretical merged institution. Should that function take 300ns?
Calculated to be at average of 12 Petabytes for the last 5 years -> yes.
Banks use a very efficient systems designed for data transfer so i assume that they won't be a bottleneck so they should be able to make the calculations locally, compress it and sent it to you assuming that you have the required permissions to access such data.
So the common excuse of "it's a lot of data it will take few hours" just because you don't know how to optimize the function is invalid.
What takes time on the processing is calling the function multiple times per set amount of time e.g. how compilation works so the efficiency of single component is directly related to the overall efficiency of the solution
e.g. assume a hypothetical scenario of a calculator function doing 1+1 calculations taking 5 seconds -> in compilation you do these kinds of calculations billions time per second (assuming that the compiler 100% efficient to utilize all the system resources) so 5*1B is 5B seconds to process one frame of instructions which will take you 158.4 years to complete thus your function is too inefficient to be used.
@clay @FrailLeaf @LordMordred @bwk You are using a very specialized usecase with which only you have the personal experience so it's impossible to argue about it as i lack the require information so provide a better example for your argument?
@clay @FrailLeaf @LordMordred @bwk name one function that has to be faster then ~300 ns
@clay @FrailLeaf @LordMordred @bwk I don't disagree that a software composed of function could take a lot of time the argument is about the invidual functions that create the software.
E.g. the common fibonacci could take days to finish calculation on INT_MAX or it could take 11.42 ns depending on how you write it
And if that function is used multiple times in a software then this inefficiency will grow exponentially
@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.
@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.
@clay @FrailLeaf @LordMordred @bwk
telescope analogy for logging is wrong and i hate that so many people are looking at it like that..
The output is expected to be very descriptive and understandable without depending on skill requirement so i argue for "clear map" instead.
@FrailLeaf @clay @LordMordred @bwk I am aware, but it never helps me when i am footprinting as i don't have established a clear working environment to rely on the output.
@clay @FrailLeaf @LordMordred @bwk
I didn't say removing random parts of the code, i said _COMMENTING OUT_ random parts of the code..
meaning comment them, run the program to see what it does and uncomment and repeat until you understand what the changes are doing to document the code.
Adding logging takes a huge amount of resources in comparison to this, but i agree that if the software is projected to be used in a production or mission critical environment then adding logging is well worth the time.
@clay @FrailLeaf @LordMordred @bwk
There is no way that it will create a chaos if you run it bootstrapped (unless you are yolo dev to run it on bare metal) and fatal failures are expected to understand the code.
