Volume Number: 24 (2008)
Issue Number: 02
Column Tag: Project Management

Getting Started with Git

Learn how to use Git to manage your project

by José R.C. Cruz

Today, we will look at the source—code management (SCM) tool called Git. First, we will get a copy of the Git source tarball and compile Git as a Universal Binary. Then, we will install the tool and configure it on MacOS X.

Next, we will learn how to use Git to do some basic SCM transactions. Then, we will learn how to use Git in Xcode by the power of menu scripts.

Git is an SCM system written by Linus Torvalds and maintained by Junio Hamano. It serves as the official SCM for the Linux kernel project. It is also a faster alternative to CVS and Subversion.

Git is made available under the terms of the Gnu Public License, version 2. Also, when this article was written, the latest usable version of the Git project is 1.5.2.3.

Both CVS and Subversion store those files in a central repository (Figure 1). When users, here shown as Jack and Jill, want to work on the project, first they get a copy of the project from the repository. If user Jill changes some of the project files, she must commit those changes back to the repository. Otherwise, user Jack will be unable to update his copy with her changes.

Figure 1. A centralized SCM repository

Git, however, lets users maintain their own local repositories of the same project (Figure 2). Each user gets a copy of the project from their repositories, and updates the latter with their changes. If they want to see each other changes, they then synchronize their repositories with each other.

Figure 2. A decentralized SCM repository

Now, a centralized repository has its own set of problems. First, this repository is susceptible to data corruption since it keeps all project files in one place. It uses more space since it stores all the changes submitted by all users. It is also slower to respond since it has to sort out which changes belong to which user. Finally, it prevents users from working offline.

These problems, and others, are non—existent if the repository is decentralized.

Git shares some of the features found in Subversion. It treats files and directories as valid project items. It can move or rename these items with a single command. It treats all commits to the repository as atomic operations. It also has native diff support to binary files.

Git, however, can do SCM transactions much faster than CVS or Subversion. This is partly due to the fact that it stores its repository locally with respect to the user. Git also can do garbage collection to trim dead items from its repository. This helps reduce the amount of space used by the repository.

Still, Git has its own set of issues. For instance, its primary interface is still the command—line. It lacks a usable GUI tool common to most host systems. It is more difficult to backup and secure, as there can be more than one repository for the same project. Also, many developer tools such as Xcode do not support Git as a viable SCM system.

These issues, and many others, may be resolved by the time you read this article.

To compile and install your own Git system, first get a copy of the project tarball git—1.5.2.3.tar.gz at the following URL:.

http://kernel.org/pub/software/scm/git/

Use the Finder to copy or move the tarball to the desired directory.

Next, double—click the tarball to unpack its contents. You can also unpack the tarball from a shellthe Terminal window by typing the following statement:.

   tar —xzf git—1.5.2.3.tar.gz

Make sure to use the cd command first to navigate to the directory that has the tarball. Either way, you should get have a directory named git—1.5.2.3 as a result.

Now, get a copy of the tarball expat—2.0.1.tar.gz at the following URL:.

http://sourceforge.net/projects/expat/

Expat is an open—source library of functions used to parse XML files. Move the tarball to the same directory as the Git tarball. Double—click on the expat tarball to unpack its contents. You should get a directory named expat—2.0.1 as a result.

First, open the .bash_profile file using your favorite text editor. You can find this invisible file in your home directory. Add the following entries to that file.

   PATH=/Library/Developer/usr/bin:/Library/Developer/usr/lib:$PATH
   export PATH

Start a Terminal window session, and type the following statements at the prompt.

   export CFLAGS="—O —g —isvroot /Developer/SDKs/MacOSX10.4.u.sdk —arch i386 —arch ppc"
   export LDFLAGS="—arch i386 —arch ppc"

The above tells GCC to compile the expat and Git binaries as Universal Binaries. But if you are already using MacOS X/Intel, set the CFLAGS variable with the following statement:.

   export CFLAGS="—O —arch i386 —arch ppc"

Now use the cd command to navigate to the expat—2.0.1 directory. Configure the project by typing the following the statement.

./configure —prefix=/Library/Developer/usr —disable—dependency—checking

The above tells the make tool to install the binaries into the directory /Library/Developer/usr. It also tells the tool to ignore all dependency checks.

