Episodi
-
Today, we bring you the final episode of the first season of Backend Banter! It’s a wrap up for now. With 69 episodes behind us, we want to tell you the story of Boot Dev and how far we’ve come from our beginnings, and for that, we bring Allan Lires, the first official employee and the second person to work on our platform!
We’re going to cover our entire timeline, achievements, hardships, how Lane and Allan were able to go all-in on building Boot Dev and our visions and plans for the future.
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Allan's X/Twitter: https://x.com/AllanLires
Boot.Dev Discord: https://discord.com/invite/EEkFwbv
Timestamps:
00:00 Intro
00:01 Last episode of Season 1 of Backend Banter
01:45 Boot.dev Story and what this episode will be about
02:26 How and when Allan was hired to work at Boot.dev
05:33 Timeline on Boot.dev
08:53 Guessing game
10:34 The Rebranding Process
12:43 Going Full-time
14:56 What was the curriculum in the beginning?
18:38 What was the original vision for Boot.dev
19:17 Being honest about how long it'll take you to learn to code
22:48 Setting expectations for difficulty
29:55 On learning the fundamentals
34:42 The Long Term vision of Boot.dev
41:30 Old gamification features and why we changed them
50:26 The Track is Never Complete
55:01 We cover a lot of the basics that traditional colleges don't cover
01:00:06 Why do we want to remove JavaScript from the learning course
01:06:12 Million Lessons Completed in a single month
01:08:28 You got to be comfortable being uncomfortable
01:13:25 Where to find Allan
-
Today we welcome Chuck Carpenter aka Charles The 3rd, co-host at Whiskey Web and Whatnot.
As two content creators in the tech scene, we discuss if and how celebrity developers and tech influencers are a good thing for the community, how we should be careful when choosing technologies based on influencers’ opinions, why so many people nowadays want to speedrun their whole career and how that could be self-sabotage, and a lot more!
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Whiskey Web and Whatnot: https://whiskey.fm/
Charles' X/Twitter: https://x.com/charleswthe3rd
Timestamps:
00:00 Intro
01:27 Does Charles listen to his own podcast episodes?
03:33 Are celebrity developers a good thing?
09:11 Podcasts are usually centered around a business
10:06 We are essentially entertainers
14:04 Tech choices being influenced by creators
17:37 Why ThePrimeagen stood out from other tech influencers
20:26 Career speedrunning
23:44 The biggest miss when starting something
24:51 What is wrong with Full-Stack application frameworks?
29:03 How Frankenstein is the Boot.dev web application stack
37:41 Rolling your own stuff vs using a provider
46:01 It's easy to screw up your architecture
50:53 What is Charles building with in 2024 and what is his preferred stack
56:39 Does it seem like people don't talk about security anymore?
01:00:30 Accessibility
01:02:02 The amount of people that are "kinda" interested in cybersecurity
01:11:03 Have some patience
01:11:37 Where to find Charles
-
Episodi mancanti?
-
In today’s episode, we bring back Aaron Francis. If you haven’t watched our previous episode with him, he is a software developer, fellow content creator and co-founder of Try Hard Studios. In the past he’s been an accountant at a Big 4 but now he focuses on Laravel, web development and all things business and video.
This episode will step away from the usual tech focused content and we’ll talk a bit more about the business side of things, how you have to balance entertainment and education when creating courses, Aaron’s High Performance SQLite course, building a personal brand through the discomfort of centering it around yourself, how good presentation matters and how proactiveness puts you miles ahead of the majority, so stay tuned!
Learn back-end development - https://www.boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Aaron's X/Twitter: https://x.com/aarondfrancis
Aaron's Website: https://aaronfrancis.com/
High Performance SQLite: https://highperformancesqlite.com/
Screencasting: https://screencasting.com/
Mostly Technical Podcast: https://mostlytechnical.com/
Timestamps:
00:00 Intro
01:32 Podcast listening going up when having a kid
02:25 Podcast about earning the first million
08:54 You have to choose the entertainment vs education levels
10:37 You have to shape your material to the platforms
16:40 Long hour videos vs 2 minute ones
20:16 Are the videos in the High Performance SQLite in linear order?
24:19 Figuring out the metrics
28:06 Building courses on other domains
31:46 Building brands is difficult
35:55 quick disclaimer
36:30 Personal brand vs company
37:57 Is this sellable?
40:23 Do you need an audience?
44:26 The strategy is simple but it is also hard to execute
49:31 The presentation matters a LOT
51:54 On being proactive
57:00 Where to find Aaron
-
In today’s episode, we bring Adam Argyle, a CSS Dev Rel at Google, content creator, co-host at CSS Podcast, Bad At CSS Podcast and host of GUI Challenges. He’s also the creator of a bunch of tools and utilities for the front-end.
We’re going to touch on a lot of hot topics, regarding the difficulty and power of CSS, how programmers most of the time underestimate and dismiss it as something trivial when in reality it’s one of the hardest things to master in the programming world. We also go over AI, the barriers between designers and developers and a bunch of other topics.
Learn back-end development - https://www.boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Adam's Website: https://nerdy.dev/
Adam's X/Twitter: https://x.com/argyleink
Adam on Chrome For Developers: https://chromeextensionsdocs.appspot.com/authors/argyle/
The CSS Podcast: https://thecsspodcast.libsyn.com/
Bad at CSS Podcast: https://badatcss.com/
Timestamps:
00:00 Intro
00:51 CSS Wizard has entered the chat
02:37 HTML and CSS are not programming languages
07:44 There's a case for complex things using CSS
10:28 CSS is declarative by nature
17:58 Writing CSS is a pain
20:43 AI isn't a threat to CSS
21:19 Breaking barriers between designers and developers
26:33 Getting to an entry-level competency on the backend is a bit more difficult when compared to the frontend
31:37 Adam's backstory
33:40 Knowing everything
34:56 The majority of the complexity lives on the frontend a lot of the times
38:48 South Park Reality
39:49 BFF vs BOF (Backend for frontend vs Backend of the Frontend)
47:03 CSS is typed in the browser
51:28 Take on why are there so many mormons and ex-mormons in the webdev and tech influencer scene?
54:08 Where to find Adam
-
In today’s episode, we welcome Matt Pocock, an educator, content creator and engineer who used to be a voice coach. Now, he teaches Typescript on his YouTube channel and is building Total Typescript, the most comprehensive TypeScript course available out there.
We talk about his transition from a completely unrelated field into tech, the importance of great communication, TypeScript’s future, AI tooling and job hunts! A lot more else is covered in this video, so get cozy and tune in into this gem of an episode!
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Matt's X/Twitter: https://x.com/mattpocockuk
Total Typescript: https://www.totaltypescript.com/
Timestamps:
00:00 Intro
01:15 What did Matt do before becoming a dev?
03:15 Career Transitions from a non-math background
04:02 What makes a good programmer?
06:46 Math knowledge > great communication?
08:55 On writing elaborate PR's
09:58 OCaml my Typescript
11:00 What is Typescript's Future?
14:21 Python type hinting and JSDoc
20:36 null vs undefined
25:02 interfaces vs type aliases
32:35 Does Matt have any rules of thumb when working with types?
37:14 How do you build nice encapsulated components with no external dependencies?
43:43 AI tooling integration
46:15 Will there be fewer jobs?
52:00 How often do you use classes?
54:29 Where to find Matt
-
In today’s episode, we welcome Lawrence Lockhart, a former hospitality manager turned full stack software developer. Apart from his tech job, he’s also a developer advocate, a teaching assistant at a coding bootcamp and a tech meetup leader, so you know he spends a lot of his time helping others build and transfer their existing skills into tech, being a powerful voice in the tech space for upcoming developers.
Today we talk briefly about how he managed to switch from hospitality to tech, and how that wasn’t as easy as a lot of people online make it out to be, the importance of local and in-person jobs as opposed to starting off remote, how learning with purpose is essential if you want to make progress and advice for people starting out!
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Code Connector: https://codeconnector.io
Lawrence's X/Twitter: https://x.com/LawrenceDCodes
Lawrence's TikTok: https://www.tiktok.com/@lawrencedlockhart
Timestamps:
00:00 Intro
00:44 When did Lawrence start to be more involved in the online tech communities?
02:23 How did Lawrence meet James Q Quick
04:42 Transition from a Blue Collar job into Tech
10:59 6 months is not the standard anymore to get in the industry
13:44 The Timeline Discussion
15:56 Kelsey Hightower
18:09 Has Lawrence worked as a dev in non-tech companies and where he works now
23:33 It's IMPORTANT to go for local market and in-person jobs first
24:27 How networking actually works
28:46 Learning with a purpose
36:43 You shouldn't be trying to minmax your career path
39:43 Advice to people that are unsure in their skills
43:51 How to approach interviews
49:31 You have to practice interviewing
54:48 Learn the thing or get out
58:33 Disagree and commit
01:01:45 Where to find Lawrence
-
In today’s episode, we bring Spiro Floropoulos, a senior developer and architect with over 20 years of experience. This episode is an unusual one, as Spiro recently got laid off due to a bizarre chain of events that involved HTMX, overworking, and technical debt.
But we’ll learn from this story, as we want to shed some light on how situations that Spiro described could be avoided, namely how the tech industry is obsessing over developer experience and why that’s detrimental, why abstractions should be teaching you the technology as opposed to just doing the work for you, why you should be able to train your junior devs and much more!
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Spiro's X/Twitter: https://x.com/spirodonfl
Spiro's Website: https://spirofloropoulos.com/
Timestamps:
00:00 Intro
00:35 Why are we having this conversation
01:33 How was HTMX involved in this?
03:38 Spiro's background
05:58 Why are we focusing so much on developer experience?
13:38 The Tech Industry as a whole is headed down the wrong path
16:17 Abstractions teaching you about the underlying technology rather than hiding it
18:47 What are the long-term consequences of unresolved technical debt?
26:46 There's things you can't blame frameworks for
28:27 We have to slow down
30:46 What happened after the introduction of HTMX into the project?
40:26 Hiring juniors is great, but you should have the resources to train them
47:00 The Technical Debt
50:32 The more complex the feature became, the bigger the struggle with HTMX
53:42 The reasons why Spiro was let go
57:10 Instead of Agile we should treat our programmers like adults
57:31 HTMX was instant and testing ability was better
01:01:21 Is Spiro looking for work?
01:02:00 Where to find Spiro
-
In today’s episode, we go to war with Sam Selikoff, co-host of the Frontend First podcast, and specialist on everything Frontend related.
We have an amazing conversation where we discuss Sam’s journey, as he also did some backend work in the past, we talk about abstractions, what JavaScript is doing differently from other languages and frameworks, why the frontend should be driving the backend and not the other way around, and finish it off with a discussion about RSCs (React Server Components).
Learn back-end development - https://www.boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Frontend First: https://frontendfirst.fm/
Sam's X/Twitter: https://x.com/samselikoff
Sam's Youtube: https://www.youtube.com/samselikoff
Timestamps:
00:00 Intro
00:51 Who is Sam Selikoff
02:12 Abstractions - Should you go a level deeper?
06:37 What was Sam's talk about
10:51 What is JavaScript doing differently?
19:10 Do you want the frameworks to push more features out of the box for backend work?
24:04 Strong opinions on a library level
30:29 Shipping more standardized interfaces
37:06 The frontend should be driving everything in the backend
39:12 Your types should flow from the database to the frontend, but not the product decisions
46:53 React Server Components
58:49 Where to find Sam
-
Today we bring Thomas Ballinger, a developer at Convex, an open-source backend for application builders. We will be discussing mainly databases, and why at Convex they use Rust and Typescript.
We'll also talk about systems scalability, infrastructure and go over different practices regarding abstractions
Learn back-end development - https://www.boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Convex: https://www.convex.dev/
Thomas' X/Twitter: https://x.com/ballingt
Thomas' Website: https://ballingt.com/
Timestamps:
00:00 Intro
00:33 Thomas' background
02:29 Convex - what it is and why should you use it?
03:16 What are query planners?
06:32 SQL is a very high level language
07:43 The primary differentiator of Convex
10:49 Who are Convex's biggest competitors?
14:20 How do you build the infrastructure
17:11 What type of database is Convex?
19:18 Why is Convex written in Rust?
23:35 Cheap abstractions
25:47 Productivity suffering from compile times
29:47 The different approaches for a backend developer to build scalable systems
32:28 Backend for Frontend
37:21 You want to be close to your data
42:13 Are there plans to support other languages at Convex?
47:06 Does the schema update the autocompletion in the editor
48:31 Naming and behavior of the queries with Convex
51:06 Why sqlc is great
52:28 Why TypeScript is a great "shortcut" for Convex
59:34 Where to find Thomas
-
Today we bring anothe returning guest, Adam Elmore! An AWS Hero, Teacher and fellow content creator! You might notice today's talk is a bit different, as we don't cover too much technical details but we do cover a lot of other interesting topics that permeate our everyday lives, such as kids and family time, religion and purpose in life...
But don't worry, we also share some hot takes on indie hackers, business models of education platforms and finally content creation and how it can help you propel your career!
Learn back-end development - https://www.boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Adam's Twitter: https://x.com/adamdotdev
Adam's Youtube: https://www.youtube.com/@adamdotdev
ProAWS: https://www.proaws.dev/
Timestamps:
00:00 Intro
01:42 Terminal Coffee
06:42 Kids' books
09:00 How serious is the Terminal Coffee business
12:51 Indie Hackers
19:11 Books
23:42 The March of Time
25:56 Commitment to the lessons
27:21 The problem with course platforms
28:31 ProAWS
35:45 The education industry isn't as cutthroat as it seems
39:13 What's Adams plan of attack with the courses?
40:00 How does streaming affect Adam?
44:05 Who is Adam's audience?
44:44 Podcasting
47:34 Who is TomorrowFM targeted at?
49:14 Burnout in podcasts
52:01 Growing up religious
57:34 Would you say that you've distanced yourself from religion for epistemological or cultural reasons?
01:03:00 Throwing the religious labels out
01:13:03 Where to find Adam
-
In today's episode, we bring back James Q Quick. Last time we talked about his best tips to land your first ever job as a developer. Today we talk about James' new startup and how he manages all his new tech adventures with being a parent and also provides some helpful insight as to why having an audience and personal connections in the industry is beneficial - but not strictly necessary to succeed.
We also talk about AWS, abstraction and the current (healing) state of layoffs, so don't lose hope if you're demotivated in your job search.
Learn back-end development - https://www.boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Deals for Devs: https://www.dealsfordevs.com/
James' Website: https://www.jamesqquick.com/
James' Twitter: https://x.com/jamesqquick
James' Youtube: https://www.youtube.com/@JamesQQuick
Timestamps:
00:00 Intro
00:55 On being a parent
04:28 Idiocracy
05:47 Deals for Devs
10:09 Comparison with Dixie Direct
12:22 How do you quantify the really high quality deals
15:57 The challenge with a two-sided marketplace
22:28 Doing stuff manually is actually pretty good
25:38 Having a personal connection helps A LOT
29:12 Zeta
34:05 The Web is being modeled on AWS
36:38 You shouldn't be learning one JavaScript framework
38:30 Know how to answer a question if you don't know the technology
41:43 When you learn to code, how much layers of abstraction you should go?
43:45 Should passion be required for a job in tech?
49:02 The state of layoffs
52:29 The ease of finding a job after a layoff when you're highly talented
55:58 Do you need an audience to find a job easily?
58:40 Developers of the world - Interviews in person
01:02:12 Where to find James
-
In today's episode, we bring back BadCop! Since last episode, she joined Boot.dev's team and is now writing courses with us!
Today we will be discussing the approaches to writing good educational material, Bash (of course, duh), working outside cloud solutions, SSH, NAS systems, workflows with different editors and cultural shifts in different areas of programming. Enjoy!
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
BadCop's Twitter: https://x.com/badcop_
BadCop's Twitch: https://www.twitch.tv/badcop_
Timestamps:
00:00 Intro
00:58 BadCop Joined the Boot.dev Team!
01:15 Writing courses is harder than it looks
03:45 Lane's approach to writing courses
05:21 What's the hardest part of writing a course for BadCop?
09:01 On writing Bash
13:19 How useful is it to know how to work outside the cloud solutions?
17:28 SSHing into the home network
20:49 What is a NAS?
23:26 Using VTuber Software off the shelf
25:55 When did BadCop start using NeoVim?
29:41 IRC talk
33:20 Cultural shift in the programming space
38:05 Getter and Setter functions
42:35 People are overusing the idea of encapsulation
48:41 Dependency Inversion Principle
51:11 The VTuber Project
52:58 Where to find BadCop
-
In today's episode, we welcome Ken Wheeler, a dope programmer, who creates cool projects and just gives them away for free, helping thousands of developers worldwide, a based beatmaker and just in general a cool person.
In this episode, we talk about AI, React, OCaml, why stressing over specific frameworks is not worth it, advice for new developers, HTMX, SPA's and a LOT of other stuff, so stay tuned!
Ken's X/Twitter: https://x.com/ken_wheeler
Timestamps:
00:00 Introduction
00:25 Do you hate AI?
02:10 How diffusion works
17:47 First impressions with writing Go
18:29 Where's the line between Backend Development and DevOps
24:11 Does anyone version their REST?
24:57 urql
25:38 Offloading the data work to the other side
29:55 Wordpress is 80% of the websites
31:15 HTMX
33:12 Single Page Apps
34:02 Is React still your go-to
36:38 Is it hard to switch from React to Vue?
39:37 Picking a first language to learn
40:43 OCaml
43:12 HEX and raw Binary Data
44:42 Bluetooth powered crossbow
52:20 What got Ken into doing talks
58:45 Where to find Ken
-
In today's episode, we welcome Casey Muratori, a seasoned programmer who specializes in game engine research and development who is currently working on a narrative game about organized crime in the 1930s in New York.
And oh boy, is this episode packed with valuable knowledge!
In this talk, we go over the differences between different job positions in the Game Development Industry and how it compares to the Web Development arena, as well as dive deep on the notions of technical knowledge, is it all useful or is some of it just a waste of time? We talk about bloated systems, how we already surpassed the tipping point of code written, so that new exploits will be appearing indefinitely. Casey gives us his opinions on what a programmer should ABSOLUTELY know to be the best at what they do, and a lot of other exciting and interesting topics.
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Computer, Enhance!: https://www.computerenhance.com/
Casey's Twitter/X: https://x.com/cmuratori
Timestamps:
00:28 Casey's Background
02:43 Game Developer vs Game Designer
09:08 What are the different ways people should think about careers that exist for game developers
14:33 Is all knowledge useful or is some of it a waste of time?
16:16 Computer, Enhance! and Casey's teaching methodologies
24:00 Devil's advocate about understanding at the hardware level
29:48 Software is getting slower, bloatier and less performant
35:42 What is the primary reason behind the rise of slow software
38:20 Top 3 concepts that people SHOULD know
43:43 Do you need to know both ARM and x86?
57:03 30 million line problem
01:08:29 Is there any way to mitigate these types of problems?
01:13:39 Where to find Casey
01:14:50 Which was the best part of Twin Peaks
-
In today’s episode, we bring AnthonyGG, a highly requested guest, a Go developer with over a decade of experience with Golang and a fellow content creator.
This episode will be all around Web Development with Go - from how Anthony started writing code with Go and why he chose this language, to tooling, migrations, integrations with databases, generics, Go job interviews and much, much more!
Learn back-end development - https://boot.dev
Listen on your favorite podcast player:
https://www.backendbanter.fm
Anthony's Youtube: https://www.youtube.com/@anthonygg_
Anthony's Twitch: https://www.twitch.tv/theanthonygg
Anthony's Twitter/X: https://x.com/anthdm
Timestamps:
00:00 Introduction
00:29 Anthony's backstory, how he learned to code and started writing code professionally
08:55 Going from go migrate to goose
13:20 What does Anthony use in tandem with goose/go migrate to interact with databases
14:46 Bun vs gorm vs sqlc
18:26 The way boot.dev is running goose at the moment
20:14 Problems with migration tools
23:47 Should HTTP handlers explicitly return an error?
29:05 Building your own middleware and helper functions
36:00 Generics
38:09 How often does AnthonyGG use a context package and for what purposes
44:57 Golang job interviews
46:12 Developer experience with working with Go on Web Applications
54:51 You still need community-built tools
57:08 Where to find Anthony
-
Today, we bring back a dear guest and friend of the podcast, ThePrimeagen! Now Ex-Netflix engineer who turned his full focus to content creation surrounding software engineering and tech.
In today's episode, we talk about his new Git course on boot.dev, where he shares motivations on why he decided to write a course on Git, how he incorporates it into his workflow and shares some hot takes regarding today's tech education landscape, his opinion on bootcamps, colleges, and what his ideal way of teaching computer science is.
To finish off, he shares some of his exciting new ventures, namely a coffee shop and a Doom game which you can play through twitch chat!
Learn back-end development - https://boot.dev
Listen on your favorite podcast player:
https://www.backendbanter.fm
ThePrimeagen's Youtube:
https://www.youtube.com/c/theprimeagen
ThePrimeagen's other Youtube:
https://www.youtube.com/@ThePrimeTimeagen
ThePrimeagen's Twitter: https://x.com/ThePrimeagen
Terminal Coffee Shop: https://www.terminal.shop/
Timestamps:
00:00 Introduction
00:27 Why teach about Git?
02:55 Was Prime taught Git?
04:50 add files individually or git add .
07:22 Hot take about git in school
10:27 What should you learn in school in the first place?
11:34 Where did school come from?
16:42 You can't become a software engineer in 3 months
19:45 Contents of Part 1 and what will Part 2 of the Git course be about
22:58 Rebase vs Merge and Prime's current workflow
24:22 Why you shouldn't merge
29:10 A lot of the times, people just don't know the tools
32:29 The advantage of rebase
34:03 Rewriting history criticism
36:30 Prime's terminal coffee shop
44:22 Doom in the terminal?
54:08 Is the bandwidth the problem with the Doom game?
55:27 Ideas for the controls for Doom
58:57 Where to find Prime
-
In today's episode, we welcome Low Level Learning, a fellow programmer and content creator. With over 500k subscribers and his own course where he teaches low level programming topics, he came on the podcast to talk about what he knows most: C, low level concepts, AI, as well as share some of his own developer experiences and preferences that he garnered over the years.
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
Low Level Learning’s Twitter/X: https://twitter.com/LowLevelTweets
Low Level Learning's Youtube: https://www.youtube.com/c/lowlevellearning
Low Level Learning's Twitch: https://www.twitch.tv/LowLevelLearning
Low Level Academy: https://lowlevel.academy/
Timestmaps:
00:47 Who is Low Level Learning?
01:34 C is a High Level Language
02:47 Is C lower level than Rust or Zig?
04:33 Front-end vs Back-end, which is harder?
06:34 The Boot.dev stack
07:11 The Low Level Academy stack
07:59 Low Level Academy
09:56 Project-based learning
12:18 sqlc
14:44 How do you debug C?
17:26 Fuzzing Harness vs Unit Testing
22:28 Favorite Feature of C
23:45 If you could change one thing in C, what would it be?
26:53 Where do C programmers work?
29:16 The White House and Garbage Collectors
31:19 What is a side-channel attack?
33:56 Power side-channel attack
35:41 Side-channel attack on boot.dev
37:08 What tooling does Low Level Learning use to write C?
43:59 How do you deal with the lack of a package manager?
48:12 Opinion on statically compiled and dynamic libraries
50:36 Where to find Low Level Learning
-
In today’s episode, we welcome Natalie Pistunovich, host of the Go Time podcast, OpenAI Ambassador and Google Developer Expert for Go. She advises companies on how to make the most of AI and adopt it properly and also teaches the Cloud and Infrastructure course for B.Sc. students at the HTW Berlin.
In this episode, we talk all about AI driven development and how is Go one of the best languages suited for code generation, the future of LLM’s and how can we boost the average developer’s job with AI, creating custom GPT’s, changes in the area of AI Chips, and a lot of other fascinating topics.
Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fmNatalie's Twitter/X: https://twitter.com/nataliepis
Timestamps:
00:47 Who is Low Level Learning?
01:34 C is a High Level Language
02:47 Is C lower level than Rust or Zig?
04:33 Front-end vs Back-end, which is harder?
06:34 The Boot.dev stack
07:11 The Low Level Academy stack
07:59 Low Level Academy
09:56 Project-based learning
12:18 sqlc
14:44 How do you debug C?
17:26 Fuzzing Harness vs Unit Testing
22:28 Favorite Feature of C
23:45 If you could change one thing in C, what would it be?
26:53 Where do C programmers work?
29:16 The White House and Garbage Collectors
31:19 What is a side-channel attack?
33:56 Power side-channel attack
35:41 Side-channel attack on boot.dev
37:08 What tooling does Low Level Learning use to write C?
43:59 How do you deal with the lack of a package manager?
48:12 Opinion on statically compiled and dynamic libraries
50:36 Where to find Low Level Learning
-
In today’s episode, we bring fellow developer and tech content creator NeetCode, to talk about his obstacles and observations on his path in becoming a FAANG engineer, where he shares his struggles and how he started both his tech career and content creation journeys.
Among a variety of other topics, NeetCode shares his advice for anyone that’s open to receiving it, and explains the pros and cons of grinding LeetCode, if it is even worth doing it or not, while also dabbling into why networking is somewhat important and highlights the importance of standing out in today’s job market environment.Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fmNeetcode's Website: https://neetcode.io/
Neetcode's Youtube: https://www.youtube.com/c/neetcode
Neetcode's Twitter: https://twitter.com/neetcode1
Neetcode's LinkedIn: https://www.linkedin.com/in/navdeep-singh-3aaa14161/
Timestamps:
00:46 Who is NeetCode and a bit of his background
02:24 Why did NeetCode start a YouTube Channel?
03:40 People don't talk about where they mess up at these big companies
04:47 Portray yourself in the best possible light at interviews
07:37 Why LeetCode?
08:44 Why Grinding LeetCode is not the smartest choice
11:31 Why LeetCode is still important if your goal is a FAANG-level company
14:47 What would be the approach for someone with CS-degree knowledge that wants to get into Google in 2024/2025
17:26 How to know if you're having trouble getting or passing interviews?
19:01 You can put projects on a resume, not LeetCode solutions
21:47 Tutorial Hell
24:47 You have to be able to prove your knowledge, just putting it on the resume isn't enough
29:20 You don't have to do content creation to get a developer job
30:29 Social Media works well for networking
33:03 NeetCode philosophy
37:57 Monetizing education content
42:17 How to level up the product experience
44:04 Amazon vs Google's culture
46:24 As usual, managers don't know what they're doing a lot of the time
49:30 Managers at these companies should be technical
51:17 Difference between Engineers and other Tech Roles
55:40 Where to find NeetCode -
In today’s episode, we welcome John Crickett, veteran software engineer, having worked at Staff, VP, and C-Suite positions over the years, and now focusing on helping thousands of engineers worldwide, through his coding challenges that have you building real applications, as well as helping with the soft skills through his articles and posts about software development.
Today we cover a LOT of ground where we explain exactly what a Software Architect is, discuss different leadership types, advice to get a software job, remote work, unpopular opinions on programming languages, performance and scale, and a couple other things, so stay tuned because this episode is a true fountain of knowledge.Learn back-end development - https://boot.dev
Listen on your favorite podcast player: https://www.backendbanter.fm
John Crickett's Twitter/X: https://twitter.com/johncrickett
John Crickett's Linkedin: https://www.linkedin.com/in/johncrickett/
Coding Challenges: https://codingchallenges.fyi/
Coding Challenges on Substack: https://codingchallenges.substack.com/
Research mentioned at 27:33 : https://www.researchgate.net/publication/232514133_Effect_of_self-differentiation_and_anonymity_in_group_on_deindividuation
More on the topic of Deindividuation: https://en.wikipedia.org/wiki/Deindividuation#Major_empirical_discoveries
Timestamps:
00:12 Who is John Crickett
01:13 What is a Software Architect
03:04 People vs Technical Leadership
03:53 What kind of decisions does a software architect make?
04:43 Is there a lot of "Thought Leadership" involved?
05:23 Do you prefer Technical or People leadership?
07:47 How did John start his coding career?
11:39 Most people don't start working at "sexy" companies
13:58 Juggling off-topic
14:32 What are the Coding Challenges?
19:03 Remote work and downtime
22:56 The wrong culture might spoil the remote environment and people care less about the work
27:05 Anonymity turns people into assholes
29:58 Why did we have a phone call when this could've been an e-mail?
33:42 Doing LeetCode vs Building Projects
36:54 Most of the time you'll be using already existing solutions
40:05 Is there too much abstraction nowadays?
41:56 Using the Command Line is cool again!
43:44 When talking about scale, what matters most is the architecture, not the language or framework
51:30 Why just switching to a "faster" language isn't enough
53:48 Go vs Rust performance comparison
54:44 Learning how to write performant code is more important than the programming language itself
55:25 The importance of benchmarking
58:33 Where to find John - Mostra di più
