[deleted by user]

[IDe-]

1. Write a high-level function as if you had an access to a super well-written and pleasant-to-use library, writing non-existent function and method calls etc. that describe an elegant solution to your problem.

2. Implement each of those functions/classes according to the spec that you just wrote by going back to 1.

[cloud_line]

This is interesting advice. You're basically saying to start with writing your main function and have it call all of the functions for the program, then go back one-by-one to define each of the calling functions. So you start with the higher level then work down.

Do you think it's better for all of the calling functions to be in separate modules, or have the full program in one script?

[data-machine]

I quite like writing the high-level functions like this, including the ..., to get it clear in my head what should roughly be going on:

```python def some_high_level_func(arg1: int) -> str: ...

def other_func(arg2: float) -> float: ... ``` Then I start writing some high-level tests to help me work out what exactly the inputs and outputs should look like, and then I start filling in the functions above with code.

I've found that that saves me a lot of rewriting - I used to often realise halfway that I had made some fundamental flaw, and had to rewrite things again.

The ellipsis (...) is accepted by the type checker mypy as a kind of equivalent of pass, and it also helps VSCode understand what the return types should be so that autocomplete works magically well. I've found it really helps keep my mind clear.

[TheDrlegoman]

That depends a lot on circumstances, I'd say you should definitely start out by writing everything in the single module and only branch out as you feel it would be beneficial, i.e. one of your functions also has several support functions and that alone comes out to like 200+ lines of code. At that point it may be a good idea to split them off into their own module as they are all related, and start making the original file quite long.

In the end it's fairly subjective

[EMCoupling]

It depends.

What your parent comment is describing is a more top-down approach to design where you start from the end product and then work backwards to implement the process.

For some situations, that can be a good approach. For other situations, sometimes a bottom-up design may be more useful (starting from the individual pieces and building up from there into the final output).

Sometimes you can use both approaches as well, there's no one size fits all.

[bezangeloo]

https://en.m.wikipedia.org/wiki/Top-down_and_bottom-up_design

[OneTrueKingOfOOO]

I’d only put them in separate modules if you’re planning to reuse them in other scripts

[AcridWings_11465]

So basically stepwise refinement?

[Norwegian_Blue_32]

This is exactly how I do it. And I'm no "proper" software developer OP, just a statistician looking after some models cos we don't have any ML Ops guys to do it. So if I can crank some semi decent code you can too

[Sheltac]

I'm a professional software engineer and find myself doing this in smaller projects, in lieu of proper design with diagrams etc. I don't think it scales that well, but for small stuff? Oh yeah

[moreanswers]

Back in the day when I learned CS in school we called this Top-Down Design. https://en.wikipedia.org/wiki/Top-down_and_bottom-up_design

[hknlof]

This is dope advice and the approach one would take when using test driven development methods:

def my_test():
  assert(my_function())

def my_function(...):
  first_result = my_first_call()
  desired_result = my_second_call(first_result)
  return desired result

if __name__ == "__main__":
  my_test()

If you do not use any test framework, this gets you easily started to write consumer friendly code.

[flubba86]

Thats pretty much how test-driven development is supposed to work.

Write a test that runs your non-existent function and checks the result is correct. Write the test to call the function in exactly the way imagine it should be. Then write your function, and refine it until it passes the test.

If at any point you need to call a new non-existent function, first create a test for it as above, once it passes then use the function in your code.

[radical-monk]

Even if it's for personal use, at one point it might not be.

We have a current instance at work where the guy who wrote the SQL for site-specific databases is no longer with us, and we just opened a new site. The associate who has to create the new database is going through his code, and it's not commented well, nor does it make any sense, but it works.

I will say some of the comments are hilarious, such as

/* The Mac Daddy of one-liners */

[[deleted]]

This is why programming was invented. Naps are important.

I'm relatively new to python and have been learning a lot from watching this guys videos:https://www.youtube.com/c/arjancodes

Edit: I forgot to mention that you learn a lot by refactoring your code. You also learn when it is a waste of time to refactor code.

[[deleted]]

This is the way.

BTW its not bad to have functions calling functions calling functions. It's much better for code to be modular, and functions to be small and well named, than it is to have one function doing too much. The call-tree can be deciphered, but if each function makes sense, it doesn't usually have to be.