Compile the expat binaries by typing make at the Terminal prompt. To test the binaries, type make check at the prompt. To install the binaries and support files, type make install. To test the installed binaries, type the following statement at the prompt.

   /Library/Developer/usr/bin/xmlwf —v

You should get the string "xmlwf using expat_2.0.1" displayed on the Terminal window.

It is now time to compile the Git binaries. First, navigate to the directory git—1.5.2.3. At the Terminal prompt, type make configure to generate the configure script for your system.

Next, configure the project using the following statement.

./configure —prefix=/Library/Developer/usr —disable—dependency—checking

Again, this tells the make tool to install the binaries into /Library/Developer/usr. To compile the binaries, type make at the Terminal prompt. To install them, type make install. Finally, to test the installed binaries, type the following statement at the prompt.

   /Library/Developer/usr/bin/git —version

You should get the string "git version 1.5.2.3" displayed on the Terminal window.

The above steps do not compile and install the help documents for the Git system. For instructions on how to do so, visit the Wincent web page at the following URL.

http://wincent.com/knowledgebase/
Installing_Git_1.5.2.3_on_Mac_OS_X_Tiger

To configure Git for local use, first you have to identify yourself to the system. Suppose your name happens to be Dee User, and your e—mail address dee.user@mail.box.com. Then, type the following statements at the Terminal prompt.

   git config —global user.name="Dee User"
   git config —global user.email="dee.user@mail.box.com" 

Git will use the above information to sign your committed changes. It will also use the same information for its reports.

Now suppose you want to use Git to track your foobar project. First, navigate to the foobar directory using the cd command. Then type git init at the Terminal prompt. Git then creates a .git directory within the foobar directory. It uses this invisible hidden directory to store and manage your project's repository.

You can also tell Git to place your project repository elsewhere. For example, to store the repository in the directory /Volumes/Projects/Database/git, add the following entry to your .bash_profile file.

   export GIT_DIR=/Volumes/Projects/Database/git

Restart your Terminal session, and type git init at the prompt. Git will now create the repository at the directory specified by GIT_DIR. It will also make that repository visible.

Below is the basic usage syntax of the git command—line tool.

git [global_options] [subcommand [command_options]]

The global_options argument sets those options that affect all SCM transactions. The subcommand argument selects what SCM transaction to do. The command_options argument sets those options that affect that transaction.

Due to length, this article will cover only those options and subcommands needed for a basic SCM work cycle. To learn more about Git, read the complete manual at the following URL.

http://www.kernel.org/pub/software/scm/git/docs/user—manual.html

To display the tool's version, use the —version option.

   git —version

To display a list of subcommands, use the help option.

   git —help

To change the repository path, use the —git—dir option.

   git —git—dir=repository_path subcommand [command_options]

Then pass the new path to the option as its parameter. This option also overrides the setting made by the variable GIT_DIR.

To store the repository in the same directory as the project, use the —bare option.

   git —bare subcommand [command_options]

This is also the default option if you did not set the GIT_DIR variable, or use the gitdir option.

Suppose you want to store your foobar project into the repository. First, use the cd command to navigate to the foobar project directory. Then type the following statement at the Terminal prompt.

   git add .

Notice that the statement ends with a period. This tells Git to include all the file and subdirectories within the project directory. Git also places an add transaction in the SCM queue.

To complete the transaction, type the following statement at the prompt.

   git commit —m "Added the foobar project to the repository."

Git then copies all the project files and subdirectories into the repository. It also updates its log with the above committal message. Feel free to use a different committal message for your project.

Suppose you created a new file named foo.xml. To add this file to the repository, use the add subcommand.

   git add foo.xml

Git places an add transaction for foo.xml in its SCM queue. When you commit the transaction, Git then copies the file foo.xml into the repository. But if foo.xml is already in the repository, Git will ignore the subcommand.

Now, suppose you want to add the subdirectory foo_bar to the repository as well. Again, just use the add subcommand.

   git add foo_bar.

First, Git places an add transaction for foo_bar in its queue. It then places add transactions for any file and subdirectory found within foo_bar. Again, if foo_bar is already in the repository, Git will ignore the subcommand.

Suppose you have the file flub.xml in the repository. To remove that file, use the rm subcommand.

   git rm flub.xml

