Відео

I sentence you to… listening to background music that’s too loud! Good suggestion, the next 2 will be the same but next ones will be less loud

Thanks for commenting, I love being challenged. Let's take an analogy: driving a car What I'm basically saying is that future building slows you down and that you should avoid it when you are speculating so this way you can go faster. That doesn't mean I'm saying drive at 180 km/h or mph I'm saying if you do it when you don't need you it will take you longer to get to your destination (ship the product) If you know what the future holds then of course you should plan and put stuff for it, but only when you are absolutely sure. And even then for me that's a bit of a grey zone. What if the product flops? Ships and then is abandoned? What does all this future-proofing give you? The product is dead...

@@theseriouscto You haven't ever gone back into a dead project for that one amazing thing that absolutely is fits the the issue you are currently having. Basically what I mean is. Future proofing is ensuring that not only yourself, but other people that you may never actually meet, you can feel more assured that you, and they will not have to solve the problem from scratch a second time.

What you’re explaining is writing clear and clean code Not implementing a whole scaffolding of abstractions or interfaces that are only used in one straight line to a single class Different things no?

Love this question, but you're probably not going to like my answer: It doesn't matter Non-coding managers should not tell you how to code. Therefore, you should be in complete control over the parameter list and how long it can get. Refactoring is your friend. If non-coding managers want to code, hand them the keyboard for a few months and turn off your cell phone. Tell them you'll go do their non-coding job (accounting, marketing, counting paperclips, etc...) Now, telling you what features are needed is another story altogether, so much so that it has nothing to do with coding. They describe the feature, you figure out how to code it.

That's exactly the point-we're often overbuilding solutions to problems that don't exist yet! We all know that one day that special person in our lives may need bigger clothes... But let's not buy those clothes until they are needed ;-)

The real context will draw a BIG LINE between speculative and the real project context Given that most software projects never get finished, I think it's important to always leave the fluff for later Refactor later is not a lie, it's work Get it working, get it working well, enhance it, repeat

Yeah Nora is a keeper, fun fact I now don't record when she's around since she tries to climb on me at the worst moments. Gotta love them ;-) More fun fact? Nooby which is much older is more used to be recording and just lays at my feet.

@@theseriouscto A... Nora... not noah, my bad. Such a cutie ^^

I think I'm attacking everyone ;-) Couldn't agree with you more, hence the power of saying no - OR - priorities. Suits want everything but they have to prioritize and you start with the most important thing. Would a suit get married and fix issues with the bride later? Well we don't write software like that either

Absolutely! It’s like some engineers think they’re composing Shakespeare when they’re really just writing a grocery list. Let’s aim for clarity over complexity!

Ah yes, the classic 'queryString of doom'-where a simple GET call looks more like a ransom note. 😂 While it’s true GET shouldn’t accept a body, cramming a dozen parameters into the query string often signals that the API might need some rethinking. Sometimes, it’s worth considering whether those parameters could be grouped into a resource or if the endpoint should be restructured to better fit the use case. After all, readability and maintainability are just as important as sticking to HTTP conventions.

@@theseriouscto - some cases, like my last API, are constrained by decisions lost to the annals of time. And to top it off, the "data store" is an old mainframe with an old XML based "API" that required 4 fields just to get past security checks. Some days you just have to package that ransom note into an object then use that one object everywhere (GET/POST/PUT/DELETE/etc). GETs are a querystring that is turned into this "channel" object. All the others that take a body have this same object as a child object. I really appreciate this series as param passing is where I see a lot of "huh?" moments! 😛

We are 100% on the same page, and that's the definition of Speculative Generality. I think the word Speculative gives it away ;-)

Maintaining bad code is like cleaning up after a party you didn't throw! At least now you know how to throw a better one next time!

So Sorry about that. Out of curiosity what content would you suggest?

