David <wizzardx@gmail.com> writes:

quoted text
> On Wed, Jun 4, 2008 at 11:39 AM, Wincent Colaiuta <win@wincent.com> wrote:
> >
> > Sounds like it would definitely work but it also sounds like a lot of
> > repetitive "busy work"[1] which could be avoided by using finer-grained
> > topic branches in the first place.
> >
> 
> I see where you're coming from, and I am learning to work more in this
> way. Using git has made a big difference to how I develop. Not just as
> a SCM, but also for improved work-flow. eg trying out things in code,
> and storing failed attempts for later reference/retries/etc if it
> doesn't work out.
> 
> My problem with your post is, even if you take this to the extreme
> (topic branches for every fix that you want to make), there will still
> be cases where while working on one fix (maybe disruptive to the main
> branch), you uncover problems with master and start fixing it in your
> topic branch.
> 
> It isn't always easy to fix the problems in master (that you're seeing
> in topic) by changing back to master and making another topic. Maybe
> you can only (easily) find & detect the problems in master because of
> other changes in topic (eg: WIP unit tests) that you aren't ready to
> merge yet.
> 
> So you would probably have to jump back and forth between your topic,
> and your new 'fix problems in master' branch a lot to track down the
> issues and get the fixes into master. This sounds like a lot more
> 'busy work' than simply cherry-picking (multiple) those fixes out of
> your topic branch into master, and then rebasing your topic branch :-)

For this I think it would be best to use some kind of patch management
interface on top of Git, be it StGIT or Guilt (interface of the latter
is based on Mercurial Queues, hence former name Git Queues (gq)), see
http://git.or.cz/gitwiki/InterfacesFrontendsAndTools (there was also
Patchy Git (pg) tool, but it is no longer maintained).  I personally
use StGIT, therefore all examples will use this tool.

Then you would be able to go back and forth between patches (commits),
correct them, with some difficulty even split or join them.

Now the workflow depends if you are third-party contributor, sending
patches upstream via email, or if you are project maintainer, and
others pull from you.

If you are third-party contributor, sending patches upstream via
email,using "stg mail" or "git format-patch" plus either "git
send-email", or your favorite mail program, you would do the
following, on your topic branch:
  1. edit, going back and forth between patches
  2. "stg mail" patches to maintainer
  3. incorporate feedback, going to 1. if necessary
  4. fetch from upstream (I use "git fetch"/"git remote update")
  5. rebase your patches ("stg rebase <upstream>")
  6. remove applied patches (which should be empty) from stack,
     using "stg clean -a"; remove patches by hand if necessary
     ("stg remove <patchname>").

If you are maintainer / main contributor your workflow would be a bit
different.  Instead of emailing patches you would probably "stg
commit" them, turning them into ordinary commits (removing from patch
queue) when you finish working on them, then probably merge (parts of)
feature branch into one of stable branches ('maint', 'master',
'next',...).

HTH.
-- 
Jakub Narebski
Poland
ShadeHawk on #git
--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html