Podcasts by Coding Blocks
Become the best software developer you can be
Further podcasts by Allen Underwood, Michael Outlaw, Joe Zack
Podcast on the topic Technologie
All episodes
#CBJAM 22 Recap from 2022-02-14T03:19:56
We have a retrospective about our recent Game Ja Ja Ja Jam, while Michael doesn't know his A from his CNAME, Allen could be a nun, and Joe still wants to be a game developer.
Listen
PagerDuty’s Security Training for Engineers, The Dramatic Conclusion from 2022-01-31T03:01:01
We wrap up our discussion of PagerDuty's Security Training, while Joe declares this year is already a loss, Michael can't even, and Allen says doody, err, duty.
Listen
PagerDuty’s Security Training for Engineers, Penultimate from 2022-01-18T01:03
We're pretty sure we're almost done and we're definitely all present for the recording as we continue discussing PagerDuty's Security Training, while Allen won't fall for it, Joe takes the show to ...
Listen
PagerDuty’s Security Training for Engineers! Part Deux from 2022-01-04T01:03
We continue our discussion of PagerDuty's Security Training presentation while Michael buys a vowel, Joe has some buffer, and Allen hits everything he doesn't aim for.
Listen
PagerDuty’s Security Training for Engineers from 2021-12-20T01:13:20
We're taking our time as we discuss PagerDuty's Security Training presentations and what it means to "roll the pepper" while Michael is embarrassed in front of the whole Internet, Franklin Allen Un...
Listen
What is a Game Engine? from 2021-12-06T02:35:03
With Game Ja-Ja-Ja-Jamuary coming up, we discuss what makes a game engine, while Michael's impersonation is spot-on, Allen may really just be Michael, and Joe already has the title of his next podc...
Listen
Designing Data-Intensive Applications – Secondary Indexes, Rebalancing, Routing from 2021-11-22T02:12:25
We wrap up the discussion on partitioning from our collective favorite book, Designing Data-Intensive Applications, while Allen is properly substituted, Michael can't stop thinking about Kafka, and...
Listen
Designing Data-Intensive Applications – Partitioning from 2021-11-08T01:03
We crack open our favorite book again, Designing Data-Intensive Applications by Martin Kleppmann, while Joe sounds different, Michael comes to a sad realization, and Allen also engages "no take bac...
Listen
The 2021 Shopping Spree from 2021-10-25T02:04:10
The Mathemachicken strikes again for this year’s shopping spree, while Allen just realized he was under a rock, Joe engages “no take backs”, and Michael ups his decor game.
Listen
Should You Speak at a Conference? from 2021-10-11T02:03:56
We discuss the pros and cons of speaking at conferences and similar events, while Joe makes a verbal typo, Michael has turned over a new leaf, and Allen didn't actually click the link.
Listen
Transactions in Distributed Systems from 2021-09-27T01:14:45
Joe goes full shock jock, but only for a moment. Allen loses the “Most Tips In A Single Episode: 2021” award, and Michael didn’t get the invite notification in this […]
Listen
Docker Licensing, Career and Coding Questions from 2021-09-13T01:46:30
Some things just require discussion, such as Docker's new licensing, while Joe is full of it, Allen *WILL* fault them, and Michael goes on the record.
Listen
Why Get Into Competitive Programming? from 2021-08-30T01:45:11
We step away from our microservices deployments to meet around the water cooler and discuss the things on our minds, while Joe is playing Frogger IRL, Allen "Eeyores" his way to victory, and Michae...
Listen
Are Microservices … for real? from 2021-08-16T00:03
We decide to dig into the details of what makes a microservice and do we really understand them as Joe tells us why we really want microservices, Allen incorrectly answers the survey, and Michael b...
Listen
2021 State of the Developer Ecosystem from 2021-08-01T00:33:50
We dive into JetBrains' findings after they recently released their State of the Developer Ecosystem for 2021 while Michael has the open down pat, Joe wants the old open back, and Allen stopped usi...
Listen
What is GitHub Copilot? from 2021-07-19T02:21:01
It's time to take a break, stretch our legs, grab a drink, and maybe even join in some interesting conversations around the water cooler as Michael goes off script, Joe is very confused, and Allen ...
Listen
Designing Data-Intensive Applications – Leaderless Replication from 2021-07-06T00:03
We wrap up our replication discussion of Designing Data-Intensive Applications, this time discussing leaderless replication strategies and issues, while Allen missed his calling, Joe doesn't read t...
Listen
Designing Data-Intensive Applications – Multi-Leader Replication from 2021-06-21T00:56:39
We continue our discussion of Designing Data-Intensive Applications, this time focusing on multi-leader replication, while Joe is seriously tired, and Allen is on to Michael's shenanigans.
Listen
Designing Data-Intensive Applications – Single Leader Replication from 2021-06-07T00:03
We dive back into Designing Data-Intensive Applications to learn more about replication while Michael thinks cluster is a three syllable word, Allen doesn't understand how we roll, and Joe isn't ev...
Listen
Some Fun APIs from 2021-05-24T02:17:16
We couldn't decide if we wanted to gather around the water cooler or talk about some cool APIs, so we opted to do both, while Joe promises there's a W in his name, Allen doesn't want to say graph, ...
Listen
Making Money with Code from 2021-05-10T03:18:41
We talk about the various ways we can get paid with code while Michael failed the Costco test, Allen doesn't understand multiple choice questions, and Joe has a familiar pen name.
Listen
Write Great APIs from 2021-04-26T00:54:02
We discuss all things APIs: what makes them great, what makes them bad, and what we might like to see in them while Michael plays a lawyer on channel 46, Allen doesn't know his favorite part of the...
Listen
How to Scrum from 2021-04-12T02:28:14
We discuss the parts of the scrum process that we're supposed to pay attention to while Allen pronounces the m, Michael doesn't, and Joe skips the word altogether.
Listen
What is Scrum? from 2021-03-29T01:20:21
During today's standup, we focus on learning all about Scrum as Joe is back (!!!), Allen has to dial the operator and ask to be connected to the Internet, and Michael reminds us why Blockbuster fai...
Listen
Show Recursion Show from 2021-03-15T02:12:50
We dig into recursion and learn that Michael is the weirdo, Joe gives a subtle jab, and Allen doesn't play well with others while we dig into recursion.
Listen
Specialize or Bounce Around? from 2021-03-01T01:31:46
It's been a minute since we last gathered around the water cooler, as Allen starts an impression contest, Joe wins said contest, and Michael earned a participation award.
Listen
Why is Python Popular? from 2021-02-15T01:03
We dig into all things Python, which Allen thinks is pretty good, and it's rise in popularity, while Michael and Joe go toe-to-toe over a gripe, ahem, feature.
Listen
Game Jam Lessons Learned from 2021-02-01T01:06:33
We step back to reflect on what we learned from our first game jam, while Joe's bathroom is too close and Allen taught Michael something (again).
Listen
Who Owns Open-Source Software? from 2021-01-18T03:00:12
We discuss all things open-source, leaving Michael and Joe to hold down the fort while Allen is away, while Joe's impersonations are spot on and Michael is on a first name basis, assuming he can pr...
Listen
Our Favorite Developer Tools of 2020 from 2021-01-04T01:03
We start off the year discussing our favorite developer tools of 2020, as Joe starts his traditions early, Allen is sly about his résumé updates, and Michael lives to stream.
Listen
Into the Octoverse from 2020-12-21T01:03:30
It's the end of 2020. We're all tired. So we phone it in for the last episode of the year as we discuss the State of the Octoverse, while Michael prepared for the wrong show (again), Allen forgot t...
Listen
What is a Developer Game Jam? from 2020-11-23T01:06:24
We learn all the necessary details to get into the world of developer game jams, while Michael triggers all parents, Allen's moment of silence is oddly loud, and Joe hones his inner Steve Jobs.
Listen
The DevOps Handbook – Create Organizational Learning from 2020-11-09T02:25:31
We wrap up our deep dive into The DevOps Handbook, while Allen ruined Halloween, Joe isn't listening, and Michael failed to... forget it, it doesn't even matter.
Listen
The 2020 Shopping Spree from 2020-10-26T01:19:16
It's our favorite time of year where we discuss all of the new ways we can spend our money in time for the holidays, as Allen forgets a crucial part, Michael has "neons", and Joe has a pet bear.
Listen
The DevOps Handbook – Enable Daily Learning from 2020-10-12T00:03:35
We dive into the benefits of enabling daily learning into our processes, while it's egregiously late for Joe, Michael's impersonation is awful, and Allen's speech is degrading.
Listen
The DevOps Handbook – The Value of A/B Testing from 2020-09-28T00:03:31
We wrap up the second way from The DevOps Handbook, while Joe has a mystery episode, Michael doesn't like ketchup, and Allen has a Costco problem.
Listen
Is Kubernetes Programming? from 2020-09-14T00:03:36
We gather around the water cooler to discuss some random topics, while Joe sends too many calendar invites, Allen interferes with science, and Michael was totally duped.
Listen
The DevOps Handbook – Enabling Safe Deployments from 2020-08-31T00:03:04
We learn the secrets of a safe deployment practice while continuing to study The DevOps Handbook as Joe is a cartwheeling acrobat, Michael is not, and Allen is hurting, so much.
Listen
The DevOps Handbook – Anticipating Problems from 2020-08-17T00:03:23
We're using telemetry to fill in the gaps and anticipate problems while discussing The DevOps Handbook, while Michael is still weird about LinkedIn, Joe knows who's your favorite JZ, and Allen migh...
Listen
The DevOps Handbook – The Technical Practices of Feedback from 2020-08-03T00:25:37
It's all about telemetry and feedback as we continue learning from The DevOps Handbook, while Joe knows his versions, Michael might have gone crazy if he didn't find it, and Allen has more than eno...
Listen
The DevOps Handbook – Architecting for Low-Risk Releases from 2020-07-20T00:03
Our journey into the world of DevOps continues with The DevOps Handbook as Michael doesn't take enough tangents, Joe regrets automating the build, err, wait never regrets (sorry), and ducks really ...
Listen
The DevOps Handbook – The Technical Practices of Flow from 2020-07-06T00:02:58
We begin our journey into the repeatable world of DevOps by taking cues from The DevOps Handbook, while Allen loves all things propane, Joe debuts his "singing" career with his new music video, and...
Listen
Survey Says … 2020 Stack Overflow Developer Survey from 2020-06-22T00:02:03
We review the Stack Overflow Developer Survey in the same year it was created for the first time ever, while Joe has surprising news about the Hanson Brothers, Allen doesn't have a thought process,...
Listen
Google’s Engineering Practices – How to Navigate a Code Review from 2020-06-08T01:33:26
As we learn from Google about how to navigate a code review, Michael learns to not give out compliments, Joe promises to sing if we get enough new reviews, and Allen introduces a new section to the...
Listen
Google’s Engineering Practices – What to Look for in a Code Review from 2020-05-26T00:02
We learn what to look for in a code review while reviewing Google's engineering practices documentation as Michael relates patterns to choo-choos, Joe has a "weird voice", and Allen has a new favor...
Listen
Google’s Engineering Practices – Code Review Standards from 2020-05-11T01:55:23
We dig into Google's engineering practices documentation as we learn how to code review while Michael, er, Fives is done with proper nouns, Allen can't get his pull request approved, and Joe prefer...
Listen
Big Data – How Far is Too Far? from 2020-04-27T00:38:24
We gather around the water cooler at 6 foot distances as Michael and Joe aren't sure what they streamed, we finally learn who has the best fries, at least in the US, and Allen doesn't understand ev...
Listen
Designing Data-Intensive Applications – To B-Tree or not to B-Tree from 2020-04-13T01:07:12
We dig into the details of how databases use B-trees as we continue our discussion of Designing Data-Intensive Applications while Michael's description of median is awful, live streaming isn't for ...
Listen
How to Work Remote Effectively from 2020-03-30T02:02:26
Since we can't leave the house, we discuss what it takes to effectively work remote while Allen's frail body requires an ergonomic keyboard, Joe finally takes a passionate stance, and Michael tells...
Listen
Designing Data-Intensive Applications – SSTables and LSM-Trees from 2020-03-16T00:02
It's time to learn about SSTables and LSM-Trees as Joe feels pretty zacked, Michael clarifies what he was looking forward to, and Allen has opinions about Dr Who.
Listen
Designing Data-Intensive Applications – Storage and Retrieval from 2020-03-02T01:02:03
In this episode, Allen is back, Joe knows his maff, and Michael brings the jokes, all that and more as we discuss the internals of how databases store and retrieve the data we save as we continue o...
Listen
Why Attend Developer Conferences and What were the Hot Topics at NDC London 2020? from 2020-02-17T01:57:38
Jamie from https://dotnetcore.show/ and Allen, ya know, from Coding Blocks, sat down together at NDC London to talk about the hot topics from the conference as well as how to get the most out of an...
Listen
Designing Data-Intensive Applications – Data Models: Query Languages from 2020-02-03T04:37:19
We dive into declarative vs imperative query languages as we continue to dive into Designing Data-Intensive Applications while Allen is gallivanting around London, Michael had a bullish opinion, an...
Listen
Designing Data-Intensive Applications – Data Models: Relationships from 2020-01-20T05:32:43
While we continue to dig into Designing Data-Intensive Applications, we take a step back to discuss data models and relationships as Michael covers all of his bases, Allen has a survey answer just ...
Listen
Designing Data-Intensive Applications – Data Models: Relational vs Document from 2020-01-06T01:41:46
We're comparing data models as we continue our deep dive into Designing Data-Intensive Applications as Coach Joe is ready to teach some basketball, Michael can't pronounce 6NF, and Allen measured ...
Listen
Designing Data-Intensive Applications – Maintainability from 2019-12-23T01:34:39
We dig into what it takes to make a maintainable application as we continue to learn from Designing Data-Intensive Applications, as Allen is a big fan of baby Yoda, Michael's index isn't corrupt, a...
Listen
Designing Data-Intensive Applications – Scalability from 2019-12-09T04:01:21
We continue to study the teachings of Designing Data-Intensive Applications, while Michael's favorite book series might be the Twilight series, Joe blames his squeak toy chewing habit on his dogs, ...
Listen
Designing Data-Intensive Applications – Reliability from 2019-11-25T08:02
We start our deep dive into Joe's favorite new book, Designing Data-Intensive Applications as Joe can't be stopped while running downhill, Michael might have a new spin on #fartgate, and Allen does...
Listen
Developer Shopping Spree 2019 from 2019-11-12T01:02:51
We discuss this year's shopping spree only to learn that Michael spent too much, Allen spent too much, and Joe spent too much.
Listen
DevOps: Job Title or Job Responsibility? from 2019-10-28T03:42:01
We debate whether DevOps is a job title or a job responsibility as Michael finally understands dev.to's name, Allen is an infosec expert, and Joe wears his sunglasses at night.
Listen
3factor app – Async Serverless from 2019-10-14T02:51:58
We take an introspective look into what's wrong with Michael's life, Allen keeps taking us down random tangents, and Joe misses the chance for the perfect joke as we wrap up our deep dive into Hasu...
Listen
3factor app – Reliable Eventing from 2019-09-30T02:54:37
We discuss the second factor of Hasura's 3factor app, Reliable Eventing, as Allen says he still _surfs_ the Internet (but really, does he?), it's never too late for pizza according to Joe, and Mich...
Listen
3factor app – Realtime GraphQL from 2019-09-17T02:13:07
We begin to twitch as we review the first factor of Hasura's 3factor app, Realtime GraphQL, while Allen gets distrac ... SQUIRREL!, Michael might own some bell bottoms, and Joe is stuck with cobalt.
Listen
The Pragmatic Programmer – How to Build Pragmatic Teams from 2019-09-03T00:02:48
We learn how to apply the concepts of The Pragmatic Programmer to teams while Michael uses his advertisement voice, Joe has a list, and Allen doesn't want anyone up in his Wheaties.
Listen
The Pragmatic Programmer – How to use Exceptions from 2019-08-20T00:02:11
After 112 episodes, Michael can't introduce the show, Allen pronounces it "ma-meee", and don't make Joe run your janky tests as The Pragmatic Programmer teaches us how we should use exceptions and ...
Listen
The Pragmatic Programmer – How to Generate Code from 2019-08-05T00:00:52
We continue our dive into The Pragmatic Programmer and debate when is it text manipulation vs code generation as Joe can't read his bill, Michael makes a painful recommendation, and Allen's gaming ...
Listen
The Pragmatic Programmer – How to Debug from 2019-07-23T02:22:43
It's about time we finally learn how to debug by taking take a page from The Pragmatic Programmer playbook, while Michael replaces a developer's cheat sheet, Joe judges the H-O-R-S-E competition fo...
Listen
The Pragmatic Programmer – Know Thy Tools from 2019-07-08T00:23:28
We dig into the details of the basic tools while continuing our journey into The Pragmatic Programmer while Joe programs by coincidence, Michael can't pronounce numbers, and Allen makes a point.
Listen
The Pragmatic Programmer – How to Estimate from 2019-06-24T01:17:16
Joe is distracted by all of the announcements from E3, Allen is on the run from the Feebs, and Michael counts debugging as coding. All this and more as we continue discussing The Pragmatic Programmer.
Listen
The Pragmatic Programmer – Tracer Bullets and Prototyping from 2019-06-10T01:27:47
The Pragmatic Programmer teaches us how to use tracer bullets versus prototyping while Joe doesn't know who won the Game of Thrones, Allen thought he knew about road numbers, and Michael thinks 475...
Listen
The Pragmatic Programmer – Is Your Code Orthogonal? from 2019-05-27T00:00:25
The dad jokes are back as we learn about orthogonal code while JZ (the 8-mile guy) has spaghetti on him, Michael's Harry Potter references fail, and Allen voice goes up a couple octaves.
Listen
The Pragmatic Programmer – The Evils of Duplication from 2019-05-13T03:02:27
We take a deep dive into the various forms of duplication and jump aboard the complain train as Allen complains about Confluent's documentation, Michael complains about Docker's documentation, and ...
Listen
The Pragmatic Programmer – Investing in Your Knowledge Portfolio from 2019-04-29T00:00:24
We begin our journey into the wisdom of The Pragmatic Programmer, which as Joe puts it, it's less about type-y type-y and more about think-y think-y, while Allen is not quite as pessimistic as Joe,...
Listen
Should Your Web App be a Progressive Web App (PWA)? from 2019-04-15T00:00:09
We dig into the nitty gritty details of what a Progressive Web App (PWA) is and why you should care, while Allen isn't sure if he is recording, Michael was the only one prepared to talk about Flo a...
Listen
The Second Date is Always Easier from 2019-04-01T02:38:52
The Date deep dive continues as we focus in on C# and JavaScript, while Michael reminisces about the fluorescent crayons, Joe needs a new tip of the week, and Allen confuses time zones.
Listen
Why Date-ing is Hard from 2019-03-18T03:37:58
We take a deep dive into understanding why all Date-s are not created equal while learning that Joe is not a fan of months, King Kong has nothing on Allen, and Michael still uses GETDATE(). Oops.
Listen
What Should You Learn Next? from 2019-03-04T01:24:26
After being asked to quiet down, our friend, John Stone, joins us again as we move the conversation to the nearest cubicle while Michael reminds us of Bing, Joe regrets getting a cellphone, and All...
Listen
Tackling Tough Developer Questions from 2019-02-18T01:02:37
We gather around the water cooler to celebrate our 100th episode with our friend John Stone for some random developer discussions as Michael goes off script, Joe needs his techno while coding, and ...
Listen
JAMstack with J.A.M. from 2019-02-04T01:02:40
We learn all about JAMstack in real-time as Michael lowers the bar with new jokes, Allen submits a pull request, and Joe still owes us a tattoo.
Listen
Data Structures – Heaps and Tries from 2019-01-21T06:24:11
We dig into heaps and tries as Allen gives us an up to date movie review while Joe and Michael compare how the bands measure up.
Listen
Data Structures – (some) Trees from 2019-01-08T00:42:49
We ring in 2019 with a discussion of various trees as Allen questions when should you abstract while Michael and Joe introduce us to the Groot Tree.
Listen
Data Structures – Hashtable vs Dictionary from 2018-12-17T04:01:02
Just in time to help you spread some cheer this holiday season, the dad jokes are back as we dig into the details of hash tables and dictionaries.
Listen
Data Structures – Arrays and Array-ish from 2018-12-03T03:56:57
We continue our deep dive into data structures, this time focusing in on arrays and array-like types as Allen gives Shania Twain some singing competition, Joe is going to owe us another tattoo, and...
Listen
Data Structures – Primitives from 2018-11-19T03:13:27
We begin our journey into data structures by taking a deep dive into primitives while Allen makes Michael blush and Joe crashes his browser.
Listen
Developer Shopping Spree from 2018-11-05T02:47:11
With the holiday season soon approaching, we address the most important requirements list of all ... our wish lists as Joe has to disclose a cheese powder incident, Michael hopes his Bitcoin gains ...
Listen
Azure Functions and CosmosDB from MS Ignite from 2018-10-22T00:00:49
This is a special episode recorded at Microsoft Ignite 2018 where John Callaway from The 6 Figure Developer Podcast joins Allen Underwood to talk about Azure Functions and CosmosDB. Find out what t...
Listen
How to Learn Programming Skills from 2018-10-08T01:35:24
We continue our dive into how to learn things while Michael's voice sounds an awful lot like Joe's, Joe says it's a square, and Allen says it's a triangle ... oh, and Google Feud is back!
Listen
Comparing Git Workflows from 2018-09-24T00:57:16
We have some fun with our names, get ahead of ourselves during Survey Says, and vet Michael's tip on-air as we take a deep dive into comparing some popular Git workflows and when should we use which.
Listen
Does Big O Matter? from 2018-09-10T01:03:32
We wrap up our conversation on complexity and play some more over/under as Allen thinks learning is backwards, Michael doesn't write clean code, and Joe brings his dog to the discussion.
Listen
What is Algorithmic Complexity? from 2018-08-27T00:52:47
We continue our dive into Rob Conery's The Imposter's Handbook as Allen is Allen, Joe is Michael, Michael is Joe.
Listen
Thunder Talks from 2018-08-13T01:52:41
Joe's voice sounds funny, Allen has a theme, and Michael pours one out for Media Play as Michael's and Allen's impersonation of Joe is on point (#NailedIt).
Listen
Lightning Talks from 2018-07-30T02:54:01
We meet up around the water cooler for a quick round of lightning talks as Allen and Michael sing FizzBuzz while Joe passes the caching buck.
Listen
Graph Algorithms from 2018-07-16T03:44:12
We continue digging into Rob Conery's The Imposter's Handbook as Joe explains Florida time, Allen likes greedy algorithms, and Michael shares his geography knowledge.
Listen
Algorithms You Should Know from 2018-06-25T03:37:50
It's time we discuss algorithms we all need to know as we continue diving into Rob Conery's The Imposter's Handbook while Michael will read anything, Allen questions Greenland's name, and Joe talks...
Listen
Search Driven Apps from 2018-06-11T01:28:52
We're talking databases, indexes, search engines, and why they're basically microwaves in this episode while Joe wears a polo, Allen's quick brown fox jumps over whatever, and Michael gives out fak...
Listen
Programmer Strengths and Weaknesses from 2018-05-28T17:53:35
Inspired by Rob Conery's The Imposter's Handbook, we take an introspective look at ourselves to find two weaknesses and one strength while Allen shows off his vocal prowess in song, Joe needs a lis...
Listen
Understanding Complexity Theory from 2018-05-14T02:14:30
This episode we talk complexity theory while digging into Rob Conery's The Imposter's Handbook as Allen channels his inner Austin Powers, Michael finds linearly to complex to pronounce, and Joe rui...
Listen
Docker for Developers from 2018-05-01T02:22:44
This episode we're talking about server naming conventions, confusing command line arguments, and how high we can get our voices. Huge thanks to the NSA and the freedom of information act for makin...
Listen
Design Anti-Patterns: YoYo, The God Object and More from 2018-04-16T00:00:41
It's time for more design Ant-EYE or Ant-EEE patterns as we venture into cesspool that awaits. Come find out what these patterns are, why you should, and how to avoid them. Bonus: Michael drops th...
Listen
Deliberate Practice for Programmers from 2018-04-03T02:53:57
It's time for more cowbell as we have a special guest in the studio, Will Madison (@IAmWillMadison), join us as Allen finally gets tripped up trying to pronounce a name, Joe teaches us the value of...
Listen
Clean Architecture – Are Microservices Truly Decoupled? from 2018-03-19T02:21:23
We're back with our last deep dive into Robert C. Martin's latest book, Clean Architecture, while Allen suffers from sleep deprivation, Joe shows us his dance moves, and Michael's mind is blown on ...
Listen
Clean Architecture – What is the Humble Object Pattern? from 2018-03-07T03:34:15
It's time for another deep dive into Robert C. Martin's Clean Architecture as Joe puts us on the spot, Allen has a new mission, and Michael shares his Easter eggs.
Listen
Clean Architecture – Make Your Architecture Scream from 2018-02-19T00:11:51
Michael can't tell higher from lower, Allen puts his views where he wants them, and Joe snaps it to a Slim Jim as we discuss how to make our architectures scream while discussing Robert C. Martin's...
Listen
Clean Architecture – The Art of Drawing Lines from 2018-02-05T00:59:41
It's time for another deep dive into Robert C. Martin's Clean Architecture as Allen warns us about driving in front of him, Joe tries to describe a diagram again, and Michael can't understand the s...
Listen
Clean Architecture – Keeping Your Options Open from 2018-01-23T03:02:26
Joe drinks too much coffee, Allen spits his coffee out, and Michael feels vindicated as the discussions about Robert C. Martin's latest book, Clean Architecture, continues.
Listen
Clean Architecture – How to Quantify Component Coupling from 2018-01-08T01:38:59
Joe baits Michael, Michael takes the bait, and Allen lets it happen, as Uncle Bob explains how we can quantify the coupling between our components from his latest book, Clean Architecture.
Listen
Clean Architecture – Components and Component Cohesion from 2017-12-11T02:43:34
Joe is down with OCP, Michael argues DRY, and Allen deletes our show notes as we dig into Components and Component Cohesion from Robert C. Martin's (aka Uncle Bob) Clean Architecture.
Listen
How to Spend $2,500 on Developer Gear from 2017-11-13T05:00:56
We're back with another installment as we challenge ourselves to compare how we'd each spend $2,500 on developer gear as Allen waxes on about the loudest quiet keyboard, Joe teaches us how cheese i...
Listen
Clean Architecture – Programming Paradigms from 2017-10-30T01:53:39
Michael forgets what his favorite part of the show is, Joe makes us wait to learn what his favorite part is, and Allen pronounces it "pair-a-dig-'ems" as we continue our deep dive into Uncle Bob's ...
Listen
Clean Architecture – Fight for Architecture from 2017-10-02T01:37:28
Joe learns of our harebrained idea, Michael learns of Eisenhower's matrix, and Allen explains polyfills as we begin our dive into Uncle Bob's latest book, Clean Architecture.
Listen
Object Oriented Mistakes from 2017-09-18T00:07:19
Allen brings the dad jokes, Michael unplugs, and Joe gets a second wind as we discuss the anti-patterns found in object oriented programming.
Listen
Project Management Anti-patterns from 2017-09-05T00:04:28
It's time for another episode as Joe wants to choke a developer, Michael scraps his new social networking platform, and Allen finally learns of dad jokes while we continuing the anti-patterns conve...
Listen
Software Design Anti-patterns from 2017-08-21T00:04:19
We've discussed design patterns too much. Now it's time for some discussion about anti-patterns as Joe has dark visions about robots, Allen has to take sensitivity training, and Michael picks Arial.
Listen
Software Architecture – What is Supple Design? from 2017-07-27T23:01:03
More Domain Driven Design talk this week: Supple Design, Declarative(ish?) Programming, and Ohio Envy. Sponsors FreshBooks.com/Coding – Use code “CODING BLOCKS” in the “How Did You Hear About Us?” ...
Listen
Software Architecture – Explicit Constraints, Processes, Specification Pattern, and more from 2017-07-10T02:10:29
Know what Joe and Waldo have in common? We can't find either, as this week, it's just Allen and Michael to continue the dive into Domain Driven Design.
Listen
Software Architecture – Strategic Design and Domain Events from 2017-06-26T02:25:33
We're not saying that Michael is Carmen Sandiego. We're just saying that nobody has ever seen them in a room together. And this week, we don't know where in the world either are, as Allen and Joe c...
Listen
Software Architecture – Aggregate Roots, Factories, and Repositories from 2017-06-13T03:13:08
Stitcher is back and so are we as Michael proves he doesn't have a career as a rapper, Allen can't type on his phone, and Joe tweets with famous authors as we continue our dive into Domain Driven D...
Listen
Software Architecture – The Domain in Domain Driven Design from 2017-05-29T04:25:27
We continue our Domain Driven Design conversation this week as Allen is indecisive, Michael decides for him, and Joe can't handle the night life.
Listen
How to Jumpstart Your Next App from 2017-05-11T18:18:16
We're back with another exciting episode as Michael questions Hollywood, Allen dreams of his Hackintosh, and Joe is surrounded by Star Wars as we talk about how to jumpstart your next app with Mich...
Listen
Why Domain Driven Design from 2017-04-24T00:50:24
This week, Michael asks his customers about their anemic domain model, Allen talks in front of people, and Joe plays Rocket League as we begin our dive into understanding domain driven design.
Listen
How We Badly Built Stuff from 2017-03-20T03:15:38
This week we talk about all of the bad things we've done while making software. The good, the bad, ... oh wait, it compiles, never mind.
Listen
Clean Code – How to Build Maintainable Systems from 2017-03-06T00:58:21
We're back with another deep dive into the infamous book Clean Code by Uncle Bob as Joe alters columns, Michael misreads things, and Allen has a positive customer service experience.
Listen
Clean Code – How to Write Classes the Right Way from 2017-02-05T22:00:22
This week Allen is troubled by circles, Michael talks like a game show host, and Joe announces it's twins as we continue our deep dive into the classic Clean Code book by Robert C. Martin.
Listen
Clean Code – How to Write Amazing Unit Tests from 2017-01-23T00:01:42
When and why should you write unit tests, and just how important are they? Take a listen and see what YOU think.
For the full show notes visit:
http://www.codingblock...
Clean Code – Integrating with Third Party Libraries the Right Way from 2017-01-08T22:30:44
In this episode we talk about how to insulate your application at it's boundaries? What in the world does that even mean?! We're not talking about those boundaries where others aren't allowed to ...
Listen
Clean Code – Error Handling from 2016-12-28T02:33:42
This week, we continue our Clean Code discussion as we dive into the joys and pains of error handing.
Listen
Clean Code – Objects vs Data Structures from 2016-12-13T03:07:09
This week we're drawing a line in the sand between objects and data structures. Who will win? Take a listen and decide for yourself!
For the full show notes visit:
ht...
Clean Code – Formatting Matters from 2016-11-29T05:05:49
Ever judged a book by its cover? Of course you have. Ever passed judgement on some code simply because it didn't look pretty? There's more to writing code than having it functional and in this e...
Listen
Clean Code – Comments Are Lies from 2016-11-07T01:10:05
This week, Michael fails geography, Allen introduces us to Croom, and Joe has to potty as we head into our third installment of the Clean Code series.
The original version of t...
Clean Code – How to Write Amazing Functions from 2016-10-17T00:40:33
We continue talking our way through Clean Code, taking a deep look at the building blocks of programming in the quest to write the best functions. Oh, and everybody sings.
The ...
Clean Code – Writing Meaningful Names from 2016-09-28T02:09:20
In this episode, we take our first dive into the book Clean Code by Robert Martin and specifically we talk about writing meaningful names for all things code related. You'll be amazed at how follo...
Listen
Caching in the Application Framework from 2016-08-27T02:56:15
Storing smaller subsets of data in a faster, closer memory can make astronomical differences in performance. This episode we're talking about the caching tools and techniques that application frame...
Listen
Caching Overview and Hardware from 2016-08-12T04:40:46
In this episode we give a general overview of caching, where it’s used, why it’s used, and what the differences in hardware implementations mean in terms we can understand. This […]
Listen
Stack Overflow Salaries and Landing the Job from 2016-08-02T05:14:20
This week on Coding Blocks, Allen says www as best he can, Joe eats the microphone, and Michael does something crazy as we discuss Stack Overflow's Salary Calculator and our experiences in landing ...
Listen
Nulls, Procs, and Impostor Syndrome from 2016-07-05T00:03:53
This time we're talking about problems with nulls, stored procedures, and impostor syndrome.
Episode 43’s Full Show Notes:
http://www.codingblocks.net/episode43
Command, Repository and Mediator Design Patterns from 2016-06-03T03:52:46
In this episode we go back to the design pattern well that we’ve been away from for so long. We cover the Command, Repository and Mediator design patterns. It was […]
Listen
Dev Talk: Django, VB vs C#, and Bash on Windows from 2016-04-19T02:27:59
This week on Coding Blocks, Joe changes a different kind of string, Allen drools over the Hellcat, and Michael shares his random thoughts. We span a collection of topics including GraphQL framework...
Listen
How to be an Advanced Programmer from 2016-03-20T01:43:36
Are you an Advanced Programmer? We dig into the final section of Robert Read's fantastic writing: How to be a programmer. Also, how to cheat at Jira, a lazy butcher and Leia vs Galadriel
...
How to be an Intermediate Programmer from 2016-02-27T22:30:38
In Episode 38, we dug into the first section of the essay by Robert Read on what it takes to be a programmer. In that episode there was a lot […]
Listen
How to be a Programmer: Personal and Team Skills from 2016-01-28T05:38:17
Talking about the short book “How to be a Programmer”, which covers a huge spectrum of important topics for developers of all levels.
Show Notes: http://www.codingblocks.net/ep...
Our Favorite Developer Tools for 2015 from 2016-01-03T22:56:05
We wrapped up 2015 with another favorites of 2015 and a chance to win a gray Coding Blocks T-Shirt just by leaving a comment on the show notes page! Tools are anything from hardware, to software o...
Listen
The Twelve Factor App: Dev/Prod Parity, Logs, and Admin Processes from 2015-12-20T16:18:12
Welcome back to the dramatic conclusion of our discussion on the 12 factor app. This time we're talking dev/prod parity, logs, and admin processes. Oh, and Call of Duty!
Listen
The Twelve-Factor App: Port Binding, Concurrency, and Disposability from 2015-11-23T05:01:16
It's time for more DevOps fun as we continue learning about the Twelve-Factor app. This week we dive into the next three chapters: port binding, concurrency, and disposability.
Listen
Toys for Developers from 2015-11-10T02:42:34
The holidays are coming sooner than we realized, so we gotta get our wish lists together. After all, no one wants to sit around the Festivus Pole without their favorite dev toys. This week we discu...
Listen
The Twelve-Factor App: Backing Services, Building and Releasing, Stateless Processes from 2015-10-22T01:40:32
We're headed back to the Twelve-Factor app territory and this time we're picking up with the next three chapters - backing services, building and releasing and processes. Jump in to get the showno...
Listen
The Twelve-Factor App: Codebase, Dependencies, and Config from 2015-09-17T20:54:45
Dipping our toes into the DevOps waters with the Twelve-Factor App. How important is depedency management, and how fired would you be if you accidently leaked your company's source code?
...
Javascript Promises and Beyond from 2015-08-22T15:48:53
In this episode we dive into Javascript Promises. If you're used to the olden way of doing an async call with a callback, you'll definitely want to give this episode a listen as you could improve ...
Listen
Design Patterns Part 4 – Adapter, Facade, and Memento from 2015-07-26T12:00:44
Part 4 of our design patterns series, this time up it's Adapters, Facades, and Mementos. Oh, and which tech luminary would make the best head of state!
See these notes on the w...
Hierarchical Data cont’d – Path Enumeration and Closure Tables from 2015-06-29T16:09:35
It's that time again.
This week we answer a question, Allen registers for school, Joe reads some numbers, Michael breaks out the survey results, and Joe cringes at the thought ...
Hierarchical Data – Adjacency Lists and Nested Set Models from 2015-06-08T22:29:22
So, how DO you persist hierarchical Data? We discuss two common solutions to this age-old problem: Adjacency Lists and Nested Set Models. Also, Build Atlanta, technical problems, multi-monitor vs u...
Listen
Your Questions Our Answers SYN-ACK with Packet Loss from 2015-05-08T03:42:46
In this, Episode 27 of the Coding Blocks Podcast, we are answering several questions / comments from our listeners regarding: more frequent episodes, naming of classes / assemblies, Test Driven De...
Listen
Algorithms, Puzzles and the Technical Interview from 2015-04-19T18:37:09
In this episode we discuss algorithms, puzzles and the best way to ensure you're prepared for an interview programming problem. It's not uncommon for interviewers to have software developers write...
Listen
ASP.NET 5 – It’s Basically Java from 2015-03-30T02:23:18
This week we give away Joe's stuff, we break up with IE8 like a big boy, Joe and Allen get excited about readme files, and we argue about which is worse: bad code or bad architecture. That and more...
Listen
Delegate all the things! from 2015-03-16T02:36:15
This week we tackle one of life's great questions, does Jack Bauer give high fives? Also, we go over everything you need to know about delegates, events, callbacks and closures in .NET.
<...
Back to Basics – Encapsulation for Object Oriented Programming from 2015-02-10T05:49:17
It's time to get back to basics. It's easy as a software developer to be working on the latest and greatest frameworks, using the best methodologies, trying out new things. Sometimes it's a good ...
Listen
Silverlighting through your College Enumeration from 2015-01-21T23:51:06
Organizing your code, moving from school-work to work-work, the future of Silverlight, and lots of poo-pooing!
See the full shownotes here:
http://www.codingblocks.ne...
Our Favorite Tools from 2014-12-28T19:48:02
We gather around the Festivus pole this holiday season and before we get into the Airing of Grievances, we discuss our favorite tools. No, not people. Actual tools. Srsly.
See ...
We’re Testing Your Patience… from 2014-12-15T05:16:31
If you're a software developer, one of the things you do in your daily job is test your code. You may be testing by running your application and trying out various things to make sure it works pro...
Listen
Design Patterns – Iterators, Observers, and Chains, Oh My from 2014-11-09T01:53:47
We're back to the gang of four, continuing with another segment of design patterns. This time we're talking about some of our favorite Behavioral Design Patterns: Observer, Chain of Responsibilitie...
Listen
Programmer Questions and Answers from 2014-10-26T03:06
We're excited about ASP.NET vNext, we might be Superman, a cute little ninja was MEAN to Allen, and we attempt to answer some questions.
See the full shownotes here:
...
Got Any Hot Stacks?! from 2014-09-26T03:48:25
In this episode, we have a discussion about what type of technology stack you should choose when you go to create your own project whether it be for profit or an open source type of deal. As progr...
Listen
Design Patterns Part 2 – Oh behave! from 2014-09-05T23:59:34
In this episode we have quite a bit of news to discuss as well as the main topic, behavioral design patterns for Object Oriented programming. This continues the series on letting you know about th...
Listen
Static Analysis w/ NDepends – How good is your code? from 2014-08-10T21:04:52
This week we're discussing NDpend, a static analysis tool for .NET.
Triage your biggest problems, Prioritize your refactoring, and CYA with real metrics and trend lines.
<...
Databases the SQL [see-kwuhl] from 2014-07-25T03:52:10
Welcome back for part 2 of the podcast about databases. In this half, we discuss several of the things we believe that developers should know about databases. From joins to unions, group by's and...
Listen
All Your Database Are Belong to Us from 2014-07-14T02:42:25
Part one of our two part database podcast starts with choosing the RDBMS (Relational Database Management System) and what to do when you run into deficiencies in that particular database system. F...
Listen
What programmer do you want to be? from 2014-06-22T23:39:53
"Water Cooler" episode talking about sweet sugary C# kisses, JavaScript as a first language, T-shaped developers, how to get addicted to drugs and...Where in the World is Carmen Sandiego?
Listen
Design Patterns Part 1 – You Create Me! from 2014-06-07T11:20:10
This week we're tackling the first section of seminal Design Patterns book: Creational Patterns.
We discuss factories of factories, "bullet hell" games, pathological liars, and...
C# 6 and Roslyn – Pour Some Sugar On Me from 2014-05-05T00:25:40
In this episode, we talk about new features in C# 6. What we like, what we love...and binary literals.
For the full show notes and links, please visit:
http://www.cod...
Aspectacular with Vlad Hrybok – You down with AOP? from 2014-04-01T17:16:01
You down with AOP - Aspect Oriented Programming? This week we're talking with Vlad Hrybok about his spectacular Aspect Oriented Framework: Aspectacular.
For all the show notes ...
Accessories for Programmers from 2014-03-18T00:30:36
Q: What do developers love more than developing?
A: Expensive accessories!!!
This week we're talking about our Christmas in July lists. Dream keyboards, mouses, offic...
SOLID as a Rock! from 2014-03-03T03:06:17
In this episode we tackle the SOLID principles in .NET and discuss the eternal struggle between perfect code and looming deadlines.
For the full show notes and links, please vi...
There’s Something About LINQ from 2014-01-25T05:40:31
In this episode we discuss LINQ - Language Integrated Query , what's so special about .NET, the differences IQueryable and IEnumerable, and another round of "Never Have I Ever". Oh, and jokes!
Listen
We Still Don’t Understand Open Source Licensing from 2013-12-28T02:37:50
We're trying to wrap our heads around open source software licensing. We discuss the main types of licenses (and a few of our favorites!), what it means to violate a license, and take a fun look at...
Listen
OWASP and You! from 2013-11-27T11:59:37
This week, we talk about OWASP and their list of top 10 application security risks. What they are, infamous examples, and what you can do about it. Application security is becoming increasingly im...
Listen
Source Control Etiquette from 2013-10-12T02:36:32
This episode is all about source control etiquette. Whether you use GIT, Subversion, CVS, Source Safe, TFS, Mercurial, or other, you can pick up some advice on things to do or avoid.
Boxing and Unboxing in .NET from 2013-09-28T14:08:39
This episode is all about boxing and unboxing. We discuss memory management, the pros (yes, there are a few!) and cons of boxing/unboxing, some of the weird side effects and how to you can avoid it...
Listen
I is for Interface from 2013-09-09T15:26:57
The good, the bad, and the ugly side of interfaces. We list some minor gripes, their limitations, and some strange gotchas as well as some tips for how we like to (mis|ab)use them.
...