Wow, two years of refactoring sounds like a tough lesson-I'm sure that’s not an experience you want to repeat! You make a great point about known futures. Ignoring clear signals of where the code might need to go can create massive technical debt and costly downtime, as you've experienced. I also think it’s important to distinguish between speculating on features and knowing about them. Speculation often leads to over-engineering for hypothetical needs, while ignoring concrete, foreseeable changes can have consequences like the ones you described. Your approach of investigating possible futures without overcommitting to them strikes a great balance. It’s about acknowledging likely changes and ensuring you’re not actively working against them while still focusing on solving today’s problems. Thanks for sharing-it’s a valuable perspective and a reminder for everyone to keep their eyes open for those 'known futures' without falling into the trap of speculation.

Great point! Striking the right balance between abstraction and simplicity is like walking a tightrope-lean too far either way, and things get messy. On one hand, too much abstraction can lead to unnecessary complexity that bogs down the whole team. On the other, too little structure turns the codebase into a plate of spaghetti no one wants to touch. My advice? Start simple. Build just enough structure to solve the problem at hand while keeping things flexible for future changes. Use refactoring as your safety net-let the code evolve as the requirements become clearer. And don’t be afraid to involve your teammates in these decisions; shared understanding is the key to maintainable code. Oh, and if a function starts approaching 1000 lines, that’s probably your code tapping you on the shoulder saying, 'Help me, I’m drowning!' 😂 Is getting a refactoring tool an option for you? I'd be curious to see if a good one spots patters.

@theseriouscto I don’t have any experience with refactoring tools, but if you have any recommendations let me know! I finished my internship at the company I was working at, and I’m not sure if it would be an option anyways, but would be nice to know.

@@owenm3112 What tech stack do you use?

Ah the classic case of "just in case" tables! Built on the ideology of inspector gadget ;-)

Happy we're on the same page, out of curiosity what content would you suggest?

Not intentionally, but I’ll take it if it makes me sound smarter! 😄 The idea does align with Altshuller’s TRIZ philosophy: the best solution is one that eliminates the problem entirely. In coding, that often means solving the problem so elegantly-or questioning whether it needs solving at all-that you don’t end up writing unnecessary code. Truly a case of less is more!

@theseriouscto it's in my email signature "the ideal system is when there is no system" along eith Churchill's exhortation "no idea is so outlandish..." etc.

Funny comments? Absolutely-future devs deserve to laugh while crying over the code! Just remember, comments are like seasoning: too few, and it’s bland; too many, and you’ve turned your code into a novel. Aim for the sweet spot where they’re useful, hilarious, and don’t double as a stand-up routine.

@@theseriouscto I can only write comments and no code so my opinion doesn't really matter. But as a problem solver, my view is that in the future I'm much more likely to go back to notes to see HOW I was thinking than WHAT I was thinking. In other words, I learn from the process more than from the results. Put another way: the way to future proof code is make it so you're better at coding after every project.

@ I have a great video coming up on a comment smell scheduled for Jan 5th I think you will enjoy the value it will bring

Welcome aboard! I’m excited to have you here. Stick around, and I’ll do my best to bring you something new, insightful, and maybe even a little fun along the way. Let’s make learning awesome together!

True, in game dev, future-proofing is like setting the rules for a board game before anyone starts playing-it keeps things consistent and makes adding new pieces a breeze. But even then, the trick is to future-proof just enough. Build for expansion, not for every possible DLC idea that might pop into your head at 3 a.m. Otherwise, you’re just creating a boss-level challenge for yourself!

Or maybe developers are just used to a different set of design patterns. I think it's key to have a common understanding how code is developed in a dev team. This might change with time but should not change over night.

Ah, the classic 'over-engineered code handoff'-where one dev’s masterpiece is another dev’s nightmare. Complexity is relative, isn’t it? What feels like elegant design to one person might look like a crime scene to someone else. 😂 That’s why shared team standards are so critical. A consistent approach gives everyone a common language to work with, minimizing that ‘what fresh hell is this?’ moment for whoever inherits the code. And yeah, evolving those standards is fine, but doing it overnight? That’s how you give your team whiplash!

