• 0 Posts
  • 24 Comments
Joined 1 year ago
cake
Cake day: June 10th, 2023

help-circle
  • A lot of responses here so I’ll suggest a different approach. You can watch your python code execute line by line using a debugger. That might help with understanding how it all works.

    def my_sum(list):
        result = 0
        for number in list:
            result += number
        return result
    
    my_list = [1, 2, 3, 4, 5]
    list_sum = my_sum(my_list)
    print(list_sum)  # Prints 15
    

    If you run the above code line by line in a debugger, you’ll see that when it gets to list_sum = my_sum(my_list) the program will jump into the function my_sum(list) where “list” is a variable holding the value of “my_list”. The program continues line by line inside of the function until it hits the return result statement. The program then returns to the line it was at before jumping into the function. “my_sum(my_list)” now has an actual value. It’s the value that the return statement provided. The line would now read list_sum = 15 to python.

    A debugger shows you which lines get executed in which order and how the variables update and change with each line.

    Just a note: python has a built-in sum() function you could use instead of writing your own my_sum() function, but a debugger won’t show you how built-in functions work! They’re built into the language itself. You’d need to look up Python’s documentation to see how they actually function under the hood.








  • My understanding is that some people are die hards to the software philosophy of “do one thing really well”. systemd at the very least does many different things. These people would prefer to chain a bunch of smaller programs together to replicate the same functionality of systemd since every program in the chain fits the philosophy of “does one thing really well”.







  • __ LINE __ is a preprocessor macro. It will be replaced with the line number it is written on when the code is compiled. Macros aren’t processed when debugging. So the code will be skipped during debug but appear in the compiled program, meaning the program will work fine during debug but occasionally not work after compile.

    “__ LINE __ % 10” returns 0 if the line number is divisible by 10 and non-zero if not. 0 is considered false and non-zero is considered true.

    #define is also macro. In this case, it will replace all instances of “true” with something that will only sometimes evaluate to true when the program is compiled.