Git then places a remove transaction in its queue. When you commit the transaction, Git deletes the file from the repository. It also deletes the same file in the project directory.

Now, suppose you have the directory flubar in the repository as well. To remove that directory and any items it contains, use the rm subcommand with an —r option.

   git rm —r flubar

But if you know beforehand that flubar is empty, just use the rm subcommand only.

   git rm flubar

Make sure, however, that the repository has the items you want to remove. Otherwise, Git will respond with an error message.

Suppose you want to change the name of the file foo.xml to bar.xml. To rename the file, use the mv subcommand.

   git mv foo.xml bar.xml

Git places a move transaction in its SCM queue. When you commit the transaction, Git makes a copy of foo.xml and assigns the copy with the name bar.xml. It then deletes the file foo.xml. Git also renames the foo.xml file in the project directory.

Now, suppose you want to change the name of the directory foo_bar to fubar. To rename the directory, use the mv subcommand as follows.

   git mv foo_bar fubar

When you commit the transaction, Git first creates the fubar directory in the repository. Next, it copies the contents of foo_bar to fubar. It then deletes the foo_bar directory from the repository. Git also renames the foo_bar directory in the project directory.

Next, suppose you want to move bar.xml into the fubar directory. To do so, use the mv subcommand as follows.

   git mv bar.xml fubar

When you commit the transaction, Git copies the bar.xml into fubar. It then deletes bar.xml in its original location. Git also performs the same operations on bar.xml in the project directory.

Make sure that the item you want to move or rename exists in the repository. Also, if you are renaming a file or directory, make sure that there is no item in the repository with the new name. Otherwise, Git will respond with an error message.

Also, if you are moving a file into a directory, make sure that the directory exists in the repository. Otherwise, Git will actually rename that file.

As shown earlier, most SCM transactions go into a queue awaiting committal. To commit all the transactions in the queue, use the commit subcommand with an —a option.

   git commit —a —m "Commit all pending transactions"

Git executes each transaction in the order they appeared in the queue. It then adds the phrase "Commit all pending transactions" to the repository's log. Again, feel free to supply your own committal phrase.

But suppose you made changes to the file bar.xml. To commit only those changes, use the subcommand as follows.

   git commit —m "Made changes to the file bar.xml" bar.xml

First, Git compares bar.xml with the one in the repository. It then stores only the differences between the two into the repository.

Now suppose you added two new files to the repository: char.xml and siu.txt. To commit only these additions, use the subcommand as follows.

   git commit —m "Added the files char.xml and siu.txt" char.xml siu.txt

Always provide a concise description of what you are committing. Failure to do so will result in an inaccurate log. If you forgot to provide a description, Git will launch the default editor, which then prompts you for the description. And if you still fail to do so, Git will abort the committal process. But it will not affect any transactions still in the queue.

Suppose you made changes to the file char.xml. Then you find those changes to be ineffective. To revert to the last version of that file, use the checkout subcommand.

   git checkout char.xml

Git first retrieves a copy of char.xml from the repository. It then replaces the char.xml file in the project directory with that copy.

Next, suppose you added the file poink.htm to the repository by accident. If you have not committed that addition, you can cancel it by using the reset subcommand.

   git reset HEAD

The argument HEAD tells Git to reset the repository back to the state before the queued addition.

Now, suppose you have committed the addition. To cancel that committal, use the revert subcommand.

   git revert —no—edit HEAD

This time, the HEAD argument tells Git to reset the repository back to a state before the committed addition. Git also updates the repository log with the right description.

Both reset and revert subcommands, however, may affect other transactions as well. For instance, if you have an add and mv transactions in the queue, typing git reset HEAD will cancel both transactions. If you have committed both transactions, typing git revert —no—edit HEAD will cancel both committals. Be careful when using these two subcommands as you may lose more data than you expect.

Suppose you just committed some of the transactions in the SCM queue. To view what transactions are still pending, use the status subcommand.

   git status

Listing 1 is a sample output of that subcommand. The first entries are transactions still in the queue. Next are files that you have changed. The last items are files and directories not in the repository.

# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   bar.xml
#       deleted:    foo.xml
#
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#
#       modified:   fubar.log
#       modified:   foob.gif
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#       fubar_2/
#       bar.png

