I have two types of videos on offer: professional studio videos that represent deep-dives into a complex technical subject and recordings of my conference presentations shot live. Some of the conference videos are links, others I host myself (when I can acquire a copy myself).

Professional

Software Architecture Fundamentals series

Software Architecture Fundamentals: From Developer to Architect cover

Software Architecture Fundamentals: Understanding the Basics

In this anticipated video series, Neal Ford and Mark Richards examine the responsibilities of a software architect, specifically the knowledge and skills you need to be effective in that role.

The first video, Understanding the Basics, not only focuses on development techniques, but also pinpoints the skills you need to be a successful team leader. You’ll learn about the four main aspects of a software architect, and quickly discover the difference between architecture decisions and technology decisions. In this video, you’ll explore:

Soft Skills:

Investigate techniques for communicating effectively as a team leader
Measure your technical knowledge, including technical depth vs. technical breadth, and multi-platform skills
Discover how to increase your expertise of business domains
Learn how ensure a successful implementation by matching methodology with architecture

Architectural Techniques:

Make your architecture more adaptable to changes in business and technology
Explore various techniques and patterns for integrating multiple applications and databases
Get a true understanding of enterprise architecture by examining the context and goals of an EA implementation

The topics in this video set the stage necessary to understand the enterprise architecture approaches and strategies demonstrated in the series’ second video: Software Architecture Fundamentals: A Deeper Dive.

Introduction (28 minutes)
Architecture Soft Skills Part 1 (11 minutes)
Continuous Delivery (41 minutes)
Architecture Soft Skills Part 2 (36 minutes)
Understanding Large Codebases (36 minutes)
Architecting for Change (17 minutes)
Architecture Patterns Part 1 (48 minutes)
Architecture Patterns Part 2 (35 minutes)
Design Patterns (22 minutes)
Architecture Anti-Patterns Part 1 (15 minutes)
Architecture Anti-Patterns Part 2 (27 minutes)
Tooling and Documentation (34 minutes)
Integration Architecture Fundamentals (47 minutes)
Enterprise Architecture Concepts and Fundamentals (14 minutes)

Purchase or stream at O'Reilly's site

Software Architecture Fundamentals: Beyond the Basics

"Software Architect" places in the top ten of most annual surveys of best jobs, yet no clear path exists from Developer to Architect. Why aren’t there more books and training materials to fill this demand? This video series by Neal Ford and Mark Richards starts filling the information gap.

Software architecture is a massive multidisciplinary subject, covering many roles and responsibilities, making it challenging to teach because so much context is required for the interesting subjects. It’s also a fast moving discipline, where entire suites of best practices become obsolete overnight.

In two videos—Understanding the Basics and A Deeper Dive—this series covers a vast array of subjects, all grounded with the common theme of architecture, emphasizing techniques to allow architecture for change. Each installment covers topics in application, integration, and enterprise architecture.

A Deeper Dive advances the discussion from Developer to Architect by covering application, integration, and enterprise architecture. We discuss evaluating architectures (including making formal processes like ATAM more agile and effective), and various architectural frameworks:

Application Architecture: Understand the impact that modern engineering practices like Continuous Delivery have on architectural decisions. You’ll learn about different abstractions, their pros and cons, and how to effectively choose between them.
Integration Architecture: Examine the pros and cons of SOAP vs REST, as well as integration hubs like ESBs as an architectural pattern, and some common integration patterns.
Enterprise Architecture:Delve into centralized and decentralized approaches, 4 types of strategies for decision making, and evolutionary architecture and emergent design.

Discussion augments the material throughout, providing differing opinions and contexts on many subjects.

Architecture Tradeoffs (31 minutes)
Continuous Delivery Part 1 (51 minutes)
Applying Abstraction (22 minutes)
Choosing and Comparing Architectures (25 minutes)
Web Services and Messaging (31 minutes)
SOA Fundamentals (28 minutes)
Integration Hubs (22 minutes)
Continuous Delivery Part 2 (49 minutes)
Enterprise Architecture Approaches (36 minutes)
Enterprise Architecture Strategies (28 minutes)
Evolutionary Architecture and Emergent Design (31 minutes)

