Cool under pressure, a contrarian, yet completely comfortable changing his opinion. On Hannity and Colmes, he made everyone look silly. His story on the Moth reminded me how brilliant he was. The title is Mistaken Divinity, an excerpt of the even more excellently named show: Mentor, Tormentor, Progenitor. He was someone who faced his opposition in debate so often he was comfortable and unflinching. And he was informed and smart enough to make mincemeat of anyone I saw him debate.

It would be hard to listen to This American Life's two part series on Harper High School, found here and here, and still feel that teachers and school administrators don't care, are all incompetant union sluggards, or don't make a difference. The story of the school who was turning things around, and about to lose the funding which made that possible is just painful to hear.

Just to marginalize a desperate situation, and make it about myself: one social worker's description of how she feels after a student drops out feels very simialr to how I feel about losing a customer. Some folks we see have sites that really are in bad shape, jobs are on the line, etc. Sometimes we fix the issue, but there are always cases where the client chooses another solution. My scenario is a million times less important in the whole scheme of things, to be sure. But the feeling of loss and failure are there, and do wear down a person.

Part of my job is to let my staff know where we succeed, in a bubble where we hear mostly complaints. More than just anecdotal, it is good to see how many successes there are. It's on my list of things to do.

I was looking at my Linkedin dash and saw this teaser for an Infrastructure Project Manager job in Lake Forest, Il:

Multi-national client has the need for an experienced System Delivery Project manager to assist on business projects and IT stand alone projects. The business projects would entail being the system lead managing the execution of all infrastructure tasks required to meet the project requirements. The IT projects would require extensive PM expertise leading and managing the stand alone infrastructure projects including system upgrades and new system installations within the IT organization.

Likely managing 4-5 projects concurrently across multiple regions and multiple technical solution domains. The professional will have to manage their allocated resources and manage project scope, milestones and budget. They will be responsible for project communication through different channels and across all levels of the organization. Additional experience in managing application projects is a plus.

Was it the goal here to write the most depressing job description possible? It's pretty common to see posts like this, where my takeaway is they are seeking an experienced, skilled PM to install some big, dull application in a big, dull office where maybe no-one wants it anyway, and the PM will take the blame if many dull projects don't get done. There isn't a single benefit listed, no details into the company, only duties. Are project managers such a commodity that HR doesn't even bother making their job sound interesting? Is this job really this dry? I would guess "probably not" to both questions, although warning flags are raised regarding the latter. So why make the job sound less appealing than McDonald's fry guy? Who would apply for this position? Woe is them.

Don't get me wrong, I am not advocating the Ninja Rockstar approach is appropriate, but assuming that a company wants to hire the best person they can, it would be helpful to make the job sound somewhat appealing. If the brutal truth is that the job is going to be this dull, it may go a long way towards discovering why the position is open in the first place.

The fact that this description is used by a recruiting company is that much worse. Is there no one at the recruiting agency who can look at this and say, "Hmm, is there anything fun about this job you want to tell readers about? Benefits, Perks, Advantages career-wise? It might make it easier for my staff to find someone." A quick check to make sure the job doesn't sound like bureacratic drudgery might put the role in a more competitive light. Enterprise could take a cue from the startup world.

When I was project managing, if I was in the code, there was a problem. Now even moreso, I have little to add as a developer, little that I can do better than others on my team. Make no mistake, I get shit done, just not that. Same thing here in the *AAS world, if I am not removing roadblocks, or developing workflow, or helping to set client expectations, I am not serving my company best. It is tempting to get in the middle of it, but it's a mistake.

When I went rock climbing, I realized if I tried to use my arms alone, I would make it about 20 feet up. I had to get train myself to let the legs to the work. It's the same kind of resource utilization question.

I am reading Good to Great. I don't care so much for business motivational books, but this is especially well written. The author describes great leaders as not having the "cult of personality" often associated with these stories. One guy said something like, "I have spent my life making sure I was qualified for the job." The one character trait that keeps coming up of is humility.

