I was at CodePaLOUsa last year as an attendee and I had a pretty good time, but this was my first time as a speaker, so I wasn’t 100% sure what to expect. One thing that immediately caught my attention was that there wasn’t a room for speakers to get ready or to practice their talks. I didn’t know what to think of this at first, but overall, I actually like the idea. A trap that I’ve fallen into in the past is to spend too much time in the speaker room and not enough time hanging out with attendees so this was a great way to get me out of my comfort zone.
On that note, I was impressed with how Chad Green and crew have been able to have as many different venues as years (6 venues in 7 years) and yet the conference seems to run without a hitch year after year.
Making the Unstable Stable – An Intro To Testing by Cameron Presley
Overall, the reviews were pretty positive with 30/41 responding with 29 “great”, 1 “ok”, and 0 “awful” with a 73% overall participation rate. From the comments, here were the major trends.
- Very engaging
- Have me sold on starting testing sooner than later
- Your talk was the best one all day!
- Your energy is awesome!
- Presented to programmers but also QA. I am QA and was able to follow along
- Very helpful as I move into QA automated testing from strictly manual testing
Slides can be found at https://www.slideshare.net/CameronPresley/making-the-unstable-stable-an-intro-to-testing
Everything I Needed to Know About Debugging I Learned in Elementary Physics by Nate Taylor
In this session, Nate talked about his experiences learning physics in undergrad and how impossible it felt to solve the problem especially with other students looking at you. However, his professor had a system for administrating partial credit if the student in question did the following:
- Create a labeled diagram
- List what is known
- List what is unknown
- Write out a starting equation
For Nate, this turned the “impossible” task to “achievable”. Not only did he show this technique by solving a couple of physics problems, but he then draw parallels to solving physics problems to how we troubleshoot problems with our applications by stepping through two different issues. What I really appreciated in this talk was that we started on a problem with a simple enough domain and the audience worked together using the technique to debug the solution.
Slides can be found at https://github.com/taylonr/romanNumerals/tree/develop
Not Just My Opinion by Martine Dowden
In this session, Martine talks about how do we actually validate a design. We’ve all heard from users that “they’ll know it when they see it”, but what does that actually mean? Her argument was that design has a single purpose (to visually communicate a message) and that a good design will never be noticed, it’ll be seamless. From there, Martine talked about the Gestalt principles of psychology and how they apply to design. To prove the point, she walked us through a sample music e-commerce store and by following these principles, we iterate to a better design.
One cool thing I loved about this presentation was at the end where she showed us popular websites and we walked through some of the good design decisions she made. Given this was near the end of the day, Martine brought a massive amount of energy with her and you could tell she was super interested in this topic and that transferred to the audience.
Getting Functional With Elixir by Nate Taylor
In this session, Nate discusses the basics of functional programming using Elixir as the motivation. Some thing that really stuck with me was his description of a functional language: declarative paradigm (what vs how), functions as first class citizens (functions have the power), and immutability (data doesn’t change).
After explaining these concepts, we dove into looking into the different constructs (pipe forward, pattern matching, return values, structs, and recursion). To wrap things up, he showed us Exercism.io, a site where you can level up your programming skills in various languages.
Overall, I thought Nate did a excellent job demystifying the jargon of functional programming and provided a primer for the for the developer interested in learning more about functional programming.
Slides can be found at https://github.com/taylonr/get_functional_elixir
How To Have Code Reviews Your Developers Actually Want by Cameron Presley
This is the third time I’ve presented this session and based on some feedback I got from CodeStock 2017, I made some changes. First, I emphasized that the reason I don’t cover tools is because a lot of the pain points from doing code reviews come from the process used for reviews, not the tooling. Your developers are smart and can find the right tools for themselves, but no tool can fix a bad process. In addition, I focused more on speed and checking in with the audience more often.
Overall, the reviews were pretty positive with 36/45 responding with 35 “great”, 1 “ok”, and 0 “awful” with a 80% overall participation rate. From the comments, here were the major trends.
- Helpful technical and professional information
- Liked the “how are we doing” check ins.
Slides can be found at https://www.slideshare.net/CameronPresley/how-to-have-code-reviews-your-developers-actually-want
Care and Feeding of your new Junior Developer by Michael Hand
In this session, Mike showed us not only the reason we should be hiring junior developers, but also how to grow them into the developers we need. His approach was to have our juniors get better by teaching them soft skills (how to communicate and that everyone comes from different backgrounds).
To sharpen their technical skills, pair programming and code reviews can accelerate their learning. With that in mind, Mike defines experience as the combination of time and feedback and that it’s our responsibility that we’re providing Specific, Meaningful, Actionable, Relevant, and Timely (SMART) feedback. Otherwise, the developers will go where there is feedback. This was one of my favorite sessions of the conference and I took so many notes to take back with me.
Slides can be found at https://github.com/stirtrek/2017MayStirTrek/blob/master/Talks/MikeHand-CareAndFeedingOfYourNewJuniorDev.pdf
Establishing a SOLID Foundation – An Intro to Software Design by Cameron Presley
This is the first time I’ve presented this session since I’ve started gathering feedback and I was curious to see what the audience thought. Overall, the reviews were pretty positive with 37/50 responding with 34 “great”, 3 “ok”, and 0 “awful” with a 74% overall participation rate. From the comments, here were the major trends.
- Super helpful, but I didn’t have time to really read and understand the examples, much less write the “fix” for the problem
- Because of my weak understanding of interfaces, I got lost with dependency inversion
- Great speakers make topics fun to learn about!
Given the feedback, I might need to scale down the complexity of the code samples and it might be worth spending some time on interfaces as preparation for Dependency Inversion.
Slides can be found at https://www.slideshare.net/CameronPresley/establishing-a-solid-foundation-an-intro-to-software-design-76802444
Going into the wild by Lisa Redemann
In this session, Lisa (QA Manager for UPS) discusses the challenges of gathering requirements for a product in the field by telling a story of when UPS replaced paper charts/maps with an iPad for their pilots. First, Lisa described what the problems were with the application/roll out (lack of conditional/non-functional requirements and little understanding of user issues). Then, she described her scientific approach (observe users using the device and app in a day) while establishing the scope of the observations (only the core use of the device).
Something that was pretty cool was how she was able to be in the cockpit of the plane, watching how the pilots were interacting with the device during a flight. At the end, she talked about some of the hurdles of finding the right crew to observe (honest and constructive) and some of their assumptions that didn’t pan out. For example, they thought that the device would be docked often, but that wasn’t the case. They also thought that the daytime/nighttime toggling feature would be used, but it was hugely important.
This was my first time speaking at CodePaLOUsa and as a speaker, I had a great time. Not only were there fantastic sessions, but I had multiple conversations with attendees about the cool sessions they had seen and what they had picked up from them. It was definitely humbling to have attendees who saw one of my earlier sessions come to my other sessions based solely on how awesome of a job I did before. I will definitely be applying back to speak for next year!