Simple `git log &lt;hash&gt;` called for a merge commit shows abbreviated hashes of its parents:

     $ git log -1 395f65d
     commit 395f65d438b13fb1fded88a330dc06c3b0951046
     Merge: 9901923 d28790d
     ...

`git` outputs parents according to their number: the first (leftmost) hash is for the first parent, and so on.

If all you want is just the hashes, the two equivalent choices are:

    $ git log --pretty=%P -n 1 &lt;commit&gt;
    $ git show -s --pretty=%P &lt;commit&gt;

`git rev-list` can also show the parents&#39; hashes, though it will first list the hash for a commit:

    $ git rev-list --parents -n 1 &lt;commit&gt;

If you want to examine the parents, you can refer to them directly with carats as `&lt;commit&gt;^1` and `&lt;commit&gt;^2`, e.g.:

    git show &lt;commit&gt;^1

This does generalize; for an octopus merge you can refer to the n&lt;sup&gt;th&lt;/sup&gt; parent as `&lt;commit&gt;^n`. You can refer to all parents with `&lt;commit&gt;^@`, though this doesn&#39;t work when a single commit is required. Additional suffixes can appear after the n&lt;sup&gt;th&lt;/sup&gt; parent syntax (e.g. `&lt;commit&gt;^2^`, `&lt;commit&gt;^2^@`), whereas they cannot after `^@` (`&lt;commit&gt;^@^` isn&#39;t valid). For more on this syntax, read the [`rev-parse`][1] man page.


  [1]: http://schacon.github.com/git/git-rev-parse.html

The following is the simplest way I&#39;ve found to view the parents of a merge

    git show --pretty=raw 3706454

I usually see this question asked the other way, such as https://stackoverflow.com/questions/5031230/ios-must-every-ivar-really-be-property (and I like bbum&#39;s answer to this Q).

I use properties almost exclusively in my code.  Every so often, however, I work with a contractor who has been developing on iOS for a long time and is a traditional game programmer.  He writes code that declares almost no properties whatsoever and leans on ivars.  I assume he does this because 1.) he&#39;s used to it since properties didn&#39;t always exist until Objective C 2.0 (Oct &#39;07) and 2.) for the minimal performance gain of not going through a getter / setter.

While he writes code that doesn&#39;t leak, I&#39;d still prefer him to use properties over ivars.  We talked about it and he more or less sees not reason to use properties since we weren&#39;t using KVO and he&#39;s experienced with taking care of the memory issues.

**My question is more...  Why would you ever want to use an ivar period - experienced or not.  Is there really that great of a performance difference that using an ivar would be justified?**

Also as a point of clarification, I override setters and getters as needed and use the ivar that correlates with that property inside of the getter / setter.  However, outside of a getter / setter or init, I always use the `self.myProperty` syntax.


----------

Edit 1
------

I appreciate all of the good responses.  One that I&#39;d like to address that seems incorrect is that with an ivar you get encapsulation where with a property you don&#39;t.  Just define the property in a class continuation.  This will hide the property from outsiders.  You can also declare the property readonly in the interface and redefine it as readwrite in the implementation like:

    // readonly for outsiders
    @property (nonatomic, copy, readonly) NSString * name;

and have in the class continuation:

    // readwrite within this file
    @property (nonatomic, copy) NSString * name;

To have it completely &quot;private&quot; only declare it in the class continuation.

Why would you use an ivar?

I am going through the Rails API docs for `collection_select` and they are god-awful. 

The heading is this:

`collection_select(object, method, collection, value_method, text_method, options = {}, html_options = {})`

And this is the only sample code they give:

`collection_select(:post, :author_id, Author.all, :id, :name_with_initial, :prompt =&gt; true)`

Can someone explain, using a simple association (say a `User` has_many `Plans`, and a `Plan` belongs to a `User`), what I want to use in the syntax and why?

**Edit 1:** Also, it would be awesome if you explained how it works inside a `form_helper` or a regular form. Imagine you are explaining this to a web developer that understands web development, but is &#39;relatively new&#39; to Rails. How would you explain it?