Purchase or stream at O'Reilly's site

Software Architecture Fundamentals: Soft Skills

In the third video of this acclaimed series on software architecture fundamentals, Neal Ford and Mark Richards focus exclusively on the often-neglected area of soft skills. Knowing the ins and outs of programming and technology is only one side of a software architect’s skillset. Aside from being an excellent developer, you also have to be a leader. Soft skills help you work well within a larger corporate structure, manage teams, and ensure that technology is a first-level concern at your company.

In this video, you’ll learn how to:

Justify, document, and communicate your architecture decisions to the right stakeholders
Create an architecture refactoring plan by determining the root cause of issues and identifying architecture changes
Make effective technical presentations and learn how to present them
Enhance your problem-solving skills with various tips and techniques
Write proposals, evaluations, business cases, and other persuasive documents
Leverage checklists effectively by finding a balance between usefulness and overhead
Manage your personal productivity, such as interacting business stakeholders and other architects
Learn the process for several certification programs, as well as architectural certification pros and cons

Once you have completed this video, follow up with Software Architecture Fundamentals People Skills to learn essential skills such as leadership, negotiation, managing meeting, building your tech radar, and working with people.

Purchase or stream at O'Reilly's site

Software Architecture Fundamentals: People Skills

Dive deeper into people skills in the fourth video of this acclaimed series on software architecture fundamentals from Neal Ford and Mark Richards. Programming and technology is only one side of a software architect’s skillset. Along with being an excellent developer, you also have to be a communicator and a leader. People skills help you work well within a larger corporate structure, manage teams, and ensure that technology is a first-level concern at your company.

In this video, you’ll learn how to:

Control various types of architecture boundaries and the personalities that form them

Work with members of your architecture team by using techniques and best practices

Cope with meetings imposed on you and meetings you impose on others

Become an effective technical leader by honing your skills

Delve into the relationship between software architecture, team structure, and the impact of Conway’s Law when designing systems

Use negotiating skills to drive consensus and understand tradeoffs with stakeholders, technologists, and team members

Build your personal technology radar as a way to investigate new technologies in a structured way

Crowd-source technology decisions within your organization by building a companywide technology radar

Purchase or stream at O'Reilly's site

Software Architecture Fundamentals:Service-based Architectures

The microservice architectural style is suddenly hugely popular, but it is only one in a family of related service-based architectures. This video covers a variety of service-based architectures, comparing and contrasting along several dimensions (structure, engineering practices, deployment, etc) from monolithic through services to microservice architectures. In particular, we highlight the differences between traditional SOA-style architectures and microservices, allowing architects to make a better informed decision as to the proper style. We also cover the challenges and best practices when migrating from monolithic or traditional SOA to microservice architectures.

This video is divided into three parts: Concepts, Engineering Practices, and Migrations and Hybrids. The Concepts section covers basic definitions and differentiation between these similar architectural styles. It also describes challenges when moving from application to integration architectural. The Engineering Practices section covers DevOps, testing, and organization, all of which are critical success factors in microservice architectures. Last, in the Migrations and Hyrbrids section, we discuss how to migrate between monolithic and several different variations of service-based architectures.

Introduction to the Course (7 minutes)
Concepts

Microservices Architecture Pattern Elements (32 minutes)
SOA Architecture Pattern Elements (23 minutes)
Service Based Architecture Microservices Hybrids (14 minutes)
Microservices and Service Based Governance (10 minutes)
Coupling and Cohesion (28 minutes)
Comparing Microservices: Service-Based and SOA (32 minutes)
Service Orchestration (11 minutes)
Remote Access Protocol Comparison (40 minutes)
Distributed Architecture Challenges (18 minutes)

Engineering Practices

Devops Practices (30 minutes)
Microservices Testing (12 minutes)
Organizational Change (16 minutes)

Migrations and Hyrbrids

Migration Paths and Drivers (15 minutes)
Migration Challenges (11 minutes)
Migration Steps - Introduction and Planning (14 minutes)
Migration Steps - Separation (6 minutes)
Migration Steps - Proxy Layer (10 minutes)
Migration Steps - Refactoring (20 minutes)
UI Evolution and Refactoring (14 minutes)