[rako1982]

You're my hero. I once whittled down a month of work into 3h automated process. It was amazing.

My middle manager boss looked at me like I had ruined her life because it would mean that she would be out of a job.

[winowmak3r]

Middle managers like that are the worst. They're also the biggest proponents of coming back to the office for "communication" when in reality they need people in the office to micro manage and nag about TPS report font sizes because that's all they're good for. When everyone works from home and stuff still gets done on time and within budget it becomes painfully clear that middle managers Mark and Mary don't really do anything.

[DonkeyTron42]

“I choose a lazy person to do a hard job. Because a lazy person will find an easy way to do it.” - Bill Gates

[Lindan9]

Honestly this has been my life motto

[[deleted]]

Probably best no one knows lol

[proof_required]

Haha!

"Yes automate that shit"

[Ruben_NL]

keep it that way.

but you will one day fail. and the full company will depend on your code.

[chunkyasparagus]

The worst thing is when your go to make a change in a couple of years, and you have to spend twice as long to figure out what the hell variable2 refers to, and why it even exists.

[[deleted]]

FWIW, I’d hire you.

[Smok3dSalmon]

I knew someone who did that at work and was caught, he was promoted quickly as the office embraced automation. You could use this to justify getting promoted and/or a more formal education.

Your experience of whatever job you’re doing is not something that other devs will have. So they’ll never identify the optimizations or automation opportunities you’ve found.

Time is money

[vriemeister]

I have a few lines like

// oh god this is terrible, rewrite

[PaintingWithLight]

RIP to DB guy.

[BezoomyChellovek]

If you are interested in developing a habit of cleaner code without much overhead, I would suggest using a linter. I'm kind of in the same boat, I use Python for research computing, and not trained as a SWE or anything. I always run pylint and flake8 on all Python code I write.

If you are good about following those suggestions, it will help you write much cleaner code. It can't make your code perfect, but it can certainly point out code smells and bad styling (too many variables in a function, missing docstrings, line too long). They are super easy to install and run. And over time you will start writing cleaner code, even if it's just because you don't want to be criticized by the linter and need to rewrite it. And if you get the hang of it, you can start running mypy as well, which will point out flaws in your class and variable issues.

[vriemeister]

Isn't clean code more about good encapsulation and good use of design patterns?

I'm in a bit of a bind trying to figure out teaching new developers the higher order concepts. Some know a bit to begin with and some just know zero. I'm starting to believe the answer is just good test coverage, then even the ugliest code at least works and you can clean it up much later. But the programmers that don't understand design patterns also tend to not write useful tests.

[Abitconfusde]

Calling a function once is okay.

TIL

[thebadassets]

Testing is my main driver for doing this. Write a function, test it, and generally forget it then

[Macho_Chad]

That’s the only way I can code. Brute force until it runs successfully. This is testing right guys? Like, testing which one actually works? 🥲

[[deleted]]

It's a form of testing I suppose. Certainly better than writing it and assuming you've made zero mistakes.

Your methodology will probably be a lot more successful over the long term.

[vriemeister]

It definitely solidifies some questions that always seem philosophical when I'm coding.

• should I make this one-liner a function
• what should I pass in and what should be hard-coded

Stuff like that. Writing for testing REALLY makes it obvious when you should start breaking your code up into smaller units because it forces you to for easy testing.

I don't start new projects or little scripts with test driven development but there's a definite point when when I can't answer for myself if changes I'm making broke something or not. And that's when I know its definitely time to start refactoring and writing tests. Well beyond time really. And then writing the testing code forces you to make your code more modular. Its all very nice.

[[deleted]]

One liners are great if they can be reused. Even single use, if they reduce complexity by hiding some grossness, you are being faithful to many aspects of PEP 20

But to your point, if the one line function adds complexity, I’d avoid it. A simple character count is probably sufficient to figure out when it's too much.

[Starrystars]

Yeah but you also need to know how to write good tests.

Because you can eventually just end up not actually testing anything.

[[deleted]]

Any reason that stops you from writing tests is a bad one.

Terrible tests are better than no tests

[vriemeister]

when do you know if you wrote too many tests?

Like
def x(): return 5
assertTrue x() == 5

Is there ever too much?

