We will cover the basics of version control and cover how to get started using Git. It is recommended that you bring a computer to this workshop. If possible, please have git installed prior to the workshop. You can download git here.
The workshop will take place on the 17th of September at 7pm in Gould-Simpson 942. Below is a post that outlines the topics covered during the workshop.
There are many different ways that you can install the git platform, including downloading the required packages from the git website. In addition, there are some platform-specific methods that can be used to download git that will be covered below.
On most Linux distributions, you can install git through your favorite package manager, such as
yum. The installation commands are as follows:
sudo apt-get install git
sudo yum install git
If neither of these commands work for, determine which Linux distribution you are running and find the appropriate commands for your package manager.
There are several ways to install git on OSX:
If none of these methods work, git has more documentation that you can find on their website.
Throughout this workshop, we will be working with the command line version of Git. To install the command line version of git for Windows, you can either download the most stable build from the official git download or download the GitHub windows package, which includes a GUI client, and is available here.
We will be assuming for the purposes of this workshop that you are using GitHub for your remote repository hosting, but other services such as GitLab or Bitbucket will work with all of the commands discussed.
To create a GitHub repository, first go to the homepage and click on the “New Repository” button:
<img src=”/public/github_homepage.png” width=720px alt=”Homepage” />
From there, you will be presented with a form to name and describe your repository. In addition to naming and describing the repository, it will also provide with some additional options. Adding a README to your repository will allow you to describe your application to your users. For an example, check out the uofa-acm README. It will also ask if you would like to add a gitignore to your repository. A gitignore will prevent you from adding unnecessary files (binaries, output files, etc.) to your repository unless you explicitly specify that you want it added. These help keep your repository clean. A repository with all of the templates can be found here. Lastly, it will ask you to supply a license describing the permissions you are giving to contributors and users of your work. GitHub has created this website to help your pick the right license for you.
Once you have created your repository, you can move on to cloning your repository and begin working on your project.
Having a remote GitHub repository is great, but how do you get that remote copy on your local
machine? The answer is
git clone. Cloning takes a repository on a git server and creates a local
copy of that repository. On the project page for your repository, you will find a link on the
left-hand side that gives you multiple URLs you can use to clone your repository, including SSH
and HTTPS. For now, we will be using the HTTPS
<img src=”/public/clone_links.png” width=720px alt=”Git clone links”/>
Once you have your url, type the following command into your terminal:
git clone <url>
Running, the above command, you should see something like this:
<img src=”/public/git_clone.png” height=130px alt=”git clone output” />
Once your repository has successfully cloned, you can change into the directory for your repository
and see the contents. Before we move on, let’s check the status of our repository with
This will show us how our local repository has changed with respect to the remote repository:
<img src=”/public/git_status.png” height=130px alt=”git status output” />
As shown above, your git status should say that there is nothing to commit. Let’s change that!
The basic workflow in git involves staging files that you have changed and adding those files to commits that you push to the remote repository. So let’s create a file that we can add to our repository, say hello_world.txt.
First let’s create the file:
echo "Hello World" > hello_world.txt
Now, if you run git status, you should see something similar to the following:
On branch master Your branch is up-to-date with 'origin/master'. Untracked files: (use "git add <file>..." to include in what will be committed) hello_world.txt nothing added to commit but untracked files present (use "git add" to track)
As you can see, git is telling us that the filled is “untracked”. Git is telling us that it is not
currently tracking updates to the file (read: the file is new to the repository). So how do we fix
that? Well, the
git add command does exactly what we need to. This command takes a file that is
currently unstaged (new, modified, removed, etc.) and stages that change to be committed. The
command takes as arguments on the command line a series of files or directories to be stage. So if
we want to stage our newly created file, we execute the following command:
git add hello_word.txt
Running git status after this will show us the following:
On branch master Your branch is up-to-date with 'origin/master'. Changes to be committed: (use "git reset HEAD <file>..." to unstage) new file: hello_world.txt
Now that we have staged a file, we are ready to create a commit. A commit can be thought of as
a self-contained patch that is applied to the repository. To create a commit, you can run the
git commit command. Upon running this, an editor should open up that asks you to provide a git
commit message. This message is something that should what was changed in your commit provides
necessary details about why the commit is being made
Once you finish your commit message, running git status should output something like this:
On branch master Your branch is ahead of 'origin/master' by 1 commit. (use "git push" to publish your local commits) nothing to commit, working directory clean
At this point, the only thing left to do is to push your changes to the remote repository:
git push origin master
One of git’s biggest strengths is that it makes collaboration between large teams incredibly managable. There are several concepts that make interacting with teams of other developers less painful and makes the lives of everyone involved easier.
Branching is a technique in git that allows you to create multiple histories branching off from a single point.
<img src=”https://www.atlassian.com/git/images/tutorials/collaborating/using-branches/01.svg” height=200px>
As an example, let’s say that you have made several commits to the master branch of the repository that you’re working in. What happens if you want to work on a new feature without potentially breaking the code for the other people who are using your code? Well if you create a branch, it allows you to work and commit your work without directly affecting the people who are working with the master branch. It allows you to sequentially develop your new feature until you have everything working and then move all of the code over to the master branch without incrementally breaking everyone else’s code by accident.
Git makes branches incredibly easy to create:
git checkout -b <new-branch-name>
This command will create a branch and automatically switch to it. To list the branches you have
locally, you can run
git branch. This will result in output similar to the output shown below:
master * new_branch
To switch between already created branches, you can use
git checkout. For example, if I wanted to
switch to the master branch after creating new_branch, I would run
git checkout master.
So what happens when you have a branch that has a bunch of commits, and you want to copy those commits into the master branch? Well then you’ve officially entered merge territory!
When you’ve finished work on the contents of a certain branch and you want to merge those changes
into a different branch, you must do several things. First of all, checkout your target branch.
This means that if you want to merge new_branch into master, you should first run
git checkout master. After you have checked out the target branch, you’re ready to start the merge
process. This is done with the following command:
git merge new_branch
This will, in most cases, result in output similar to the following:
Updating 1d91f95..4eda83d Fast-forward a.txt | 0 b.txt | 0 c.txt | 0 d.txt | 0 e.txt | 0 f.txt | 0 g.txt | 0 7 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 a.txt create mode 100644 b.txt create mode 100644 c.txt create mode 100644 d.txt create mode 100644 e.txt create mode 100644 f.txt create mode 100644 g.txt
Afterwards, your git status will note that you are currently some number of commits ahead of the remote repository. This number is the number of commits the merged branch was ahead of the master branch. In most simple cases, merges are relatively easy to handle. However, you might be asking about what happens if two branches have modified the same file and then a merge is performed. This situation will lead to one of two outcomes: (1) Git automatically resolves the merge and everything is fine; or (2) Git is unable to automatically resolve the merge and results in a merge conflict.
In the case that your merge results in a conflict, the process for merging the code takes a more manual process that is discussed below.
Try GitHub - Try Git in your browser
Git Cheatsheet - General tips for git
Git Pretty - Cleaning up after your mistakes
Git Commit Tips - Tips for writing better commit messages
Intermediate Git - More complicate git commands
Pro Git - Scott Chacon and Ben Straub’s “Pro Git” book is available online for free. From very basics to git internals. Good stuff.
This is a talk on some of the probability you need to know for programming thingies.
These are the slides I used for the talk.
Make a LISP is a project on github that walks you through a implementation of a LISP dialect based on Clojure. Currently, the spec has been implemented in 27 different languages, including interesting implementations in bash and GNU make.
This talk will serve as a high level introduction to the project.
Now that processors have become cheap and efficient, everything from your car to your credit card has become integrated with “smart” technologies, essentially meaning that they have become small computers. However, along with the benefits and capabilities of these new platforms come increased security risks. This talk will provide a brief overview of some of these risks, and demonstrate how to detect, exploit, then mitigate them. As with any talk of this nature, the subjects of illegal access and “hacking” will be covered. However, the University of Arizona ACM chapter does not condone such actions, and they are discussed purely for academic and preventative reasons.
LISP is a family of programming languages spanning decades that has spawned dozens of incarnations. This talk will serve as an introduction into what makes LISP different and why those differences make it powerful.
The slides for this talk are available here.
While IRC seems like a somewhat dated form of communication, it is still prevalent in software development communities. There are active IRC channels for:
The communities that form in IRC channels are often quite helpful, and are generally interested in discussing a project you might be working on, or a bug you are stuck on.
Part of IRC’s appeal is the fact that it’s an open protocol. This means companies or individuals can write bots to perform non-trivial tasks, and interact with these bots via IRC, where the rest of their team can be aware of what is going on.
To this end, I have been working on an IRC Bot template called BotPlate. BotPlate contains a core class to handle IRC connection and communication, and is easily extensible to add any new functionality.
While Python has a reputation for being a simplistic language, it’s open architecture means that it’s capable of being an extremely powerful language. This talk will provide an intro to some of Python’s more advanced features, including making your classes behave more like “native” classes.
We had a great turnout with 60 people competing at this year’s local University of Arizona ACM Programming Contest.
Come to this week’s ACM meeting to talk to fellow competitors about those problems that had you banging your head against the wall, or the ones that you had a particularly clever solution to. We have the source code for the official solutions, but its always much more interesting to see how our peers approached the problems.
In case you missed the competition, or lost your problem statements, the problems can be seen below:
Following up with Matt Gautreau’s talk earlier in the semester, we’ll be discussing the purpose and functionality of maintaining projects in both local and remote repositories using Git and Github.
We’ll be starting with a coding problem from HackerRank in preparation for the programming competition this weekend.
We’ll also have an interactive portion wherein users can fork from the U of A ACM Homepage Repository, implement their own member profile, and post the results to the live ACM website!
To prepare yourself, Install Git and create a Github account before the meeting if possible
Also, check out the Git Immersion tutorial if you want to prepare for the material beforehand.
Slides and instructions for posting a member profile to the website will be posted after the meeting.
This ACM talk serves as an introduction to the realm of intellectual property law specifically related to software inventions. The discussion will mainly revolve around issues relevant to the perspective of the inventor (in this case a computer scientist in the midst of filing for a patent on a software invention). Central topics include the process and requirements behind obtaining a software patent, the reasons for doing so, and how to effectively avoid infringement. Other topics include recent litigation and legislation in the arena such as Alice Corp. vs. CLS Bank, patent assertion entities and the LOT agreement, the debate surrounding the open source movement, and more. You can find the presentation slides here.
The goal of this talk is to introduce functions in the functional programming sense. We will think about why these are different from methods in Java. Once we start to get an understanding of these differences, we will explore how much information we can get out of the type signature of functions. Finally, we will talk about what it means to be a first class function, and how this allows functions to be cleaner and more reusable.
No previous knowledge of functional programming is assumed.
WARNING: This talk will make you think! I will asking questions, and we will work out the answers together, so bring your thinking cap.
This talk is geared towards a student in CS245 . Most of the content will be approachable by someone in the introductory courses (CS127A/B or CS227), but it will be challenging (in the good way, of course!).
Ruby on Rails is a powerful web application framework that allows you to be productive and write well-structured, easy-to-understand code, instead of focusing on the complex infrastructure necessary to implement a web site all by yourself. A more detailed introduction to the framework can be found here.
This talk will introduce the fundamentals of web development and then will move into a basic exploration of Ruby on Rails. There will also be a small demonstration to show how quickly and easily Ruby on Rails allows you to build a website, just by using an object-oriented mindset, even with minimal knowledge of databases.
The slides associated with this talk can be found here
Bring your laptop to ACM for this one. Its going to be a hands on introduction to git and github. We will use the ACM Homepage Source as an example, so that everyone knows how to contribute.
One person will be leading the walk-through, while experienced members of the club will be meandering around helping anyone who needs it.
In order for us to have a productive meeting, there is some software you need to install before hand.
If you want to read ahead a little (highly encouraged!) check out:
If you have any questions, feel free to email the group and we will do our best to help. Just to remind you, this is the email group
One of the biggest technologies in industry today is big data. As the amount of data in the world grows, the demand for people in the data field increases.
For my talk, I’ll be going over the basics of big data. I’ll talk about what’s included in big data, as well as how it is received, stored, and then retrieved. Also, as I work with large amounts of data, I’ll be sharing some of my own experience as I go through the talk.
What do old hockey stadiums, 1980’s soda machines, 2030’s downtown Tucson and Star Trek have in common? How can the same virtual environment be easily navigated with a mouse and keyboard on a pc, over the web on a browser, in a Virtual Reality CAVE or through an Oculus Rift and Omnidirectional Treadmill (even sets of all three in the same networked world)? And when are we going to get around to building the Matrix (without the robots taking over)?
During the September 11th ACM meeting, join Steven Eiselen, an undergrad CS major and assistant in the UITS AZLIVE Laboratory for a talk on real world applications with virtual reality and 3D modelling.
A series of talks on what our members did over the summer
As my senior talk, I will be presenting components of the projects I have spent the last year working on. Upon encountering a problem at work, I was challenged to develop a creative solution that could change our throughput of projects from one every 2 months to 1000+ every year. I will be showing how, despite not being an interesting challenge, interesting solutions are always present and should always be embraced. I will also be showing some of the technologies that I have developed to achieve this fabled goal of 1000 projects per year.
One of the things we barely emphasize at the U of A is how to test your code - and not just doing unit tests either. I’ve noticed that industry doesn’t necessarily emphasize it either. But how can we guarantee our product will work if we don’t heavily test it? I’ll be going over how to bring in UI Testing (using selenium and unit tests) to test interactions with the product, as well as how to mock interactions with outside sites to fully test your code.
This will be a 10,000 foot view of artificial neural networks (ANNs), the convolution, convolutional neural networks (CNNs), and automatic differentiation. ANNs will be shown graphically: what they look like structurally, what they can recognize, what they can create after being trained, backpropogation and gradients. Finally, we will cover a neat technique called automatic differentiation for calculating exact gradients used during backpropogation learning as opposed to the traditional difference quotient or symbolic manipulation methods.
Genetic Algorithms are algorithms that are modeled from biological reproduction found in nature.
GAs attempt to find optimal solutions to problems sets, just like in reality these algorithms adapt to find new solutions when their environments change.
GAs carry metaphors that help us think about how to relate reality to code for creating novel abstractions. I hope to inspire ideas of how to implement models of other mappings of reality that could potentially have useful application.
Metaprogramming is the practice of writing programs that produce new code. This talk will serve as a gentle introduction to basic metaprogramming concepts. It will include some of the history of metaprogramming, applications of metaprogramming, and some examples in C++ and Python, though no experience in either programming language is required.
Conceptualizing how sorting algorithms work, and comparing efficiency can be difficult. I used a graphics language called Processing to visualize different comparison sorts, including BubbleSort, InsertionSort, SelectionSort, MergeSort, and Quicksort
Code for these visualizations can be found here Sorting Algos
With the release of Java 8, a whole slew of new features have been released into the wild. These features include features that have long been missing from the Java environment, yet have long existed in other development environments. This talk will serve as a basic introduction to the primary features that were introduced and the concepts that they are based on.
A short explanation of software development for embedded systems, with examples drawn from my LED-Grid car.
In production environments, especially immediately after inheriting a project, asking a piece of software to immediately “be secure” is unreasonable. Thus, threat models are created to prioritize fixing vulnerabilities. This talk covers the basics of vulnerability identification, assesment, and patching, using the DREAD and STRIDE threat models and the Buggy Web Application Project as an example.
Counting sort operates by counting the number of objects that have each distinct key value and uses arithmetic on those counts to determine the positions of each key value in the output sequence. Its running time O(n+r).
For many problems in AI, and games in particular, it is beneficial to allow an agent (general name for a program that runs with an artificial intelligence) some form of predictive power, and the ability to learn a certain amount of information. While the field of machine learning is rather broad scoped, this talk will focus primarily on two different approaches - Decision Trees and Reinforcement Learning.
The talk assumes that you have a brief understanding of artificial intelligence concepts, as well as understanding of a Tree structure (whether or not you understand how to code one in software).
Part 3 in the algorithms series -Quicksort
This week, Josh will be presenting a basic introduction to web application (and site) security. While not designed to be an all-encompassing presentation, this talk will hopefully provide you with a basic understanding of the most common attacks against web applications, using DVWA (Damn Vulnerable Web App). This talk will use live exploits against intentionally vulnerable targets, so networking setup will be important. There is quite a bit of setup for this talk, so email me at firstname.lastname@example.org if you get confused. I will respond as quickly as I can.
####For VMWare Users: 1. In the menu bar at the top: File > Open 2. Browse to the directory where you unzipped the Metasplotable archive 3. Open 4. Press “Edit virtual machine settings” (Right under “Power on this virtual machine”) 5. Go to Network Adapter 6. Set to Host-only
####For VirtualBox Users (Don’t worry, it’s not that much harder)
####For both VMWare and VirtualBox users (After setting everything up) 1. Start up your virtual machine 2. Log in with username “msfadmin” and password “msfadmin” 3. Run “sudo dhclient && ifconfig” 4. Remember the IP address that isn’t 127.0.0.1, it should be listed under an interface like eth0 5. Go back to your regular computer (Right control in VirtualBox, ctrl+alt in VMWare) 6. Check that you can ping Metasploitable (“ping [The IP you previously found]” for windows, “ping -c5 [The IP you previously found]” for Mac/Linux) 7. Shut down Metasploitable (close out of its window, select “shut down”) 8. Profit. You’re finally finished.
When programs are small, it it simple to mentally keep track of its behavior and interactions. However, as programs get large, this becomes a near impossible task. Fortunaltely for us, there’s Valgrind.
Valgrind is an instumentation framework for executable files. It comes packaged with a suite of built-in tools for analysing memory usage, cache statistics, callgraphs, and more. In this talk, I will give a brief intoduction to Valgrind, and show a few examples of how to use it to make your programs better.
This talk assumes that you have some background in C programming and UNIX (either from cs352 or elsewhere). If you don’t, fear not! I will try to make it understandable for everyone. Also, there will be some live examples, so if you want to follow along make sure you install Valgrind on your laptop ahead of time. Also, the slides and some example programs are available here.
This week, Ben and Roey will be presenting some best-practices for efficient software development. We will first do an introduction to the Vim text editor, and explain why mastering a console-based editor is so useful. We will follow that up with a talk about git.
These presentations are designed to give you a solid overview of these tools, so if you are new to all of this, no worries! If you have a Mac, Linux or Windows laptop, feel free to bring it and follow along with the presenters.
vim resources: ftp://ftp.vim.org/pub/vim/doc/book/vimbook-OPL.pdf http://www.fprintf.net/vimCheatSheet.html
git resources: http://gitolite.com/gcs/index.html http://try.github.io/levels/1/challenges/1
Having a solid background in computer science provides one with many interesting opportunities. Come hear about what club members have done with their computer science skills and education.
Club members have had internships and jobs at Microsoft, Raytheon, the U of A, and various other companies, as well as participated in hack-a-thons and ventured out into the world of startups.
Each person will have a few minutes each, and audience participation is encouraged; So come by, see what opportunities are out there, and tell us what you have been up to.
As a student of Computer Science, how can you make a positive impact on problems in other majors? Short overview of applying CS techniques and culture to solving traditional engineering problems.
This talk will focus on applying web technologies and general CS culture of being lazy and inefficient to solve traditional engineering problems in efficient and innovative ways.
keywords: robots, aerospace, python, message queues, web programming, military industrial complex-ities, nonconformity
When you write a “Person” class, does it contain enough attributes to describe a person? Are we nothing more than eye color, hair color and height? Would you be surprised that it might be easier to write a “People” class than a “Person” class? How can this be? This talk will cover abstraction at the”groups instead of individuals” level and hint that this may likely be an intrinsic part of our universe(s).
Lots of space references.
keywords: monads, comonads, ensembles, universe/multiverse, method getters & setters
Our first lightning talk of the semester kicks off with an introduction to Go. Go is concurrent, garbage-collected, and scalable language. It provides a fast, fun, and interesting design that allows for interfaces, reflection, concurrency and more. With that said we are setting up a talk line-up, so talks, times, and dates are subject to change.
Join us and discuss the solutions to our largest ACM local ICPC turnout! Over 50 students competeted to solve eight problems in five hours. This week we will provide solutions to a few problems and go over the basic strategy of the others. We will also be providing a solution’s page in the style of CodeJam for all our competitors. Stay tuned!
If you have any last minute questions or suggestions for the competition then you will want to be here today. We will briefly discuss the competition and provide details on the catering, problems, and afterparty.
Show up and hang-out. Talk about the HN-flavor of the day, your favorite subreddit, or just vent your weekly-CS irritations. You’re welcome to continue the discussion afterwards while enjoying a few drinks. Aftermath: We ended up solving two problems from the 2011 competition, enjoyed a discussion on embedding Python, a primer on core concepts in the ACM competition, and a look at other competitions outside of ICPC. The night ended with drinks and food at a local bar.
The ICPC ACM Programming Competition begins with the qualification round on September 22nd. We will discuss the times, food, and structure of the competition. Our Fall sponsor, Microsoft, will be providing prizes and internship opportunities. (view this presentation)
Join your local uofa ACM chapter at 5PM (hopefully in GS-701). Topics of interest for the first week are the usual: welcoem to the club; upcoming talks; focual points of the semester; and the regional competition. We will also be electing a new president and establishing a common meeting time.
It’s a framework for perfectionists with deadlines. This week’s talk concerns a high-level web framework written in Python. See its applications and usages. (view this presentation)
If you have ever been interested in developing a game, then this talk will put you in the right direction. Learn how to create your tools, utilize OpenGL, and work with libraries like Pyglet, SDL, and more.
Katie Cunningham will continue her talk on graph theory and related research with graph visualizations.
Katie Cunningham will be giving a short talk on basic graph theory and related research in graph visualization.
Stripe is hosting a 6-level capture the flag competition and we want to show you how to get to level 6! It’s up to you to solve the last problem, but we will walk you the first five. We’ll explain and demonstrate buffer overflows, stack smashing, shellcode, regex exploits, and more.
Rise up, hacker! Cast of the chains of your IDE! An introduction to vim for high speed text editing.
It’s time to decide how we’re structuring the competition this semester. We’ll spend the next few weeks going over the problem or problems as well as funding, location, and so on.
Inotify is a Linux kernel subsystem that provides a mechanism for monitoring file system events. Never again will you have to poll files or directories for changes. Justin will demonstrate the C API as well as the equivalent Python API.
An introduction to version control with git, covering what version control is and why we use it, how to do basic operations with git, how to use git to collaborate with others, and the basics of github.
Continuing from the “Haskell in 15 Minutes” talk from last week, Chris will
cover monads and remove some of their mystique. The talk will give the
rationale of monads in a pure lazy functional language like Haskell. The
Wadler interpreter will be the vehicle of discovery for derivation of two
standard Haskell monads: