Lightbend

Today's guest is Leon Stigter, Principal Product Manager for Akka Serverless. We discuss the origins and promises of serverless, some of the limitations of stateless functions for serverless, why data-centric serverless applications need more data access patterns to get the job done, how Akka Serverless democratizes access to the features and patterns developers need to be successful, and more.

Our guests Kiki Carter, Lead Developer Experience Engineer, and Hugh McKee, Developer Advocate for Akka Platform, return to the show after our last podcast, where we discussed whether it is worth it to manage Kubernetes (and other cloud native technologies and infrastructure) yourself, or use a managed solution. This naturally led to the topic of what developers actually want out of the technologies they use, and what are the truly important parts of the user experience.

Today we sit down with Christopher Hunt (Twitter: @huntchr), former Lightbender and now the founder/CTO of an Australian IoT startup called Titan Class. Commissioned by Cisco Systems, Titan Class makes Farmify, a field-based digital twin IoT solution designed using Akka Streams that gathers and analyzes various sensor metrics to enable intelligent farming. Learn more here: https://www.titanclass.com.au/ https://www.farmify.com.au/

In this podcast, our special guest is Alison Gianotto, aka [at]snipeyhead on Twitter. Alison is the CEO and founder of Grokability, the company behind Snipe-IT, which is a free as well as hosted solution for managing the where, when, and what of a company's physical assets. Today we're talking about going from an open source hobby to a hosted platform with a global client base and increasing revenues, and hopefully touch on other topics like using social networks for business, the implications of serverless as an industry trend, and questions we're tired of answering repeatedly. Note: This discussion includes some NSFW language so please throw those headphones on! :-) Here are the relevant links to subjects we discussed: - https://grokstar.dev/business/2021/06/feel-the-churn-but-preferably-not/ - https://grokstar.dev/business/2020/12/the-awkwardness-of-branding-and-naming-things-in-open-source-saas/ - https://grokstar.dev/business/2017/08/choosing-a-model-for-your-open-source-business/ - https://goodforms.com

In this Lightbend podcast with Kiki Carter, Lead Developer Experience Engineer, and Hugh McKee, Developer Advocate for Akka Platform, we take a look at work. Namely, how much time should software engineers give to working on something that we don’t like, aren’t especially good at, or would otherwise avoid in favor of other more interesting topics? Industry trends indicate that the less we developers need to mess with Kubernetes and other cloud based entities like databases and load balancers, the better off we all are. Today we’ll talk about why developers feel this way, what technologies are out there to help, and how to think about what we might outsource in terms of operations, deployment and management of our cloud-based systems.

In this Lightbend podcast, we are joined by Abby Kearns, CTO at Puppet and Lightbend board member, to discuss how cloud native applications enable enterprise innovation, best practices for getting started, and the rise of new cloud native technologies.

In this Lightbend podcast, we are joined by Jeremy Pollock, Senior Director of Product Management, to discuss the recent release of Akka Cloud Platform on AWS, what this means for Akka users, where Lightbend is heading with regards to cloud-based marketplace offerings and even our plans for hosted services. Read the transcription: https://www.lightbend.com/blog/lightbend-podcast-akka-cloud-platform-what-why-and-whats-next

Aleksandar Skrbic, a software developer based in Novi Sad, Serbia, and author of some great introductory posts on Akka Actors, discusses how Akka has boosted his Scala career as a distributed systems developer.

Has the momentum behind serverless architectures for cloud native apps stalled? Viktor Klang, VP of Cloud at Lightbend, weighs in.

In this Lightbend Podcast, we sit down with Renato Cavalcanti, senior engineer on the Akka team, frequent conference speaker (at least in past days), and organizer of the Belgian Scala User Group, BeScala. The topic is the recent release of Akka Projections 1.0, a new addition to the Akka toolkit that provides the next generation solution for CQRS and Event Sourcing in cloud native applications.

Lightbend Field CTO and Cloud Advocate, Sean Walsh, discusses the developments in Cloudstate, Lightbend’s open source tool for distributed state management for serverless workloads on Kubernetes. Read the full post at: https://www.lightbend.com/blog/lightbend-podcast-cloudstate-leveraging-distributed-state-for-serverless

This webinar's guest is Manuel Bernhardt, Akka expert, Reactive systems consultant, trainer, and author. We discuss what it looks like to scale Akka Cluster to 10,000 nodes using Rapid, a cluster membership methodology that can speed up cluster membership in some interesting ways.

