Kaizen is the unstated, ever-present cornerstone of Agile Development, but it's if often seen as distant and abstract thing rather than one of the tangible Agile practices, like standups, testing, or estimation. Seen as a "soft skill", Kaizen is in fact it's the hard science, the central motivator, the justification, and the traffic cop of other Agile practices. This presentation delivers Kaizen without the typical esoteric language, and re-casts it as the tangible, central aspect of Agile Development that all other practices pivot around. It presents the tools and techniques of Kaizen that you can put to work in your team right now in the pursuit of ever higher levels of performance.
TDD has been tattered, torn, twisted, stood on its head, and pounded into an pulp of techno-fetishism. TDD was a game-changer, but the focus in the interceding years has shifted from technique to tools, and TDD has been devolving into a lost art. By tearing TDD down to its bones, this presentation presents TDD in its essence, free of tools, and reinforcing the primary focus on design principles. It attempts to convince you to return to a simpler time when TDD was still about design, and software developers were dutifully steeped in the critical importance of design principles. To avoid being held to any particularly offensive positions, this talk liberally attacking the status quo of testing and contemporary tool-obsessed TDD in Ruby, while introducing yet-another testing library in Ruby. :)
We identify ourselves as geeks. We're language geeks, data geeks, process geeks, UI geeks… geek everything. It's our strength. It keeps us together. But is there a downside? Is it all good, or does geek also come with some disadvantages? This presentation explores the good, the bad, and the not-so-great of "geek". With a smattering of psychology and sociology thrown in for good measure, it summarizes twenty-five years of observation and self-observation of the software geek. And ultimately, it urges an more objective stance and a re-consideration of our commiseration around the geek identity.
Nothing but code in this presentation. Just Ruby code. Specifically, Ruby code that may be rare in typical Ruby projects. Counter-intuitive Ruby code, but Ruby code backed by justifications rooted in design principles that sustain developer productivity. These techniques were gleaned over a handful of years of Ruby development, and seeing the lauded productivity of Ruby not actually measure up to reality. It offers alternative patterns to patterns commonly found, and traces their roots to popular misconceptions that have been merely replicated from library to library. This presentation offers some challenges to the status quo, highlights inconsistencies between typical claims of the average Ruby and the on-the-job reality, and asks whether Ruby development has become as insular as predecessors that achieved similar popularity.