How to go from writing code that works to writing efficient, clean code and following good practices?
How to go from writing code that works to writing efficient, clean code and following good practices?
Besides some of the very, very obvious (don't copy/paste 100 lines of code, make it a function! Write comments for your future self who has forgotten this codebase 3 years from now!), I'm not sure how to write clean, efficient code that follows good practices.
In other words, I'm always privating my repos because I'm not sure if I'm doing some horrible beginner inefficiency/bad practice where I should be embarrassed for having written it, let alone for letting other people see it. Aside from https://refactoring.guru, where should I be learning and what should I be learning?
The simplest advice I can give is to not ignore the compiler warnings. Sure your app may compile, but the warnings are there for a reason. Every warning is tech debt.
For following good practices, I highly recommend using a linter like ruff. I've learned a lot from it's explanations on why my code is bad.
Also I have tried to avoid using else statements.
how do you avoid using else, and why?
I think this is the kind of advice that if taken without context as a dogmatic approach, you'll get worse code.
There are ideas around "exit early" and "balanced branches"... But they're IMO a pretty low-value add, and the likelihood of misapplication is pretty high.
I'd be way more focused on designing for testibility.
If you focus on that, so many good design choices will fall out naturally.
Often the order that if/then are placed in can make 'else' unnecessary. "Exit early"is the guiding principle.
The reason to avoid 'else' is because if an if/then can be resolved in a few lines of code, it reduces nesting, which can make the code dramatically more readable and maintainable.
Disclaimer: I would only call my skill level as intermediate and would yield to any more senior developer here.
It's not a hard and fast rule, but you can usually write it without the else and in fewer lines.
So take for a very contrived example a function that needs to return a non boolean value for a boolean test. A use case could be if you need to figure out a string argument for another function, such as you need to determine if you need to keep the "first" or "last" duplicate in a dataframe (I'm thinking about pandas's df.drop_dupliactes method).
Continuing with the drop_duplicate thing let's say we have a dataframe we need to de-duplicate but for some reason if the overall length of the dataframe is even, we need to keep the first duplicate and if the dataframe length is odd we keep the last. I don't know why we would, but that was a very particular request from the customer and we need the money to buy more Warhammer figurines.
import pandas as pd # With else statement def foo(x: int) -> str: if x%2>0: return "last" else: return "first" # No else statement, shorter. def foo(x: int) -> str: if x%2>0: return "last" return "first" #import dataframe, deduplicate df = pd.read_csv("c:\\path\\to\\data.csv") dedup = df.drop_duplicates(keep=foo(len(df))
The already given advice is good: use linters, read.
However, just to say something different: Write a lot of code and do complex stuff. The reason you write code that "just works" is most probably because that's all you've needed.
Good code is good for a reason: it's maintainable. If you never write code that needs to be maintained, you're going to go uphill. If you write complex code you'll NEED to write maintainable code. After refactoring the same kind of code multiple times, you'll see why it is a bad pattern, and you'll learn good code because you need it.
Avoid "simple" languages like python or JavaScript. They let you patch old code too easily to work with new code, creating a mess of legacy code that you'll be afraid to touch. Rust, C++, Ada, java and many others are much less forgiving on bad code, specially due to their type system and compilers.
You should try to write code using SOLID principles. You should then write one using CUPID, try following OOP patterns, functional patterns and good old procedural ones. You should develope one huge code base and then try to maintain it for years. You should build a binary in Ubuntu, in alpine, in nixos, in Mac, in Windows and try to ship them to each other. You should run your code on a bare metal server and you should try writing lambdas. You should start a green field project and a try to maintain a legacy system that none of the original authors are there yet. You should write code in a company that hires 500 people per day and lays off in thousands. You should write code for a company that has 2 engineers that have been there for years. You should write a backend, a frontend , and one that does not do all these. And you should ship them. And use them. You should write codes idiomatically and you should write them idiotically.
The idea is not that a good programmer had done all these, the idea is that no simple tip or priciple can apply to every situation. Anyone claiming that, is no more than a snake's oil salesman. You should learn to code and design and engineer your software critically based on each situation. You should constantly learn. And you should not be afraid to go against the grain or break from the beaten path or go with the most popular mediocre choice.
It depends on what type of programming you’re doing.
But for OOP, my favorite patterns are composition over inheritance and dependency injection (with constructor injection). Once you know these two the rest will follow naturally, and your programs will turn more modular and easier to maintain.
One common misconception about dependency injection is that you need a framework for it. That’s not the case. Frameworks only make some stuff more convenient, but you can do without it.
Otherwise, I think the best way to learn is by doing. It’s easier to see why a pattern is important when you have first hand experience of how painful it is without it.
Edit: Avoid the book “Clean Code”. That book has just done more harm than good in the world.
I agree on doing. I don't think I've ever picked up a good coding practice by reading about it and doing it, I'm just not wired like that. Not that I didn't read good coding practices, but most of them I dismissed as overkill... until later when I realized that while working to reverse engineer and cleanup my old, ugly, code, I had independently "invented" a lot of those practices that I had originally dismissed.
That's the test right there imo, you can't really know how bad your code is until you've been away from it long enough to no longer have memory of your intentions on your side. "Wtf is this variable for again? When I figure it out I'll rename it to be more descriptive". "What? This function is doing way more than it's name implies. Tf was I thinking?"
The most important thing is that the codebase can grow without too much refactoring. Then you know you got the overarching design right. The rest then doesn't really matter that much. You can always rewrite certain parts when/if needed.
A good way to do this is by making the core really solid, this is called bottom up programming: https://paulgraham.com/progbot.html
I’m always privating my repos because I’m not sure if I’m doing some horrible beginner inefficiency/bad practice where I should be embarrassed for having written it, let alone for letting other people see it.
Well that's something not to do. Make you "horrible code" public, and ask people to do a code review. Or see what contributors want to change through a PR (if you're so lucky). You're not going to learn anything from others by hiding your mistakes. And no one besides you really cares if you're committing horrible code.
It's pretty hard to just give generic advice on how to write clean code, but if people can just tell specifically what you can improve it's much easier
In my opinion, this article is extremely valuable: https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/
You will not get through it without at least a Haskell cheatsheet, but the concepts it shows can (and should) be applied in any programming language, even if some are definitely more capable for this.
This might be a bit advanced, but indeed a very good article.
This might be contrary to some, but i recommend diagramming! Can be anything from paper doodles to d2 to full blown uml diagrams. They help you stay focused, and aware of the program's data dependencies.
Regarding code practices - read code. If you use a library for something, dive into its code. This can be beneficial in many ways - you observe the style they used, you understand better how the library works (documentation rarely contains enough detail), and you see how libraries are structured, which is often lacking in newbies.
Learn your language's idioms. They can reduce complexity, and are usually more readable to people with experience in the given language.
Finally, don't sweat it too much. The more you write, the better you'll become, so just do it. New problems lead to new insights.
Someone said it before: write for test-ability. I find that code which is easier to test, is easier to read.
Also, use a linter and a code formatter. Those can be used from the get-go. They cost little and will allow you to write code without thinking too much about what it looks like.
What more, I can recommend letting the code rest for a while after having written it (1 week or more), then try to read it again and see how well you understand your own code. You'll notice things like variable names being confusing, function names being non-descript or missing documentation, methods being too long, code branching too much, and so on.
And finally, ask for people to review the part of your code you are unsatisfied with. https://programming.dev/c/code_review isn't very active, but I check it sometimes and try to give advice when I can.
use sonarlint/sonarqube
Since the first lines of your linked site mention SOLID and design patterns, you're already onto the right stuff there. That's the framework side of things. Beyond that, I advise you to go study the advanced features of your preferred language so you know how to code "correctly" and idiomatically in that language (although not in a way that obscures intent). Then it's perhaps a mental hurdle to open your repos and know that all code has imperfections. Opening it may indeed help to improve it - code review is arguably the single most useful practice in code quality.
Read a book on writing good code. There are several ones available. It's a common thing. Especially for self-taught programmers. And also if you studied... Usually once you progress to complex projects or have to collaborate in bigger teams, you have to learn this. And that's also why there is a demand (and supply) of books on the subject.
And I always recommend books. They're a way better way to learn than most of the other stuff you'll find (in my eyes). And usually written by smart people and structured the right way to teach you something fast and effective. You'll get the whole picture (something you don't get when curating your information yourself), it takes like less than half of the time of watching online tutorial videos to finish a book including the assignments. And generally: learn it in a structured way if you want to move past the basics.
This is a very good comment for me because I usually hate tutorial videos with a passion. It's better with transcripts now, but it's still harder to CTRL+F a video for what I want. And like most human beings, I read faster than people talk in videos. I definitely have already been convinced as to how unsuitable videos are for me personally. I am glad they exist for people who can learn better that way, knowledge transmission is knowledge transmission, it's good that the creators made them to help people learn! But I'll spend an hour searching for articles and failing to find any before I give in and turn to the video that was the first result.
Do you have any book recommendations?
Do you have any book recommendations?
I think The Pragmatic Programmer by Andy Hunt and Dave Thomas is a great book everyone should read every couple of years. It's not really a lot of "low level coding tips" - more like overall paradigms
I myself don't have any. Most of the books I studied with were in German. But I saw plenty in the library. And it depends on what you want. There are some on specific programming languages, or design patterns, or concepts like object oriented programming ....
Practices and practice mean two different things here. Decide which you mean.
Please clarify on how they are different. I'm really confused by this comment and want to know what I'm missing.