The code below is one of my earliest Python codes and I find it terribly cute :3
My code input:
print("WELCOME TO PYPET")
bunny = {
"name" : "Muffy",
"hungry": False,
"weight": 5.4,
"age": 4,
"photo": "(-'.'-)",
}
bird = {
"name": "Bell",
"hungry": True,
"weight": 0.7,
"age": 2,
"photo": "(v)",
}
print("Hello " + bunny["name"] + "!")
print(bunny["photo"])
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ")
print("Hello " + bird["name"] + "!")
print(bird["photo"])
def feed(pet):
if pet["hungry"] == True:
pet["hungry"] = False;
pet["weight"] = pet["weight"] + 1
else:
print("The Pypet is not hungry.")
pets = [bunny, bird]
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ")
for pet in pets:
feed(pet)
print(pet)
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ")
print("It seems all is well here!")
print(bunny["photo"] + "<3 " + bird["photo"] + "<3 ")
My code output:
WELCOME TO PYPET
Hello Muffy!
(-'.'-)
Hello Bell!
(v)
The Pypet is not hungry.
{'name': 'Muffy', 'hungry': False, 'weight': 5.4, 'age': 4, 'photo': "(-'.'-)"}
{'name': 'Bell', 'hungry': False, 'weight': 1.7, 'age': 2, 'photo': '(v)'}
It seems all is well here!
(-'.'-)<3 (v)<3
A screenshot of my code input and output:
Run my Pypet program on Sololearn: https://www.sololearn.com/compiler-playground/cc7aEOtvMmUi
I do not feel the least bad about my old code. It is what it is. It was a start, my start and we all have to start somewhere!
Are you ashamed of your old code?
Top comments (41)
Not that much. After all, my old code is from when I had less experience. I sometimes rewrite my old projects, to help me learn more. Then I get more experience, and the cycle repeats. I'm sure I'm not the only person like that.
This is exactly what happens to me. =
As my mentor said just yesterday:
No offense, he is a tough one. And this was said in the context of an internal chat for devs with, at least, a few years of experience.
I want to assume good faith and file that under an invocation of the olympic motto "faster, higher, stronger". Yet, I am not sure if such a view point doesn't degrade into some kind of programmer machismo that in the end impedes growth in adjacent areas, that are of equal (if not higher) importance the more senior you get. Investing in programming alone yields diminishing returns.
I cannot agree or disagree with you here because I don't understand what you mean by programming. But it seems, that you are meaning "programming in small".
Certainly, I wasn't verbose enough about my mentor and our cool underground OOA/D cult.
I feel like this is a really bad take from an insecure person.
Why would you feel shame over your past contributions? Does your code not work? At least this would make sense to me, because if your implementation falls down after two months, then perhaps you were doing it wrong in the first place.
I mean, I did a lot of stupid s*t when I was younger, because I didn't know any better. If I was still doing the same stupid s*t now, I'd probably feel ashamed and it would be valid to say that I have not progressed as a human.
But come on! Why do you need to be ashamed of your past work in order to progress in your programming?
I don't feel ashamed of my eight year old because he can only count to 10 in binary: I feel proud, because he's able to count to 10 in base2! That's amazing for someone with little to no experience.
You should feel proud of your work and be kind to yourself. You delivered something that work(s/ed). It's the reason you're here today, and not quitting for another profession because some brogrammer flexed their muscles to make you feel inferior.
Hopefully your dev team are secure enough to ignore this kind of brain-rot being passed of as sage advice.
In our underground, Spartan-like software architects' school, we don't do wimps or whiners.
Everyone picks their own comfort zone, pace and their view from the window.
This is ours ยฏ_(ใ)_/ยฏ
Come on, if you're able to spot a major flaw in your programming or architectural decisions from just two months ago, and if you're brave enough to not only feel ashamed but also to rush in and fix it, that's a real reason to be proud of yourself :)
It is always easy to bring pawns up and "let it work for the time being, this is working innit"? naah))))
But of course, this is us, and unfortunately (or fortunately?), this approach and mindset doesn't work for most people. Everyone deserves to live their lives filled with happiness and joy. Keep spreading the love, my friend <3
Taking pride in being ashamed... how quaint.
What happens when you discover defects introduced by other team members? Does everyone in your team dogpile on them? In my experience these kinds of attitudes in teams don't produce wins: quite the opposite.
Also, does everyone in your team go to crush weights in the gym together, and do you go before or after throwing the wimps off the cliff? I'm dying to know so I can incorporate this into my routine :P
Spartans are famed for their military prowess, individuals putting aside their little egos and working together as a single unit - although mostly applied to enslaving the helots to do all of their work for them. The modern day software equivalent would be outsourcing your work to India and then showboating around while you take credit for the work.
It's a false equivalency to say that people who don't feel ashamed of defects in their software won't fix said defect. You don't need to be ashamed of yourself to roll up your sleeves and fix a problem, and not feeling ashamed of your past choices doesn't mean that you'll say, "Nah mate, she'll be right." In my experience it's usually the people who are ashamed of their mistakes who try and cover them up, not the other way around.
More to the point, the assumption that your code is "shit" is the only reason for defects to appear in your system is not a good starting point for resolving issues. Yes, I think it's healthy to assume that you are at fault and work on eliminating yourself as the cause first. But that's literally so you can avoid the blame game - not buy into it like your mentor seems to suggest.
Text book example would be a regression, which could have happened through no fault of your code, and possibly been introduced by someone else. So back to my first question, do you reach for the dunce's hat and pile on that person, or do you kindly explain what's happened and work with your team to resolve the issue?
Here's a thought: try skipping the pride and the shame and go straight for humility.
Anyway, point is that your decisions two months ago produced a working implementation and passed whatever checks and multiple stakeholder approvals to get shipped in the first place (this is a team sport).
And some friendly advice from a greybeard who has spent countless hours mentoring impressionable young lads such as yourself: get a mentor who is not shit and is secure in the fact that they have no clue. <3
It is a tale of two kitchens code does not age gracefully, even if it started out clean, it accrues technical debt over time. The decisions you made originally probably seemed like a good idea at the time.
We have all been there:
What does this do ๐ค๏ธ ?
What ๐๏ธ?
WTF ๐๏ธ?
WTAF ๐คฌ๏ธโ๏ธ
This is so wrong on so many levels ๐ก๏ธ !
How did this even work ๐คฏ๏ธ?
Who wrote this ๐ฉ๏ธ ?
Ooooooops ๐๏ธ๐คซ๏ธ๐ค๏ธ๐๏ธ
There's only one project that I can say I'm ashamed I wrote. It was a Computer Graphics class, and we had to implement simple low level graphics algorithms (drawing lines, polygons, clipping, etc) in a series of assignments. I chose to do it in the language I knew best at the time, Perl. It was definitely not my best work.
Besides that, no because I always tried my best, it did the job (and hence I got paid, when it was for work), and even mistakes are learning opportunities.
I used to be โ now I'm self-assured enough to be proud of my progress without much regard for shame for the old thing.
You can format your code by putting it inside backticks - here's a
Markdown cheatsheet about embedding code. It's particularly important for Python since whitespace is significant to the language and without using proper formatting, your program looks like it's all left-aligned :)
Not at all. When I or someone else looks at my old code, I hope they say, "You have come a long way."
Which is also an excellent way of saying I have learned and expanded my understanding of the problem I was solving.
This is also something I learned to get over real fast when I started live streaming development thanks to all the back seat coders :)
This is an excellent way of looking at your old code! I like to see my code this way as well :)
That is why someone invented Refactoring. The "old code" is your creation. It is to be approached, improved, refactored and then feel good about it. When you are done you know that you are a better programmer!
No I am not, It reminds me how far I came and I smile a little bit whenever I see my old works. Also my old projects are my fav I keep working on them whenever I got time and try to improve them as much as possible. And yeah its good.
In a word, no.
I do feel some negative emotions when previously working implementation stops working, even though it's remained unchanged for
[insert age of last commit here]... But never shame.If there is any emotion, thought or action that my previous work inspires in me, it's the same when one I experience when working with less knowledgeable or experienced developers: kindness.