ketan bhavsar

Thank you Raju and Junilu,

You are correct. It increases the testing time. Also, difficult to manage the merging as well.
This thread is really helpful for me to clear the concept. Thanks to both of you.

I really need to think of the promotion process. Based on my understanding, if I put it in different words, a single branch will have all the features all team members are working on it. It is some configuration that will make it active/inactive. And based on the decision, making it active on pre-poroduction environment. Which will be tested and the same artifact will move forward to production. Please let me know if I misinterpreted.  

Thanks a lot.

Hello Raju,

Thanks for your quick and descriptive answer. And sorry for the question which is not properly written.
Actually, I have no detailed understanding of the Git flow or Trunk based development. So, what we manage is based on our requirements.
like, there is 3 environments of the project.

Dev

- Dev environment where integration testing will be done. all team completes their small or big feature development. Unit test in their local environment and merge it into the release/dev branch for integration testing.
- This release dev branch is initially created from the master branch only.
- when any new feature development started, a new branch is created from the release/dev branch.  

Stag

- Stag environment where all the features will be merged which are to be released on the next production release. We don't have any concept of setting a TAG. So, whenever it is decided that in the next release feature1, feature 3, and feature 5 will be released, we merge those branches into the release/stag branch. resolve merge issues if any.
- This release stag branch is also initially created from the master branch only.

Prod

- Production environment where all last tested stage branch code will be used. This is a master branch. Stag code is merged to the master branch when required to release.

I also read one post https://www.toptal.com/software/trunk-based-development-git-flow If I compare the above commit workflow then it is not a pure git flow or pure trunk based.  

I have always advocated (assuming you don't have a very unique scenario, and truth be told, very few orgs have such scenarios) to only have one integration branch—that is your development branch (you can call this main, develop, master—I'll refer to it as main hereon).

Everything is created off this branch, and disappears as soon as a release is done (I am assuming some variant of the GitFlow model here, and not trunk based development). How would this work?

- You are ready to release—create the "release" branch from the commit on main that is going to production. This is the code that represents the next release
- Deploy it to whatever environment, test it, and make sure all is well. If you find bugs, fix them on the release branch
- Once you are done, the tip of the release branch represents the version that you will take to production
- Deploy that to production
- Tag the commit on the release branch (more on this in a minute)
- Merge the release branch back to main - This is important b/c you want all the fixes you detected on testing and the tag you just created to be part of the main history
- Delete the release branch

The reason for the tag is so if you have a production bug, you can check out the tag, create a branch, make a hotfix, deploy that to production, and then merge that "hotfix" branch back to main.

I think this is really a very good way if it is rapid development and rapid release. But what if we have already merged 3-4 features in the main branch and also resolve merge integration issues on the main branch too (That is the same dev branch). But after that, it is decided that only 1 feature should be taken out of it and released on production?

Welcome to Raju Gandhi,

I just want to git merging technic for the scenario which will be there in almost all the projects.
In a project, there are many different kinds of tasks and bugs assigned to the different team members. Which needs to gradually merge and deploy to Dev, Stag and Production environment/branch in a sequence.

Some tasks are very small and some are like an Epic level. For everything, if it is a 1-day task or 30 days epic, I prefere to create a branch so that it can be easily merged to the release branches.

Consider There are two major epic kinds of tasks which are developed simultaniously. feature/epic1 and feature/epic2. And there are 3 release branches release/dev, release/stag and release/prod.

As and when few of the work complete under epic1 or epic2 it is merged to the release/dev branch. So, it has well integration testing. But epic1 needs to be moved to prod first then epic2. What should be the best way to get all tested code updates of feature/epic1 from release/dev to release/stag?

Thanks and understood.

with respect,
Ketan

Hello Davi,

When we say Hexagonal Architecture, it is mainly of 3 layers of the entire application.

Application Layer - Application interaction with external system

Domain Layer - Domain business logic and connection with the repo or data layer

Infrastructure Layer - data layer design

Can you please explain what are the key components that we should/must keep it in a mind to design the architecture of any system for each Layer?
Moreover, what are the main difference between Quarkus and Spring Boot framework? Is this book covering the above-layers architecture using Quarkus?

Hi Iuliana,

Thanks for the book promo and details about Java 17.

I have read through the topics covered on the Amazon site for this book.
It is mentioned over there "Exchange data using the new JSON APIs ".

Does it mean Java 17 has inbuilt JSON converters and other JSON functions similar to ObjectMapper of Jackson library?
Or it is something else? Can you please give a bit more details for the same?

Thanks.
Ketan

Ohk. I see. Thanks. Tim & Ted.

Hi Ted,

Many of the developers (like me) started their programming study/carrier using eclipse. Can you please describe, what are the benefits of using intelliJ over eclipse. What will be the learning curve if they want to move from eclipse to intelliJ.

Thanks.
KB

What are new additions in spring framework 5 over the last one?

Hello Adam,

Spring Framework is a very big.
The main problem for the developer is what should be used where?
Which modules covered in this book?  
Is this book consider an example of a covered modules?

I.e. spring AOP concept can be used for resolving multiple problems'. so which problems we can resolve using in AOP and how we can resolve it. Such things are very useful while reading.

Hello @Rafael del Nero

What kind of challenge questions are there in this book?
Design patterns? Java new version benifits? Code challenges? Scenario based challanges?
Is it for new bees or experts?

Hello Author,

What are the best techniques to create the pipelines? Actually, in my current project, I have created pipelines for build and deploy the project based on the process that we were doing manually? But at certain points that looks certain things can be done using only manual way.
For example,
1. only ftp upload is possible where there is no agent set on deployment server.
2. Manual database change, like backup and ddl dml queries.
3. Rest assured test runs. Etc.
Does this book cover how to setup such mechanism and what are the best tools and how to use it with such normal scenarios?

Hello Billy,

I read in one of the blogpost that Gitops is commit practice using which developer can directly push or start deployment process on production.
But wher it will be like code quality checks, peer review, database migration, revert in case of some drastic failure? And what are the base points with which we can compare Devops with Gitops?

Hello Samer,

Can we use graphql where it is not a single table query? In a way tables are in many to many or in one to one relationship. Also, in some cases data can be available after joining 4 to 5 tables. So how can we use graphql in such case?