The first talk I will be attending is called Mentoring Moments: Creating Opportunities for Success presented by Amber Graner

I will be doing live blogging throughout the day..

UPDATE….

Mentoring Moments: Creating Opportunities for Success presented by Amber Graner.

What is a mentor?
- Strong interpersonal skills
- Strong Supervisory Skills
- Knowledge of the project
– Have a broad knowledge of the project to match up people
- Interested in someone else’s growth
– What their feedback, you care about their growth..It can not be about you it has to be about their growth.

What Mentors Do?
- Set high expectations of performance, but not unattainable.
- Offer challenging ideas
- Help build self confidence
- Encourage professional behavior
- Offer friendship
- Listen to personal problems
- Control negative behaviors & attitudes
- Teach by example
- Provide growth experiences
- Explain how the project works
- Couches are not the same as mentors
– Couches successes can be easily measured by performance
– Mentors teach the whole of the person
— Interpersonal skills
— Communication skills
– Good leaders are usually good mentors
- Mentors are self aware of their actions & behaviors
- Open source work should be put on their resume..

What makes you a mentor?
- Role Model
– People want to emulate their behavior
- Teacher
- Friend
- Support
- Resource

What are moments?
- teaching someone skills in brief periods of time, should be present.

How to create moments?
- 1:1 Conversions
- Meetings
- Blog posts
- Actions
– You need to create those moments..every day.. all the time..
– Make those moments fun

How do you evaluate success?
- If you can create favorable or desired actions in people from brief moments.

Take ways
- Know the person well enough to know when to push them and when to hold back.
- Always be open to being mentored yourself..
- Traditional mentoring does not work
- Corporate methods do not work, because community based teams do not care about traditional methods.
- Be yourself without apology
- It is not personal
- Don’t be afraid to fail publicly
- I am good enough
- Collaborate openly
– Tell people your ideas, do not be afraid to share your thoughts
- Be Transparent
- Take ad-hoc moments to mentor people, when people ask for help
- Teach someone how to do something then get out of their way so they can do it
- Set times, no longer than a day to work on a skill set or share information
- How to find a mentor? Look for them! Ask them!

UPDATE….

-
Lee Thompson
DevOps Day Keynote

SCALE DevOps day
Lee Thompson is CTO at MorphLabs

- DevOps is a community based idea, not a set of specific practices.
- DevOps toolchain
- Ops wants stability
- Dev wants change
- Each have different traditional goals
- The Visible OPS Handbook
- Agile development fixes the wall between Biz & DEV
- DevOps fixes the wall between DEV & Ops
- Dev view
– Lack of visibility into production
– Schedule slippage due to deployment problems
– Lack of understanding in operations
– Release process is awkward
- Ops view
– 80% of prod outages are related to changes
- Businesses spend almost half them time on change management
– 47% of time is related to change management
- Everyone has monitoring, but almost no one has control, why?
- Need a control toolchain
– Runbook Automation
– Control
– Eventing, Alarm
– Charting, History
– Measurement Instrumentation
– System
- SPC
– Process control
— Keep things in standard deviation, goes out start alarming
— View few companies do SPC
- Lean Development
– Focus on Value Stream Mapping
— Understand what creates value in the process
- Read the Lean Startup – discusses the biz problem
– Aligns the concepts of DevOps with biz
– Provides tools
— Minimum Viable System
— Reduce Batch Size
— Continuous Integration
— Continuous Deployment
— Innovation Accounting
– Fail quick and Pivot
– To do lean Startup, you need DevOps!
Take ways
- Development has over focus on unit test and lack of focus on integration tests
- Integration testing is harder than actual development
- It is about people working together..
-

UPDATE…

Christopher Nolan

nventory – Your Infrastructure’s Source of Truth

nVentory
- Collects data in automated fashion
- Allows programs and people collect data about your infrastructure
- Common, but painful Sources of Truth
– Spreadsheet
– Static file
– DNS
– Hostname
– MySQL/Postgres
– Custom Solution
- Better approaches
– Puppet and Chef are better
– Enterprise solutions are expensive

Why nVentory?
- Centralized
- Detailed
- Metadata
- Multiple access methods
- API
- etc

Why for DevOps?
- It is essential that all individual tools be consider part of a a large toolchain that spans the entire dev to ops lifecycle
- Your tools should all talk to a master
– Everyone should know where to go for answers

