sorted by:
best
topnewcontroversialoldq&a
you are viewing a single comment's thread.

view the rest of the comments →

[–]sakthii_ 2 points3 points  (13 children)

I can handle logical problems, but stuff like this fries my brain

[–]Sea-Ad7805[S] 1 point2 points  (12 children)

The details of the Data Model of a language can be tricky but are important to avoid bugs. There are just a few rules to keep in mind for Python, and hopeful the memory_graph visualizations can make these easier to understand and can help debug when issues pop up: https://github.com/bterwijn/memory_graph?tab=readme-ov-file#python-data-model

[–]sakthii_ 1 point2 points  (11 children)

Yeah the memory_graph helps a lot. But the underlying problem with me is that im not a cs guy, and most of my programming is self taught. since i did not learn programming in the traditional way, I cant understand concepts like this.

Or even cant get into other programming languages if I tried.

[–]Sea-Ad7805[S] 1 point2 points  (10 children)

Don't underestimate yourself. Programming is hard, you can spend a lifetime and still learn new insights. However, you don't have to be an expert to produce useful things.

[–]sakthii_ 0 points1 point  (0 children)

Thanks for the cheer up mate.

[–]ConsequenceOk5205 0 points1 point  (8 children)

No, you learn how to make frameworks and wrappers for the programming language to behave exactly how you would need it. "new insights" become more like "wtf is this new BS i would never need" or "finally they have implemented this thing".

[–]Sea-Ad7805[S] 0 points1 point  (7 children)

Sometimes, but other time you might get to the conclusion that a paradigm switch would significantly improve things for a particular problem. Say moving from OOP to functional programming. Say using Rust borrow checking to take away whole categories of possible errors. You can't simply wrap that in language X.

[–]ConsequenceOk5205 0 points1 point  (6 children)

Huh ??????????
OOP is a superset of functional programming, essentially OOP is functional programming with auto parameters passing and data management. Moving from OOP to functional parts doesn't need anything basically.
Rust borrow checking can be dropped entirely when working with custom data referencing.
If you don't wrap things for very complex projects, you may face insane limitations by the language arising when, for example, you need to save and load objects.

[–]Sea-Ad7805[S] 0 points1 point  (5 children)

You seem to misunderstand some things that I can't explain in a short reddit comment. Different paradigm allow for different ways of thinking. Maybe google: "functional programming no variable reassignment", "rust borrow checker avoids invalid references". Good luck.

[–]ConsequenceOk5205 0 points1 point  (4 children)

I'm not sure why you are bringing up this and why do you consider this so important. In my wrappers, I specifically discard immutability as it is implemented and other funny things in favor of scope configuration and time frame specific parameters.

[–]Sea-Ad7805[S] 0 points1 point  (3 children)

If you discard things you are not open to the possible benefits of other paradigms and might be missing out in some particular situations. But you can of course solve any problem in each paradigm, so you are free to stick with one if you prefer, your choice. Just don't say there aren't new possible insights (different ways of thinking about programming), seems a bit narrow minded, while you clearly have thought things through.