Now, suppose you want a list of files and directories in your repository. To get that list, use the lstree subcommand with a —r option.

   git ls—tree —r HEAD

Listing 2 is a sample output of that subcommand. The first column is a the file's permission flag; the second is the repository type. The third column is the file's hash ID; the third is the name and path of that file.

100644 blob 1538a2be5fe5edf9f5e37185ebf1ea1cd5be3a82    foobar.css
100644 blob df3bc5d3b66449784badd32d5dc7c38c039a320f    foobar.htm
100644 blob 09db1ab264eb8d708951d8cde2efb33ee20e1e76    fubar/foo.xml
100644 blob 2cc9eaa293eed562ee400dffd51b25e493daf991    fubar/bar.gif

Next, suppose you want to compare the project file foo.htm with the one in the repository. To do so, use the diff subcommand.

   git diff foo.htm

If the file is a text file, Git will lists those lines of text that have changed (Listing 3). If the file is a binary file, Git will list the range of bytes that have changed.

index 76ea0fe..c982c02 100644
—— a/foo.htm
+++ b/foo.htm
@@ —4,7 +4,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
        <meta http—equiv="content—type" content="text/html; � />
—       <title>Foobar A</title>
+       <title>Foobar B</title>
        <meta name="generator" content="BBEdit 6.5.3" />
        <link rel="Stylesheet" rev="Stylesheet" href="foobar.css" />
 </head>

Suppose you want a project history. To get that history, use the log subcommand.

   git log

Listing 4 shows a sample output of that subcommand. Each entry consists of at least four lines. The first line is the transaction ID. The second is the user who made the transaction. The third line is the date and time of the transaction. The remaining lines describe the transaction.

commit 64b9079bcad2bb5fc4eea38da334af395462bf13
Author: Dee User <dee.user@mail.box.com>
Date:   Thu Aug 23 13:26:55 2007 —0700
    Revert "Changed the file foobar.htm"
    
    This reverts commit 1133d0a1d3af8fc94f74d0cc2c5b6581882012e1.
commit 1133d0a1d3af8fc94f74d0cc2c5b6581882012e1
Author: Dee User <dee.user@mail.box.com>
Date:   Thu Aug 23 13:14:38 2007 —0700
    Changed the file foobar.htm

Git uses the less tool to display the project history. To page down the history, press the Space—bar. To page up, press the <B> key.

Now, suppose you want a list of users who worked on the file foo.htm. To display those users, use the blame subcommand.

   git blame foo.htm

If the file is a text file, Git displays the lines of text and the last user who edited each line (Listing 5). If the file is a binary file, Git displays each line of hexadecimal bytes and the last user who changed them.

7442b04 (Dee User 2007—08—04 13:11:57 —0700  1) <?xml version="1.0" �
^7442b04 (Foo Bar 2007—08—04 13:11:57 —0700  2) <!DOCTYPE html PUBLIC "�
   .
   .
^7442b04 (Bar Foo 2007—08—04 13:11:57 —0700  3) <html xmlns="�
^7442b04 (Dee User 2007—08—04 13:11:57 —0700  4) <head>

Currently, you can only use CVS or Subversion to manage your Xcode projects. But, with a little work, you can also use Git for the same tasks. All it takes is to write menu scripts that will add Git functionality to your Xcode setup.

The following are three examples of Xcode menu scripts that use Git. Feel free to modify these scripts to suit your project needs.

Listing 6 shows a menu script that stores the current project into a Git repository.

First, the script add the directory /Library/Developer/usr/bin to the PATH variable. Then it prompts the user for a description of the project. After the user supplies a valid description, the script creates an empty Git repository. It then adds all the files and directories in the current project to that repository.