What is nVentory?
- Provides the foundation, you have to build the house
eHarmony uses:
- Chef-solo – app config mgt
- Etch – sys config mgt
- Jenkins – ci
- Self service VMs – custom private clouds
- Splunk – Monitoring
- Finance – audits
- QA, Ops, and Engineering

Objects are the key to nVentory!
- Everything is an object
– Rack, nodes, load balancer, etc
– Tree of relationships
– Node Group is related objects based on purpose

Other Objects that nVentory provides!
– status
– hardware_profile
– operating_system
– network_interface
– ip_address
– vip
– lb_pool
– tags & graffiti
— allow customization of nVentory

How is the nVentory Server built?
- Uses MVC pattern
- Heavy usage of ActiveRecord
- For each object, there are corresponding model, view and controller for it
- RESTful API
– Makes integration very easy since it uses HTTP and associated VERBS (GET, POST, PUT, DESTROY)

nVentory Clients
- Written in Ruby & Perl
- Uses various tools to gather host/hardware info
- Clients use the RESTful api to talk with the Server by invoking the nv-register command

How do you setup client?
- Install one each box at build time

nVentory client provides simple commands for getting things such as:
- Get host names
- Get node groups
- Get named hosts
- etc..
- Can also use Ruby api for developing clients

How does eHarmony use nVentory?
- User mgt
- Actions to a group of machines
- Config mgt
- Discovery of node details
- Change mgt
- Use the api to write scripts that pull all the machine in a given node group then act on them

Demo
– http://nventory.slacklabs.com/

UPDATE…

DevOps Lightning Talks

Four lighting talks..

Communication topic
- Part of a triangle
– Infinity
— natural emotional response
— degree of liking, people are naturally social
– Reality
— the state of things as they are or they appear to be
— is subjective
– Communication
— imparting or interchange of ideas
— most important part of the triangle

Increase Infinity
- Find something to like about another person
- Find something that the person agrees with to find a common ground
———————–
HA Proxy topic – Slides
- mature 10 years old
- purpose is a load balancer, that is it
- configuration can get ugly
– haproxy_join can solve complexity
- has web ui for managing
- has command line, but unfriendly
– haproxyctl simplifies
- ruby gems
– rhapr – can manage multiple HAProxies
– easy libs
—————————–
Visualizing Http benchmarks topic – parbench
- incorporates time into the benchmark
- randomly sleep benchmarks

——————————-
Control for the Cloud topic – John Willis

Three legs of the cloud – Challenges
- Infrastructure
– Private, Public, Hybrid?
- Cloud Management
– ACL, DR, Auth, Auditing, Security, financial controls, compliance
- Configuration Management
– Puppet, Chef?

I was doing the run, but not being in the run.

Then in my quest for inspiration I happened to be reading a Runner’s World article about how Flea from the Red Hot Chili Peppers was inspired by the book Born to Run by Christopher McDougall. So I picked up a copy of the book and started reading. I was amazed how it quickly transformed by view point on running. My next run I decided to ditch the iPod and focus on being mindful during my run.

I focused on my breathing, how my legs felt, the temperature outside, how it made me feel, the trees, the wind, essentially the pure feeling of the run.

So my journey went from:

Now with my first 1/2 marathon complete with a pretty good time,

I know now that I am just starting my journey…

rvm use ruby-1.9.2-p0 - ruby version manager; switches to Ruby 1.9.2
rvm use ruby-1.9.2-p0 --default  - ruby version manager; sets 1.9.2 as default
rvm use system - ruby version manager; switches to Ruby 1.87
rails new - creates a new Rails application
rails server [s] - launches WEBrick web server
rails generate [g] - lists available generators 
rails generate controller --help - provides usage documentation
rails generate model --help - provides usage documentation
rails generate migration --help - provides usage documentation
rails destroy controller [Name] - undo generate controller
rails destroy model [Name] - undo generate model
rails generate scaffold [Name] --skip --no-migration - scaffold skipping existing files
rake db:migrate - runs database migrations
rake db:test:clone - clones current environment's database schema
rake db:test:purge - empties the test database
rake routes - list of all of the available routes
rake -T - list of rake commands
git init - creates git repo
git add . - adds all files to working tree
git commit -m "Initial commit" - commits files to repo
git status - status of the working tree
git push origin master - merges local repo with remote
git checkout -b new-dev - creates topic branch
git checkout master - switches to master branch
git merge new-dev - merges new-dev branch into master branch
git checkout -f - undo uncommitted changes on working tree
git branch - list branches
git branch -d modify-README - deletes branch
git mv README README.markdown - renames files using move command
heroku create - creates app on Heroku servers
git push heroku master - pushs app on to Heroku servers
heroku rake db:migrate - runs database migrations on Heroku servers
heroku pg:reset --db SHARED_DATABASE_URL - deletes database file
heroku db:push - transfer an existing database to Heroku.
rails console - command line interface to Rails app
rails dbconsole - command line database interface
bundle install - installs gems from Gemfile

