I am getting ready for the Pacific Northwest Drupal Summit taking place this weekend in Seattle. I’m looking forward to it – should be fun to feed my inner geek by delving into Drupal, the open source software platform that powers Kabissa, and to connect with local area Drupalistas in attendance to find out what they are working on and where we might be able to work together. I’m also looking forward to catching up with old friends who are coming to town for the event like Kurt Voelker and Ivan Boothe. It’s been a while.
What follows is a shameless copy-paste job of cherry picked session descriptions from the Drupal Summit program for Saturday followed by some notes on my goals for each session. I am not able to come Sunday. Suggestions and comments most welcome. 
[Oh - and this reminds me that we should get the next Bainbridge Island Drupal User Group meeting on the calendar so we can keep working on issues like this and nurture our island Drupal community. It's not always easy for us to get into Seattle for the monthly Seattle Drupal Users Group meetups. Note to self to check in with Leif Utne, Marc Shor and the rest of the island Drupalistas to get this going.]
Git super basics (10:00)
Git has continued to be the version control system of choice for Drupal and the related projects. If you have yet to take the plunge or are unsure of how to use git with Drupal during development this session is for you. This will be an interactive session so bring your laptop and take the plunge into git.
If you want to start contributing code to modules as patches, share work with others in your team, or start your own project you will want to use git.
- Create an ssh key on your platform of choice – Windows, Mac, Nix
- Initialize a repository for your project and check in some code.
- Make changes to your code and review it against your original code.
- Create a separate branch and merge those changes into your production branch.
- Clone Drupal 8
The above interactive examples will be done via your systems terminal application not a GUI. GUI’s are great but I believe clouds what is really happening with git when first learning how it works. The goal of this session is for you to leave with a solid understanding of git so that when you start to use a GUI you are confident about what you are doing.
Pre-session prep. Github has a great walk-through on setting git up on your system.
Git Logo by Jason Long is licensed under the Creative Commons Attribution 3.0 Unported License.
Personal goal: set up git and a working development environment on my laptop that lets me install and work on clean Drupal profiles.
Agile Project Management – Scrum & Drupal (11:15)
You’ve heard of Agile, and probably even worked on a team that said it was agile. You may have attended a scrum, or a standup worked off of a back log, and with iterative sprints, but do you really know what Scrum is? In this session, GregoryHeller, certified Scrum Master and Certified Scrum Product Owner will walk you through the various aspects of The Scrum Methodology, explain the different roles on a scrum team, and talk about applying scrum to Drupal projects, and applying scrum to projects for external clients.
Personal goal: learn about Scrum from the master, Gregory Heller, and reflect on how it might apply to Kabissa and the development of our platform with inputs from volunteer and contract developers. Think about how Scrum Methodology works with Redmine (the tracker we use at Kabissa)
Git it on (13:30)
Git is the latest and most exciting piece of SCM in a long time, even better it’s 100% open source. Git is now the main source control on drupal.org. Easy to install and super flexible, source control isn’t just for the corporate types anymore. This introductory session highlights how to use Git not only as a source control client in a team setting, but how to manage just about any kind of electronic information.
Providing the unique perspectives of a serial team developer and a freelance designer, this session will cover topics like:
- How to set up your repository
- How to commit
- How to share with others
- Branching and merging to maximize efficiency on a project
- How to use git to do other neat things besides manage your project code
- How to contribute back to the community by using git
- Tricky tips and tricks to make git fly – with a publicly shared git config file, shared using (what else) GIT!
- Why git is so special, why should anyone who works in web design / development should use it.
- Identifying the suck, how git helps find what broke & (if you care) whodunnit.
- Besides D.O. who else is using Git? (Hint: the answer may surprise you)
Warning: This session may contain odd humor, awkward metaphors, sudden flashes of inspiration and an intense desire to register for a GitHub account.
Personal goal: properly set up the git repository for Kabissa to make it as easy as possible for anyone who wants to contribute to Kabissa to do so and to make sure that code developed for Kabissa that can be shared back to Drupal is in fact shared back. Learn how it fits in with Redmine.
Drupal Archaeology (15:00)
- Allow you to gain a better understanding of your site and how it works
- Address security vulnerabilities and issues
- Prepare for upgrading to Drupal 7, Drupal 8 and beyond!
Personal goal: What he said. The three points above are a perfect fit for my personal need to gain a handle on the Kabissa Drupal installation, deal with security issues, and start thinking about the upgrade from D6 to D7.
Using Drupal for Multiple Sites: Effective Strategies for Enterprise Web Platforms (16:15)
How many websites is your organization running? Your main site. Program and project sites. Product sites. Community sites. Marketing sites, blogs, and event sites. There is a way to manage it all. Drupal can help you save time and money by efficiently managing your ecosystem of web properties that, like it or not, most organizations find themselves having to manage across their enterprise.
In this session, you’ll learn practical how-to’s and real-world case studies of using Drupal as a platform to:
- Easily launch and manage multiple websites on a single platform
- Instantly deploy “starter sites” that can be extended and customized over time
- Reduce costs by re-purposing features across websites
- Centralized security and patch management
This session is aimed at providing an overview of all of the ways that Drupal can be used to support an ecosystem of multiple websites for a single organization. We’ll get into architectural approaches, but not necessarily deep into code – its a great session for those that are looking for how best to approach multiple site needs within their organization with Drupal.
Personal goal: Mainly I want to reconnect with Kurt, who I haven’t seen for a few years! But I also am interested in the topic and getting an overview on how to quickly and easily deploy Drupal installations, both for Kabissa and also so I can help others set up their sites. For Kabissa I am interested in quickly setting up sandbox and dev versions of the Kabissa site for testing and development.
@leifutne you coming to #pnwds @drupalsummit in Seattle this weekend? My sessions and goals: http://t.co/j07RKsSq
OK – now I’m at the summit and after a spagetti tower-building ice breaker exercise modelled on a ted talk (http://www.ted.com/talks/tom_wujec_build_a_tower.html) am digging into Git!
Takeaway: Good links on session description page to install git, useful resources like opendiff, cheatsheets showing a workflow – would be interesting to find one similar to Kabissa. Good overview at the session (see notes below) on getting started and basic steps to using it. I think getting into it in practice will be the only way to really gain an understanding of how it all fits together, especially understanding cloning remote repository, diffs, branches, etc.
Note to self: remember to review/edit the git bash file – esp to add osx hidden files to an ignore files list.
Notes:
Git is a version control system (VCS) and successor to SVN in Drupal ecosystem. Lets you store incremental changes of files locally, share files and changes with others. You can also compare changes between fle versions.
To get started:
- initialize a repository
git init
- adding and staging files
git add helloworld.txt
git status
- committing changes
git commit -m”initial commit”
- removing files
git rm helloworld.txt
git rm -m”dont need it” helloworld.txt
- git log and reverting
git log
- branches take a snaptshot of your system and let you start altering it. you can then switch back to your master branch to put the branch on hold and go back to what was official/working before.
- creating a branch
git branch mars
- switching between branches
git checkout mars
- check out a prior commit
git checkout -b pluto d0f4aa3
- tips HEAD^ is the commit just before the latest one
git diff HEAD^ –stat
- tips delete branches no longer need
- commit message is really important for describing diffs. make sure you can read diff output as well
- use opendiff app on the mac to compare diffs through a GUI
- creating patches
git checkout -b emailwording
git diff 8.x
git am “Patch to fix issue 950534.” (a = get all files you changed, m = message about what patch is for)
git diff 8.x > consistent_email_950534_08.patch (create patch file)
- apply a patch
git apply –check -v /path/to/patch
git apply –stat /path/to/patch
git am “Patch to fix issue 950534.”
git apply -v /path/to/patch
- merging branches
- working with remotes – ssh keys, pull, push, clone
git pull
git push
git clone –recursive — branch 8.x http://git.drupal.org/project/drupal.git
Now on to #pnwds #agile with @gregoryheller.
Takeaways: Look at http://trello.com as new tool alongside redmine.
The Agile Manifesto (12 principles at http://agilemanifesto.org) values:
- Individuals and interactions over processes and tools
- working software over comprehensive documentation
- customer collaboration over contrat negotiation
- responding to change over following a plan
(things ln left are valued more htank things on right)
** collaboration – b/c web property that is evolving and developing that clients are part of, not thing that is delivered and ever finished
** temptation with drupal to play with and add many features that are available as modules – using agile
** kanban
** gregory advocates: extreme lean agile kanban (.com)
** gregory with civicactions works using scrum on web development with distributed teams and external clients.
** 1. the *process* is the product. getting project manager on client side to buy into process, that is well defined, can make the foundation for a great project. only as much as is necessary.
** 2. deeply respects stakeholder input.
** 3. builds partnership and collaboration
** 4. increases capacity for self-management and trust
** 5. drives organizational empowerment
** 6. the agile process delivers continuous value (so client isn’t disappointed when project goes over budget with nothing to show for it)
*******
AGILE/SCRUM 1-2-3! Can do it with scrum software but it’s expensive and clunky and we can use our ticket system for it.
Three Roles
- PO product owner (represents the voice of the stakeholder). Manage product backlog. Filtering input from stakeholders continuously and reordering product backlog. Once you’re in a sprint the PO only gets to answer question.
- ScrumMaster (facilitator, roadblock remover and coach). Making sure everyone is doing everything right. Coaches everyone on how scrums work and how to perform their roles within scrum.
- Scrum Team performs actual work of designing, problem solving and building. Good to keep scrum teams together working across all projects.
Three Artifacts
Three Meetings – sprint planning/kickoff, daily scrum (involves negotiation, should be 15 minutes – what have youd one since last meeting, what will you do between now and next mtg, is anything blocking you), sprint demo and retrospective (each sprint finishes with dem of completed work – celebrate wins, create accountability, builds team)
Scrum Production Sprints I want so that some reason>.
– PO compiles features and specs planned for product/project and prioritizing them
– Prioritization: look at quadrants prioritization method – ABCD. High risk/low value, High risk, high value, Low risk, low value, low risk, high value.
— Do high risk, high value first! (can sometimes be broken down and made less risky/easier)
— Low Risk, high value second
— Low risk, low value third
— high risk, low value fourth
– Prioritization: MOSCOW =
Must have
Should have
Could have
Won’t have (this release)
– User Stories and Tickets: INVEST =
Independent
Negotiable (there may be many ways to solve the problem)
Valuable
Estimable
Sized appropriately or Small
Testable
** What is the story, how do we know we were successful, what work is necessary to do it.
** example story: As a
resources
- http://civicactions.com/tags/agile
- agilemanifesto.org
- scrumalliance.org
- scrum.org
- solutionsiq.com (in seattle area, gregory used to get certification)
What tools?
- https://trello.com/ has drag and drop functionality.
- avoid freeconference call – use skype, facetime, google hangouts .. anything with video will improve productivity and keep people focused
Great lunch, chat with folks from ForumOne and FuseIQ and others, set up a birds of a feather meetup at 4:15pm today to talk about OPEN DATA. Yay.
Now back to learning about GIT with “GIT IT ON” session. Looks like it’s covering
- German legislature releases draft legislation on github!
- idea: why not have all teachers share lesson plans on github? find other lesson plans, fork one you like and then change it to what you want
most used git commands:
git status < -- use this 50 times a day!
git init
git add [path to file]
git rm [path to file] (0-0cached for removing only form repo
git commit -m "sss"
git log --stat
tip - learn commands first before trying to start using the gui
.gitignore file lets you have git ignore some files and paths in your repository
branching and merging style of development - you
gitflow
http://drupal.org/node/707484
use drush make to build your distro using your own code and the core and modules – don’t keep core and modules within your own dev site