People have been optimizing the wrong things and increased complexity. While that may make your job more interesting, seasoned System Administrators and devotees of chinese proverbs will tell you that “boring” really is the standard to aspire.
Simplicity pays in scalability. Simplicity pays in security. Instead of building “optimized” systems based on more complex solutions, focus on simplifying interfaces, code and, yes, technologies used.
Adapting any new technology incurs a cost. Some of the cost is in the maturity of the codebase, some of it is in the quality of the code produced by the people who cannot possibly have more than small-n years of experience with the technology (seriously, how many programmers with 10 years of experience deploying Scala in large-scale production environments can there be?), some of it is the overhead of maintaining yet another new programming language, interpreter, library, or other components and some of it is finding people to maintain the code after your rockstar coder has left the building.
No matter what fancy new advantages technology brand-new-spanking-X may offer, you end up having to adapt your infrastructure, your code base, your ever so agile test environment, your deployment system and who knows what else to the new platform. I hope it won’t come as a surprise to you that you will most likely fail in pushing it to an actual 100% of your systems. It also should not come as a surprise to you to hear that no matter how dev-opsy your SA team is, it really would prefer it if you didn’t insist on the new hotness.
Stability, maturity and, most importantly, simplicity still outweigh leetness and sparkle, though it’s sometimes hard to not be blinded by shiny new objects. In this talk, I will argue that a certain “back to the basics” approach is what is needed to actually push forward our systems. As much as simple tools like shell, awk and the like are simultaneously derided and claimed to be revered, few people actually scale them. In fact, a lot of energy is spent on claiming they won’t — can’t! — scale, when the limiting factor is not inherent to the language or tool, but to the way it is used.
However, with a bit of appreciation of the general unix philosophy and a willingness to at times sit back and review whether or not the right thing is being optimized, we could build more stable, scalable, secure systems with a shelf-life larger than that of a Kardashian wedding if we focused on standard tools and code quality. Perhaps we could then solve the remaining simple problems by throwing money (ie hardware) at them? That would be nice.
In this talk I will further make a point to move away from all the fancy new tools, languages and memes and focus on learning the basic building blocks. I will illustrate how simple shell code can scale, how basic unix interfaces knock the socks off shuffling around complex structures that make you yaml from just looking at them and will suggest that “DevOps” really isn’t all that new.
Whether or not parts of the talk will be tongue-in-cheek or intentionally confrontational to current trends is then left to the interpretation by every attendee’s own personal reality distortion field, likely based on their level of experience.
Jan Schaumann has worked in various system and infrastructure administration, architecture, and security-related functions in both small scale academic as well as massive industry-leader corporate enterprise environments. In addition, he is an adjunct professor of computer science at Stevens Institute of Technology, where he teaches classes in system administration and UNIX programming.
For information on exhibition and sponsorship opportunities at the conference, contact Gloria Lombardo at email@example.com
For media partnerships, contact mediapartners@ oreilly.com
For media-related inquiries, contact Maureen Jennings at firstname.lastname@example.org
View a complete list of Velocity contacts