diygoapi VS wild-workouts-go-ddd-example

Hi Go reddit community! For my https://github.com/gilcrest/diygoapi project, I recently re-refactored the way I do errors (this is like my 5th time over the years). I wrote a quick post and updated the README with details - the post is here: https://dangillis.dev/posts/errors-again/

Great idea. Added Issue 20

Hey - I've been working on something like this for a while. Take a look - https://github.com/gilcrest/go-api-basic - as others have said this is really an opinionated thing, there are no standards, but I've found some ways of structuring web apis that I like over the years. I'm still learning and making changes, so it's in no way static, but you may get some ideas.

I have been working on a project called go-api-basic for a while now and setup what I think is a decent way of implementing transactions. In my datastore package I have a Datastorer interface, with a DB() method to return the sql.DB, a BeginTx method to begin a Transaction, a RollbackTx method to rollback a transaction and a CommitTx method for committing. The Datastore struct implements this interface and has appropriate error handling, etc. In my controller package, you can see how I use this towards the end of the CreateMovie method. I've actually been working on this thing for 3.5 years and this is the first time I've ever posted on reddit about it haha, hope it helps.

I am writing a simple project like this called go-api-basic - I'm in the middle of adding tests (I know, wrong order) and rewriting the README, but what's there you may find helpful.

Take a look at: https://github.com/ThreeDotsLabs/wild-workouts-go-ddd-exampl...

(I’m one of the authors.)

This project shows how to apply more complex patterns popular in business applications while staying true to the Go ideas, and not copying them blindly from Java.

In the Go community, you’ll often hear people say „just keep things simple” beats all patterns and is all you need. This may be true if you write a CLI tool or a small library, but if you have a team maintaining a big application, some patterns are super helpful.

Here is a reference implementation by the same authors of the blog post you referenced: https://github.com/ThreeDotsLabs/wild-workouts-go-ddd-example/tree/master/internal/trainer.

In this case I recommend Three Dots Labs blog and Ardan Labs courses and blog posts.

As a rather new developer, I'm ashamed to admit that I struggle with this. I've seen the Dave Cheney writeup about it and I agree with your reasoning, but sometimes I end up in situations like this, where they wrote a server utility, put it into the common package and imported it into the services that need it. The issue I have is the organization of it all because the folder structure seems to make a clear separation of the core services from the utility package. If you have any ideas or tips to help avoid it, that'd be awesome!

Clean architecture is not tied to some specific paradigm. It's a way of thinking about programs that is common to almost every mature developer. Many developers use it without even knowing the name - they just came to it by themselves through many tries and errors. There is a good free book about using it in Go, called Go with the Domain if you interested.

Wild Workouts should match your needs: https://github.com/ThreeDotsLabs/wild-workouts-go-ddd-example

For Event-Driven / DDD / Microservice projects, take a look at this Github org https://github.com/ThreeDotsLabs and their blog detailing the techniques used https://threedots.tech .

Nice job at taking a stab at DDD in Go! You may want to check out https://github.com/ThreeDotsLabs/wild-workouts-go-ddd-example for some inspiration and learning around DDD and Go.