Can someone explain collection_select to me in clear, simple terms?

Some Git commands take the parent as a revision; others (such as `git revert`), as a parent number. How can I get the parents for both cases?

I don’t want to use the graphical log command as that often requires scrolling down a long tree to find the second parent.


How can I get the parents of a merge commit in Git?

<p>Some Git commands take the parent as a revision; others (such as <code>git revert</code>), as a parent number. How can I get the parents for both cases?</p>
<p>I don’t want to use the graphical log command as that often requires scrolling down a long tree to find the second parent.</p>


I have a different git repository for my office and a different git repo for my hobby projects. 

When I do `git config --global user.name`
the user name changes globally and this creates a confusion
of committing to a repo with user name. 

Hence the question is how can i have the same username across all my hobby projects and 
the same username across the office projects. I use the same machine to work on both the places.

git multiple user names for the different projects within the same system

I been happily using submodules to track all the libraries my project depends from. 
The thing is I&#39;m using a library called core-plot that only has a public mercurial repository. 
I can probably mirror it in a readonly Git repository, but is this the best option I got? 
I had seen there is modules in Mercurial to track things in Git.  Someone know if the other way around exists?


Is there a way to use a Mercurial repository as Git submodule?

Using `gitk log`, I could not spot a difference between the effect of `git merge` and `git merge --no-ff`. How can I observe the difference (with a git command or some tool)?

What effect does the `--no-ff` flag have for `git merge`?

The sysadmin for a project I&#39;m on has decided that SSH is &quot;too much trouble&quot;; instead, he has set up Git to be accessible via an `https://` URL (and username/password authentication). The server for this URL presents a self-signed certificate, so he advised everyone to turn off certificate validation. This does not strike me as a good setup, security-wise.

Is it possible to tell Git that for remote X (or better, any remote in any repository that happens to begin with `https://$SERVERNAME/`) it is to accept a particular certificate, and *only* that certificate?  Basically reduplicate SSH&#39;s server-key behavior.

configure Git to accept a particular self-signed server certificate for a particular https remote

I have two tags in my git in same branch. There are at least 5-6 commits between them. How can I create a single patch between the two tags so that it can be applied to a GitHub repo?

How to create patch between two tags with multiple commits between them?

Consider there are some lists of integers as:

    #--------------------------------------
    0 [0,1,3]
    1 [1,0,3,4,5,10,...]
    2 [2,8]
    3 [3,1,0,...]
    ...
    n []
    #--------------------------------------

The question is to merge lists having at least one common element. So the results only for the given part will be as follows:

    #--------------------------------------
    0 [0,1,3,4,5,10,...]
    2 [2,8]
    #--------------------------------------

**What is the most efficient way to do this on large data (elements are just numbers)?**
Is `tree` structure something to think about?
I do the job now by converting lists to `sets` and iterating for intersections, but it is slow! Furthermore I have a feeling that is so-elementary! In addition, the implementation lacks something (unknown) because some lists remain unmerged sometime! Having said that, if you were proposing self-implementation please be generous and provide a simple sample code [apparently **Python** is my favoriate :)] or pesudo-code.  
**Update 1:**
Here is the code I was using:

    #--------------------------------------
    lsts = [[0,1,3],
            [1,0,3,4,5,10,11],
            [2,8],
            [3,1,0,16]];
    #--------------------------------------

The function is (**buggy!!**):

    #--------------------------------------
    def merge(lsts):
        sts = [set(l) for l in lsts]
        i = 0
        while i &lt; len(sts):
            j = i+1
            while j &lt; len(sts):
                if len(sts[i].intersection(sts[j])) &gt; 0:
                    sts[i] = sts[i].union(sts[j])
                    sts.pop(j)
                else: j += 1                        #---corrected
            i += 1
        lst = [list(s) for s in sts]
        return lst
    #--------------------------------------

The result is:

    #--------------------------------------
    &gt;&gt;&gt; merge(lsts)
    &gt;&gt;&gt; [0, 1, 3, 4, 5, 10, 11, 16], [8, 2]]
    #--------------------------------------

