Nathaniel T. Schutta is a software architect and Java Champion focused on cloud computing, developer happiness and building usable applications. A proponent of polyglot programming, Nate has written multiple books, appeared in countless videos and many podcasts. He’s also a seasoned speaker who regularly presents at worldwide conferences, No Fluff Just Stuff symposia, meetups, universities, and user groups. In addition to his day job, Nate is an adjunct professor at the University of Minnesota, where he teaches students to embrace (and evaluate) technical change. Driven to rid the world of bad presentations, he coauthored the book Presentation Patterns with Neal Ford and Matthew McCullough, and he also published Thinking Architecturally and Responsible Microservices available from O’Reilly. His latest book, Fundamentals of Software Engineering, is currently available in early release.
Back in the day, it used to be so simple. Our projects had a main.js file that contained a few hundred lines and every so often the corporate communication department would ship out some new CSS files. But now things are not quite so easy. With more and more single page apps containing thousands or hundreds of thousands of lines of JavaScript, we're going to need a bigger boat.
In this talk I will explore various options you can deploy on your projects to tame the mass of code that lives on the front end of our applications. From NPM to Gulp to Webpack, this talk will help you establish a front end pipeline.
How is your architecture group perceived in your organization? Be honest now…is it seen as a group of ivory tower dilettantes intent on saying NO while filling a whiteboard with boxes and arrows? Or is it seen as a key component in developing rock solid software? If it's the former, how do you shift things towards the latter? Even if everyone thinks the world of the architecture team, odds are you have more work than you can handle and a bunch of tech leads that may (or may not) be thinking of all the right ilities. How do we reach out to them, mentor them, and bring them in to the fold?
Building an architectural community can help grow architects, improve the architect group's standing in the organization and ensure projects are built to last. This talk will discuss the steps one group took to grow a community of practicing architects, recognizing that not all those doing architecture work have “architect” in their job titles.
By now I bet your company has hundreds, maybe thousands of services, heck you might even consider some of them micro is stature! And while many organizations have plowed headlong down this particular architectural path, your spidey sense might be tingling…how do we keep this ecosystem healthy?
In this talk, I will go beyond the buzzwords into the nitty gritty of actually succeeding with a service based architecture. We will cover the principles and practices that will make sure your systems are stable and resilient while allowing you to get a decent night's sleep!
Development teams often focus on getting code to production losing site of what comes after the design and build phase. But we must consider the full life cycle of our systems from inception to deployment through to sunset, a discipline many companies refer to as site reliability engineering.
While your organization may or may not have an SRE team, you have someone playing that role and we can all benefit from looking at the principles and practices that we can bring to bear on our projects. In this talk, I will introduce the concepts of SRE and how you can adopt these ideas on your applications.
At the end of the day, an architect's primary job is to communicate. Not only do we need to make sure our teams understand the design of the system well enough to implement it, we must be able to explain our decisions to an audience that isn't impressed with how many TLAs you can rattle off in one sentence. Successful architects need to seamlessly transition from in depth technical conversations to budget meetings to discussions with end users adjusting the message to fit the audience.
While oral communication is key, good architects also spend a good deal of time putting pixel to screen via email, IM and various architectural documents we're expected to create. We need to write clearly and concisely while also knowing when the best course of action is to pick up the phone or walk to someone's desk.
In this talk, we'll explore the various methods that we as architects use to communicate with our stakeholders. We'll talk about knowing our audience, being able to present as well as how to run a good meeting. We'll discuss various patterns (and antipatterns) of presenting along with some concrete advice on how to do it better. At the end of the day, our job is to tell effectively tell a story - this talk will look at ways to do that.
Good architects are, almost by definition, good story tellers. And while good communication skills are vital to success as an architect, so too is an ability to constructively critique an architecture. In this talk, we'll explore why reviews are important and what it takes to perform them well. Additionally, we'll talk about the importance of planning and preparation in conducting a successful review.
Good architects are, almost by definition, good story tellers. And while good communication skills are vital to success as an architect, so too is an ability to constructively critique an architecture. In this talk, we'll explore why reviews are important and what it takes to perform them well. Additionally, we'll talk about the importance of planning and preparation in conducting a successful review.
Rich Hickey once said programmers know the benefits of everything and the trade offs of nothing…an approach that can lead a project down a path of frustrated developers and unhappy customers. As architects though, we must consider the trade offs of every new library, language, pattern or approach and quickly make decisions often with incomplete information. How should we think about the inevitable technology choices we have to make on a project? How do we balance competing agendas? How do we keep our team happy and excited without chasing every new thing that someone finds on the inner webs?
As architects it is our responsibility to effectively guide our teams on the technology journey. In this talk I will outline the importance of trade offs, how we can analyze new technologies and how we can effectively capture the inevitable architectural decisions we will make. I will also explore the value of fitness functions as a way of ensuring the decisions we make are actually reflected in the code base.
As a developer, your focus was squarely on the “functional requirements” aka the business capabilities your application must meet. But once you step in the architect role, you discover a world inhabited by “the ilities” otherwise known as the non functional or quality attributes of a software system. But how do we know which ilities matter and which ones don't? And much as we may want to turn every knob up to 11, many ilities are inversely related - maximize one and you by definition minimize another.
In this talk we will look at various architectural problems giving participants opportunities to try and balance non functional requirements. We'll discuss the consequences of various approaches as well as how we can best document the inevitable decisions we arrive at.
In some organizations, architects are dismissed as people that draw box and arrow diagrams - the dreaded whiteboard architect. While we don't want to foster that stereotype, it is important for an architect to be able to construct basic architectural diagrams. An architect must also be able to separate the wheat from the chaff eliminating those models that don't help tell the story while fully leveraging those that do.
In this workshop, we'll discuss the various diagrams at our disposal. We'll walk through a case study and as we go, we'll construct a set of diagrams that will help us effectively communicate our design. We'll talk about stakeholders and who might benefit from each typ of diagram. Additionally we'll discuss how to constructively review an architectural model.
In some organizations, architects are dismissed as people that draw box and arrow diagrams - the dreaded whiteboard architect. While we don't want to foster that stereotype, it is important for an architect to be able to construct basic architectural diagrams. An architect must also be able to separate the wheat from the chaff eliminating those models that don't help tell the story while fully leveraging those that do.
In this workshop, we'll discuss the various diagrams at our disposal. We'll walk through a case study and as we go, we'll construct a set of diagrams that will help us effectively communicate our design. We'll talk about stakeholders and who might benefit from each typ of diagram. Additionally we'll discuss how to constructively review an architectural model.
Presentation Patterns is the first book on presentations that categorizes and organizes the building blocks (or patterns) that you’ll need to communicate effectively using presentation tools like Keynote and PowerPoint.
Patterns are like the lower-level steps found inside recipes; they are the techniques you must master to be considered a master chef or master presenter. You can use the patterns in this book to construct your own recipes for different contexts, such as business meetings, technical demonstrations, scientific expositions, and keynotes, just to name a few.
Although there are no such things as antirecipes, this book shows you lots of antipatterns—things you should avoid doing in presentations. Modern presentation tools often encourage ineffective presentation techniques, but this book shows you how to avoid them.
Each pattern is introduced with a memorable name, a definition, and a brief explanation of motivation. Readers learn where the pattern applies, the consequences of applying it, and how to apply it. The authors also identify critical antipatterns: clichés, fallacies, and design mistakes that cause presentations to disappoint. These problems are easy to avoid—once you know how.
Presentation Patterns will help you
Whether you use this book as a handy reference or read it from start to finish, it will be a revelation: an entirely new language for systematically planning, creating, and delivering more powerful presentations. You’ll quickly find it indispensable—no matter what you’re presenting, who your audiences are, or what message you’re driving home.
Ajax (Asynchronous JavaScript and XML) is the ultimate web programming methodology for producing dynamic, rich web experiences. Java developers are crying out for guides showing how to add Ajax functionality to web applications, and this book meets their needs with Pro Ajax and Java. This is the book every Java developer needs to become expert in Ajax. The authors provide the reader with the perfect Java/Ajax toolkit to get started quickly, exploring Ajax development in detail using the 4 most popular Java web application frameworks: Struts, Spring, JSF, and Tapestry.
* Ajax works across many platforms and different groups of developers – this book is designed to be suitable for all those developers across all those platforms, who are interested in the hot new topic of Ajax.
* Demand for Ajax knowledge will be strong. Leading technology companies like Google, Yahoo, Adaptive Path, and Amazon are adopting Ajax techniques, and many other companies are doing the same in order to compete with Ajax. This book connect the developer community to the new Ajax functionality.
You know about Extreme Programming, Agile cooperation, and continuous improvement, but did you know you can apply these to UI design? I'll show you how to make your end users happy all the time by applying what you already know about software development to the design and implementation of user interfaces. More and more, developers are being called upon to create user interfaces without designers. Extreme UI Design: The User is Always Right will show you how to use your well-honed programming skills to build measurably effective front ends.
It's all about usability, the software equivalent of flossing; you know you should do it, yet sometimes there just isn't time. For developers, there often isn't money to hire a designer. In tough times, developers who can design become essential, but most software engineers are schooled in algorithms and compilers and rarely in the intricacies of user interaction. This book is for all of you who find yourselves working on the front lines of software development and want to create an application that respects the maxim that all users are right.
Looking to get an edge in today's workplace? Worried about being downsized? As companies look to cut expenses, the developer who can do more has a better chance of survival. If the UI team gets the axe, can you step in and help run a usability test or whack out a paper-based prototype? After reading this book, you'll be more valuable to your software development organization, you'll have a more complete toolbox, and you'll create applications that don't make your users yack .
This book is primarily aimed at software developers who are tasked with front-end development. Considering that almost all software has some kind of interface, it should appeal to a large audience. Depending on how the book is slanted, it should also interest the agile community.