[00:00] (0.16s)
10 programming mistakes that'll ruin
[00:02] (2.88s)
your life. Okay, I'm being a little
[00:05] (5.12s)
dramatic. Number one, skipping the
[00:07] (7.56s)
fundamentals. Wait, is this for real?
[00:09] (9.60s)
People do this. Please don't skip the
[00:11] (11.60s)
fundamentals. Look, I get it. You want
[00:13] (13.20s)
to learn how to code, be a cool kid,
[00:14] (14.96s)
automate your life, get rich or be
[00:16] (16.64s)
homeless, replace humans with AI, make
[00:18] (18.72s)
goofy looking games, whatever. But if
[00:20] (20.32s)
you don't understand the fundamentals
[00:21] (21.60s)
like variables, loops, and functions,
[00:23] (23.60s)
and a lot of other stuff that I uh can't
[00:25] (25.44s)
seem to remember, uh you're trying to
[00:27] (27.20s)
run before you can even crawl. Damn. How
[00:29] (29.52s)
do I know? Because I did that. Yeah.
[00:31] (31.92s)
Wait, is this for real? People do this.
[00:33] (33.60s)
Hi. If you're new to the channel, I'm a
[00:35] (35.20s)
terrible programmer. Now, here's what
[00:37] (37.44s)
actually happens when you skip the
[00:38] (38.80s)
fundamentals. You end up copy and
[00:40] (40.64s)
pasting code from AI without
[00:42] (42.24s)
understanding what it does. And then
[00:43] (43.68s)
when something breaks, and it will
[00:45] (45.36s)
break, you're completely lost. And not
[00:47] (47.36s)
only does it mess up your learning, it
[00:49] (49.04s)
could also affect your career. You're
[00:50] (50.48s)
going to become that developer who gets
[00:52] (52.08s)
exposed in a technical interview when
[00:54] (54.00s)
they ask you to explain a simple
[00:55] (55.36s)
concept. Now, I'm not going to lie to
[00:56] (56.64s)
you. The fundamentals are pretty boring
[00:58] (58.24s)
to learn. You don't get to build the
[00:59] (59.84s)
cool fancy stuff. You got to stick to
[01:01] (61.52s)
the boring stuff. But it is very, very
[01:04] (64.40s)
important. Once you survive the boring
[01:06] (66.00s)
stuff, you'll be able to create the cool
[01:07] (67.44s)
things way faster and it'll be way more
[01:09] (69.36s)
enjoyable because you actually know what
[01:10] (70.88s)
you're doing sometimes. So, please learn
[01:13] (73.12s)
these concepts. And if you don't, then
[01:14] (74.64s)
just put my fries in the back. Number
[01:16] (76.00s)
two, writing clever code over readable
[01:18] (78.64s)
code. This one's mainly inspired by
[01:20] (80.56s)
those leak code gods who drop oneline
[01:22] (82.80s)
Python solutions in the forums because
[01:25] (85.12s)
what are these? And you know what? I
[01:27] (87.04s)
respect it. These people are definitely
[01:29] (89.12s)
geniuses, but I'm not. These answers
[01:31] (91.52s)
look like they're speaking Minecraft
[01:32] (92.96s)
Enchantment Table to me, and I love the
[01:34] (94.80s)
people that post these, but bro, please.
[01:36] (96.96s)
Your solutions have given me more brain
[01:39] (99.04s)
damage than the actual lead code
[01:40] (100.72s)
problem. I mean, yeah, these oneliners
[01:42] (102.24s)
are cool and all, but please never ever
[01:44] (104.80s)
write code like that in an interview or
[01:46] (106.64s)
in an actual codebase. Your interviewer
[01:48] (108.88s)
is not going to stand up, slow clap, and
[01:51] (111.12s)
make you the CEO. They're just going to
[01:52] (112.56s)
stare at your code like you just
[01:54] (114.00s)
committed a war crime. If it takes an
[01:55] (115.92s)
entire YAP session to explain your code,
[01:58] (118.16s)
it might be too clever. Unless the code
[01:59] (119.84s)
has crazy performance benefits and it
[02:02] (122.24s)
can't be rewritten in a readable way,
[02:04] (124.24s)
there is zero reason to make your code
[02:06] (126.48s)
look like a cross word puzzle. Oh, and
[02:08] (128.16s)
by the way, if you're interested in
[02:09] (129.36s)
programming and you want to learn more
[02:10] (130.64s)
tips and tricks, you should check out my
[02:12] (132.00s)
newsletter, Sloth Bites. Oh, you don't
[02:13] (133.44s)
know what Sloth Bites is? Sloth Bites is
[02:15] (135.76s)
my weekly newsletter where I share
[02:17] (137.12s)
byite-size programming information every
[02:19] (139.04s)
week to make you a better programmer.
[02:20] (140.88s)
And the best part about it, it's free.
[02:22] (142.48s)
All you have to do is give me your
[02:23] (143.84s)
email. I won't do anything with it. I
[02:26] (146.44s)
promise. Number three, being afraid to
[02:29] (149.60s)
break things. You know, when I started
[02:31] (151.28s)
out, I treated my code base like a bomb.
[02:33] (153.44s)
I was scared that one wrong move and
[02:35] (155.20s)
this project was But I learned
[02:37] (157.20s)
something. The best way to learn is by
[02:39] (159.20s)
breaking things, change a value, break a
[02:41] (161.12s)
feature, refactor if possible, see what
[02:43] (163.52s)
happens. You're not going to destroy the
[02:45] (165.04s)
universe. Your project probably isn't
[02:46] (166.72s)
even public or has any users, so who's
[02:48] (168.80s)
going to notice? Now, I know this sounds
[02:50] (170.08s)
counterintuitive, but the moment I
[02:51] (171.84s)
stopped trying to write quote unquote
[02:53] (173.60s)
perfect code and just started
[02:55] (175.04s)
experimenting, that's when things
[02:56] (176.64s)
started to click and I was making real
[02:58] (178.80s)
progress. If you learn how to mess
[03:00] (180.32s)
around without fear, you're going to
[03:01] (181.76s)
learn 10 times faster than someone who
[03:03] (183.60s)
just reads tutorials and tiptoes around
[03:05] (185.36s)
their own project. Now, uh before you
[03:07] (187.60s)
start breaking things, please learn
[03:08] (188.96s)
version control with Git. Version
[03:10] (190.32s)
control is basically the programming
[03:12] (192.00s)
equivalent to a quick save. And once you
[03:13] (193.92s)
learn Git or you have some sort of
[03:15] (195.60s)
backup, start testing things out. Now,
[03:17] (197.20s)
if you do mess up something, worst case
[03:18] (198.88s)
scenario, you just hit control-z. Or if
[03:20] (200.96s)
you know how to use get and branches
[03:22] (202.48s)
correctly, just switch and delete that
[03:24] (204.16s)
branch into the void. If anything, just
[03:25] (205.76s)
delete the whole folder and start fresh
[03:27] (207.36s)
because you probably only had hello
[03:28] (208.80s)
world written. Number four,
[03:30] (210.76s)
overengineering. I swear every
[03:33] (213.12s)
programmer has fallen into this trap
[03:35] (215.04s)
hard. I know I did. You see this book
[03:37] (217.04s)
right here? Design data inensive
[03:38] (218.72s)
applications. This starts every
[03:40] (220.64s)
programmer's descent to overengineering.
[03:42] (222.88s)
Okay, it's not just this book. There's a
[03:44] (224.32s)
lot of other reasons. I remember I was
[03:45] (225.68s)
in a whole system design and scaling
[03:47] (227.28s)
phase. So I was really into reading
[03:49] (229.28s)
engineering blogs where I understood
[03:51] (231.20s)
like 20% of the information and um one
[03:53] (233.84s)
time I was reading Discord's engineering
[03:55] (235.92s)
blog and I thought you know what what if
[03:57] (237.76s)
I built a full Discord clone using this
[04:00] (240.24s)
blog and try to copy their architecture
[04:02] (242.40s)
all of it. Needless to say the project
[04:04] (244.80s)
died before it even rendered a login
[04:07] (247.20s)
screen. But once you have some
[04:09] (249.04s)
experience programming and you start
[04:10] (250.48s)
moving away from the beginner stuff, you
[04:12] (252.08s)
start learning these best practices and
[04:13] (253.84s)
all these fancy system design techniques
[04:15] (255.68s)
and technologies that enterprise
[04:17] (257.76s)
companies use. And now every time you
[04:19] (259.44s)
want to build a personal project, you
[04:20] (260.96s)
start to think about these concepts and
[04:22] (262.48s)
think, I should build it like these
[04:23] (263.84s)
enterprise companies because that's how
[04:25] (265.52s)
real engineers do it. And now all of a
[04:27] (267.36s)
sudden your project needs microservices
[04:29] (269.28s)
for every tiny function, multiple
[04:31] (271.28s)
specialized databases, message cues,
[04:33] (273.52s)
elastic search, cafka, blah blah blah
[04:35] (275.36s)
blah. But you start to forget some
[04:36] (276.48s)
things. One, the reason these companies
[04:38] (278.24s)
made these decisions is because they had
[04:40] (280.40s)
to. Two, they evolved to this complexity
[04:42] (282.96s)
over years, not days. Three, they have
[04:45] (285.68s)
entire teams dedicated to each
[04:48] (288.00s)
component. Four, they're serving
[04:50] (290.08s)
millions of users. Your project is
[04:52] (292.32s)
serving one yourself. Please don't
[04:54] (294.88s)
overengineer your projects. Now, my
[04:56] (296.80s)
advice to you, if you're in this
[04:58] (298.08s)
overengineering phase or you're starting
[04:59] (299.92s)
to reach it, don't worry about this
[05:01] (301.60s)
stuff unless it's for system design
[05:03] (303.04s)
interviews or, you know, you need it. If
[05:05] (305.12s)
you're actually trying to implement this
[05:06] (306.48s)
in a side project, you're going to waste
[05:08] (308.16s)
some time. I'm not going to lie. But if
[05:09] (309.84s)
you're doing this purely just to learn,
[05:12] (312.00s)
just for the love of the game, go ahead.
[05:13] (313.68s)
Bonus mistake. Using Gmail. What? Okay.
[05:17] (317.12s)
Honestly, I just don't know how to sneak
[05:18] (318.40s)
this in. Sneak one in. Today's sponsor,
[05:20] (320.56s)
Notion. Woo. Look, we all know email is
[05:22] (322.72s)
a nightmare. Your inbox is probably a
[05:24] (324.64s)
mess right now with hundreds of unread
[05:26] (326.24s)
messages you're pretending don't exist.
[05:27] (327.76s)
Notion realized this problem and they
[05:29] (329.36s)
created Notion Mail. Notion Mail is one
[05:31] (331.44s)
of the first emails that organizes your
[05:33] (333.20s)
inbox, draft responses, and schedule
[05:35] (335.20s)
meetings exactly how you wanted, helping
[05:37] (337.12s)
you get back to the real work. It's easy
[05:38] (338.80s)
to get started as well. All you have to
[05:40] (340.24s)
do is connect your existing Gmail
[05:41] (341.68s)
account, and you'll upgrade your email
[05:43] (343.12s)
experience for free. Check out some of
[05:44] (344.72s)
the cool features. Instead of having to
[05:46] (346.24s)
manually categorize emails with stars
[05:48] (348.16s)
and labels, Notion Mail automatically
[05:49] (349.92s)
labels and sorts incoming emails based
[05:51] (351.76s)
on what's important to you. I love this
[05:53] (353.68s)
feature. I use this for my newsletter
[05:55] (355.36s)
when people reply to it. I don't have to
[05:56] (356.96s)
manually label them and I don't have to
[05:58] (358.56s)
scroll through hundreds of emails to
[05:59] (359.76s)
find those responses. It's great. And
[06:01] (361.20s)
one of my favorite features, you can use
[06:02] (362.72s)
AI to help you write emails. You can use
[06:04] (364.72s)
their suggestions or if you need to
[06:06] (366.08s)
adjust your tone or check your grammar,
[06:07] (367.52s)
you can ask AI to help you out. And of
[06:09] (369.20s)
course, you can write your emails using
[06:10] (370.80s)
the same clean Notion editor you already
[06:12] (372.64s)
know. So, if you want to try out Notion
[06:14] (374.16s)
mail and upgrade your email experience
[06:15] (375.68s)
for free, click the link in the
[06:17] (377.12s)
description. Number five, forgetting
[06:19] (379.36s)
that users are not developers. You know,
[06:21] (381.76s)
a lot of programmers live in a weird
[06:23] (383.60s)
bubble where they think everyone
[06:25] (385.36s)
understands technology like them. Well,
[06:27] (387.28s)
guess what? They don't. You can build a
[06:29] (389.68s)
website that you think is super
[06:30] (390.96s)
intuitive and then you watch someone
[06:32] (392.32s)
else use it and they somehow break it.
[06:34] (394.32s)
This happens every single time. Regular
[06:36] (396.96s)
people are going to give you a reality
[06:38] (398.72s)
check. You might think hamburger menus
[06:40] (400.88s)
are universal knowledge. It's not. Try
[06:43] (403.68s)
asking your grandma or grandpa. They're
[06:45] (405.92s)
going to look for an actual hamburger
[06:47] (407.60s)
menu. And here's an unfortunate truth.
[06:49] (409.84s)
The more time you spend programming, the
[06:51] (411.76s)
worse you become at predicting how
[06:53] (413.28s)
normal people use your software because
[06:55] (415.12s)
you've been brainwashed with technical
[06:56] (416.72s)
knowledge. So remember, try to make
[06:58] (418.80s)
websites that make sense for regular
[07:00] (420.96s)
people because they touch grass, unlike
[07:03] (423.68s)
us. Number six, starting too big.
[07:07] (427.12s)
Imagine you have a big project idea. The
[07:09] (429.36s)
productivity app to end all productivity
[07:11] (431.92s)
apps. It's going to have real-time
[07:13] (433.76s)
syncing, cananband boards, calendars,
[07:16] (436.24s)
habit tracking, pomodoro timers, AI task
[07:18] (438.96s)
suggestions, and you know what? Maybe
[07:20] (440.56s)
it'll even order you breakfast. You open
[07:22] (442.56s)
up your code editor full of hopes and
[07:24] (444.24s)
dreams. You write a readme file
[07:25] (445.68s)
explaining what the app will do if you
[07:27] (447.60s)
ever finish. You're trying to set up
[07:28] (448.96s)
your database schemas for 18 different
[07:30] (450.72s)
features, and all of a sudden, you
[07:32] (452.56s)
stall. You burn out. You question your
[07:34] (454.88s)
entire existence. You think you're a bad
[07:36] (456.88s)
programmer. You stop programming. The
[07:38] (458.88s)
project dies. You die. Now, here's some
[07:40] (460.88s)
advice to a lot of you. Start small,
[07:43] (463.60s)
feature by feature. Focus on one thing,
[07:46] (466.40s)
one small thing. Like literally just
[07:49] (469.04s)
making a button. For example, you want
[07:50] (470.72s)
to do a note-taking app. How about you
[07:52] (472.24s)
start with, oh, I don't know, creating
[07:54] (474.48s)
note. Make that one thing solid. Don't
[07:56] (476.64s)
worry about any other features. If you
[07:58] (478.40s)
start worrying about a lot of other
[07:59] (479.60s)
features, you know what that's called?
[08:00] (480.96s)
Feature creep. Nobody likes feature
[08:02] (482.96s)
creep. Don't fall into that trap. The
[08:04] (484.88s)
features you want, those can come later,
[08:06] (486.88s)
or maybe not at all. If you're trying to
[08:08] (488.88s)
build everything all at once, you're
[08:10] (490.72s)
just going to end up with 5% of a mega
[08:12] (492.72s)
project and 95% of a mental breakdown.
[08:15] (495.12s)
This is why I personally like the MVP
[08:17] (497.28s)
approach. Minimum viable product if you
[08:19] (499.36s)
didn't know. This isn't just startup
[08:20] (500.80s)
jargon. Well, nah, you can decide that
[08:22] (502.72s)
one. It's honestly the only way most of
[08:24] (504.56s)
us will ever finish anything. But I do
[08:26] (506.32s)
have to say this, MVP does not mean
[08:29] (509.28s)
garbage app. It's just a smaller app
[08:31] (511.60s)
that works properly. Build the simplest
[08:34] (514.08s)
version that does one thing well and
[08:36] (516.00s)
then add features one by one. If I can't
[08:38] (518.24s)
describe my project in one sentence,
[08:40] (520.16s)
it's too big. Scale it down before you
[08:42] (522.24s)
end up with another abandoned GitHub
[08:43] (523.92s)
repo. Number seven, no comments or
[08:46] (526.68s)
documentation. The four lies every
[08:48] (528.96s)
programmer tells themselves. Number one,
[08:51] (531.04s)
I'll remember what this does. Number
[08:52] (532.80s)
two, it's obvious what this code is
[08:54] (534.64s)
doing. Number three, the code is the
[08:56] (536.80s)
documentation. Number four, I don't need
[08:59] (539.20s)
to document this. Do not lie to
[09:01] (541.12s)
yourself. Add documentation, please.
[09:04] (544.08s)
What does documentation look like? A
[09:06] (546.00s)
readme file would be greatly
[09:08] (548.00s)
appreciated. Comments that explain why,
[09:10] (550.88s)
not what. Here's a test that'll help you
[09:13] (553.04s)
out. If someone with reasonable
[09:15] (555.12s)
programming skills, but zero knowledge
[09:16] (556.96s)
of your project can understand what your
[09:18] (558.72s)
code does, you've documented pretty
[09:20] (560.40s)
well. If not, you must be a massochist
[09:22] (562.72s)
because you clearly love pain. Number
[09:24] (564.72s)
eight, reinventing the wheel. We've all
[09:27] (567.44s)
been here. You need something for your
[09:29] (569.20s)
project, but instead of using one of the
[09:30] (570.88s)
5,000 existing solutions, you decide to
[09:33] (573.04s)
build your own from scratch because it's
[09:34] (574.64s)
not that complicated. Stop right there
[09:37] (577.20s)
because you're wrong. Trust me, someone
[09:39] (579.68s)
already solved this problem better than
[09:41] (581.44s)
you ever will. The only time you should
[09:43] (583.52s)
do this is if you actually want to learn
[09:45] (585.36s)
how something works or you have some
[09:47] (587.28s)
weird edge case or requirement that
[09:49] (589.20s)
these libraries can't handle right now.
[09:51] (591.20s)
But if you don't care about it, don't
[09:52] (592.88s)
make it from scratch. It's a complete
[09:54] (594.88s)
waste of time. Unless you're one of
[09:56] (596.72s)
those rare 0.1% engineers that have
[09:59] (599.20s)
skills, then please make our lives
[10:01] (601.28s)
easier. We need it. But for the rest of
[10:03] (603.52s)
you, your authentication system is not
[10:05] (605.84s)
better than a lot of these libraries.
[10:07] (607.60s)
Trust me, many have tried. Number nine,
[10:11] (611.12s)
comparing yourself to other programmers.
[10:13] (613.44s)
You open up Twitter or X, I guess, and
[10:15] (615.92s)
boom, I built a SAS in 4 hours, made 10K
[10:19] (619.44s)
in a week, quit my job, and now I surf
[10:22] (622.00s)
in Bali every morning. And then you
[10:23] (623.84s)
scroll down and see some 16-year-old
[10:25] (625.52s)
like, "While you're all applying to
[10:26] (626.88s)
colleges, I just launched my third AI
[10:29] (629.12s)
startup." Meanwhile, you're here trying
[10:30] (630.96s)
to figure out why your calculator is
[10:32] (632.80s)
adding numbers like this. And look, I've
[10:34] (634.56s)
been there. I'm still there. It feels
[10:36] (636.16s)
like everyone else is sprinting while
[10:37] (637.76s)
you're still trying to learn how to tie
[10:39] (639.04s)
your shoes. But here's what you need to
[10:40] (640.88s)
remember. You're watching everyone
[10:42] (642.64s)
else's highlight reel while you're
[10:44] (644.24s)
living through your own blooper reel.
[10:45] (645.92s)
You did not see the 300 hours they spent
[10:48] (648.48s)
debugging, the projects they abandoned,
[10:50] (650.40s)
or the existential crisises they had at
[10:52] (652.24s)
2 a.m. wondering if they should have
[10:53] (653.60s)
gone to law school. So instead of trying
[10:55] (655.04s)
to compare yourself to them, compare
[10:56] (656.72s)
yourself to what you were like 3 months
[10:58] (658.40s)
ago. Are you improving? Are you learning
[11:00] (660.16s)
new things? Are you making fewer
[11:01] (661.60s)
mistakes? That's what truly matters.
[11:03] (663.84s)
Number 10, having shiny object syndrome.
[11:06] (666.64s)
This is what shiny object syndrome looks
[11:08] (668.32s)
like. You start working on a project.
[11:09] (669.92s)
You make decent progress. You see a cool
[11:11] (671.84s)
article or video about a technology. You
[11:13] (673.76s)
abandon your project to learn the
[11:15] (675.28s)
technology. You start a new project with
[11:17] (677.12s)
the new technology. You see another cool
[11:18] (678.96s)
article or video about a different
[11:20] (680.56s)
technology. You abandon that project to
[11:22] (682.64s)
learn this new technology. And you're
[11:24] (684.24s)
going to repeat this until you realize
[11:25] (685.92s)
you have it or until you quit
[11:27] (687.52s)
programming. Here's some signs you have
[11:29] (689.12s)
shiny object syndrome. You have more
[11:30] (690.96s)
projects than lines of code written. You
[11:32] (692.72s)
can write Hello World in 12 different
[11:34] (694.32s)
languages, but you can't build an app in
[11:36] (696.08s)
any of them. 40 different ultimate
[11:37] (697.76s)
guides to random technology articles
[11:39] (699.44s)
that you'll read later. You'll never
[11:41] (701.20s)
read them. Pick one thing and commit to
[11:43] (703.68s)
it. If you make any of these mistakes,
[11:45] (705.60s)
you're a terrible programmer. And I know
[11:47] (707.52s)
this because I've made all these
[11:49] (709.04s)
mistakes and I'm a terrible programmer.
[11:51] (711.12s)
See you in the next video.
[11:52] (712.43s)
[Music]