Purchase or stream at O'Reilly's site

Engineering Practices for Continuous Delivery

Releasing software to actual users can be a painful, risky, and time-consuming process. With this video workshop, experienced developers, testers, and operations engineers learn the principles and technical practices that enable rapid, incremental delivery of new, high-quality, valuable functionality to users.

This video from Neal Ford (and guest experts Tim Brown, Rachel Laycock, and Ryan Murray) demonstrates the engineering practices that allow you to get fast feedback on the production readiness of your application every time there is a change to the code, infrastructure, or configuration.

You’ll learn that, through automation of the build, deployment, and testing processes—and improved collaboration among developers, testers and operations engineers—delivery teams can get changes released in a matter of hours (sometimes even minutes), no matter how large or complex the project is.

Topics include:

Introduction to deployment pipelines
Deployment pipeline best practices with Cruise Go
Testing practices
Continuous integration
Trunk-based development
Incremental deployment strategies
Data management and migration
DevOps impact on all facets of a project
Continuous delivery for architects
Contract tests
Engineering practices for microservices
Metrics and monitoring
Details on setting up deployment pipelines
How continuous delivery works with Fan-in and Fan-out integration
How to ensure automated backwards compatibility among evolving services

Purchase or stream at O'Reilly's site

Clojure (inside out)

Why is Clojure the most interesting new language on the horizon? With this video, you'll not only learn how to tackle real problems with this functional language, you'll learn how to think in Clojure--and why you should want to.

Neal Ford (software architect and meme wrangler at ThoughWorks) and Stuart Halloway (CEO of Relevance, Inc.) show you what makes programming with Clojure swift, surgical, and accurate. Clojure compiles to many target environments, including the JVM, JavaScript, and the .NET CLR, and you'll quickly get up to speed on its syntax, ecosystem, and libraries. Then Ford and Halloway take you much deeper into the language, while keeping the focus on practical application:

Learn how to leverage macros to solve real problems
Discover how Clojure helps you manage time the way garbage collection helps you manage space
Understand why functional programming is so important
Clojure represents a vision for building software that could only be implemented by building a new language. You've heard the hype, now come learn the facts on the ground.

Introduction (33 minutes)
Data (19 minutes)
Code Part 1 (41 minutes)
Code Part 2 (34 minutes)
Functions (80 minutes)
Abstraction (33 minutes)
Concurrency Part 1 (18 minutes)
Concurrency Part 2 (22 minutes)
JVM Interop (30 minutes)
Integration (37 minutes)

Purchase or stream at O'Reilly's site

Functional Thinking

Learning the syntax of a new language is easy, but learning to think under a different paradigm is difficult. This video from renowned software architect Neal Ford helps you transition from a Java-writing imperative programmer to a functional programmer, using Java, Clojure and Scala as examples.

Rather than focus on specific language features, Functional Thinking looks at a variety of common practices in OOP languages and then shows you how to solve the same problems using a functional language. For instance, you know how to achieve code-reuse in Java via mechanisms such as inheritance and polymorphism. Code reuse is also possible in functional languages, using high-order functions, composition, and multi-methods.

Ford encourages you to value results over steps, so you can begin to think like a functional programmer. Expect your mind to be bent, but you’ll finish with a much better understanding of both the syntax and semantics of functional languages. This video is ideal for any experienced programmer.

Introduction (35 minutes)
Gradually Getting Started (41 minutes)
Functions (29 minutes)
Laziness (34 minutes)
Coupling vs. Composition (25 minutes)
Functional Data Structures (25 minutes)
Rethinking Dispatch (20 minutes)
Summary (25 minutes)

Purchase or stream at O'Reilly's site

Agile Engineering Practices

Many people who explain agile software development often discuss project and planning practices, but hardly mention the development phase. In this insightful video, renowned software architect Neal Ford drills into the real details of agile engineering practices from a pure development perspective. Discover the development and design practices that make the agile approach work, the pros and cons of feedback mechanisms, and a host of related topics.