TextMate

Head over to http://macromates.com/ and download TextMate. Once we have installed TextMate we are going to configure it. From the TextMate menu go to:

TextMate >> Preferences >> Fonts & Colors. Then select the “Twilight” theme.

For smaller projects where we do the markup ourselves we are going to use Haml, which we will install shortly, TextMate does not include this bundle by default, so we need to add it. Open up terminal and enter the following:

cd /Applications/TextMate.app/Contents/SharedSupport/Bundles
svn co "http://svn.textmate.org/trunk/Bundles/Ruby%20Haml.tmbundle/"

Back in TextMate go to Bundles >> Bundle Editor >> Reload Bundles.

Terminal

Next on our list is to configure Terminal.

The first thing we want to do is setup the bash prompt for Git. This cool trick will show our checked out topic branch right at the prompt:

Git_topic_branch_at_prompt, a photo by Carlos Gabaldon on Flickr.

Open a Terminal session and type the follow:

sudo mate ~/.bash_login

To configure we will copy the following into our .bash_login file:

   RED="\[33[0;31m\]"
     YELLOW="\[33[0;33m\]"
 	  GREEN="\[33[0;32m\]"
       BLUE="\[33[0;34m\]"
  LIGHT_RED="\[33[1;31m\]"
LIGHT_GREEN="\[33[1;32m\]"
      WHITE="\[33[1;37m\]"
 LIGHT_GRAY="\[33[0;37m\]"
 COLOR_NONE="\[\e[0m\]"

function parse_git_branch {

  git rev-parse --git-dir &> /dev/null
  git_status="$(git status 2> /dev/null)"
  branch_pattern="^# On branch ([^${IFS}]*)"
  remote_pattern="# Your branch is (.*) of"
  diverge_pattern="# Your branch and (.*) have diverged"
  if [[ ! ${git_status}} =~ "working directory clean" ]]; then
    state="${RED}⚡"
  fi
  # add an else if or two here if you want to get more specific
  if [[ ${git_status} =~ ${remote_pattern} ]]; then
    if [[ ${BASH_REMATCH[1]} == "ahead" ]]; then
      remote="${YELLOW}↑"
    else
      remote="${YELLOW}↓"
    fi
  fi
  if [[ ${git_status} =~ ${diverge_pattern} ]]; then
    remote="${YELLOW}↕"
  fi
  if [[ ${git_status} =~ ${branch_pattern} ]]; then
    branch=${BASH_REMATCH[1]}
    echo " (${branch})${remote}${state}"
  fi
}

function prompt_func() {
    previous_return_value=$?;
    # prompt="${TITLEBAR}$BLUE[$RED\w$GREEN$(__git_ps1)$YELLOW$(git_dirty_flag)$BLUE]$COLOR_NONE "
    prompt="${TITLEBAR}${BLUE}[${RED}\w${GREEN}$(parse_git_branch)${BLUE}]${COLOR_NONE} "
    if test $previous_return_value -eq 0
    then
        PS1="${prompt}➔ "
    else
        PS1="${prompt}${RED}➔${COLOR_NONE} "
    fi
}

PROMPT_COMMAND=prompt_func

Next let’s make terminal a little prettier. From the Terminal menu:

Terminal >> Preferences >> Startup; New window settings: "Homebrew".
Terminal >> Preferences >> Settings; Font select "Andale Mono 18pt".

Now that we have TextMate and Terminal configured we are going to setup our development tools.

Development Tools

XCode Tools

Go to http://developer.apple.com/mac/ and download the latest version of XCode. Once it is downloaded simply run the installer.

Git

Next we will download the git-osx-installer, then run it.

RubyGems

From terminal we need to update our RubyGems:

sudo gem install rubygems-update
sudo update_rubygems

SSH

Still at terminal we will run:

ssh-keygen -t rsa -C "cgabaldon@gmail.com"
cat ~/.ssh/id_rsa.pub | pbcopy