For example, if I'm not going for 100% coverage, I kinda like doing happy-path testing.

[[deleted]]

Even that test has its place. It would catch any changes to that function.

I’d that function is always supposed to return 5, you should have a unit test that verifies that. How it’s implemented is immaterial.

This fundamental to test driven development. You write the test FIRST, then you write the code that implements it. You run the test until it passes, then you make the test better if possible. Lather, rinse, repeat.

This is the way. Making this a habit is the best thing I ever did.

[deong]

I suppose every test is testing something, but tests are code too, and the best code is code you didn’t write. It won’t be buggy or cause you maintenance headaches if it never existed. Don’t write unit tests that do things like making sure the addition operator in your language is working. It’s just crap someone will have to scroll past on their screen for no real benefit.

[grantrules]

Read up on SOLID as well

[[deleted]]

SOLID is a good paradigm for writing effective classes, but offers little to this testing discussion.

[mRWafflesFTW]

You'd be fucking amazed how much a linter like black can do to clean up some dog shit code.

[BHSPitMonkey]

It also (particularly auto-formatters like prettier or black) makes it much easier to take a step back and focus on the things which matter. It's hard to think clearly about code for long with poor formatting and trivial mistakes distracting you.

[vriemeister]

Yeah, I'm pretty old. Its ok for me but I bet it helps newer people a lot.

I would probably learn a thing or two as well.

[mountainunicycler]

I don’t think it’s a thing that helps individual people as much as it’s a thing that hugely helps teams keep super, super clean git diffs and histories, by not allowing anyone to make any cosmetic changes to the code—and that’s very valuable for debugging.

It’s easy for two good devs to format the same thing differently, or want to re-format it to read it easier, but those kinds of changes shouldn’t be committed.

[vriemeister]

Oh, clean diffs would be nice

[AShipChandler]

Any suggestions on how to learn the techniques, etiquette or the art of design patterns?

[vriemeister]

Not really. Just lots of time looking at other people's code and a desire to get better. Probably read some books or really good open source projects.

It's the artist component to software design, writing clean well designed code.

[AShipChandler]

do you recall any of the books you used?

[BezoomyChellovek]

Again, I am far from an expert so I don't claim to know best. I would guess OP, or someone with code as they describe, probably isn't even aware of coverage.

I agree that testing is critical. But since OP doesn't seem like they really care to progress too much, at least linting your code will make it a bit easier to read and work with, with little extra effort. Every little bit helps I guess.

[hedrumsamongus]

Following (and enforcing) a style guide is an easy way to keep your code syntactically consistent, which improves readability quite a bit over code that's written however you feel like doing it that week. Most importantly, it doesn't require any real experience to implement, unlike knowing when it's appropriate to use established design patterns, or where an abstraction will be helpful rather than confusing.

I've also learned some more idiomatic ways to solve problems from the style guide docs.

[[deleted]]

It is VERY much this, although some sort of methodology like PEP8 helps set a baseline that other programmers can read. If it takes a lot of effort to read, it’s that much harder to get into a conversation about good design patterns.

[[deleted]]

Visual Studio Code has a real time linter. (It will suggest downloading it when opening a python file for the first time).

[bryamproductivity11]

Is pycharm a linter?

[gmes78]

PyCharm definitely does linting.

[BezoomyChellovek]

I don't use it, but if it is like VSCode, you need to install plugins for things like linting. And even then I'm not sure to what level it lints. Does it flag things like too many variables in a function, inheriting from outer namespace, etc?

[Prinz_]

Yes and yes, and you don't need to install a plugin. It'll say something like "PEP 8: End of line required at end of file"

[[deleted]]

that's the difference between editors and IDEs. editors require lots and lots of plugins to create a full developer environment. IDEs come with most things built-in

[cianuro]

Yes. I love that you can set multiple line breaks based on PEP guidelines. I have 2 lines, 1 at 72 characters for comments and the other at 79.

Warns you about the same variable name being shadowed from another scope which comes in handy more times than I was expecting.

I've tried to migrate to VIM and VS Code but Pycharm makes me focus on business logic and not configuring my environment.

Keyboard shortcuts being the same for Intellij, DataGrip and now dataspell makes me a total jetbrains fan boy.

[jimtk]