In this Lightbend podcast, Akka expert Hugh McKee (Developer Advocate) is questioned by non-Akka expert Oliver White (Chief Storyteller) about some of the new features in the latest release of Akka 2.6.4. We talk about why distributed systems require thinking differently about how message delivery works compared to traditional monolithic systems, and how it all works with Akka to ensure reliable delivery of messages as massive scale across JVMs, nodes, clusters, and even data centers. For more information, visit http://akka.io/blog

In this Lightbend podcast, we sit down with Dr. Mark Lewis, professor of computer science at Trinity University in San Antonio, Texas, to discuss the benefits he sees of teaching Scala to introductory computer science students. For more information, see the Lightbend blog: https://www.lightbend.com/blog/teaching-scala

In this special roundtable conversation about all things Akka, we sit down with notable Akka experts Helena Edelson, Johan Andren, and Manuel Bernhardt, to discuss the recent release of Akka 2.6, which introduces the long-awaited Typed Actor API to overall toolkit. For the videocast version of this, and more Akka resources, see the Lightbend blog: https://www.lightbend.com/blog/akka-fireside-chat-on-new-akka-actors-in-akka-2.6

In this podcast, Jonas Bonér (CTO) and Viktor Klang (Deputy CTO) of Lightbend talk about CloudState, Lightbend's latest OSS project that provides application state handling in a world of stateless infrastructure. And as Kubernetes continues to dominate this area of cloud native container orchestration, this is just the right time for addressing one of the trickiest areas in distributed computing: managing state. Visit www.cloudstate.io for more information :-)

In this Lightbend Podcast, we sit down with Kitawa Wemo (Kiki), co-founder of Mama Ventures, a women-led growth accelerator company based in Nairobi, Kenya. We discuss the IT sector in Kenya and how industrial trends, Artificial Intelligence, and culture play a role in the technology start up space there. You can find out more about Kiki and Mama Ventures at http://www.mamaglobal.co.ke/

In this Lightbend podcast, we sit down with Wade Waldron, Microservices Practice Lead at Lightbend, to discuss a question that we hear frequently from Lightbend customers and the OSS community: should we use Play Framework, Lagom Framework, or Akka HTTP for our next application? While all of these tools feature parts of the overall Akka Toolkit under the hood, they are in fact specialized for specific use cases. Wade describes which Lightbend technology is best suited for particular requirements.

Lightbend CEO Mark Brewer discusses what joining the Eclipse Foundation as a founding member of the Jakarta EE Working Group means for bringing Reactive closer to the traditional Java enterprise landscape.

We were excited to connect with Middlegate’s Roshan Fernando (CEO) and Ed Stull (CTO) to learn more about their use of Akka as the backbone of their Grace platform, and how their new approach is taming key medical billing complexity issues that apply to every healthcare provider in the United States.

In this Lightbend podcast, we sit down with Marina Sigaeva, who recently presented a talk called “SBT: Baby Steps”, and Dale Wijnand of Lightbend to get the latest on sbt, discuss some of the history of this fascinating project, and see where things are heading in the future.

In this Lightbend podcast, we sit down with Renato Calvalcanti, Senior Engineer on the Lagom team and founder of the Belgium Scala User Group, who tells us about the latest release of Lagom 1.4, some history of Lagom since the 1.0 launch, as well as some ideas the team is working on for future releases.

In this Lightbend Fast Data Platform interview for Operations teams, Michael Nash and Oliver White of Lightbend discuss the value of resilient production tooling, and the benefits of one-stop shop support for various technologies integrated with Fast Data Platform. This conversation focuses on: • Why is it difficult to maintain always-on, dynamic workloads without resilient tooling, as well as managing multiple support contracts with various vendors? • What new challenges (and risks) are presented by the significantly more complex streaming, Fast Data ecosystem? • How Lightbend Fast Data Platform can set your mind at ease by providing one-stop shop for support that covers Akka Streams, Apache Spark, Apache Kafka, Apache Flink, Mesosphere DC/OS, Lightbend Reactive Platform and more. Learn more at: https://lightbend.com/fast-data

In this Lightbend Fast Data Platform interview for Operations teams, Alan Ngai and Oliver White of Lightbend discuss the implications of monitoring and troubleshooting distributed, streaming Fast Data applications. This conversation focuses on: •Why can’t existing application monitoring tools designed for monoliths easily trace and gather metrics from distributed Fast Data applications? • What are the main challenges and considerations for monitoring Fast Data applications? • How Lightbend Fast Data Platform intelligently provides deep telemetry, automated topology discover, configuration, and visualization, right out of the box for Spark, Kafka, Akka, Mesosphere DC/OS and more. Learn more at: https://lightbend.com/fast-data

