Essentially every software project having more than one developer is a collaborative project

Benedikt Hegner on Collaborative Software Development, GridKa School 2017, 28.08.2017

Exercise 0

goto https://GKS-2018-CollaborativeSoftware.github.io/workshop-collaborative_software/ to see this presentation
Get involved and be part of the team!

if you have a GitHub account:
    write your GitHub identification on a piece of paper
else:
    create a GitHub account
    write your GitHub identification on a piece of paper
while not invited:
    sleep

Agile methods

A key part of software development is developing software in a team
Many different methods exists for teams ranging from single persons to dozens of developers
A common approach is agile software development
- Focusing on working software
- Individuals and Interactions
- Responding to Change

Exercise 1

Get agile!

if you have no neighbour next to you:
    choose another seat
    move

Using `git` locally

# Initialise an empty git repository
$ git init

# Put a file into your staging area
$ git add <file>

# This makes your commit.
# To show what's in your staging area, use `git status`
$ git commit -m "message"

# You can also check what you did lately
$ git show

Useful configurations

Introduce yourself...

# Configure your user name and email
$ git config --global user.name 'Your Name'
$ git config --global user.email 'Your email'

Configure auto correction for git commands

$ git config --global help.autocorrect 1

Use colors to show git information

$ git config --global color.ui auto

Suppressing the noise

Don't track junk or personal settings

$ echo ".idea/" >> .gitignore

There are predefined templates for programming languages, operating systems, etc.
- e.g. check https://github.com/github/gitignore

Centralised Workflow

You are working on your own local copy of a central repository
Your commits are stored locally
At some point in time you publish your changes to the central repository

$ git push origin master

Managing Conflicts

Before you can publish new features, the updated central commits need to be fetched to rebase your changes on top

$ git pull --rebase origin master

This sometimes requires to resolve merge conflicts manually

Diverged commits from central repository

Managing Conflicts (2)

CONFLICT (content): Merge conflict in <some-file>

git pauses rebasing until you resolve the merge conflicts
When you are happy with the results, continue the rebasing

$ git add <resolved file>
$ git rebase --continue

Otherwise, you can still abort and you are back where you started

$ git rebase --abort

Feature Branch Workflow

Each feature lives in a dedicated branch

$ git checkout -b <feature> master

Encapsulation enables developers to work on a particular feature without interfering with main codebase
Master branch is spared from broken code
Leveraging of pull requests

Merging a feature branch

$ git checkout master
$ git pull
# the actual merge of the new feature
$ git pull origin <feature>
# pushing it back to origin
$ git push

Finishing a feature branch

# a new branch is merged into develop
$ git checkout develop
# create a new commit to retain historical infos
$ git merge --no-ff <feature>
# delete the branch after merging
$ git branch -d <feature>
$ git push origin develop

Take-away Messages

Commit often
Try not to mix up different things into one commit, make up logical units
Think about your commit messages
- Include references to tickets if available

$ git commit -m "$(curl -sL https://bit.ly/funny-mesg | sh)"

Branching is cheap

Exercise 4

The board develops over time
Neighbours preserve, kill or spawn alive cells

###        o cell
#o#        # neighbour
###

Simplify the process

Nowadays for documentation Markdown is heavily used
- There are many dialects and dozens of implementations in many languages
- CommonMark tries to standardise this
Easy to learn
Get the things done, fast

# Heading

## Subheading

Your can include *italic* and **bold** texts easily.

Caring about the enthusiasts

For some people Markdown is not sufficient
TODO: have a look at reStructuredText (ReST)
With ReST you can easily document your classes, methods, etc. to generate documentation

"""
Dispatch a call to a :py:class:`RpcServer` at ``_host``
:param _host: host to connect to
:param _port: port on host the server is listening add
:param _name: name a payload is registered with the server
:param args: positional arguments for the payload
:param kwargs: keyword arguments for the payload
"""

What is wrong here?

def daysInYear(year):
    days = 365
    if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
        days += 1
    return days

What is wrong here? (2)

def generate_checksum(self):
    nnc = 'PREFIX{0}{1}{2}{3}'.format("%04d" % int(self.account.id), datestr, num, self.sender.id)
    checksum1 = nnc[-2]
    checksum2 = 0 + (1 + 2 + int(nnc[4]) + int(nnc[6]) + int(nnc[8]) + int(nnc[10]) + int(nnc[12]) + int(nnc[14])+ int(nnc[16]) + int(nnc[18]) + int(nnc[20])) * 4
    checksum3 = 0 + int(nnc[3]) + int(nnc[5]) + int(nnc[7]) + int(nnc[9]) + int(nnc[11]) + int(nnc[13]) + int(nnc[15]) + int(nnc[17]) + int(nnc[19] + int(nnc[21])) * 7
    checksum4 = checksum2 + checksum3
    checksum = 0
    while (checksum4 + checksum) % 10:
        checksum += 1

What is wrong here? (3)

def calculator():
    num1 = int(input('Please choose your first number: '))
    sign = input('What do you want to do? +, -, /, or *: ')
    num2 = int(input('Please choose your second number: '))

    if num1 == 0 and sign == '+' and num2 == 0:
        print("0+0 = 0")
    if num1 == 0 and sign == '+' and num2 == 1:
        print("0+1 = 1")
    [...]
    if num1 == 1 and sign == '+' and num2 == 0:
        print("1+0 = 1")
    if num1 == 1 and sign == '+' and num2 == 1:
        print("1+1 = 2")
    [...]
    if num1 == 50 and sign == '*' and num2 == 49:
        print("50*49 = 2450")
    if num1 == 50 and sign == '*' and num2 == 50:
        print("50*50 = 2500")