That Venn diagram is where optimism goes to die! 😂 But you're spot on-there’s a difference between guessing wildly and making an informed bet on a likely future. Planning for the inevitable? Smart. Trying to outsmart the unknown? That’s how you end up with a Rube Goldberg machine in your codebase.

Absolutely! Premature optimization is like packing for a trip to Mars when you're just planning a weekend road trip-you'll probably end up hauling a lot of unnecessary baggage and still forget your toothbrush.

@@theseriouscto Abso-fkn-lutely.

It's not speculative then

If you’re basing your abstractions on known patterns or prior experience, it’s not speculative-it’s informed design. The distinction lies in whether you have concrete evidence or are just guessing about future needs. Speculative generality becomes a problem when developers try to anticipate future requirements without sufficient context or data to justify those decisions. This often leads to over-engineered solutions that solve problems no one actually has, making the codebase harder to work with. On the other hand, leveraging prior experience to create abstractions that address recurring patterns is a smart way to future-proof in a controlled, meaningful way. The key is knowing when you’re dealing with a recurring problem versus stepping into the unknown.

You’re absolutely right-performance can make splitting data impractical, especially at 'trillion vertices' levels. Encapsulating the entire dataset with getters, setters, and pointers to internal arrays can be the right call in those cases. Objects are a tool, not a religion! That said, I don’t propose silver bullets. I propose solutions to actual problems-problems that exist. If your current approach works and doesn’t cause issues, there’s no need to go hunting for problems to solve, especially if they don’t exist yet. Overengineering is just speculative generality in a shiny new outfit.

Thank you for the thoughtful comment! You bring up an excellent point about how developers often default to solving problems with code because that's the toolset they know best. I agree-sometimes, these issues are better addressed through team standards and tools, but that requires organizational buy-in, which isn't always easy to get. In my experience, most products don't even make it to the shelf, so the priority is often building a minimal viable product as quickly as possible. While I don't advocate writing bad code, there are so many great refactoring tools available now that cleaning up the code later isn't as intimidating as it once was. So, for early-stage projects, I recommend focusing on getting the product out the door without worrying about future-proofing. After all, if the product doesn’t succeed, all that extra effort was wasted. That said, explaining this approach to management can be a challenge. I’ve found that construction analogies work well for this. For example, you can compare bad code to poorly placed electrical wiring: it works initially, but if you later need to add plumbing in the same spot, you’ll have to redo the wiring first. This helps non-technical stakeholders understand why cleanups like refactoring are necessary. Finally, when you have these conversations, it’s important to establish your role as the technical expert. A little humor helps: I like to tell management, 'I won’t mess with accounting or marketing if you don’t tell me how to architect software or write code!' It’s lighthearted but gets the point across.

Sub #953? You're officially part of the cool kids club! Welcome!

I know right? I can usually debunk that one just by looking at the queries and see if they use specific functions ;-)

@@theseriouscto you have to be prepared. You might get a call in the 3am and you have to change the DB immediately :)

I've actually done that. One of our products used to sync through Dropbox, and we moved it to sync via S3. Because of the abstract base class, it was relatively non-invasive. That said, it's not a sure thing that the base class helped. I could just have changed all references from Class A to Class B, and implemented functions until it compiled again. And it was a one-time deal.

@@ivanmaglica264 Definitely, my DevOps team got those calls from clients all the time

@@HollywoodCameraWork If the base class didn't really help then it wasn't done right and didn't need to be done. Sounds like you deal with some strange issues.

Clear and concise? Looks like I’m on a roll! Next up: making spaghetti code look like gourmet cuisine!

Inappropriate intimacy? Sounds like a coding class I’d sign up for! Just remember, keep your code clean and your jokes cleaner!

You are very welcome Regards from a grey beard 😄

Thanks for the positive feedback and welcome aboard. Let me know if there’s anything specific you’d like to hear about.

Totally agree but equally true for many other professions. I think a simple slack channel for these kinds of announcements is best as it will minimize the chatting and distractions. The higher up can monitor it and push out the message when necessary.

99% agree, the 1% would be the details and scope of the rewrite