Key Principles (41 minutes)
Estimation (57 minutes)
Test-driven Design Part 1 (41 minutes)
Test-driven Design Part 2 (27 minutes)
Pair Programming (49 minutes)
Automation (46 minutes)
Version Control Strategies (23 minutes)
Testing the Entire Stack (32 minutes)
Functional Tests (34 minutes)
Agile Design (39 minutes)
Emergent Design Enablers (Free Preview available) (32 minutes)

Purchase or stream at O'Reilly's site

Found "in the wild"

w-jax 2013 Keynote: 5 Reasons You Should Care About Functional Programming

Link on Vimeo Link at JAXenter.de

The blurb from the wjax site: In this keynote from W-JAX 2013, Neal Ford explores why learning functional programming paradigms now is critical for developers with five concrete reasons:

why it’s beneficial to cede control over mundane details to the language and runtime
how nailgun driven development differs from building prefab houses
the wonderful benefits of immutability 4. embrace results over steps
how bendable languages make hard problems easier to tackle.

Even if you don’t care about Scala, Clojure, F#, or Haskell, the important features of those languages will impact your life. Now is the time to increase your comfort level with these new paradigms.

w-jax 2013: Agile Architecture & Design

My Agile Architecture & Design talk at w-jax combined elements from my Emergent Design, Continuous Delivery for Architects, and various architecture topics.

Abstract: Donald Rumsfeld was right: it’s the unknown unknowns that are the real killers in software development. Design decisions made too early are just speculations without facts. But you must have architecture in place before you can do anything. Neal Ford's session at W-JAX 2013 talks about the tension between architecture and design in agile projects, discussing two key elements of emergent design (utilizing the last responsible moment and harvesting idiomatic patterns) and how to de-brittlize your architecture, so that you can play nicely with others. This talk includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping your code in sync with the problem domain.

OSCON 2013: A Brief Bit of Functional Thinking

This is a brief version of the 2013 version of my Functional Thinking regular conference presentation: normally 90 minutes, this is a 40 minute version). It covers some of the same material as my O'Reilly Functional Thinking video in a more cursory fashion due to time constraints.

OSCON opened the Big Stage for regular session in 2013, and they were nice enough to schedule my talk in that room. It's a talk I've given many times, so it was well rehearsed and was consequently one of the top rated talks of the conference (I don't know what the ranking was, I'm going on their Twitter announcement of this video).

w-jax Interview on Learning Functional Programming

This in an interview from the 2012 w-jax conference, touching on the relevancy of functional programming and some digressions on things like habit and thinking processes.

Download the video.

OreDev 2011 Keynote: Abstraction Distractions

Watch

I delivered my 2011 keynote, Abstraction Distractions, about a dozen times in different venues. This was towards the end of the year, where most of the talk is pretty honed and I have a great audience, the attendees of the awesome OrdDev conference.

RailsConf 2010 Keynote: Creativity & Constraint

Watch...

I was asked to do one of the mid-week morning keynotes at RailsConf in 2010. I suspect I was a replacement for someone who dropped out because I was asked only about 6 weeks out. That's fine with me - I'll gladly jump at the chance to keynote one of my favorite conferences!

But now I had to come up with a topic, and I didn't want it to be the run-of-the-mill "Enterprise Software Development Isn't So Bad" kind of talk. I solicited several mailing lists of Really Smart Guys, and my friend (and the author of the preface to The Productive Programmer suggested something about the effect of constraint on creativity. I had also had some thoughts along those lines, and started thinking about the subject. Because of the subject matter, I decided to not touch Keynote until 24 hours before the talk, spending the rest of the time thinking and designing what it should be. That's what I did, but the outcome was not what I (or anyone) expected. While I kept trying to keep the subject on Creativity and Constraint, the subject of art kept intruding, and eventually took over. You'll have to watch it to see how I finally resolved the two subjects.

Meta-Presentation