In this Lightbend Fast Data Platform interview for software developers, Sean Walsh and Oliver White of Lightbend discuss developer tooling for deploying and tuning high-performance Fast Data applications. This conversation focuses on: • Why is it important to understand the differences between the monolithic systems we used to build and deploy compared to streaming, Fast Data systems? • What changes in the traditional developer role impact building, and also deploying, these applications early in the development process? • How Lightbend Fast Data Platform tackles these challenges for development teams by providing integrated, out-of-the-box features designed for deployment and production needs early in the SDLC. Learn more at: https://lightbend.com/fast-data

In this Lightbend Fast Data Platform interview for software developers, Kikia Carter and Oliver White of Lightbend discuss the challenges that development teams are experiencing in this new era of Fast Data applications. This conversation focuses on: • Why does the nature of distributed, Fast Data applications make it difficult for developers to get started with new projects? • What are some of this biggest challenges development teams have described to Lightbend with building these types of applications? • How Lightbend Fast Data Platform gets developers started off right with the easiest on-ramp possible, including an integrated platform of curated technologies, on-demand technical guidance, sample applications, and a world class support team. Learn more at: https://lightbend.com/fast-data

In this Lightbend Fast Data Platform interview for software architects, Duncan DeVore and Oliver White of Lightbend discuss why it’s important to design a Fast Data system architecture based around resilience, scalability, and how this affects future deployment strategies. This conversation focuses on: • Why does architecting for resilience–the ability to rapidly self-heal rather than trying to avoid failures–enable your systems to scale in a much safer way? • What architectural design considerations should be examined for production deployment of these systems? • How Lightbend Fast Data Platform ensures that enterprises can not only design resilient, self-healing, highly-scalable and resource efficient applications, but also be equipped for when it’s time to deploy to production. Learn more at: https://lightbend.com/fast-data

In this Lightbend Fast Data Platform interview for software architects, Dean Wampler, PhD., and Oliver White of Lightbend discuss what’s going on in the rapidly evolving world of streaming engines. This conversation focuses on: • Why is the streaming and Fast Data ecosystem especially challenging to embrace? • Which best-of-breed streaming engines has Lightbend learned and analyzed deeply for inclusion in Fast Data Platform? • How Lightbend’s technical and domain expertise provides enterprises with an easy on-ramp to designing, building and running Fast Data applications. Learn more at: https://lightbend.com/fast-data

In this Lightbend Fast Data Platform interview for business leaders, Craig Blitz and Oliver White of Lightbend discuss the emergence of Fast Data as a competitive differentiator, and how this rapidly evolving ecosystem affects software design, development, and deployment. This conversation focuses on: • Why should we care about streaming architectures and Fast Data applications? • What do architects, developers and operations teams need to know about designing, building, and running these apps? • How Lightbend provides organizations with an easy on-ramp to get started in the right direction the first time around. Learn more at: https://lightbend.com/fast-data

In this Lightbend podcast, we sit down with special guest Jan Machacek, CTO of Cake Solutions, conference speaker, and author of the upcoming O'Reilly book, “Reactive Systems Architecture: Designing And Implementing An Entire Distributed System.” Jan tells us a bit about his book, which focuses on technologies and initiatives like Akka, Scala, Reactive Streams (coming to JDK 9), as well as some of his opinions on why Reactive is the best way for enterprises to keep up with changing business demands.

About six months ago, I started to see some really great blog posts come from a person named Colin Breck, who I’ve since had the pleasure of getting to know better. Colin is an experienced Akka developer who recently spoke at QCon London about using Quality Views to combat technical debt, and followed up with a podcast with InfoQ: https://www.infoq.com/podcasts/tesla-colin-breck Colin has spent a lot of time writing on http://blog.colinbreck.com to help developers understand the different modules in the overall Akka toolkit, with a special focus on how to use Akka Actors and Akka Streams in conjunction for the greatest benefit. So I wanted to invite Colin to this Lightbend Podcast to go into more detail on this particular aspect of building resilient, distributed, back-pressured streaming applications with Akka. Enjoy!

With major enterprises such as LinkedIn, Verizon, Samsung, Weight Watchers and Norwegian Cruise Lines using Play Framework in production, we felt it would be interesting to invite Will back to our podcast program so that he could describe, at a deep technical level, what exactly makes Play Framework one of the fastest JVM web frameworks on the market.