I can learn from that. In Buddhism, it is related to the illusion of self, and the importance we place on self.

Clear civi cache: /civicrm/menu/rebuild&reset=1

Send all scheduled queue: /civicrm/mailing/queue&reset=1

Field Glossary (from here):

• Activity: fields that may be assigned to all activities or to a specific activity type, such as Meeting or Phone Call.
• Addresses: creates an address block, which allows the administrator to create additional fields related to an address.
• Contacts: fields that may be assigned to all contacts.
• Contributions: fields that may be assigned to all contributions or to a specific contribution type, such as Donations or Event Fees.
• Events: fields that may be assigned to all events or a specific event type (e.g., Conference or Fundraiser). These fields are applied to an actual event, not the participant registration record.
• Grants: fields specific to grants.
• Groups: displayed in the Group settings (note that these fields are not searchable).
• Household: fields specific to the Household contact type.
• Individual: fields specific to the Individual contact type.
• Memberships: fields that may be assigned to all membership records or to a specific membership type.
• Organization: fields specific to the Organization contact type.
• Participants: fields that appear on the participant registration record. There are three options for  these: general fields applied to all registration records, role-type fields assigned to a specific participant role, and event participant fields assigned to a specific event.
• Pledges: fields specific to pledges.
• Relationships: fields that may be assigned to all relationship records or to a specific relationship type, such as "Spouse of" or "Employee of".

Chapter 6 notes
git show enterfirstfewshahere
add branch to show
git show HEAD^ shows parent
git log master..experiment shows all commits on exp not on master
git log ^refA refB all commits from multiple braches not on master
git log master...exp all commites reachable by either not both

-i for many commands starts interactive mode
you can use this to patch or stage parts of files you have changed

stashes
git stash saves uncommited and not added files so you can switch branches, etc
git stash list shows all stashes
git stash apply applys last stash
git stash apply stash@(n) applies older stashes

this doesn't change previously staged files; use git stash --index
git stash drop stash@(n) removes stash
git stash show -p stash@{0} | git apply -R unapplies last stash
git stash branch to turn a stash into a branch

amending
git commit --amend changes last commit message
$ git rebase -i HEAD~3
$ git rebase -i HEAD~2^ allows you to edit last 3 commits (both)
rebasing also allows for changing the order or splitting a commit
filtering a branch can remove a file from every commit, like a file with passwords

git blame shows the contents of a file and the commits that got it there.
git blame -L #,# limits line numbers returned.
git bisect is cool for debug; git bisect start, bad, good[commit]; then it starts in between. tell git good or bad until bug is found.

Submodules
skipping.

I get the benefit of working in pairs for programming and other IT projects. I am beginning to explore working with another on tasks I traditionally have done alone.

• Working on support tickets
• Project Planning
• Other "work:" Just doing things like documentation, data formatting, investigating recurring issues, research.

Having a sounding board helps, and we make decisions based on 2x the knowledge and experience. Also my productivity comes in waves, so having someone else to share tasks with is helpful: when my interest ebbs, I can switch tasks with my co-worker. I have to admit, I don't take breaks to check email when I am working with others. Finally, working alone is well, kind of lonely. Having someone else to talk to makes the job more fun.

git diff --check checks for whitespace, run before committing

using as contributer and integrator (maintainter) roles
simplest example: 2 devs clone, one pushes changes, next merges those then pushes

With maintainer, more complex:
A contributor clones the repository and makes changes.
The contributor pushes to their own public copy.
The contributor sends the maintainer an e-mail asking them to pull changes.
The maintainer adds the contributor’s repo as a remote and merges locally.
The maintainer pushes merged changes to the main repository.

More complex
Regular developers work on their topic branch and rebase their work on top of master. The master branch is that of the dictator.
Lieutenants merge the developers’ topic branches into their master branch.
The dictator merges the lieutenants’ master branches into the dictator’s master branch.
The dictator pushes their master to the reference repository so the other developers can rebase on it.4