As part of my work on the Presentation Patterns book, I created a super-detailed annotated version of this talk, explaining in gory detail all the design decisions I made & why. If you really want to understand what I was thinking about as I authored & presented this keynote, it's here in full glory. You should watch it first, then look at the annotated slide deck, which is every slide including all the transitions & animations and my comments.

Download the annotated keynote here.

Introduction to the Annotated Slide Deck

Like any form of art, you can infuse a presentation with a lot of sophisticated, mostly hidden little features (foreshadowing, symbolism, advocacy, etc). Most of the audience probably won't pick up on it directly. For example, you can watch the movie The Sixth Sense as just a thriller with a very surprising ending. But you can also watch it as a brilliant bifurcated plot, with tons of color symbolism. For example, watch out for the color red, which suffuses the whole movie. At first, red seems to show up in 2 circumstances: when the boy sees ghosts and when we're looking at scenes about his doctor. Of course, by the end you realize that there is only 1 trigger for the red after all. You would never notice that the first time through the movie. However, it is my contention that those elements, even if they are subtlety invisible, make the movie seem more solid, more sophisticated, more artistic. And, of course, you can go back and identify those things, but it shouldn't diminish your enjoyment of the movie itself. It is those subtle features that help differentiate between things that are art and things that are merely entertainment.

I think that, if have a presentation that includes all these artistic elements, it seems more complete somehow than one that doesn't. This is my justification for building this really elaborate keynote for RailsConf, which includes tons of stuff that I'm sure no one noticed and will never go back to notice (I don't for a moment think my keynote is as entertaining or compelling as The Sixth Sense).

I've wanted to do a keynote at RailsConf for a while because it's one of my favorite conferences. In 2010, they turned down all my regular talk proposals (not too surprising: they have a huge number of submissions, and they tend to be pretty cutting edge at this conference). However, about 6 weeks before the conference, they contacted me about doing a 30 minute keynote (one of their keynoters had dropped out). I agreed.

I solicited some advice from several mailing lists, and David Bock ended up with a good suggestion that resonated with some stuff I had already been thinking: what is the effect of constraint on creativity?

Based on the topic, I resolved to not touch the presentation tool until the day before, to keep myself from committing to a visual idea too early. But I thought about this a lot over the intervening time, created mind maps, found some elements I knew would be there (the quote at the end I discovered very early & knew it would be the ending).

When I started putting all my thoughts together, though, I found that the combination of subjects I had assembled kept “pushing” me towards another theme, which I ended up going with. About 2 days before the talk, I decided that I would use the Creativity & Constraint theme to act as a path to lead to the real theme, which is a very broad, very abstract challenge to the crowd to start thinking about writing software in a different way, that the code itself that we use as a medium might be an interesting artistic medium.

JAX 2009 Keynote: Ancient Philosophers & Blowhard Jamborees

Download the video.

Description

My keynote for 2009 was entitled Ancient Philosophers & Blowhard Jamborees. In it, as in many of my keynotes, I try to dissect the ills of the software industry from a developer's standpoint.

The conceit of this talk is that we always think the interesting stuff is in the future, that technology always marches forward. Yet this causes us to ignore important lessons from the past. The ancient philosophers had a lot to say about how to build software, and we'd better start listening, or all the jobs are going to other placeswhere they aren't so silly.

Meta-presentation

This keynote is a classic example of a 3-act Narrative Arc. The first part sets the stage, using the Ancient Philosophers to supply a framework that allowed me to talk about the topics I wanted to talk about. The philosophers were carefully chosen to make sure they fit the overall narrative. I'm introducing the players and situations here.

The second act explains a variety of disfunction in the enterprise development world (easily identified because I numbered them). The end of the second act is the "Do you want fries with that?" slide. Whenever I give this talk, you can hear a pin drop at this point; I've bummed everyone out to the point of suicide.

The 3rd act is all about how we can change to prevent this dire outcome (also numbered, a magic 10 items), and ends with an inspirational quote.

This keynote also demonstrates the metronomic Brain Breaks pattern: the humor is carefully planned and distributed throughout.

InfoQ

I've done a variety of videos at conferences that InfoQ taped. These are hour-long versions of 90 minute talks, based on the constraints of the conferences.