San Francisco, CA
Expertise: Spring, Microservices, Kubernetes, CloudFoundry, EAI, Cloud Computing, YAML, Spring, Java, Architecture, Cloud, Full Stack
Josh (@starbuxman) became the first Spring Developer Advocate in 2010 and hasn’t looked back! He contributes (bugs, mostly..) to numerous open source projects, including Spring Boot and Spring Cloud.
Josh has a variety of talks and workshops on the following topics:
He is a world-renowned speaker who has spoken on every continent except Antarctica at thousands of events, shows, and organizations.
Josh puts together a weekly series on YouTube, Spring Tips, where he explores the latest-and-greatest in the wide and wonderful world of Springdom
Josh has put out an installment of This Week in Spring over on the Spring blog every Tuesday - without fail, since the first week of January 2010! - that (attempts, and often fails to) round up the latest and greatest in the wonderful and wide world of Springdom.
Josh is the host of a podcast called A Bootiful Podcast whose new episodes drop every Friday (roughly). In it, he sits down and talks to people that are smarter than he is (a shallow bar!) about the Spring and adjacent ecosystems.
Josh has done longer-form training courses - seen by hundreds of thousands of people worldwide - on the Livelessons platform since 2013.
Hi, Spring fans! In this installment, Josh Long (@starbuxman) talks to Spring observability guru Jonatan Ivanov (@jonatan_ivanov)
Hi, Spring fans! In this installment, Josh Long (@starbuxman) talks to a very busy rabbit-herder on the RabbitMQ team, Dan Carwin (@dcarwin)
Hi, Spring fans! In this episode, Josh Long (@starbuxman) talks to a person who knows more than most about the awesome implications of both the words "Spring" and "Cloud," Spring Cloud Kubernetes ninja Ryan Baxter (@ryanjbaxter).
Hi, Spring fans! In this installment, Josh Long (@starbuxman) talks to his friend, teammate, and architect extraordinaire, Nate Schutta (@ntschutta)
Hi, Spring fans! In this installment Josh Long (@starbuxman) talks to fellow teammate and Kubernetes ecosystem legend Leigh Capili (@capileigh) about Gitops, Kubernetes, Puppet/Chef, continuous delivery, how zoom scales if you deploy on-prem, being a developer advocate, Flux, and so much more.
Hi, Spring fans! In this installment, Josh Long (@starbuxman) talks to fellow Spring Developer Advocate Dan Vega (@therealdanvega)
Hi, Spring fans! In this installment, I (@starbuxman) talk to my old friend, world-famous polyglot, code curmudgeon, software philosopher, industry veteran, and legend of ecosystems aplenty, Ted Neward (@tedneward)
Hi, Spring fans! In this installment Josh Long (@starbuxman) talks to Spring Framework contributor S?bastien Deleuze (@sdeleuze) on GraalVM, AOT, project Leyden, and WebAssembly.
Hi, Spring fans! In this installment, Josh Long (@starbuxman) talks to Kubernetes legend and fellow Tanzu Developer Advocate Cora Iberkleid (@ciberkleid) about Kubernetes and Cartographer supply chains.
Hi, Spring fans! At long last, against all odds, Josh Long (@starbuxman) finally gets to talk to Spring I/O founder and more-than-a-decade-long friend Sergi Almar (@sergialmar) about an edition of Spring I/O after 2019!
Hi, Spring fans! I once met Dave Chapelle (no, not that Dave Chapelle!), who was a legend from the messaging industry. He worked on SonicMQ and a bunch of other famous messaging initiatives. He also wrote the O'Reilly book on the Java Messaging Service. I met him once, asked him to sign my copy of the book. He wrote, "Get the message!" and then signed it. I always loved him for that. And that's what I want you to do. Spring Boot and Apache Kafka are leaders in their respective fields and it's no surprise that they work well together. Join me, Spring Developer Advocate Josh Long (@starbuxman) and we'll look at how to use Spring Boot and Apache Kafka to build better, scalable systems and services so that you, too, can get the message!
?It is not necessary to change. Survival is not mandatory.? -W. Edwards Deming
Work takes time to flow through an organization and ultimately be deployed to production where it captures value. It?s critical to reduce time-to-production. Software - for many organizations and industries - is a competitive advantage.
Organizations break their larger software ambitions into smaller, independently deployable, feature -centric batches of work - microservices. In order to reduce the round-trip between stations of work, organizations collapse or consolidate as much of them as possible and automate the rest; developers and operations beget ?devops,? cloud-based services and platforms automate operations work and break down the need for ITIL tickets and change management boards.
But velocity, for velocity?s sake, is dangerous. Microservices invite architectural complexity that few are prepared to address. In this talk, we?ll look at how high performance organizations like Ticketmaster, Alibaba, and Netflix make short work of that complexity with Spring Boot and Spring Cloud.
In this workshop we'll look at how to build cloud-native Java applications. A cloud native application is:
A cloud native application is one that is designed to fully exploit a cloud platform both in the application layer - where things decompose into microservices - and at the data layer where NoSQL offers better horizontal scaling and fitness for specific purpose. This is what we mean by elastic.
A cloud native application is one that is agile. It should be easy to write, change, test, deploy and operate. If the cost of change is prohibitive then normal people under normal situations won't do it. We must make doing the right thing - that which supports change - the easy thing.
A cloud native system is observable. It must support at-a-glance insight into what is happening in the system and support remediation. It must be instrumented at the application and systems levels to support the effort of crisis-management.
A cloud native application is one that is fault tolerant, or robust. If a service should fail, the system must be able to recover and degrade gracefully. Instead of trying to build a system that is predicated on the lie that things are highly available, build instead to optimize for time to remediation.
In this workshop we'll cover:
Basics - we'll look at Spring Boot application development concepts like auto-configuration and embedded web container deployments (Spring Boot)
REST APIs - we'll look at concerns like API versioning and hypermedia. (Spring MVC, Spring Boot, Spring HATEOAS)
Data Access - we'll model a service domain and define bounded contexts. (Spring Boot, Spring Data)
Observability - what happens when there's a problem with your production application? How quickly can your team respond? How do you know if you're making improvements to a system? How do you measure progress? How do you monitor individual applications? How do you monitor the flow of requests through circuit breakers? How do you trace requests across the system? Can you visualize all the services in the system? We'll look at how to surface information about your services and systems. (Spring Boot Actuator, Micrometer, Graphite, Spring Cloud Sleuth, OpenZipkin, Spring Cloud Hystrix Dashboard)
Testing - we'll look at the concepts of test-driven development. We'll cover unit testing individual components and mock them out. We'll look at how to test service interfaces. We'll look at how to write integration tests that don't sacrifice speed in order to be exhaustive using consumer driven contracts and consumer driven contract testing. (JUnit, Spring Boot, Spring MVC Test Framework, Spring Cloud Contract)
Routing and Load-Balancing - where does your service live? How do your clients find it? How do you handle custom routing requirements? How do you handle custom load-balancing? (Spring Cloud, Ribbon)
Message-driven and integration-centric architectures - We'll look at how to build microservices that talk to each other over messaging fabrics like Apache Kafka or RabbitMQ. We'll look at how to integrate existing systems and how to use messaging to connect disparate systems. (RabbitMQ, Spring Integration, Spring Cloud Stream)
Stream Processing - We'll look at how to build solutions that process ongoing data over time. We'll look at how to compose messaging-based microservices and orchestrate them over a cloud-based fabric. (Spring Cloud Stream, Spring Cloud Data Flow)
Partitioned Batch Processing - In this section we'll look at how to process large amounts of sequential data and scale the processing across a cloud fabric. We'll look at how to scale processing horizontally as our processing needs demand. (Spring Batch, Spring Integration)
Reliability Patterns - In this section we'll look at how to employ retries and circuit breakers to build fault-tolerence into service invocations. We'll look at approaches to gracefully degrade if a service invocation should fail. (Spring Cloud Hystrix, Spring Retry, Spring Boot)
Ad-hoc Task Processing - Need to send an email? Resize an image? Generate a report? In this section we'll look at a few ways to distribute these longer-running workloads across a cloud