#! /bin/bash
#
# — PB User Script Info —
# %%%{PBXName=Add project to the repository}%%%
# %%%{PBXInput=None}%%%
# %%%{PBXOutput=Discard}%%%
# %%%{PBXKeyEquivalent=}%%%
# %%%{PBXArgument=}%%%
#
# set the following shell variables
export PATH="/Library/Developer/usr/bin:$PATH"
GIT_MSG=`date "+Committed on %m/%d/%y %H:%M:%S"`
# prompt the user for a commitalcommittal message
GIT_MSG=`osascript <<—APPLESCRIPT
   tell application "Xcode"
      activate
      display dialog "Reason for committal" default answer �
            "${GIT_MSG}"
      return (text returned of result) as string
   end tell
   APPLESCRIPT
`
# validate the message
GIT_CHK=`expr "$GIT_MSG" : '.*'`
if [ $GIT_CHK —gt 0 ];
then
   # initialize the repository
   git init
   
   # add the project files to the repository
   git add .
   
   # commit the project files
   git commit —m "${GIT_MSG}"
   
   echo "Finished adding the project to the repository."
else
   echo "You must supply a committal message."
fi

Listing 7 shows a menu script that will do four basic SCM transactions.

First, the script creates a separate menu option for each transaction. It also adds the directory /Library/Developer/usr/bin to the PATH variable. Next, the script checks which transaction the user has chosen. If the transaction needs more data, the script prompts the user for that data. Finally, the script executes the right subcommand for the chosen transaction.

