Excel Basics Consolidated

Posted on November 16 2012 09:11 AM by John Atten in Excel Basics, Education   ||   Comments (0)

I have done a series of posts on Microsoft Excel, targeted largely at beginners, and/or those who use Excel casually and seek to expand their skills a little. MS Excel is a powerful program, which has a host of advanced analytical and math functions, for those who spend a moment exploring them.

What is important about using excel to maximum effect is not remembering how to use each specific function of formula - it is enough to understand the syntax excel requires, and to realize that if you can dream up a use-case, there is most likely a built-in function which can do what you need.

Here, I have combined all of my Excel-related posts to date to make it easy to find what you might need. More will follow. If you have a specific request, let me know, and I will do my best to create a post addressing the topic you are interested in.

This area was created specifically for Mary (you know who you are) to begin with, a friend who has applied herself to the pursuit of learning and personal growth. Mary, you inspire! Hopefully, others will benefit as well.

Links to Excel Articles on this blog:

More links will follow, including some to useful resources outside this site. Lastly, remember, for all things related to tech, programming, and math functions, Google is your friend. Use it!

             

            Posted on November 16 2012 09:11 AM by John Atten     

            Comments (0)

            Getting Started with Git for the Windows Developer (Part II) - Get Acquainted with Bash

            Posted on September 9 2012 08:10 AM by John Atten in Git, Education, CodeProject   ||   Comments (0)

            This is the second installment of a multi-part series about getting your feet wet with Git for Windows Developers. If this is your first time here, you may want to review of the series.

            If you have been following along so far, you likely have by now installed msysgit on your development machine, and performed the initial configuration necessary to begin using git to track changes in your source code. So, what next?

            Well, before we can do much with Git, we need to make sure we have at least a token familiarity with using the Bash command prompt. To do this, we will walk through some basic commands related to navigating in bash, getting information about the file system and environment, and working with directories and files. All of these are necessary in order to work with Git using the Bash command line.

            Since these posts can get long (due in large part to the large number of screen shots), this may span a few posts. It’s not as bad as it looks, really. Lots of pictures.

            If you are already familiar with the concepts here, and mainly just need help with the proper syntax for performing these actions in Bash, refer to my which contains a listing of the most common git and Bash commands without all the narrative.

            Otherwise, read on, and let’s get comfortable using the Bash command line in a Windows environment.

            Get Acquainted with Bash

            The Bash command line comes from a Unix heritage, and even if you are familiar with the Windows command line, or Powershell, using Bash is different.

            First, we should get a little comfortable moving around our file system and performing basic tasks with files and directories.

            When you first open the Bash command window, you should see something like this:

            Open-Bash-Default

            In the above, the text in green is the User Name and Computer Name, displayed using the convention UserName@ComputerName. The curlicue character following means that we are in our default directory (or folder), usually our Windows User Folder.

            A line which begins with the default prompt (in this case, a $ symbol) is a line on which you will enter a command. Lines without the $ symbol will represent feedback from the system. Each time you type in a command and hit enter, Bash will execute the command, return whatever output (if any) and the leave you with a new prompt.

            Note that many commands simply execute, and there is no output. It is a principle amongst Linux programming that a good program executes silently, and only provides feedback if requested, or if something has gone wrong. More on this momentarily.

            List the Directories within the Current Folder

            We can list other directories within our current folder using the ls command. Type ls into your Bash window and hit enter:

            Use Bash to list the contents of the current directory:

            Bash-List-Directory-Contents

            Huh. That’s a lot of stuff, and except for those items with file extensions, it is hard to tell what is a directory (folder) and what is a file of some sort. Wouldn’t it be nice to show just the folders, without the other stuff?

            In a clear case of stating the obvious, the following will clear your Bash window. Type this and hit enter:

            Clear the Bash window:
            $ clear

             

            Now, let’s try to examine the folders in our current directory again, and see if we can get a more useful view of the subfolders we are working with. Type the following command into the Bash window, and hit enter again:

            Print a listing of all directories within the current directory:
            $ ls -d */

             

            The result should look like this:

            Bash-List-Directory-Contents-Folders-only

            That’s a little more like it. Ok, so now we can see what folders exist within our current directory.

            For a cleaner listing of the variations for the ls command, see the section of my .

            Create a New Directory in the Current Directory

            Next, let’s create a new folder. The command for creating a new directory is as follows:

            Create a new directory within the current directory:
            $ mkdir NewFolderName

             

            Type that into your Bash window, substituting MyNewFolder for NewFolderName and hit enter. This is what you should see when you are done:

            Bash-Create-New-Folder

            But hey - nothing happened, right? Wrong.

            As mentioned above, when the mkdir command executed properly, the result is “silence.” In other words, Bash assumes YOU know that, lacking additional feedback, everything went fine. Let’s check and see. Type your new “Show me all the folders, but only the folders” command we discussed previously, and hit enter:

            Bash-List-Directory-Contents-With-New-Folder

            Well, what do you know. There is our new folder. But wait. What if we want spaces in the name of our folder? Let’s try THAT with a another new folder. Type the following and hit enter:

            Create a folder named My Other New Folder:
            $ mkdir My Other New Folder

             

            When you hit enter, you should see something like this:

            Bash-Create-New-Folder-With-Sapces-Wrong

            Hey, looks like everything worked! No complaints from Bash. Let’s see, using our “Show directory contents” command again:

            Bash-List-Directory-Contents-With-New-Folder-Wrong

            Uh-oh. Looks like things didn’t go quite the way we expected. As it turns out, we confused Bash, because the actual syntax of the mkdir command is:

            The full syntax for the mkdir command:
            $ mkdir Folder_1 Folder_2 . . . Folder_n

             

            So when we typed in a folder name containing spaces, Bash thought we were creating a separate new folder for each word. As it turns out, most of the time when using Bash, we need to enclose text with spaces in quotes, so that Bash will know that the quoted text represents a single object or idea. Let’s try creating our new folder with spaces in the name again. This time, type the following into the Bash window:

            Create a new folder with spaces in the name:
            $ mkdir "My Other New Folder"

             

            When you are done, you should see something like this:

            Bash-Create-New-Folder-With-Sapces-Correct

            Again, we assume that nothing went wrong from a technical standpoint, because Bash executed the command and returned without complaint. If we check to see again, we find the following:

            Bash-List-Directory-Contents-With-New-Folder-Correct

            Yay! So now we can not only create folders, but with spaces in the names too, dammit!

            For more on creating directories, see the in my Basic Git Command Line Reference Post

            Move to a Folder Within the Current Directory

            Ok, so now let’s navigate ourselves into the first folder we created, MyNewFolder. First, though, let’s clear the bash window again, so we can get rid of all the clutter we have accumulated so far.

            When we want to move to a new location using Bash, we use the :

            The correct syntax for this command is:

            Change Directory Command Syntax:
            $ cd [options] [<DirectoryName>]
            In the above, the square brackets denote optional inputs, and the angle brackets denote user-supplied values. In both cases, we do not type the actual brackets into the command window.

             

            Since Bash already knows the current directory we are in, we can specify a folder name which exists in the current directory, without the rest of the directory path. Type the following into the Bash window, and hit enter. You should see something similar to this:

            Bash-Change-Directory-Within-Current-Folder

            Note in the above that the line above our prompt has changed, and appears to indicate our current path as:

            ~/MyNewFolder

            Remember that Bash uses the ~ symbol to denote our default (User) directory, so this is a relative reference within the user directory. From where we are right now, there are a number of ways we could return to the user directory.

            The first is to simply enter the cd command with no additional input. Doing this will return us to the default directory from wherever we happen to be in the file system:

            Return to the Default Directory (“Take Me Home”)
            $ cd

             

            Another option is to type cd - (that’s the cd command followed by a space, followed by a single dash). This tells bash to go back to the previous directory. In this particular case, the previous directory also happens to be our home user folder, but it really doesn’t matter what directory we came here from, cd - returns us there.

            Return to the Previous Directory (“Take Me Back”)
            $ cd -

             

            The third option is to type cd .. (that is the cd command, followed by a space, followed by two periods in a row). This command tells bash to go up one level in the folder hierarchy.

            Move Up One Level (“Take Me Up”)
            $ cd ..

             

            Considering that we are currently in a folder within our home directory, you can see why in the current situation, these three are all about the same in terms of returning to the home directory. At the moment, it is not only the last place we navigated from, but is also one level above our current location. And it is, indeed the home folder. So all three options work for us in this case. Try the “Take Me Up” command. Type it into your Bash window and hit enter. You should see something like this:

            Bash-Change-Directory-Up-One

            Note that we now appear to back in the “directory known as ~” or, our user  folder.

            Now type the “Take Me Back” Command (cd -) and hit enter:

            Bash-Change-Directory-Back

            Now, here we are right back in the MyNewFolder directory. Note that Bash decided to tell us where it took us in long form:

            A Linux-Style Directory Path
            /c/Users/xivSolutions/MyNewFolder

             

            But wait - what is with that funny directory syntax? That is the Linux directory style. In fact, when typing explicit directory paths into Bash, you will need to use that format, because Bash will not recognize the Windows directory style. It’s easy enough to follow though:

            1. Instead of using the forward-slash (\) character as a path delimiter, Bash (and Linux) uses the backslash (/)
            2. /c/ is the Linux way of expressing the familiar C:\

            Move to a Specific Directory Using the Complete Directory Path

            Knowing this, we can also use explicit paths for navigation. For example, let’s say I wish to move from the current directory to my Documents folder. I can type the following:

            Move to a specific directory using the directory path:
            $ cd /c/Users/CurrentUserFolder/Documents

             

            Try that now, substituting your user folder, assuming that you have a standard Windows file structure, which includes a Documents folder in your user folder by default:

            Bash-Change-Directory-To-Documents

            Ok. If all went well, you should now find yourself in your Documents folder. Note that even though you are within a subfolder of your user folder, Bash is now displaying the long form of the directory path, instead of the shorthand relative path.

            Now try using the “Take Me Home” version of the cd command (simply type cd and hit enter):

            Bash-Change-Directory-To-Default-TakeMeHome

            Presto - back in our home directory.

            For more on directory navigation, see the of my

            Remove Directories

            Ok, now what about those folders we “accidentally” created when we entered a multi-part directory name? You know, the folders named “My” and “Other” and “New” and “Folder”? Remember THIS:

            Bash-List-Directory-Contents-With-New-Folder-Wrong

            Since these folders are all empty, we can simply use the rmdir command:

            Remove One or More Empty Directories:
            $ rmdir Directory_1 Directory_2 . . . Directory_n

            Type the rmdir command as follows and hit enter. When you are done, you should see something like this:

            Bash-Remove_Empty-Directories

            Then, if we check the directory contents again, we see that those extra directories no longer exist:

            Bash-List-Directory-Contents-After-Removed-Unwanted

            Removing an empty directory or directories is a simple undertaking. The process is a little different if the directory to be removed contains files or other directories. We’ll look at this in the next post.

            Next: Creating and Working with Files using Bash

            Additional Resources


            Related Posts

             

            Posted on September 9 2012 08:10 AM by John Atten     

            Comments (0)

            Basic Git Command Line Reference for Windows Users

            Posted on September 8 2012 09:22 AM by John Atten in CodeProject, Education, Git   ||   Comments (0)

            gitWhile there are GUI interfaces available for GIT (some good, some bad), familiarity with at least the basics of git’s command line interface can only enhance your ability to use the tool to maximum effectiveness. Since I am relatively new to git and version control in general, I set out to learn the basics of the git command line. In doing so, I found it handy to keep a list of the commonly-used commands nearby so that I didn’t have to keep Googling.

            In this post, I am going to cover the very basic set of commands one might require to effectively navigate and maintain your source repo using only the git Bash command line interface. Probably, in creating this post, I will not need to look at this again, as the sheer fact of composing this list and explaining it all will burn these into my brain forever. On the other hand, if I am ever unsure, I will now have a place to come look!

            NOTE: The references here are by no means comprehensive. I have included the basic commands required to get started, and the commonly used options for each command. There is a wealth of additional information available on the internet, and I have included some helpful reference links at the end of this post.

            To more easily find what you might be looking for, here are some links to specific sections of this post:

            Working with the file system

            Configuring Git and Creating a Repository:

            Staging and Committing Changes

            Working with Remote Repositories (like Github)

            Undoing Changes and Working With Tags

             

            Git Bash: Syntax Notes


            Directory Paths

            First off, note that Git Bash is a *nix application (Unix/Linux), and expects inputs according to *nix conventions when it comes to file system navigation. This is important when using Git on a windows system, because we need to mentally map the familiar Windows directory notation to Unix format:

            Windows Directory Path <---- Becomes -----> *nix Directory Path
            C:\Users\MyUserFolder\   /c/Users/MyUserFolder/

             

            Strings with Spaces

            When we are going to provide an input string with no spaces, we need do nothing. However, strings which contain spaces must be enclosed in quotes. Remember this. Personally, I just use quotes around strings in general.

            The “Home” Directory

            The file system in *nix systems is set up a little differently than in Windows. Git Bash assumes the existence of a “home” directory for each user. In Windows, the default is your personal user folder. This folder is where Git Bash opens by default. Typing only cd after the command prompt will always return you to the root level of the home directory.

            Command Syntax Format:

            The basic command syntax for a git Bash Command is:

            $ CommandName [options] [directory]

            In the above, the square brackets denote optional parts of the command. The square brackets themselves are not typed into the command line. Items following a command which are not enclosed in brackets are required.

            Cases and Spaces Count

            Also note that git Bash is case-sensitive, and spaces count. For Example, the common command to change to another directory is cd. This is NOT the same as CD or Cd.

            Optional Input

            When portions of a command are optional, we will note this by enclosing them in square braces:

            $ Command [options]

            In the above, we do type the square brackets.

            User Input

            For our purposes here, when we are presenting command syntax examples, we will denote user-provided values between angle brackets:

            $ Command [options] <SomeUserInput>
             

            In the above, we do type either the square or angle brackets.

             

            Git Bash: Navigating the File System (cd)


            Syntax:

            cd [options] [<directory>]

             

            Navigate to the Home Directory (Default folder for the current user):
            $ cd

             

            Navigate to a specific folder in the file system:
            $ cd /c/SomeFolder/SomeOtherFolder/

             

            Navigate to a specific folder in the file system (if there are spaces in the directory path):
            $ cd “/c/Some Folder/Some Other Folder/”
             
            Go back to the previous Location:
            $ cd -
             
            Move Up One Directory Level:
            $ cd ..

            In the above, the cd command is followed by a space, then two period with no space between.

             

            Git Bash: Show Directory Contents (ls)


            Syntax:

            ls [options]

            Options:
            -1 = List 1 item per line
            -r = Reverse the sort order
            -a  = Show Everything, including hidden items
            -d = list only directories
            -l = (letter L, lowercase) = Use a long listing format (more info per item, arranged in columns, vertical listing)

             

            List the contents of the current directory (folder):
            $ ls

            The above will display the contents of the current directory as a horizontal list. Not real convenient.

            List the contents of the current directory, one item per line:
            $ ls -1

            That’s better. Note, however, that we can only differentiate files from subdirectories based upon the file extension.

            List only the subdirectories (folders) within the current directory:
            $ ls –d */

             

            List everything in long form, vertically:
            $ ls –al

            The above gives a swath of information. Also, subdirectories are differentiated by the first column (begin with drwxr instead of -rw)

            List all contents, including subdirectory contents, single item per line:
            $ ls -1 *

             

            Git Bash: Create a New Directory (mkdir)


            Syntax:

            mkdir [options] <folderName>

            Options:
            -p = Create parent directories as needed
            --verbose = Show a message for each new directory created (note the double dash)

             

            Create a folder in the current directory (without spaces in the folder name):
            $ mkdir NewFolderName

             

            Create a folder in the current directory (with spaces in the folder name):
            $ mkdir “New Folder Name”

             

            Create a folder at the specific directory path:
            $ mkdir /c/ExistingParentFolder/NewFolderName

             

            Create a folder at the specific directory path, and create parent directories as needed:
            $ mkdir -p /c/NewParentFolder/NewFolderName

             

            Create a folder at the specific directory path, create parent directories as needed, and print a description of what was done in the console window:
            $ mkdir -p --verbose /c/NewParentFolder/NewFolderName

             

            Git Bash: Create Files (touch, echo)


            Syntax:

            touch [options] <FileName>

            echo [options] TextString > FileName

            (NOTE: FileName can include directory. Default is the current directory).

            Create a single (empty) text file in the current directory:
            $ touch newFile.txt

             

            Create a single (empty) text file in the specified directory:
            $ touch /c/SomeFolder/newFile.txt

             

            Create multiple (empty) text files in the current directory:
            $ touch newFile_1.txt newFile_2 . . . newFile_n

             

            Append text to a file. If the file does not exist, one is created:
            $ echo “This text is added to the end of the file” >> newFile.txt

             

            Overwrites text in a file. If the file does not exist, one is created:
            $ echo “This text replaces existing text in the file” > newFile.txt

             

            Overwrites text in a file at the specified location. If the file does not exist, one is created:
            $ echo “This text replaces existing text in the file” > /c/SomeFolder/newFile.txt

             

            Git Bash: Remove Files (rm)


            Syntax:

            rm [options] -<FileName>

            Options:

            -I (or --interactive) = Prompt before removal

            -v (or --verbose) = Explain what is being done

            Remove the specified file from the current directory (no spaces):
            $ rm -DeleteFileName

             

            Remove the specified file from the current directory (with spaces):
            $ rm -“Delete File Name”

             

            Prompt for confirmation before remove the specified file from the current directory (no spaces):
            $ rm -i -DeleteFileName

             

            Removes the specified file and reports what was done in the console window:
            $ rm -v -DeleteFileName

             

            Git Bash: Remove Directories (rmdir, rm -rf)


            Syntax:

            rmdir [options] <FolderName>

            rm -rf

            Removes the specified folder if empty. Operation fails if folder is  not empty:
            $ rmdir -DeleteFolderName

             

            Removes the specified folder and all contents:
            $ rm -rf -DeleteFileName

             

            Git Bash: Configure Git (git config)


            Syntax:

            git config --global user.name <“User Name”>

            git config --global user.email <UserEmailAddress>

            Set the global User.Name value for the current user on the system:
            $ git config --global user.name “FirstName LastName”

             

            Set the global User.Email value for the current user on the system:
            $ git config --global user.email UserEmailAddress

             

            Show me the current values:

            The following return the current values for the user.name and user.email properties respectively and output the values to the console window:

            Print the current global User.Name value to the console window:
            $ git config --global user.name

             

            Print the current global User.Email value to the console window:
            $ git config --global user.email

             

            Git Bash: Initialize a New Git Repo (git init)


            Syntax:

            git init

            Create files required in the current directory to perform version control:
            $ git init

             

            Git Bash: Add/Stage for Commit (git add)


            Syntax:

            git add [options] [<File_1>] [<File_2>] . . . [<File_n>]

            Options:

            -A (or --all) = Add all new or changed files to the staged changes, including removed items (deletions)

            -u = Add changes to currently tracked files and removals to the next commit. Does not add new files.

            . = Adds new or changed files to the staged changes for the next commit, but does not add removals.

            Note that git add -A is semantically equivalent to git add . followed by git add –u

            -p = Interactive add. Walks through changes in the working directory and prompts for add

            Add all changes in the working directory to the next commit, including new files and deletions:
            $ git add -A

             

            Add all changes to tracked files and all new files to the next commit, but do not add file deletions:
            $ git add .

             

            adds all changes to tracked files and all file removals to the next commit, but does not add new files:
            $ git add -u

             

            Walks through changed files and prompts user for add option. Does not include new files:
            $ git add -p

             

            Git Bash: Unstage from Commit (git reset)


            Syntax:

            git reset HEAD <File_1>

            Remove the specified file from the next commit:
            $ git reset HEAD FileName

             

            Git Bash: Committing Changes (git commit)


            Syntax:

            git commit [options] [<File_1>] [<File_2>] . . . [<File_n>] [-m <“Commit Message”>]

            Options:

            -a = Commit all changes to tracked files since last commit

            -v = Verbose: include the diffs of committed items in the commit message screen

            --amend = Edit the commit message associated with the most recent commit

            --amend <File_1> <File_2> . . . <File_n> = redo the previous commit and include changes to specified files

            Commits the changes for the specific file(s) and includes the commit message specified:
            $ git commit FileName –m “Message Text”

            Note that Git requires a commit message. If you do not provide one using the -m option, you will be prompted to do so before the commit is performed.

            Commits all files changed since last commit. Does not include new files.
            $ git commit –a –m “Message Text”

             

            Adds all changes to the previous commit and overwrites the commit message with the new Message Text. Does not include new files:
            $ git commit –a –amend –m “Message Text”

             

            Git Bash: Remote Repositories (git remote)


            Syntax:

            git remote add <RemoteName> <RemoteURL>

            git remote show <RemoteName>

            NOTE: As used here, RemoteName represents a local alias (or nickname) for your remote repository. The name of the remote on the server does not necessarily have to be the same as your local alias. 

            Add the specified remote repo to your git config file. The remote can then be pushed to/fetched from:
            $ git remote add RemoteName https://RemoteName/Proj.git

             

            Print information about the specified remote to the console window:
            $ git remote show RemoteName

             

            Git Bash: Branching (git branch)


            Syntax:

            git branch [options][<BranchName>][<StartPoint>]

            Options:

            -a = List all local and remote branches

            -r = List all remote branches

            List all local branches:
            $ git branch

             

            List all remote branches:
            $ git branch -r

             

            List all local and remote branches:
            $ git branch -a

             

            Create a new branch starting at the some point in history as the current branch:
            $ git branch BranchName

            Note that this creates the new branch, but does not “check it out” (make it the current working branch).

            Switch from the current branch to the indicated branch:
            $ git checkout BranchName

             

            Create a new branch and switch to it from the current branch:
            $ git checkout –b NewBranchName StartPoint

            Note that StartPoint refers to a revision number (or the first 6 characters of such) or an appropriate tag.

             

             

            Git Bash: Merging Branches


            Syntax:

            git merge [<BranchName>][--no-commit]

            Merge the specified branch into the current branch and auto-commit the results:
            $ git merge BranchName

             

            Merge the specified branch into the current branch and do not commit the results:
            $ git merge BranchName --no-commit

             

            Git Bash: Pushing to Remote Repositories (git push)


            Syntax:

            git push [<RemoteName> <BranchName>]

            Update the remote server with commits for all existing branches common to both the local system and the server. Branches on the local system which have never been pushed to the server are not shared.
            $ git push

             

            Updates the remote server with commits for the specific branch named. This command is required to push a new branch from the local repo to the server if the new branch does not exist on the server.
            $ git push RemoteName BranchName

             

            Git Bash: Fetching from Remote Repositories (git fetch)


            Syntax:

            git fetch <RemoteName>

            Retrieve  any commits from the server that do not already exist locally:
            $ git fetch RemoteName

            NOTE: git fetch retrieves information from the remote and records it locally as a branch in your current repository. In order to merge the new changes into your local branch, you need to run git fetch followed by git merge. Since there may be more than one branch on the remote repository, it is necessary to specify the branch you wish to merge into your current branch:

            Merge syntax for post-fetch merge:

            git merge <RemoteName/BranchName>

            Merge the newly fetched branch from the remote into your current working branch:
            $ git merge RemoteName/BranchName

            Using fetch before merging allows you to pull changesets in from the remote, but examine them and/or resolve conflicts before attempting to merge.

             

            Git Bash: Pulling from Remote Repositories (git pull) 


            Syntax:

            git pull <RemoteName/BranchName>

            Fetch changes from the specified branch in the remote, and merge them into the current local branch:
            $ git pull RemoteName/BranchName

             

            NOTE: git pull is essentially the same as running git fetch immediately followed by git merge.

             

            Git Bash: Undo (git reset)


            Syntax:

            git reset [options]

            Options:

            --hard = undo everything since the last commit

            --hard ORIG_HEAD = Undo most recent merge and any changes after.

            --soft HEAD^ = undo last commit, keep changes staged

            Undo everything since the last commit:
            $ git reset --hard

             

            Undo most recent successful merge and all changes after:
            $ git reset --hard ORIG_HEAD

             

            Undo most recent commit but retain changes in staging area:
            $ git reset --soft HEAD^

             

            Git Bash: Tags (git tag)


            Syntax:

            git tag [options] [<TagName>] [<CommitChecksum>] [<TagMessage?]

            Options:

            -a = Annotated Tag

            -m = Annotated Tag Message

            List all tags in the current repository:
            $ git tag

             

            Create a tag at the current revision:
            $ git tag TagName

             

            Create a tag at the commit specified by the partial checksum (six characters is usually plenty):
            $ git tag TagName CommitChecksum

             

            Create an annotated tag:
            $ git tag -a TagName -m TagMessage

             

            Create an annotated tag at the commit specified by the partial checksum:
            $ git tag -a TagName CommitChecksum

             

            Push tags to a remote repository:
            $ git push --tags

             

            Print information about a specific tag to the console window:
            $ git show TagName

             

            Almost all of the information presented above represents a “toe in the water” sampling designed to get started. There are plenty more commands for use both within Git itself, and from the more general Bash command line. Additionally, most of the commands listed here have more options than I have included. I tried to keep this simple, as a reference for myself, and for whoever else may find it useful to get started with the basics.

            Additional Resources


             

            Posted on September 8 2012 09:22 AM by John Atten     

            Comments (0)

            About the author

            My name is John Atten, and my username on many of my online accounts is xivSolutions. I am Fascinated by all things technology and software development. I work mostly with C#, Java, SQL Server 2012, learning ASP.NET MVC, html 5/CSS/Javascript. I am always looking for new information, and value your feedback (especially where I got something wrong!). You can email me at:

            jatten@typecastexception.com

            Web Hosting by