GitHub

Then we will navigate over to GitHub.com >> Account Settings to add our RSA key that we copied to the clipboard.

GitHubAccountSettings, a photo by Carlos Gabaldon on Flickr.

MySQL

We are next heading over to download mysql-5.1.47-osx10.6-x86_64.dmg, and then once downloaded run the installer.

After MySQL is installed we will install the MySQL preference pane which gets added to the OS X System Preferences. To install we simply double clicking on the MySQL.prefPane contained within the MySQL install package. This gives us a convenient way to start and stop our MySQL server from the System Preferences.

Back to terminal to add our newly installed MySQL server to our path:

cd
sudo mate .bash_login # add: export PATH=/usr/local/mysql/bin:$PATH

Then last, but not least we need to install our ruby mysql gem:

sudo gem install mysql -- --with-mysql-config=/usr/local/mysql/bin/mysql_config

Sinatra

sudo gem install sinatra

Rails

sudo gem install rails

Other Gems

sudo gem install sequel
sudo gem install haml
sudo gem install do_sqlite3
sudo gem install cheat
sudo gem install cucumber
sudo gem install dancroak-twitter-search
sudo gem install faker
sudo gem install geokit
sudo gem install giraffesoft-timeline_fu
sudo gem install github
sudo gem install heroku
sudo gem install json
sudo gem install mislav-hanna
sudo gem install nokogiri
sudo gem install passenger
sudo gem install rack
sudo gem install railsmachine
sudo gem install RedCloth
sudo gem install redgreen
sudo gem install reek
sudo gem install rest-client
sudo gem install right_aws
sudo gem install right_http_connection
sudo gem install rr
sudo gem install rspec
sudo gem install technicalpickles-le-git
sudo gem install thoughtbot-factory_girl
sudo gem install thoughtbot-paperclip
sudo gem install thoughtbot-shoulda
sudo gem install webmat-git_remote_branch
sudo gem install webrat
sudo gem install wirble

Capistrano

To simplify deployment we need to install Capistrano:

sudo gem install capistrano
sudo gem install capistrano-ext

FireFox

We of course need to install FireFox, by downloading and installing.

FireBug

Then Firebug and YSlow to help us on our front end engineering work.

Quicksilver

To help us keep our hands off the mouse we will install Quicksliver so we can exercise our keyboard foo. To install simply extract the tarball and drag to Applications.

Update the mappings to be Apple+Space for Quicksilver and Option+Space for Spotlight.

Fluid

Finally, we will install Fluid to help us turn our commonly visited sites into apps. Once downloaded drag to Applications.

Virtual Box

All production applications get deployed to a LAMP server, so we need a place to test out various configurations locally. Say hello to virtualization! We are going to use VirtualBox; download and install.

Evernote

Never forget anything; install Evernote and sign up.

Concentrate

Multitasking does not work when trying program, distractions will kill you. We are going to install Concentrate to apply the Pomodoro technique to keep focused and productive.

Things

We have a lot of Things to get done, so we need a great task management tool.

Growl

Most of the cooler OSX applications support notifications, Growl is the system for doing that.

Pencil

Pencil is one of the coolest UI prototyping tools I have used since a Sharpie.

Hack

We are now ready to do some serious hacking..

I like to get integration and deployment tasks figured out early since these tasks contain the most risk. Here is where I usually start:

1. Setup the the code repository.
2. Create the initial project structure; so we have something to deploy and iterate over.
3. Deploy the initial project to the production web server; Apache on a Linode VPS.
4. Script the the subsequent deployment process for continuous deployment.

Today I am going to go over step number 3; deploying a LAMP server.

Server

The first thing you are going to need is to get a virtual private server (VPS) or dedicated server account at a hosting company such as Linode or SliceHost. I am using Linode running Ubuntu 10.04 LTS (Lucid Lynx).

SSH

Once you have your server you will need to open a console and SSH into your new server:

$ ssh root@{your.ip.address}

Prerequisites

Now that we are logged in we need to install the prerequisites:

$ apt-get update
$ apt-get upgrade
$ apt-get install libapache2-mod-python python-mysqldb
$ apt-get install python-setuptools
$ apt-get install mysql-server
$ apt-get install subversion

Django

We want to be on the bleeding edge so we are going to install the trunk version of Django. First we checkout django-trunk to /usr/local/lib:

$ cd /usr/local/lib/
$ svn co http://code.djangoproject.com/svn/django/trunk/ django-trunk

