The Goals

• Share common code quickly and easily
• Solution bundles that can lower the barrier for adoption of Hydra 
• Focus on partner needs first before considering adopters only

In the past, development proceeded by forking common code bases.  This worked well for sharing code quickly but when someone wanted to push changes back up the tree and have the changes distributed among the forks it was extremely painful.  The problems:

• Each fork could have diverged enough away from the core where original features are now different
• A patch that is created works for a diverged fork but does not fit in another
• Everyone has the same problem but cannot easily use a patch because it must be written for the fork, then for the core, and then modified again to work for every other fork.
• A feature that exists in one fork is wanted by everyone else but to adopt it must be rewritten for every single fork
• There are many desirable features locked up in multiple Hydra solutions

[Insert pictures of past workflows]

To move away from this it needs to be a multi phase approach:

Identify code and gems you want to share and create common gem:

Integrate gem into destination Hydra Head(s)

Replace source destination code with new gem

Apply patch to common gem that gets shared automatically in Hydra Heads

More detailed list below

1. Identify existing solutions that contain code that can be transformed into a common module with descriptions
2. Identify who is interested in working on it and/or is able to work on the common gem
3. Create common gems (modules)
   
   1. In existing solution? If yes?
      
      1. Check test coverage and expand testing as necessary
      2. Extract desired code from existing solution
      3. Transform into common gem
      4. Integrate into new solution
      5. Reintegrate new common gem into source solution
      6. Verify tests pass and still working for source and destination solution
      7. Contribute future changes to common code base
   2. If no? 
      
      1. Create common module that has good test coverage
      2. Create common gem
      3. Start using common gem in solution bundle
4. Adapt Hydra core to smoothly integrate common components into solution bundles
5. Identify common modules needed for solution bundles
6. Assemble solution bundles with existing modules and/or create new modules to complete the solutions
   
   1. How automatic should this be?
   2. If solution bundles are created how much do we pursue adoption by teams with no development resources?  Do we look for some kind of maintenance funding support?  Seek sponsors?
      
      

Hydra Core solution bundle architecture

(feature gems below not complete or exact list, but just examples illustrating possible architectures).  

• Phase 1: Simply bundle common gems together in a Hydra Head application   - or - 
• Phase 2: Create an integration layer that plugs gems together on demand.  We would need allowable combinations to be tested and stable.

Phase 1

Phase 2?

Create multiple solution bundles using this pattern as turnkey distributables (keep scope within needs of partners)

         ...

     ….