In this short interview with Jonas Bonér, CTO and Co-founder of Lightbend, and Viktor Klang, Deputy CTO of Lightbend, we demystify the confusion around the term "Reactive", drawing from their recent O'Reilly Radar article and subsequent expanded white paper. Go here for more: https://www.lightbend.com/blog/white-paper-understanding-reactive-programming-vs-reactive-systems

In the final webinar with live Q/A in the Reactive Revealed series, we explore the way that Reactive systems maintain resiliency with an infrastructural approach designed to welcome failure often and recover gracefully.

In the second of three webinars with live Q/A, we look into how organizations with Reactive systems are able to adaptively scale in an elastic, infrastructure-efficient way, and the role that location transparency plays in distributed Reactive systems.

In this first of three podcasts with live Q/A, we explore the underlying technologies and approach of Reactive systems. Akka Team member and Reactive Streams contributor Konrad Malawski will detail what you should know about: The differences and trade-offs between synchronous blocking I/O and asynchronous non-blocking I/O, what these mean for execution efficiency as well as code maintainability. The difference between event-driven and message-driven approaches in terms of design considerations in the small and the large as well as the costs and benefits of either way. The role of flow control in Reactive systems, how it impacts service latency and throughput and which technologies are available to help with implementing it.

Jamie Allen, Sr. Director of Global Services at Typesafe, walks you through how Typesafe technologies are Reactive.

Keynote at Scala Days San Francisco 2015 by Martin Odersky, Chief Architect and Co-Founder at Typesafe.

Akka for Java Devs: Bridging the Imagination Divide Today's applications are expected to support a multitude of devices, employ hybrid cloud deployments, persist petabytes of data, deliver millisecond response time and have near-perfect reliability. Traditional patterns and practices for enterprise Java application development simply can't support these demands, or are so complicated that entire systems can be brought down by single points of failure. Developers need new tools to help bridge existing infrastructure with changing models. For many, trying to operate in these distributed environments is simply unimaginable. Which is why Akka, a toolkit and runtime for building highly concurrent, distributed, and fault tolerant systems, has been a game changer for Java devs. Akka decouples business logic from low-level mechanisms such as threads, locks and non-blocking I/O, and liberates devs from the hariest challenges of managing the state and location of services. In this podcast with Duncan DeVore, Akka Expert and Trainer at Typesafe, we will walk you through: Why do I need to think “distributed” now? What is Akka and what is it used for How can you leverage Akka as a Java developer

Last month, we ran a survey to assess the Apache Spark ecosystem trends and adoption. More than 2,000 respondents shared their thoughts, resulting in some interesting findings in areas such as: Key problems developers are trying to solve using Spark The top barriers to Spark adoption What role Spark plays in enterprise Big Data strategy In this webinar resident Big Data expert, Dean Wampler, will present the surveys findings and discuss why JVM devs should care even a little about Big Data tooling in 2015.

One important addition to Typesafe’s Reactive Platform is the new Akka HTTP module, the successor of spray.io. It provides a fast and fully-featured client- and server-side HTTP stack, which allows you to easily build high-performance REST/HTTP-based integration layers for connecting your Scala applications to the world. Join us for a session with spray’s original author and current akka-http lead Mathias Doenitz. Mathias will be sharing and discussing what improvements akka-http brings over spray, how it is used, when and how you can upgrade as well as the general roadmap.

Are you ready to move your application from prototype into production? From architecture and security concerns to operational hurdles, the complexity of an enterprise-scale production deployment can increase rapidly. In this session you will learn where to find potential blockers for deployment success, in areas such as · Architecture and code quality · Performance testing methodology · Production monitoring and "SWAT" team strategy · Deployment strategy · Security Join us for a podcast with Jamie Allen, Director of Global Services, to learn more about how you can ensure a successful production deployment of your app

Gilt, the global online shopping destination, has built a micro-service architecture using the Typesafe platform. Gilt uses Play to build beautiful customer-facing pages and intuitive back-office UIs. The Akka framework facilitates scaling our customer email, push notifications, and order aggregation systems. Michael will talk about how Gilt uses Akka to scale it's push notification infrastructure.

Last year, Nurun and Walmart Canada launched the first responsively designed enterprise e-commerce website created for a large Canadian retailer. Built on a new platform with the Play Framework, Scala and Akka at its core, this foundation has proven itself in terms of flexibility, developer productivity, performance and scalability. We’ll share some of the insights we’ve gained in creating a best of breed solution that scales to Walmart’s needs—now and into the future.

