Standing out among many other benefits of coming to YAPC is the access to experts in the field for training. Both prior to and after YAPC, full day classes are offered, usually at a low, low price. We're very excited about this year's training opportunities.
All training classes are 6 hours of classroom/lab time, with three breaks and snacks included. See the YAPC Schedule for times and classroom locations at Thompson Conference Center.
- Saturday June 1, 2013
- Zero to Perl (Day 1) - John "genehack" Anderson ($50)
- Test Automation using Perl (Day 1) - Gabor Szabo ($250)
- Sunday June 2, 2013
- Zero to Perl (Day 2) - John "genehack" Anderson
- Test Automation using Perl (Day 2) - Gabor Szabo
- Git For Ages 4 And Up - Michael Schwern ($125)
- Thursday June 6, 2013
- Git For Ages 4 And Up - Michael Schwern ($125)
- Intro to Moose - Dave Rolsky ($125)
- Friday June 7, 2013
NOTE: If you cannot afford to attend a class but are interested in going, we do offer a limited number of scholarships for these classes. Please email firstname.lastname@example.org
Saturday June 1, 2013
Zero to Perl (Day 1) - John "genehack" Anderson
Infinity Interactive is proud to offer a two day "Zero To Perl" training session at YAPC::NA 2013, led by John "genehack" Anderson.
About the Course:
The "Zero To Perl" course is designed to introduce programmers of any experience level to Perl 5 programming. (Non-programmers are welcomed as well!) This two-day course will give you the basic skills you'll need to program in Perl for a variety of tasks, including Web development, text processing, bioinformatics, database manipulation, systems administration, devops, and more.
The course will cover basic Perl syntax, including variables and data structures, flow control, functions, reading and writing files, and regular expressions. More advanced topics like object-oriented programming and Perl module development will be explored on the second day. Instruction will be interspersed with hands-on sessions where you'll put into practice the concepts that you have just learned. Instructors will be available to give each student direct assistance as needed.
After completing this course, you'll be ready to start writing your own Perl programs and you'll be perfectly positioned to enjoy the rest of YAPC::NA, even if this is your first exposure to Perl.
About the Instructor:
John SJ Anderson has been using Perl for over fifteen years, since teaching it to himself as part of a desperate plan to finish his graduate work. He's been teaching computing concepts and introductory Perl and BioPerl to bioinformatics students at The Johns Hopkins University for the last ten years. In his free time, John contributes to several Open Source projects, moderates the perl-beginners mailing list, and organizes the Salem Oregon Dynamic Languages Users Group.
Students should bring a laptop, ideally with Perl and a programmer's text editor (such as Vim, Emacs, Sublime Text, Notepad 2, etc.) already installed. Be prepared for two intense days of hands on learning. Code samples and course materials will be provided on site.
Test Automation using Perl (Day 1) - Gabor Szabo - $250
The 2-days class will include both lectures and hands-on exercises. Therefore the participants are requested to bring their own notebook machine to be able to enjoy the whole course.
This class assumes you are familiar with Perl but have little or no experience in writing tests in Perl.
In the first 3/4 of the course we'll learn about the testing framework available in Perl (TAP and the Test::* modules). In last 1/4 we are going to learn about various tools to interact with external system (e.g. Databases, Web applications, Networking devices, CLI).
After the course the participants will be able to write test for their applications. They will be able to setup a simple smoke testing environment to run regression tests, collect the results, and create nice reports.
the class we'll be talking about unit, integration, system and even acceptance testing with both white- and black-box testing in mind.
The planned 4 parts of the training. (There might be some changes, but more or less this is how the parts will work out.)
- Introduction to testing, why, when, who and how ?
- Understanding the basic tasks of the QA engineer
- Introduction to TAP - the Test Anything Protocol
- Testing tools in Perl for testing Perl Modules (Test::Simple, Test::More)
- Common reporting framework (Test::Harness)
- Extending the testing framework (Test::Builder)
- Other testing modules including Test::Most, Test::Deep
- More from Test::* (e.g. Test::Warn, Test::Exception)
- Setting up continuous integration (smoke testing)
- Report integration with Smolder
- Command Line Interface (CLI) applications
- Testing network devices
- Testing Web application
- Examples for database testing
- If time permits also Testing file-systems
- and Microsoft Windows GUI applications
Participants are expected to bring their own computer to do the exercises. Sharing one computer by up to 2 students is acceptable and even encouraged.
Sunday June 2, 2013
Zero to Perl (Day 2) - John "genehack" Anderson
Test Automation using Perl (Day 2) - Gabor Szabo
Git For Ages 4 And Up - Michael Schwern - $125
A full day class on how to think the way Git wants you to think using, not computer science jargon, but children's toys.
Git is hard; the interface is not the best; it's not your fault if you don't get it. The Git guts are elegant, and it is better understood from the inside out. Rather than learning the dozens of poorly named and highly overloaded commands, it is simpler to learn the four or five basic actions a Git repository can do and how the commands relate.
A Git repository is best understood visually. The class will teach how to visualize the state of the repository, how commands change it, and what you want the repository to look like, all using children's toys to build a remarkably accurate presentation of the internals. Then you can figure out what commands you need to run to get from where you are to where you want to be.
Once the basic repository internals are understood, formerly complicated and frustrating concepts like branches, remotes, and rebase become... it would be too far to say simple, but understandable and eventually comfortable.
The full day class includes small group exercises. Your group will be given situations to work through, list the commands they would run, and draw the repository as it changes. Once you've have done it visually, you'll do it again on a computer.
The class deliberately avoids detail in favor of conceptual understanding. Rather than try to teach you everything, we teach how to think about everything. There are excellent resources for learning the detail, and after this class you'll understand them better.
Specifically, the class covers:
- A flexible workflow, what sequence of commands should you run and why?
- Adapting the workflow to these common variants...
- Local vs remote work
- Merging vs rebasing
- Forking vs shared repositories
- The staging area
- The commit ID
- Branching and merging
Commands we will cover are:
- Initialization: init, clone
- Isolation: branch, checkout
- Work: add, rm, commit
- Status: diff, log, status
- Sharing: merge
- Remotes: push, pull, remote
- Fixing: rebase, reset, reflog
- Misc: stash, tag
- Pre and during class Google Moderator questions.
- Collective note taking.
- Git workflow cheat sheets.
- Git command flash cards.
Thursday June 6, 2013
Git For Ages 4 And Up - Michael Schwern - $125
At the end of the course you will be able to build two things:
- A web application with Perl Dancer framework as a back-end which is also mobile enabled.
- An installable mobile application for Android devices and iDevices that can run stand-alone or have a Dancer-based back-end.
The objectives are very far-reaching and it will require a lot of work during the two days of the course, but I believe the hard work will bear fruits.
During the class we'll create a relatively simple application. You will follow the creation of the application and implement some of the code yourself.
Intro to Moose - Dave Rolsky - $125
Join us for an interactive hands-on course all about Moose, an OO system for Perl 5 that provides a simple declarative layer of "sugar" on top of a powerful, extensible meta-model.
With Moose, simple classes can be created without writing any subroutines, and complex classes can be simplified. Moose's features include a powerful attribute declaration system, type constraints and coercions, method modifiers ("before", "after", and "around"), a role system (like mixins on steroids), and more. Moose also has a vibrant ecosystem of extensions as seen in the variety of MooseX:: modules on CPAN.
This course will cover Moose's core features, go in depth on many of them, and explore some of the more powerful MooseX:: modules available on CPAN.
This is a hands-on course. Each lecture section is followed by a hands-on exercise section where you put what you've just learned into practice. The instructor will work with each student individually as needed to help you get the most from these exercises.
Students are expected to bring a laptop. You will also be provided with a tarball a week or so before the class is scheduled. This will contain the exercises for the class.
This class has consistently received excellent evaluations from students who've taken it:
"I thought Dave's class was outstanding. Well prepared and highly valuable content. This course was one of the best organized I've had the opportunity to take." - Chris Fedde
"It damn sure was a good use! It would've been a huge mistake not taking your class; Moose is a magnificent beast and I couldn't have picked a better primer." - Brian Fraser
"The class was great. There was a nice balance of material presented to hands-on experimentation, and alternating between lecture and exercises helped nail down concepts." - Philip Monsen
Stick around for more Moose on Friday. Stevan Little of Infinity Interactive is offering an Advanced Moose course that will help you get the most out of Moose.
Friday June 7, 2013
Advanced Moose - Stevan Little - $125
Infinity Interactive is proud to offer a one day training session on advanced usage of Moose. The training is comprised of a series of interactive lectures each of which delves deeper into a specific Moose related topic with a strong focus on using Moose in real world scenarios. This course will be taught by Stevan Little, the original author of Moose, and Shawn Moore, a prolific contributor to Moose and the MooseX extension namespace.
- Learning to Love Stack Traces (30m)
- Native Traits and Delegation (50m)
- Break (30m)
- Role Usage Patterns (100m)
- Lunch (60m)
- Moose, CPAN and Legacy Code (50m)
- Moose Optimization (50m)
- Break (30m)
- Advanced Meta Extensions (50m)
- MooseX Tour (50m)
Learning to Love Stack Traces (30 minutes)
Exception handling in Perl is tricky to get right, but the Moose ecosystem provides some help in this area. We will discuss modern tools for dealing with exceptions, such as Throwable and Try::Tiny, and use these tools to give examples of proper structure for exceptions used in your applications. We will also discuss the errors that Moose produces, explain why full stack traces are an essential tool for debugging, and give some tips on interpreting and understanding them by investigating the stack traces of some common Moose errors.
Native Traits and Delegation (50 minutes)
Delegation is one of the most powerful features that Moose provides, but it can also be one of the most confusing. This talk will review the standard class based delegation features as well as the "native" delegation features. We will explore some of the idiomatic usage of both of these features and see how they can be used to craft well encapsulated APIs. We will also cover some related but different solutions like autobox and explain their differing tradeoffs.
Role Usage Patterns (100 minutes)
Roles are one of the most exciting and powerful features provided by Moose, but also one of the most misunderstood. This talk will explore, in depth, some common usage patterns (and antipatterns) for roles and how best to use them in the design of your classes. We will also talk about the philosophy of roles and how they fit in with the larger OO toolset.
Moose, CPAN and Legacy Code (50 minutes)
Part of what makes Perl so great is the CPAN, and from the very start, Moose has always strived to interoperate well with ordinary Perl classes. In addition to this, Moose was designed to work well with legacy codebases
Advanced Moose - Meta Extensions (50 minutes)
This talk will contain a review of the MOP (meta object protocol) that Moose is built upon in preparation for discussing two main topics. First, how to best navigate and use the detailed information it contains, and second, how to go about extending that same MOP to provide elegant solutions. We will cover some of the most common extension types, such as custom attribute traits and custom sugar layers on top of Moose.
Moose Extensions Tour (50 minutes)
Moose has a rich and varied set of extensions available on the CPAN; many good, some bad. This talk will provide a tour of both the best and worst extensions as well as teach you how to evaluate extensions on your own.