I know right? Common sense as it turns out is not that common, it’s rare Should we call it rare sense?

A) What a coincidence, I was asking myself that very question! B) Thought about it, I think you're the 2nd person to suggest this to me through comments - Problem is my recording studio prevents me from having a large one... but I've been thinking about alternatives like an iPad and a Pen... You think that would fit the bill?

@@theseriouscto I think it removed my comment from earlier... either way any visual aid like a diagram or ipad will work just as well if not better

@@niftylius Ok, let me see what I can do - thanks!

Been thinking about that, also been thinking about making them available through GitHub - What would be your personal preference?

Thanks for the comment! I appreciate your perspective-UML and class diagrams certainly have their critics, and there’s no one-size-fits-all approach to software design. You’re right that some diagrams can become stale or irrelevant if they’re not updated. That’s why, in my experience, they work best as lightweight planning tools for aligning teams early on, especially in larger projects. They’re not meant to replace iterative practices like TDD but to complement them when mapping out complex systems. As for the 'wonderful system that doesn’t exist,' I can see where you’re coming from. But in real-world scenarios, like when I sold software to a major automotive manufacturer, UML diagrams were a necessary part of the process (big-company vibes, right?). We only used them for critical areas, and they added just enough clarity to get everyone on the same page without over-engineering. Ultimately, whether it’s UML, TDD, or any other methodology, the key is flexibility-using the right tool for the right job. Dogma rarely works in software, and I’d never recommend a one-size-fits-all solution. What works for one team or project might not work for another, and that’s perfectly okay.

Nice reply, probably better than my sarcasm warranted 😂 agreed completely!

Awesome, let me know if there’s any specific subjects you would like me to pick

@@theseriouscto Tech zoo - having too many languages and methodologies in the same project.

@@niftylius Love it, definitely putting on my list

Haha, I get where you’re coming from! The software industry does have a knack for rebranding concepts, often to make them easier to communicate or to highlight their broader applications in new contexts. You’re absolutely right that the core idea behind Inversion of Control has been around for a while-function pointers, virtual tables, and callback functions are great examples of similar concepts. What IoC does differently, though, is take these principles and organize them into a systematic approach that scales well in large applications. It’s not just about function calls but about managing object lifecycles and dependencies at an architectural level. As for the “Cloud” comparison-spot on! It’s the same infrastructure idea rebranded with a buzzword. 😂 But hey, if these new names help more people understand and adopt useful ideas, maybe it’s not such a bad thing! Glad you’re seeing through the jargon, though-it’s always good to remember the roots of these concepts. Thanks for sharing your perspective! 😊