Then create our symbolic links to point to our new trunk version of Django:

$ ln -s `pwd`/django-trunk/django /usr/lib/python2.6/dist-packages/django
$ ln -s `pwd`/django-trunk/django/bin/django-admin.py /usr/local/bin

Also, while we are in this directory we will create a symbolic link to the Django admin media:

$ ln -s `pwd`/django-trunk/django/contrib/admin/media /var/www/media
$ cd

Git

We need to install Git and then clone the project repository. To keep things simple for this tutorial we are going to put the web site under the Apache root.

$ apt-get install git-core
$ cd /var/www
$ git clone git://github.com/{YourGitHubAccout/your_django_project}.git

Apache

Next we need to configure Apache. I will be using modpython as the python host for Django. Since Django has support for WSGI we could use modwsgi, but I am going to stick with modpython for this tutorial since it has a proven track record in large scale production environments. The only draw back to using modpython over modwsgi is that an Apache restart is required after each deployment. Also, to keep this tutorial simple we are going have Django sever up the static meda files. This is not an optimal setup for a high traffic web site, but for the initial setup it works fine.

To configure Apache will open the default vhost and edit it to look like below:

$ nano /etc/apache2/sites-enabled/000-default
<VirtualHost *:80>
        ServerName {your.domain}.com
        DocumentRoot /var/www
        <Location "/">
                SetHandler python-program
                PythonHandler django.core.handlers.modpython
                SetEnv DJANGO_SETTINGS_MODULE {your_django_project}.settings
                PythonOption django.root /{your_top_level_folder_name
                PythonDebug On
                PythonPath "['/var/www/'] + sys.path"
        </Location>

        <Directory /var/www/>
                Options Indexes FollowSymLinks MultiViews
                AllowOverride None
                Order allow,deny
                allow from all
        </Directory>
        ErrorLog /var/log/apache2/error.log
</VirtualHost>

For the changes to take effect we need to restart Apache

$ /etc/init.d/apache2 restart

MySQL

We need configure the database. Connect to the mysql server using your mysql user name and password.

$ mysql -u root -pXXXX
$ create database {your_db_name};
$ nano /var/www/{your_django_project}/settings.py # update database connection info

Finally, we have Django create the tables.

$ cd /var/www/{your_django_project}
$ ./manage.py syncdb

If everything was done right we can open a browser and point it to http://{your.ip.address}/home/ and we should be running. The final step would be to open your DSN manager (i.e. godaddy) where your domain is registered and point the @ record to {your.ip.address}

What do I mean by low tech tools? Low tech tools are tools that do not require the team to sit in front of the computer to use; simple things like big visible charts or information radiator and index cards. Why is this so important? Because the team already spends a large amount of time sitting in front of the computer developing and testing the software, why make them spend all their remaining time updating and managing user stories, burn down charts, and tasks chained to the that same machine.

Low tech tools have a way of connecting people with the ideas and concepts in a much more clear, tangible, and meaningful way. For example, a team can sit down and write all the user stories on index cards then with some large wall space tape the index cards to the wall to create a product backlog. From that the team can do sprint planning by simply moving cards from the backlog section of the wall to the next planned sprint; all with no dual core’s required!

In a large organization or working with some remote team members the low tech way can be difficult and the organization may require that the planning be documented in a more formal project management or tacking tool. To address this have the PM on the team be responsible for keeping the low tech tools in sync with the high tech tools. They are the ones that need to communicate the status of the project to many different types of stakeholders so it makes the most sense for them to manage the communication; and leave the team to focusing on the code…

1. Meetings should never be scheduled; you should strive to create an environment where meetings just happen. How do you do this? Create open development environments where there are no offices or cubicles just groups of desks with lots of couches and whiteboards. In this environments meetings become organic and happen only when people need to talk.
2. You should never have meetings to communicate status; that is why you use wiki’s and bug tracking tools. People who want status should just pull the status from those tools. It does not matter if you are standing up while you are giving status in a meeting or you call it agile. Status or issues should be an asynchronous activity where the people who need to know should be pulling those from the team, not slowing them down with a synchronous meeting.
3. You should only have meetings for productive things like brainstorming new ideas, doing use cases, group design, discussing code, or getting the team together for drinking beer.

The first article is just a quick intro into this cool and powerful language, I will be sharing more soon..

http://carlosgabaldon.com/erlang/hello-erlang/