For retail, there has never been a time when so much change is occurring: Multiple devices, data and communication in the hands of every associate High demand for real-time connectivity between all stores in the cloud Customer-facing devices, customers at home, customers in progress all of the time All this goes way beyond traditional point-of-sale and back-office apps. And it’s this state of change that led Tomax, a retail solutions company, to look at a different architecture and framework for building the next generation of retail software. In this podcast, Scott Lewis will explore how a Reactive model helps retailers tackle issues like concurrency and real-time data flow, while creating beautiful, highly responsive user experiences for customers.

In this podcast, we'll cover the basics of dependency management in Activator, including tools, tips and tricks to find the libraries you need, and to deal with library incompatibility issues. Additionally we'll cover the best practices of setting and picking dependencies for your build. Visit www.typesafe.com/resources to view the video.

sbt has been the subject of quite a bit of controversy among Scala developers. It's different enough from other build tools that not everyone has the patience of really getting into it. As a natural consequence, they tend to either go back to the build tools they know or employ sbt in a way that is similar to what they are used to and doesn't require them to fully understand it. While it is possible to build your projects with only a minimal comprehension of sbt, there is a lot to gain from really understanding how it works. If you are one of the people who have never gone a lot further than "sbt test", this talk is for you. You will learn how it can make your daily Scala development workflow more productive. We'll dive into the concepts behind sbt and see how we can embrace its interactive shell, how to customise our build to our needs, and what the sbt ecosystem of plugins has to offer to improve our development workflow. This talk will involve a lot of live sbt interaction, and also some coding. At the end of the talk, we will have seen not only what sbt and the existing ecosystem has to offer, but also built our own little sbt plugin.

Macros are a powerful feature of Scala 2.10 that have received significant updates in Scala 2.11. For the journeyman Scala programmer, however, they can be difficult to approach. There is a scarcity of detailed documentation on important concepts such as AST creation, type inspection, and debugging, that can make your first non-trivial macro a daunting prospect. In this talk, Dave Gurnell will approach Scala 2.11's macros from the point of view of the journeyman programmer. He will walk through the creation of a simple macro-based library for data validation, highlighting hints, tips, and best practices that will dramatically lower the barrier to entry into the world of macros. Topics covered will include: project setup and separate compilation AST creation quasiquotes type inspection macro debugging Dave is a Scala consultant and developer working for Underscore in London, UK. He has been a Scala developer since 2010 and a functional programmer for nearly a decade.

Most modern 3D game engines are written close to the metal in C++ to achieve smooth performance and stunning. Managed languages and runtimes are usually avoided for this task since they incur garbage collection lags and other performance penalties. We decided to put this conventional wisdom to test with an experiment - we used an Rx-style reactive programming framework enriched with reactive collections and isolates in unison with a high-level OpenGL framework to build a modern 3D engine. Game engines are traditionally written in low-level imperative style to achieve optimal performance. Such code can be hard to understand and maintain - the uprising reactive programming is much more natural for writing games, since game engines are in essence discrete event simulations. However, reactive programming comes with performance penalties that we overcome using Scala Specialization, inlining and efficient reactive data containers. Similarly, the OpenGL API exposes a plethora of low-level routines unfit for large scale development - a more structured approach to graphics programming with higher level programming abstractions is desired, but yields a higher performance cost. Through the use of Scala Macros we eliminate these inefficiencies while in the same time retaining the advantages of a structured graphics programming framework. Result? A high-throughput reactive 3D real-time game engine achieving smooth 60FPS on modern hardware with high polygon counts, texture blending, GPU-based object instancing, and effects like ambient occlusion, shadow mapping and image filtering. No need to spread Fear, Uncertainty and Doubt about performance anymore - Scala is ready for modern real-time game engines, delivering great performance with the convenience of the modern managed language. To view the video visit www.parleys.com.

Scala provides a lot of power for the application developer. Even more the library author. This talk will walk through various tricks/techniques that can be used to expose a well-designed API for your users. We focus on three areas: Exposing design through types Designing for binary compatibility Remaining versatile in the runtime To view the video visit www.parleys.com.

Monads are the talk of the town right now, everyone is saying something about them and much of it makes little sense, especially when you try and combine the messages from all of the sources. This talk will take a different tack. We will have a quick definition of a few terms and concepts, but that will be quick and to the point. Instead I will concentrate on the mechanics of Monads, why you would want to use them at all, how you can use them to solve real problems in different situations, and what we can ask for from our languages and tools to make them even more useful and easy to adopt. Along the way we will look at many examples in Java 8, and how syntactic constructs ease their use in languages like Scala and Haskell.