When working on 2 issues, the example shows user creating a branch based on origin/master, not issue1, keeping issue discreet.

remember to use fetch just to fetch branch names, then merge.
git push origin localbranch:remotebranch pushes to specific branch
use rebase -i to squash your work down to a single commit

contributing  to public projects:
fork, create branch, work, add remote, push, then
git request-pull summarizes changes, can be emailed for pull request.
git format-patch allows the patcht to be emailed.
you can config git to send email and input smtp server, un/pw, etc.

Maintaining a Project
test in topic branch: named after issue, maybe even devs initials/branch name
Branches
create remote git remote add jessica git://github.com/jessica/myproject.git
get branchs git fetch jessica
switch to branch git checkout -b rubyclient jessica/ruby-client

Patches
git am reads format-email created patch cleanly
git am --resolved after patch resolution
git am -3 more verbose explanation, 3 way merge
git am -i interactive mode asks as it applies multiple patches from mbox file
git apply --check tests patch application
git apply /path.patch applies patches

git patch -pl not recommended, others better
Determining What Is Introduced

Multi-phase merge cycle has two or more long-running branches, master and develop. Topic branches are merged into develop branch.
Releases are tagged, then master is fast forwarded to the now-stable develop branch. Both of these branches are regualarly pushed to the public repository.
Having branches pushed for review requires maintainance: they are kept living while being reviewed and then are pushed to a staging branch and deleted when done.
git cherry-pick attempts to rebase a single commit
git describe attempts to mimic naming of commits, adds tags name + no. of commits + sha-1 val

archiving a release: git archive master --prefix='project/' | gzip > `git describe master`.tar.gz
result: v1.6.2-rc1-20-g8c5b85c.tar.gz

git shortlog shows summarized commits
git log --pretty=short
git log --not master: review all the commits that are in this branch but that aren’t in your master branch
git log -p appends diff
git tag -s 1.2.3 -m 'Various bugfixes, including critical CVE-123' && git push --tags

g

chapter 4 notes
on the server
your remote repo is bare, no working directory; just .git
local network: git clone /path or git clone file:///path
ssh: git clone ssh://user@server:project.git or git clone user@server:project.git
(assumes ssh, assumes current user)
git: fast but no authentication, complex to setup
http: git clone http://example.com/gitproject.git
requires activation of default post update hook:
$ cd /var/www/htdocs/
$ git clone --bare /path/to/git_project gitproject.git
$ cd gitproject.git
$ mv hooks/post-update.sample hooks/post-update---
$ chmod a+x hooks/post-update

Setup start to finish:
giving users access and perms:
1. create a single 'git' user on the machine:
sudo adduser git
su git
cd
mkdir .ssh
get everyone's SSH public key, and add those to the ~/.ssh/authorized_keys file of your new 'git' user:
$ cat /tmp/id_rsa.john.pub >> ~/.ssh/authorized_keys
(Other options: 2. adduser 3. LDAP)

Create bare repo:
$ cd /opt/git
$ mkdir project.git
$ cd project.git
$ git --bare init

On local, init, add, commit, push:
# on Johns computer
$ cd myproject
$ git init
$ git add .
$ git commit -m 'initial commit'
$ git remote add origin git@gitserver:/opt/git/project.git
$ git push origin master

Others can too:
$ git clone git@gitserver:/opt/git/project.git
$ vim README
$ git commit -am 'fix for the README file'
$ git push origin master

Also possible to restrict users from using other non-git shell
Gitosis uses a gitlike environ for managing repos and access
Gitolite has more perms, easier setup, scales
Git daemon uses git protocol.

Github:
Allows you to add other gh users by username
Find a project you like, fork it, change it, have original project owner pull changes back
Make your initial commit on local.
Then add github as a remote and push:
$ git remote add origin git@github.com:testinguser/project.git
$ git push origin master