Toby's Clean Spring - Domain Model Pattern and Hexagonal Architecture Part 1

If you're someone who wanted to write code that goes beyond simply functioning well to code that is easy to maintain and structurally clean, I think this course will be of great help. Even developers with some experience in Spring development often find themselves at a loss about how to actually apply domain-driven design, and this course guides you well to solve such concerns one by one. I was particularly impressed by the way it explains what domain models are, why they are important, and how to incorporate them into realistic code structures through a combination of theory and practice. While it may feel somewhat difficult at first, Toby's delivery is calm and kind, allowing you to follow along to the end and internalize the concepts. Also, because it shows practical examples that can be applied directly to real work along with actual refactoring processes, I think it's a course that has both learning immersion and practicality. If you're a developer who has ever thought "I want to try clean design now too," you'll be able to find a more concrete direction through this course. I sincerely recommend it to those who want to gain a perspective of viewing applications from a domain and business-centered approach, beyond functional implementation.

As a junior developer, while applying hexagonal architecture in development with only a very basic level of knowledge, I encountered this lecture. Through the course, I was able to clearly organize concepts that I had not properly understood or had misunderstood. It was a great help that the lecture deeply and meticulously explained points where junior developers often get confused, or content that is usually easy to overlook. When developing, there are many cases where one simply follows trends like "they say this is how it's done nowadays" or "they say that's good," but this lecture went beyond such trends and pointed out why things should be done that way and on what basis they were designed, which was very impressive. What particularly stands out is that it explained the basis of concepts using official documents like RFC standards, and also taught how to efficiently apply them to Spring. Furthermore, when unexpected bugs or exceptional situations arose during the lecture, I learned a lot by observing the process of resolving them. I believe the debugging process, which involves interpreting error messages and analyzing the current situation to infer the cause, is an indispensable and important part of development. Personally, it was a valuable experience, like pair programming with 토비님, and I highly recommend it to other developers to experience at least once. 😊

Hello. I have Toby's Spring book, but this is my first time taking the lecture, and I really appreciate how meticulously you explain the parts that require attention and care at the code level. Of course, other contents are also very helpful, but I also liked that you explained even basic things like why line breaks are done this way, or how to separate things by meaning units... things that make you wonder, 'Do we really need to explain this?' I actually have a lot of interest in these kinds of things. So, I appreciate that you explain them even without me having to ask separate questions. I'm also reading the questions students post in the community. Each answer is very helpful because it contains thorough explanations. Thank you ^^ I'm currently listening to Section 4, and I'll come back to leave another review after completing the course. Thank you ^^ -------------------------Course Completion Review Before taking this course, my foundational knowledge was scattered among concepts like Clean Architecture, Domain, Test Code, Object-Oriented Code, Refactoring, and so on. After watching the lecture on DDD development methods within Hexagonal Architecture, it felt like my scattered knowledge was coalescing. Ultimately... I realized once again that my foundational knowledge was all about writing good test code. Being able to see the development process in detail, from initial design to unit tests and architectural design, seems incredibly beneficial... It felt like directly observing development from the side... I learned so much new knowledge, and I plan to absorb it all before part 2 comes out. I'll ask questions as they arise during my review to make this knowledge my own. Thank you, I look forward to part 2!!!

When I first developed with Toby, I hoped fellow developers could also experience those times. So, I suggested the idea for a roadmap called <토비의 클린 스프링>. The first lecture of that roadmap has started, making me excited! With this lecture, discuss business together, apply to development, learn, try in practice... I hope you enjoy taking it in your own way. I'll also diligently attend and gradually fill in where I'm still lacking. Anyone who wants to join~?🥰

Hearing that the lecture was released, I decided to watch it over the weekend and just finished it. It was a valuable time where I could indirectly experience the work style and know-how of Korea's Spring Commander. Although the difficulty is classified as beginner, I believe that regardless of difficulty, another developer's work style and way of thinking are not something you can easily hear just anywhere. The process of incrementally changing code while designing models, considering roles that should be held, and states required for those roles, along with occasional glimpses of humanity (typos, omissions) that were identified by test code, truly highlighted the value of test code, as these are countless situations that can occur in daily life. There's a lot of testing know-how, such as the use of Fixture, Mock (Stub), identifying what to verify, actions, and purposes, and distinctions like unit and integration testing! junit-platform.properties amazing MockMvcTester amazing Especially the section "Facts and Misconceptions of Hexagonal Architecture" was impressive. Since I only had patchy knowledge, it felt like the difficult parts were well-organized, as it clearly pointed out how founders like Eric Evans and Alistair Cockburn expounded and what essential aspects they spoke about. This lecture would be helpful for the following people: Senior developers who need to lead design Those who have studied and experienced Hexagonal Architecture projects but feel they lack deep understanding Those who want to properly learn about Domain Model Pattern, Transaction Script Pattern, and Hexagonal Architecture Those who want to know how Spring Commander develops I learned about a composition method that gained many benefits through Clean Spring and integration with Spring. Thank you. I don't develop without Spring. Spring is POJO!!!