#! /bin/bash
#
# — PB User Script Info —
# %%%{PBXName=Commit changes}%%%
# %%%{PBXArgument=—fsav}%%%
# %%%{PBXOutput=Discard}%%%
# %%%{PBXKeyEquivalent=}%%%
#
# %%%{PBXNewScript}%%%
# %%%{PBXName=Add the file}%%%
# %%%{PBXArgument=—fadd}%%%
# %%%{PBXOutput=Discard}%%%
#
# %%%{PBXNewScript}%%%
# %%%{PBXName=Discard changes}%%%
# %%%{PBXArgument=—frev}%%%
# %%%{PBXOutput=Discard}%%%
#
# %%%{PBXNewScript}%%%
# %%%{PBXName=Tag the project}%%%
# %%%{PBXArgument=—ptag}%%%
# %%%{PBXOutput=Discard}%%%
#
# set the following environment variable
export PATH="/Library/Developer/usr/bin:$PATH"
# set the following shell variables
GIT_PTH=%%%{PBXFilePath}%%%
GIT_PTH=`basename $GIT_PTH`
# determine the selected git transaction
if [ $# —gt 0 ] ; then
    if [ "z${1}" = "z—fsav" ] ; then
         # commit the current file
         GIT_ASK=1
         GIT_MSG="Enter a committal message"
         GIT_DAT=`date "+Committed on %m/%d/%y %H:%M:%S"`
    elif [ "z${1}" = "z—ptag" ] ; then
         # apply a tag to the project
         GIT_MSG="Set the project's revision tag to"
         GIT_DAT=`date "+%m%d%y_%H%M%S"`
         GIT_ASK=1
      else
         GIT_ASK=0
    fi
else
   # just exit
   exit 0
fi
# prompt the user for input
if [ $GIT_ASK —eq 1 ];
then
   GIT_DAT=`osascript <<—APPLESCRIPT
      tell application "Xcode"
         activate
         display dialog "${GIT_MSG}" default answer "${GIT_DAT}"
         return (text returned of result) as string
      end tell
      APPLESCRIPT
   `
   # validate the user input
   GIT_CHK=`expr "$GIT_DAT" : '.*'`
   if [ $GIT_CHK —le 0 ];
   then
      # just exit
      exit 0
   fi
fi
# execute the git transaction
if [ "z${1}" = "z—fsav" ] ; then
   # git commit
   git commit —m "${GIT_DAT}" $GIT_PTH
elif [ "z${1}" = "z—fadd" ] ; then
   # git add
   git add $GIT_PTH
elif [ "z${1}" = "z—frev" ] ; then
   # git revert
   git checkout $GIT_PTH
elif [ "z${1}" = "z—ptag" ] ; then
   # git tag
   git tag "${GIT_DAT}" $GIT_DAT
else
   # just exit
   exit 0
fi

Listing 8 shows a menu script that will display four types of reports.

First, the script creates a new menu option for each report. Then, it adds /Library/Developer/usr/bin to the PATH variable. Next, it checks which report the user wants to display. It then uses the right subcommand to generate the report.

Finally, the script stores the report output into a temporary file. Then it uses Xcode to display the contents of that file in a separate window.

#! /bin/bash
#
# — PB User Script Info —
# %%%{PBXName=Show file history}%%%
# %%%{PBXInput=None}%%%
# %%%{PBXArgument=—fhis}%%%
# %%%{PBXOutput=SeparateWindow}%%%
#
# %%%{PBXNewScript}%%%
# %%%{PBXName=Show file differences}%%%
# %%%{PBXArgument=—fdif}%%%
# %%%{PBXOutput=SeparateWindow}%%%
#
# %%%{PBXNewScript}%%%
# %%%{PBXName=Show project history}%%%
# %%%{PBXArgument=—phis}%%%
# %%%{PBXOutput=SeparateWindow}%%%
#
# %%%{PBXNewScript}%%%
# %%%{PBXName=Show project status}%%%
# %%%{PBXArgument=—prpt}%%%
# %%%{PBXOutput=SeparateWindow}%%%
#
# set the following environment variable
export PATH="/Library/Developer/usr/bin:$PATH"
# set the following shell variables
GIT_PTH=%%%{PBXFilePath}%%%
GIT_PTH=`basename $GIT_PTH`
GIT_DIR=`osascript <<—APPLESCRIPT
   tell application "Finder"
      path to temporary items from user domain
      POSIX path of result as string
      return result
   end tell
   APPLESCRIPT
   `
# set the chosen git subcommand
if [ $# —gt 0 ] ; then
    if [ "z${1}" = "z—fhis" ] ; then
      # display file history
        GIT_DOC="$GIT_DIR/git_fhist.out"
    elif [ "z${1}" = "z—fdif" ] ; then
      # display file differences
        GIT_DOC="$GIT_DIR/git_fdiff.out"
    elif [ "z${1}" = "z—phis" ] ; then
      # display project history
        GIT_DOC="$GIT_DIR/git_phist.out"
    elif [ "z${1}" = "z—prpt" ] ; then
      # display project status
        GIT_DOC="$GIT_DIR/git_pstat.out"
   else
      exit 0
    fi
fi
GIT_DOC=${GIT_DOC//\/\//\/}
# execute the git transaction
if [ "z${1}" = "z—fhis" ] ; then
   # display file history
   git log $GIT_PTH > $GIT_DOC
elif [ "z${1}" = "z—fdif" ] ; then
   # display file differences
   git diff $GIT_PTH > $GIT_DOC
elif [ "z${1}" = "z—phis" ] ; then
   # display project history
   git log HEAD > $GIT_DOC
elif [ "z${1}" = "z—prpt" ] ; then
   # display project status
   git status > $GIT_DOC
else
   exit 0
fi
#display the git report document
GIT_DOC="OS X"`echo $GIT_DOC`
GIT_DOC=`echo ${GIT_DOC//\//:}`
GIT_DOC="\"$GIT_DOC\""
osascript <<—APPLESCRIPT
   tell application "Finder"
       set fileref to get file $GIT_DOC as string
       
       tell application "XCode"
         activate
         open file fileref
       end tell
    end tell
   APPLESCRIPT

Git is another in the line of tools for managing software projects. Like CVS and Subversion, Git is an open—source project. Users can download its sources and port the tool to their own operating systems. But unlike CVS and Subversion, Git lets users work on the same project in a distributed, non—centralized fashion.

Git is easy to setup and use over the command—line. You can also use Git to manage your Xcode projects, even though Xcode lacks any support for that tool. All it takes is to write a menu script that will perform the desired action.

So far, we have used Git to do some very basic tasks. We will, however, learn more about Git and its capabilities in the near future. Please stay tuned.

Baudis, Petr. "The Git User's Manual (for version 1.5.3 or newer)". Git — Fast Version Control System. 2007 Aug 13. Online: http://www.kernel.org/pub/software/scm/git/docs/user—manual.html.

Baudis, Petr. "Git—SVN Crash Course". Git — Fast Version Control System. 2007 Aug 16. Online:

http://git.or.cz/course/svn.html.

Wikipedia. Git (software) (2007 July 13). Copyright 2007. Wikipedia Foundation, Inc. Online: http://en.wikipedia.org/wiki/Git_%28software%29.

JC is a freelance engineering writer who lives happily in North Vancouver, British Columbia. He divides his time between writing technical articles, and teaching origami at his district�s public library. He can be reached at anarakisware@gmail.com.