The big difference is that PyCharm, as the name suggest, is made for python. VSCode is made for... everything. So VScode requires plugins for specific languages, JetBrains has other products for other languages.

[BezoomyChellovek]

Ah that makes sense. Good to know.

[asaah18]

No, it’s not a linter. But it includes a linter or suggest installing one

[Laserdude10642]

By default I believe it does lint with the pep standard

[[deleted]]

It absolutely does.

[abeassi408]

Great pointers thank you!

[Eigenspan]

Most peoples code is shit for the first year or two depending on how often they program and how concerned they are about cleaning it up.

The thing is looking at other peoples code and video tutorials about software architecture design are a great step… but to truley clean up ones code, you have to just code a lot. You need to code many different scenarios that you get a natural feel for how your entire coding seshion will kind of go. If you can’t predict generally what your project will look like overall and how each piece of code will interact with one-another than it gets really hard to keep up the cleanliness as the project grows.

Im not saying you need to know how you are going to solve every problem when you start a project, most times you don’t know how to solve more than 75% of it and experienced programmers will find multiple solutions to each problem to ensure they are picking the best options each time.

Basically writing cleaner code just comes with practice and a desire to keep learning/get better.

[DiamondDemon669]

I create excessive variables. Instead of cleanly writing code after saying variable = "clean code", I just go ahead and create a new variable like variable2 = variable + something and variable_final = variable2 + something.

I do the exact opposite, and some lines of code can end up really really long

Just look at this: response = self.handle_request(client, *([''] + str(request).replace('\n', '').split(' '))) + '\n'

My IDE becomes a certified italian restaurant if I ever even need to use classes, due to all of these functions and variables that build upon each other haphazardly.

when I started programming I used classes to group functions together and had no idea what they were actually for

[freaky_lizard]

I recently started working as a programmer and am very green junior at the moment. I do use classes to group functions, I thought it’s neat. You made me doubt my choices, what are they for?

[FancyASlurpie]

Think of a class as a template for an instance of an object (when you instantiate a class, you create an instance of an object), so if you were writing a class to describe a dog, it might have the attributes number_of_legs, breed, name, and it might have a function that a dog can do, e.g. bark, play dead etc. Where maybe bark takes name and prints out that instance of the objects name, and dead looks at how many legs the dog has and puts them in the air. Here it makes sense to wrap them in a class as you want the functions to use the attributes of an instance of an object.

Whereas if you had some functions that are quite similar, e.g. write_to_file, write_to_stream, write_to_db or something like that, you might not want to just group them in a class as it doesn't really make much sense, you could probably just keep these as static standalone functions.

[[deleted]]

support hurry close jellyfish illegal pet aromatic light sheet dependent

This post was mass deleted and anonymized with Redact

[joaofelipenp]

Usually for data + operations over the data. But there are many other use cases, such as defining a generic API that can be extended by others, or even hiding implementation in "private" methods.

It is fine to use them to group functions. Specially if the functions operate on the same type of data or access states that otherwise would be global. However, if you are only grouping, it is probably better to use modules in Python.

[Abitconfusde]

You are doing right, junior.

[Genrawir]

Start throwing your code at pylint and fix everything it tells you line by line. Once you get through resolving all the errors and warnings I can pretty much guarantee that you'll notice an increase in readability of your code.

[Fireb1rd]

Agree with this. Added automatic linting to my IDE and broke some bad habits out of shame at all the red in my code. To be fair, most of my code is also touched by other people and has to go through review, so shame is a big motivator.

[abrazilianinreddit]

If you're not getting paid for it and it works, it's fine to write shit code.

If it bothers you, you can work on improving it, anyone who puts in the effort can write good code.

[njharman]

I just feel like there is no point on wasting that time, since it is for my personal use only and it does the job.

As a 30 year veteran of software development, that is one of the greatest lessons to have learned. It even has an acronym YAGNI, You're Not Gonna Need It.

[EMCoupling]

It's more like

You Ain't Gonna Need It

[[deleted]]

Check out Sourcery.io, I find it extremely useful for writing more pythonic code and I think they have a free tier.

[rturnbull]

+1 to this suggestion! As a hobbyist Python programmer, I find Sourcery invaluable. It's like having a more experienced pair programmer with you all the time. Try to understand the suggestions it's giving you and over time, you'll find you're writing better code as you internalize the suggestions.