I'm transferring the course completion review I left on LinkedIn to Inflearn as well. https://www.linkedin.com/posts/arawn_%EA%B8%B0%EB%8B%A4%EB%A6%AC%EB%8D%98-%EC%9D%B4%EC%9D%BC%EB%AF%BC%EB%8B%98%EC%9D%98-%EC%8B%9C%EB%A6%AC%EC%A6%88-%EA%B0%95%EC%9D%98-%EB%A1%9C%EB%93%9C%EB%A7%B5-%ED%86%A0%EB%B9%84%EC%9D%98-%ED%81%B4%EB%A6%B0-%EC%8A%A4%ED%94%84%EB%A7%81%EC%9D%98-%EC%B2%AB-%EC%A3%BC%EC%A0%9C%EC%9D%B8-activity-7352614457123987456-pleA?utm_source=share&utm_medium=member_desktop&rcm=ACoAABvezLwBBEWVnGUkIY_xxm2aE3-sGtVHt0g -- Lee Il-min's lecture once again did not disappoint. His characteristically thoughtful and kind explanations, as well as the way he calmly unfolds his thought process through live coding, were particularly excellent. The way he proceeds by pointing out what he's thinking and with what intention he's writing code was truly admirable. Following the lecture, I could feel an immersive experience as if I had become the instructor myself, experiencing his thought process firsthand, and through this, I naturally came to understand how to apply domain model patterns and hexagonal architecture when developing applications with Java and Spring. While the technical depth was outstanding, what particularly impressed me about this lecture was how it demonstrated the 'attitude toward technology' and 'learning methods' of a professional. First, it clearly presents the correct approach to technology learning. When explaining hexagonal architecture, the content is developed based on the original text and core arguments of Alistair Cockburn, who first proposed it. This seems like an obvious approach, but in reality, many people encounter technology through secondary or tertiary processed content rather than primary sources. While processed materials can be useful for understanding, there's also a risk that the original author's intent may be diluted or distorted. It reminded me once again that to understand the essence of technology, we should access original sources whenever possible. Second, I could truly appreciate the importance of having a thinking approach equipped with one's own logic. For example, in the "Entity vs DTO" class, he logically demonstrated his views on why using entities in the presentation layer is not problematic. As developers, when we make any technical decision, we should be able to explain the reasons with our own logic rather than relying on external authority. This is obvious but not easy to practice in reality, and Lee Il-min directly shows how to implement this obvious principle. This lecture was a valuable experience that didn't just teach technology but also conveyed the mindset and attitude that developers should have. I highly recommend it to those who want to approach development seriously.

In a place full of chaos and disorder, Toby said, "Let there be light," and light appeared, setting things in order. I feel like I'm seeing the definitive argument regarding the domain model pattern and hexagonal architecture, which I've been pondering deeply. Highly recommended.

I wanted to watch the course right away after purchasing it and write a review quickly, but time has passed and I'm only now leaving my feedback. Tears.. 😢 Once again, I could feel that the saying "Toby's lectures you can trust and listen to" didn't come about for nothing!!! Recently, many developers have shown increased interest in hexagonal architecture, and various discussions are taking place. However, it seems that misconceptions about the concept are also growing. But in this course, to clear up such misunderstandings, you carefully went through the definition of architecture from the beginning and logically explained why such structures are necessary, which was very impressive. Especially, it wasn't just limited to theory, but you explained it with actual examples, which made it much easier to understand. Also, many people have questions and sometimes feel confused about JPA annotations like @Entity and @Column invading domain models. What was really great about this course was that you shared deep thoughts on that part and presented realistic solutions. The way you faced the concerns frequently encountered in practice head-on and addressed them one by one, along with explaining appropriate trade-offs, was impressive! It was the best. And when developing, complexity gradually increases, and often we end up losing track of the flow of the systems we created ourselves. But in the course, you systematically showed how to handle such complexity and how important the process of organizing complexity is, and the approach of continuing development based on that was really impressive. These parts contained practical content that's hard to see in other courses. The immersion was so high that it felt like being on the same team as Toby and working on an actual project together. And what I liked most was the flow of gradually improving while thinking together without hastily presenting answers. This approach was so similar to real development environments that I could naturally learn not just receiving knowledge, but what perspective to view problems from in practice. It was a really enjoyable course experience. While watching the course, those days when I developed in the past flashed by, generating dopamine, and I missed those times. I really want to look forward to the next course! It was really so so so so fun! Thank you so much for providing such a precious course!