**Update 2:**
To my experience the code given by **Niklas Baumstark** below showed to be a bit faster for the simple cases. Not tested the method given by &quot;Hooked&quot; yet, since it is completely different approach (by the way it seems interesting).
The testing procedure for all of these could be really hard or impossible to be ensured of the results. The real data set I will use is so large and complex, so it is impossible to trace any error just by repeating. That is I need to be 100% satisfied of the reliability of the method before pushing it in its place within a large code as a module. Simply for now **Niklas**&#39;s method is faster and the answer for simple sets is correct of course.  
**However how can I be sure that it works well for real large data set?** Since I will not be able to trace the errors visually!

**Update 3:**
Note that reliability of the method is much more important than speed for this problem. I will be hopefully able to translate the Python code to Fortran for the maximum performance finally.

**Update 4:**  
There are many interesting points in this post and generously given answers, constructive comments. I would recommend reading all thoroughly. Please accept my appreciation for the development of the question, amazing answers and constructive comments and discussion.



Python: simple list merging based on intersections

I&#39;m attempting to customize an existing JS library without modifying the original JS code.  This code loads in a few external JS files which I do have access to, and what I&#39;d like to do is change one of the functions contained in the original file without copying and pasting the whole thing into the second JS file.
&lt;br&gt;
So for example, the off limits JS might have a function like this:

    var someFunction = function(){
        alert(&quot;done&quot;);
    }

I&#39;d like to be able to somehow append or prepend some JS code into that function.  The reason is primarily that in the original untouchable JS the function is pretty enormous and if that JS ever gets updated, the function I overwrite it with will be out of date.

I&#39;m not entirely sure this is possible, but I figured I&#39;d check.


Adding code to a javascript function programmatically

I made some changes in my master branch and want to bring those upstream. When I cherry-pick the following commits. However, I get stuck on fd9f578 where git says:

    $ git cherry-pick fd9f578
    fatal: Commit fd9f57850f6b94b7906e5bbe51a0d75bf638c74d is a merge but no -m option was given.

What is git trying to tell me and is cherry-pick the right thing to be using here?  The master branch does include changes to files which have been modified in the upstream branch, so I&#39;m sure there will be some merge conflicts but those aren&#39;t too bad to straighten out. I know which changes are needed where.

These are the commits I want to bring upstream.

    e7d4cff added some comments...
    23e6d2a moved static strings...
    44cc65a incorporated test ...
    40b83d5 whoops delete whitspace...
    24f8a50 implemented global.c...
    43651c3 cleaned up ...
    068b2fe cleaned up version.c ...
    fd9f578 Merge branch &#39;master&#39; of ssh://extgit/git/sessions_common
    4172caa cleaned up comments in sessions.c ...



git cherry-pick says &quot;...38c74d is a merge but no -m option was given&quot;

I would like to merge a nested hash.


    a = {:book=&gt;
        [{:title=&gt;&quot;Hamlet&quot;,
          :author=&gt;&quot;William Shakespeare&quot;
          }]}

    b = {:book=&gt;
        [{:title=&gt;&quot;Pride and Prejudice&quot;,
          :author=&gt;&quot;Jane Austen&quot;
          }]}

I would like the merge to be:

    {:book=&gt;
       [{:title=&gt;&quot;Hamlet&quot;,
          :author=&gt;&quot;William Shakespeare&quot;},
        {:title=&gt;&quot;Pride and Prejudice&quot;,
          :author=&gt;&quot;Jane Austen&quot;}]}

What is the nest way to accomplish this?

Content Type	Original Author	Original Content on Stackoverflow
Question	Casebash	View Question on Stackoverflow
Solution 1 - Git	Cascabel	View Answer on Stackoverflow
Solution 2 - Git	user1483344	View Answer on Stackoverflow

How can I get the parents of a merge commit in Git?

Git Problem Overview

Git Solutions

Solution 1 - Git

Solution 2 - Git

Can someone explain collection_select to me in clear, simple terms?

Why would you use an ivar?

Attributions