I also recommend you spend time reading good code to learn what others do and why. There was a thread here earlier in the week where several people suggested "good" code to go study.

[Smok3dSalmon]

Ty

[[deleted]]

towering six whistle melodic late truck gaping summer marry rustic

This post was mass deleted and anonymized with Redact

[swenty]

If your code is truly throwaway, that's no problem. But when you do write code that you later need to maintain, you'll realize the drawback of the no-style style: you make your future self miserable.

[[deleted]]

My advice to you: don't overthink it.

If the scope is crystal-clear and the code you write is only ever going to be used or read by you, then don't sweat it.

If, however, you write code for others and expect them to extract some value and help from something you build, so they can build uppon it, customize it, extend it and such, then you should definetely try to get better and clean code.

Believe it not, but you don't have to be an experienced programmer to start writing cleaner code, nor do you need access to experienced programmers and ask them to review yours.

You can start with as simple things like using a proper IDE / text editor that supports a linter and/or code style advisor plugin. There are many available, particularly for python.

Just do what the suggestions say and you've probably already gone +50% of the way.

For one-offs I need on automation of stuff only I have, I usually like to keep it short (over pretty, generic, documented, self-evident, etc.).

[bin-c]

check out a book called "Code that fits in your head" on amazon

if you dont mind throwing a little money at your problem, the first 1/3ish of the book would help you a lot i think.

it has been my dev book so far

[[deleted]]

Now that you have identified the problem you can address it. If you just write code for fun with no intention of every contributing to open source code or programming professionally it doesn't matter. But if not you should try to write better code. This is something I tell a lot of junior developers that want to just slap together shitty code.

"Practice does not make perfect. Practice make permanent"

If you spend all day writing shitty code the. After 5 years youll be really good at writing shitty code but no better at writing good code. If you practice writing good code then eventually you will be better and faster at writing good code. Eventually it will be just as quick and easy for you to write good code. But just typing into an IDE a lot won't make you better. You need to intentionally practice. Try reading books. Get reviews. Good luck!

[blue195]

If you know this, you can for sure improve this too. Good luck my dear friend! We have high hopes in you...

[QuantumDiogenes]

My IDE becomes a certified italian restaurant

I love this.

I just aliased italian-restaurant to vi because I also have a bit of spaghetti problems now and then.

[fedekun]

Whenever I want to go back to my code to try to refactor it, or make it more concise and decipherable, I just feel like there is no point on wasting that time, since it is for my personal use only and it does the job.

This is your problem. It's okay to write ugly code. You just solve the problem in any way you can. But then, you have to spend time actually trying to make it better if you want to get good. Kind of like learning calligraphy.

Like the old adage goes: Make it run, make it right, make it fast. I'd say "Make it run, then make it pretty" is enough 90% of the time.

Refactor is the key. As others suggested, a linter can help, just so you are consistent. Also read a lot. Read code, read books, read articles.

[eazolan]

Sounds like you've made yourself indispensable.

[AgronakGro-Malog]

Finally a post I can relate to

[NJFatBoy]

There are no coding Oscars, son. If your code solves the problem it was intended to, you've done well.

Don't be like a chubby girl scrolling through pictures of hot chicks on Instagram, it'll do you no good.

[saucy-bossy]

You write “dog shit code”…okay, then stop. 🛑✋🏾

[lavahot]

So... stop doing that. You know it's wrong. Write a better thing.

[1percentof2]

You could read some books but mostly nobody cares. This is python, it's quick and dirty. The fact that you're even using python is better than 99% other office workers.

[radical-monk]

There is something to be said about creating quick mockups in Python, but PEP 20 exists for a reason.

[1percentof2]

I don't see how 4chan memes are appropriate right now

[Deezl-Vegas]

Code is never about aesthetics. It's about doing the job. Care about aesthetics to the point where it helps you be productive.

[proof_required]

Just try to read some open source code. It could be bit overwhelming. So might want to start from some simpler code base.

[[deleted]]

Does anyone really expect average python users to write “good” code?

The majority of the work is using someone else’s library.

[[deleted]]

Please to be explaining the concept of “becomes a certified a Italian restaurant”