Thanks for the feedback! 🎉 You’re absolutely right-sometimes too many metaphors can water down the technical depth, especially if you’re here for hands-on coding insights. The goal was to make IoC accessible to a wide range of viewers, but I see how it leaned more toward explanation than demonstration. Here’s what I’ll do for future videos (and maybe even update this one!): 1. **Trim the Metaphors:** Stick to *one clear analogy* to explain the concept, then dive into a real-world coding example. 2. **Bad-to-Good Workflow:** Show a messy, tightly coupled code example (bad), explain its issues, and then refactor it using IoC principles (good). 3. **Balance the Audience:** I’ll make sure the video stays technical enough for developers but still approachable for non-programmers. In fact, since you mentioned it, here’s a quick **example** I’d include in an update: **Bad Example (Tightly Coupled Code):** (java) public class UserService { private UserRepository userRepository; public UserService() { this.userRepository = new UserRepository(); // Hardcoded dependency } public void saveUser(User user) { userRepository.save(user); } } (/java) **Why It’s Bad:** The `UserService` depends on the specific implementation of `UserRepository`. If `UserRepository` changes (e.g., switching to a caching layer), you’d have to modify `UserService`, breaking modularity. **Refactored with IoC (Dependency Injection):** (java) public class UserService { private final UserRepository userRepository; public UserService(UserRepository userRepository) { this.userRepository = userRepository; // Dependency injected } public void saveUser(User user) { userRepository.save(user); } } (/java) **What Changed:** Now the `UserService` doesn’t care how the `UserRepository` is implemented-it just needs the interface. This makes the code more testable and flexible. Let me know if this kind of example would resonate better. Thanks for helping me improve the channel-your input is gold! 💡

@@theseriouscto Hey! Nice to see that you take the feedback seriously! I think the example muddies the distinction between IOC and DI. For the latter you can just point people to the Code Aesthetic video. That's like gold standard coding video so I'd recommend not to compete there but to make a complementary video about different examples of IOC and then just point to CA's video for those interested. Best of luck!

Thanks for your honest feedback-it’s super helpful! 😊 It sounds like the metaphors were intriguing but didn’t quite connect the dots for you. Let me break it down a bit more plainly: Inversion of Control (IoC) is about shifting the responsibility for creating and managing dependencies away from your code and into a central system, like a framework or container. Instead of your class saying, “I need this tool, let me go build it,” it says, “I need this tool-someone else will hand it to me.” For example, imagine you're building a house. Normally, you’d hire a plumber, an electrician, and a carpenter yourself (this is like your class creating its own dependencies). IoC is like hiring a project manager who brings in the right specialists for you. You just focus on designing the house (your app logic). If you’re curious, I’d recommend checking out our videos on **SOLID Principles** and **Shotgun Surgery**-they explore related ideas in a more step-by-step way that might make IoC click for you! Let me know if you’d like a deeper dive or more examples! I'm here to help. 🙌

@@theseriouscto Yeah, another metaphor isn't helping here. You're bringing coals to Newcastle. What I don't understand is how this differs from what I do already in say, JS and Java, by listing out imports at the top of the file--which is what it sounds like IoC would change--, and what difference it would make for programming in those languages.

Great question-let’s break this down! IoC isn’t about changing how you handle imports at the top of the file. It’s about shifting the responsibility of creating and managing dependencies away from your code and into something external, like an IoC container. Here’s what this looks like in practice: ### **Manual Wiring vs. IoC** **Without IoC (Manual Setup):** ```java public class UserService { private UserRepository userRepository; public UserService() { this.userRepository = new UserRepository(); // You create it manually } } ``` Here, `UserService` determines *how* `UserRepository` is created and tied to it. If you need to switch to a `MockUserRepository` for testing, you’d have to change this code. **With IoC (Dependency Injection):** ```java public class UserService { private final UserRepository userRepository; public UserService(UserRepository userRepository) { // IoC Container injects it this.userRepository = userRepository; } } ``` Now, the IoC container handles creating `UserRepository` and injecting it into `UserService`. Want to swap `UserRepository` for a mock? Update the configuration, not the code. --- ### **Why This Matters** IoC isn’t just about avoiding manual wiring-it’s about making dependency management **external and flexible**. Instead of hardcoding object creation, IoC lets you decide via configuration, annotations, or environment settings. **Example with Configuration:** ```java @Configuration public class AppConfig { @Bean public UserRepository userRepository() { return new SqlUserRepository(); } } ``` This way, your code doesn’t care *which* implementation of `UserRepository` it’s using. Testing? Use `InMemoryUserRepository`. Production? Use `SqlUserRepository`. The system is modular, scalable, and easier to test. --- ### **What About JS?** In JavaScript, you might use frameworks like Angular or NestJS to leverage IoC. Even in React, hooks like `useContext` mimic some IoC principles by centralizing dependency management. The real benefit is **decoupling your app’s logic from its plumbing.** Your objects stop worrying about *how* to get their tools and focus only on using them. Let me know if this clears things up or if you’d like a deeper dive into any part! 🚀

I agree with you on the quantity of code part, however... Ever consider how computers work? Say with all those different types of printers? Ever hear of drivers? Flexibility, Scalability and Maintainability are the 3 key advantages. I wouldn't use this approach to press less keystrokes on the keyboard, but to make my system flexible, extensible and/or configurable without needing to recompile. No?

IoC is the what, not the how. It’s the principle. One popular way to implement IoC is through Dependency Injection (DI).