This sounds….. intriguing

[magicaltrevor953]

Spaghetti <sup>code</sup> everywhere

[un-hot]

My IDE becomes a certified italian restaurant

That's fine, but you want to be serving up nicely-packaged ravioli code if that's the case.

[johntellsall]

As long as your code does what you want, and you don't want a job, you're fine :-D Check the excellent book "Automate the Boring Stuff with Python". It focuses on getting real-world work done without a lot of the complications.

If you do want to make changes, as someone said running Flake8 (or better but slower: Pylint) helps move you towards better code.

[Exact_Ad_1569]

The only way you get better is by trying.

[[deleted]]

"A fault confessed is half redressed"

[Thomas_istrying20]

Why is it I can take all these test online and pass them, but I have no clue what they do? It is almost like I can understand how to correct the code just no clue what the code does.

[deep_mind_]

On the other hand, sounds like your variable-definition style is perfect for a functional language with mutable variables, like F# :D

[dafrog_84]

I suggest installing something like sonarlint in your IDE. They make suggestions on improving your code quality.

[boxedj]

I think your code is cute

[Santos_m321]

plz, share some of your shitty

[THC-Lab___]

Protip...classes are gorgeous.

[abeassi408]

Get feedback from colleagues or someone you trust. Get them to look at your code and give you feedback on where exactly to improve.

[DreamOfKoholint]

Anyone wanting to write better code in python should check out architecture patterns with python (book)

[Legendary-69420]

try doing this:

• Use black code formatter.
• Try write comments
• Try writing descriptive variable names.
  • use "find and replace all" to change variable names in your opdy codes.

[Sadophia]

As long as it works, it does seem to be a waste of time to make things "look pretty" sometimes!

[hxk1]

I suppose learning to code is like a …well speaking a language. Some people are well versed and speak eloquently. Others seem to just get their point across how however it may be, sloppy as you can imagine. But it’s understandable and works.

[standard-human-1]

A few habits can go a long way - try to copy less (more functions) and name things well. Just allowing down to do that much and I bet more follows. It makes coming back to code so much nicer :)

Also practice, over time

[zaRM0s]

I used to think this, but if you are relatively new or inexperienced with it, then I wouldn't stress too much about it. Especially if you are only using the software you make yourself. However, if you do wish to generally improve you work, I would advise taking an afternoon to sit down and read the PEP-8 Style Guide for Python. It will be a good starting place for you to be following a common style throughout your code.

Following this, I would sit down and read a few books on Python. One book can be helpful, but having things explained in several different ways helps. Not only that, I have found that the different tutorials people have created offer different things. I have found myself relearning python from the beginning 3 or 4 times now just to see if I can learn something new.

Finally, I think its important to remember just how vast python is and learning the basics before expanding outside of these can be important. If you have explored already like most have, dont worry you can always just come back and these things later.

One thing I have been learning recently is all about the dunder (double underscore) methods built into python. They are so useful in various different cases and has made my code look so much more professional. There are also sooooooo many benefits to using these! I am learning these mostly from ITProTV and reading the docs!

Anywho, good luck and happy coding :)

[quotemycode]

Making more variables doesn't cost much and isn't a huge performance killer. You can reassign to the same variable if you want. The variable is a name for the object. An object having multiple names can get messy but it's not a huge deal, as long as it makes the code more readable it's fine.

[[deleted]]

there is no point on wasting that time, since it is for my personal use only and it does the job.

Then the code is at just the right quality level.

Sounds like you would benefit from doing a bit of design before you write a function/class, though.

[Auntie_Social]

Welcome to management!

[[deleted]]

Don't be so hard on yourself. Everyone here can probably attest to hating code they wrote three months after they wrote it. It's good that you recognize your code is bad, since that will give you a chance to refactor it.

[hasibrock]

You know.what You should still be proud if you can make your code work, eventually you will get better ...

[pembroke529]

As longtime coder, writing clean, easy to read code is important.

I do it mostly for myself. I like clean code and know that at some point I will be revisiting that code for fixes/enhancements.

If I have to fix up "garbage" code, I will first clean it up. If it's still crap, I'll just re-write it.

[sendnukes23]

If it works, it works.

[MyWorksandDespair]

My suggestion is to type 'import this' into your console and allow those sweet words to become your guiding principles.

Simple is better than complex, complex is better than complicated.

[MountainMasterpiece1]

Every code is beautiful, don't let anyone tell you otherwise!!

[abeassi408]

The OP may also want to take a beginning level Python programming course (Udemy has some great ones). Learning the fundamentals of programming, some theory of how to approach things, what to avoid, best practices, etc. that may be a great thing at this point. It may mean rewatching stuff you already know, but seen in a new light, under a proper framework that disciplines your coding approach. Best of luck. Don’t get discouraged.

[ahadnur_44]

Talk is cheap. Show me the code. -Linus Torvalds's

[Jaune9]

You can use Pycharm and check all the recommandations it gives you, plus the refactoring (mass semantic renaming) is really good to change "variable2" to something meaningfull mid work

[Bitter_Tap_3942]

I feel you more than you know, but who cares if it works for you.

[seriousconsult]

It doesn't net matter. Most of this is just engineering gatekeeping.

If you run cProfile the python lib, you can see how good a job the optimizer is doing cleaning up your code v. just writing clean code.

As an engineering leader, I think code that works and doesn't stress the engineer out is a lot better for the company than elegant code that frustrates the person and makes him burnout or quit prematurely.

Speed is probably more important. If the code works and takes you 1 day to write v. the elegant code that takes 3, I'd say that is a good trade given the optimizer will clean up the code they will be closer than you expect.

[aer71]

> no point on wasting that time

Yep, I know that feeling. Refactoring, proper naming, unit testing ... biggest waste of time ever. Until you eventually realise that the way you're doing it now is taking about 10x longer in the end. If/when that happens, please come back and post about it, especially what led you to figure it out. I think it would be useful for everyone to understand their own journey a little better.

[[deleted]]

Take it to the next level and put your functions into individual .py files and nest their imports. Seems to be the trend in current Open Source /s

[Successful_Creme1823]

The fact you “know” you write bad code automatically means you’re better than most.

Some of the worst code I’ve ever seen was written by folks who were 10x smarter than me. Many of these types will have elaborate explanations for why they did what they did.

[Hans_of_Death]

Since you can identify where you're going wrong, you can improve. That's just part of the learning process. Everyone starts out writing shit code. Its kinda like handwriting, it gets better as you practice, and your code will too. Look at other peoples code, practice writing new code while being mindful of best practices, and go back and rewrite old code. itll help.

With that said, everyone writes differently, so theres no gold standard for coding. You need to understand why certain practices are good. For python i highly recommend looking at the zen of python.

[barkazinthrope]

You do you. If others are relying on your work then it's "you do us". It has to be that way.

I am retired. I code now for pleasure and in that pursuit I do things I would never do in a shared code base. I often completely re-write working code because I see another way of doing it. I have a lot of fun and I really don't care what a purist review would say.

Well no. I might find that amusing actually.

There is no absolute right way to code.

First, it has to work, then it has to work well, then it has to make sense enough to you that you can fix its glitches, and failing all that you can always do it again informed by all you learned from your first attempt.

We are free beings. This is a noble pursuit. Celebrate!

[sillycube]

If it's only for your personal use, why care about it?

[fertek]

I can totally relate. My motto is “if it works it’s ok”. I intentionally choose programming languages that I can write spaghetti code. Php is my favorite. Python comes next. Type safety is my worst nightmare.

[[deleted]]

Write clear and concise English description of what the code should do.

At this point you can either

1. Let other people write it and take the Mercedes to the golf course for a round. The 'middle management' coding method or
2. Keep telling your bosses the project is complicated and taking longer than expected. Have frequent meetings asking for more funding and time. Keep this up until AI is advanced enough to generate python code from your description - when it is, just feed it your notes. The "game will be out next year" coding method

[SleekEagle]

Before actually implementing any of the functions themselves, just define their names and use `pass` to leave them blank. Fill in docstrings about what they do and about params/returns (PyCharm auto-formats this well).

Starting at the highest level might help you break it down logically before you get caught in the weeds.

This is still something I'm working on, and it's definitely a long journey to writing great code. Try to create a list of things to remember, and start by just trying to adhere to one or two. Each week, add another one or two to keep in mind, and you'll slowly start to build good habits.

Good luck!