Lightbend: Recent Episodes
Lightbend
Lightbend (@Lightbend) is leading the enterprise transformation toward real-time, cloud-native applications. Lightbend Platform provides scalable, high-performance microservices frameworks and streaming engines for building data-centric systems that are optimized to run on cloud-native infrastructure. The most admired brands around the globe are transforming their businesses with Lightbend, engaging billions of users every day through software that is changing the world. For more information, visit www.lightbend.com.
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.
In the final episode of the "Deep Dive in to the Typesafe Reactive Platform" series, Nilanjan Raychaudhuri will walk you through building Reactive apps with Akka and Scala. He will expand on both projects and outline how they support the Typesafe Platform.
Beginning with Akka, an asynchronous event-driven runtime implemented in Scala, Nilanjan will demonstrate how the project enables the development of high performance and reliable distributed applications. He'll walk us through how Akka decouples business logic from low-level mechanisms and how, with Akka, you can easily configure how Actors will be created, destroyed, scheduled, and how to deal with failures.
You can get started building Reactive Akka applications using Java APIs. Nilanjan will cover how, when you're ready, the Scala programming language makes building Reactive applications on the JVM less complicated and elegant. Because Scala integrates both functional and object-oriented paradigms and retains full interoperability with your existing Java libraries and infrastructure, you can take advantage of multicore hardware. Consequently, it’s an excellent programming model for Reactive.
Typesafe Activator gets you started with the Typesafe Reactive Platform, Play Framework, Akka and Scala. In this deep dive presentation, we'll walk through the rich developer content in Typesafe Activator, and learn how to get started building reactive apps with Play.
The Play Framework is a modern alternative to legacy Enterprise Java stacks. It focuses on developer productivity, modern web and mobile applications, and predictable, minimal resource consumption (CPU, memory, threads) resulting in highly performant, highly scalable applications.
Reactive development is fueling a new wave of business applications; these apps are event-driven, scalable, resilient and responsive by nature. To help developers build Reactive applications on the JVM, Typesafe has brought together the Play web framework, a runtime called Akka, and the Scala language under a unified platform. The platform is distributed through Typesafe Activator, a tool that includes easy-to-use templates and tutorials designed to accelerate adoption and skill acquisition.
The world operates in real time. Anything else is an illusion. Events happen all around us, that is why they are "events”. The days when we can look at synchronous method calls as the only interaction model have been dead for a while. We just never wanted to fully admit it. Well, it’s beyond time to embrace asynchrony. We’ve been doing it all along anyway with protocols and networking! Let’s (re)learn all the lessons from those guys! How did protocols evolve from request/reply, such as HTTP, to more asynchronous protocols, such as WebSocket? What are best practices (and things to avoid) for making applications asynchronous and event driven? How do architectures change when asynchrony is the new normal? What is this loose coupling and why is it good?
About the speaker
Todd L. Montgomery - Chief Architect for Kaazing
Todd is a networking hacker who has researched, designed, and built numerous protocols, messaging-oriented middleware systems, and real-time data systems, done research for NASA, contributed to the IETF and IEEE, and co-founded two startups.
He currently works for Kaazing as Chief Architect.
Timing is everything. If a system does not respond in a timely manner then: at best, its value is greatly diminished; and at worst, it is effectively unavailable. Reactive systems need to meet predictable response time guarantees regardless of load or datasets size, even in the presence of burst traffic and partial failure conditions.
In this talk we will explore what is means to be responsive and the fundamental design patterns required to meet predictable response time guarantees. Queueing theory, Little's Law, Amdahl's Law, Universal Scalability Law - we'll cover the good bits. Then we'll explore algorithms that work with these laws to deliver timely responses from our applications no matter what gets thrown at them.
Martin Thompson - High-performance and low-latency specialist
Martin is a high-performance and low-latency specialist, with experience gained over two decades working on the bleeding edge of large transactional and big-data systems. He believes in Mechanical Sympathy, i.e. applying an understanding of the hardware to the creation of software as being fundamental to delivering elegant high-performance solutions. The Disruptor framework is just one example of what his mechanical sympathy has created.
Martin was the co-founder and CTO of LMAX. He blogs at mechanical-sympathy.blogspot.com, and can be found giving training courses on performance and concurrency when he is not cutting code to make systems better.
Reactive applications need to be able to respond to demand, be elastic and ready to scale up, down, in and out—taking full advantage of mobile, multi-core and cloud computing architectures—in real time.
In this talk we will discuss the guiding principles making this possible through the use of share-nothing and non-blocking designs, applied all the way down the stack. We will learn how to deliver systems that provide reactive supply to changing demand.
Jonas Bonér - CTO and co-founder of Typesafe
Jonas Bonér the co-founder and CTO of Typesafe and the inventor of the Akka project. Learn more at: jonasboner.com
Jonas Boner asked me to write an abstract for this talk. We were talking about some of the things I'd learned while building resilient systems. I mentioned a few simple things I knew - he said "Tell them these things, stories from real-life experience are always fun"
I sat on the underground, with my notepad out and started scribbling. The planned title of the talk was 7 things I'd learned about programming. But by the time I got to Kista I had a list of 32 things.
By the time I've written the talk it might be more than 32.
So I'll talk about the K things that I've learned where K >= 32
About the speaker
This person is speaking at this event.
Joe Armstrong - Principal Inventor of Erlang
Joe Armstrong is one of the inventors of Erlang.
When at the Ericsson computer science lab in 1986, he was part of the team who designed and implemented the first version of Erlang. He has written several Erlang books including Programming Erlang Software for a Concurrent World. Joe held the first ever Erlang course and has taught Erlang to hundreds of programmers and held many lectures and keynotes describing the technology.
Joe has a PhD in computer science from the Royal Institute of Technology in Stockholm, Sweden and is an expert in the construction of fault tolerant systems. Joe was the chief software architect of the project which produced the Erlang OTP system.
He has worked as an entrepreneur in one of the first Erlang startups (Bluetail) and has worked for 30 years in industry and research.
What does it mean to be Reactive? The history of reactive programming and why it is not just functional.
React brings together a small but highly influential group of developers to explore and discuss the fundamental principles of the Reactive Manifesto and why they are important for the new generation of systems being developed. There is no call for papers - instead React invited some of the best speakers and thinkers from the industry to share their wisdom about specific traits of the manifesto. So instead of some random selection of loosely connected talks, React presented a coherent journey through the reactive programming stack, trait by trait, UI to database.
Martin Thompson, High-Performance & Low-Latency Computing Specialist and Jonas Bonér, Co-founder & CTO Typesafe presented the React 2014 conference introduction.
This session proposal will focus on the tenets and tools for building a reactive application, as well as simple real world examples.
Duncan DeVore has been hooked on Scala since 2008. He's a strong advocate for Event based reactive architectures.
View the video at www.parleys.com.
Build reactive applications - get started at www.typesafe.com/activator.
Monads are the talk of the town, and everyone's doing them. In the virtual monad gold-rush, however, have we lost sight of some of the other useful tips, tricks and patterns that have got us to where we are. In this session I will examine a number of useful code snippets and ideas that I have used successfully on many projects, sometimes alongside monads, to great effect. There may be some useful corner cases you have overlooked, or perhaps just would like a refresher in some of the things you may have discovered but then forgotten.
This talk is suitable for Scala beginners but (I hope) will be of use to more experienced Scala developers as well, even if only as a gentle reminder about some of the tricks used, or perhaps in the effective combinations of some of them that have proven useful over time.
To view the video visit www.parleys.com.
To get started building Reactive Apps visit www. typesafe.com/activator.
Scala has come a long way since the summer of '04, when Miles and Jon first ran scalac. This year celebrates the ten-year anniversary of Scala's first public release, and to celebrate the occasion, we will relive some of the highlights of the last decade, taking an archaeological rummage through mailing list archives, commit messages, bug reports and some old-fashioned Scala code, semicolons and all!
In this lighthearted trip into Scala's past, we look at everything that's changed about the language since 2004, and with help from some special guests, will attempt to fight the bitrot with a vintage live-coding session on Scala version 1.3! Jon has been developing Scala for the last decade, and has deployed Scala into startups, large corporations, government and open source. He is best known these days for his Rapture IO and JSON libraries. Despite popular belief, Jon did not invent the Cake Pattern.
Miles has been doing stuff with Scala for the last 10 years, most recently with _.underscore and Precog. Rumours that his generic programming library shapeless is an elaborate ploy to try and get people to forget that he ever had anything to do with the Scala IDE for Eclipse are entirely
To view the video visit www.parleys.com.
Build reactive apps - get started www.typesafe.com/activator.
As a typical representative of highly abstract Scala libraries, standard collection library faces a number of performance challenges that arise when genericity and high-order code meet the JVM. In particular, commonly used standard Scala collections operations such as 'reduce', 'map', 'filter' suffer huge slowdowns in comparison with equivalent Java code because of abundant boxing and HotSpot-unfriendly code patterns.
One of the standard approaches to performance-critical design in Scala is eschewing high-level abstractions and churning low-level code with predictable performance characteristics. However, the advent of macros in Scala 2.10 enables a better opportunity that we've seized in ScalaBlitz, a library of highly optimized collection operations. The best thing about this approach is that you don't need to rewrite your code to get advantages.
In ScalaBlitz, we have written a macro that inlines and specializes operations on Scala collections, turning high-level abstractions into fine-tuned, performant code. This decreases memory pressure and provides speedups(ie up to 30x for Range.reduce) all that while retaining the conventional, compatible interface of standard collections.
In this talk we will identify the most common pitfalls that prevent vanilla collections from being fast and explain how we dealt with them. We will show how using ScalaBlitz can help you achieve better performance, while continuing to write code against the familiar interface.
Dmytro Petrashko is a programming languages and algorithms researcher and a doctoral assistant at EPFL. He is currently working on a doctorate as a research assistant in the School of Computer and Communication Sciences at the EPFL in Switzerland, in the LAMP laboratory on Scala development under the supervision of Dr. Martin Odersky. Prior to that, he received his Bachelor degree at the Moscow Institute of Physics and Technology. His research interests include parallel and concurrent data structures, I/O efficient algorithms as well as design and implementation of frameworks, languages and tools for data-intensive software development.
To view the video visit www.parleys.com.
Build Reactive Apps - Get started at www.typesafe.com/activator.
Tests provide benefits, but also incur costs. Tests can help you achieve and maintain desired levels of software quality, but they take time (and therefore cost money) to write, compile, and run. They can give you confidence to perform needed refactoring, but can slow you down during refactors that break many tests. And although they can help you find bugs, they can't prove the absence of bugs.
So how do you maximize the return on your investment in tests? In this talk, Bill Venners, lead developer of ScalaTest, will tackle this question and give his opinions. You'll come away with a set of specific guidelines that can help you decide how best to employ testing in your projects.
Bill Venners is president of Artima Software, Inc. and editor-in- chief of Artima Developer. He is author of the book, Inside the Java Virtual Machine, a programmer-oriented survey of the Java platforms architecture and internals. His popular columns in JavaWorld magazine covered Java internals, object-oriented design, and Jini. Bill has been active in the Jini Community since its inception. He led the Jini Community ServiceUI project, whose ServiceUI API became the de facto standard way to associate user interfaces to Jini services
JScala is a Scala macro that produces JavaScript from Scala code. I'll present JScala features, including client-server code sharing via @Javascript annotation, macro-based TypeScript definitions import via @Typescripted annotation, automatic macro-based toJson/fromJson serialization and browser Tetris example.
Additionally, I'll talk about further plans, Lift/Play integration and popular JavaScript libraries (jQuery, Angular.js)support.
Alexander Nemish is a software engineer, Scala enthusiast, musician, skydiver and a bit more.
To view the video visit www.parleys.com.
Build Reactive Apps - get started at www.typesafe.com/activator.
About Introduction to Reactive: A Hands-on Workshop with Play and Akka Modern web applications that are always connected require a new kind of architecture to handle real-time streaming of data. They require a reactive architecture that is event-drive and resilient to failures. But how hard are these applications to actually build? In this hands-on workshop we will learn just how easy it can be to build a reactive application using Play and Akka. The application will use Play to asynchronously read from a web service and stream it to the client using websockets and JSON. In building this sample you will learn the basics of how a Play application is structured and how it integrates with Akka for building reactive applications. Get started with Typesafe Activator - http://typesafe.com/platform/getstarted.
Most people agree that you become more productive by using IntelliJ IDEA for Scala. However it's not always clear how much more. In this talk we'll take a look at the key features of IntelliJ IDEA and reveal some of its usage statistics. And of course we'll get a report on what's going on with the IntelliJ IDEA plugin for Scala: what have been recently done and what's is coming in the future.
To view the video visit www.parleys.com.
Build Reactive Apps - get started at www.typesafe.com/activator.
Jan will show how the Reactive Monitor helped a major financial services organisation to provide monitoring of their Akka system. The talk will explore the challenges of monitoring mission-critical systems, especially under heavy load. Jan will show the implementation details of the Reactive Monitor, pointing out the benefits of the Akka IO layer to implement non-blocking and resilient transport layer. The talk will close by going back to the large-scale system and show how we used the information from the monitoring to tune the Akka system.
You will not need any extensive Scala or Akka experience to understand the core principles, though a good appreciation of the challenges of mission-critical systems will help you understand the scale of the problem; knowledge of Akka, Scala and AspectJ will help you understand the details of the code.
Jan Machacek graduated in Computer Science from the University of Hradec Kralove, Czech Republic and joined UK-based Cake Solutions in September 2002. Prior to this, Jan worked as a network administrator and programmer in Prague and has much experience in Internet and installation technologies.Jan's role as Lead Developer at Cake Solutions sees him at the centre of all implementation-level details in all projects. In particular, Jan is often called upon to work on some of the most complex and challenging aspects of a system. Since joining Cake, Jan has proven his expertise in both Java and Microsoft .NET not only by taking on a wide variety of highly complex projects but also through his collection of published works covering both topics.Jan co-authored the bestselling book Pro Spring with Rob Harrop in 2005.
To view the video visit www.parleys.com.
Build reactive apps - get started http://www.typesafe.com/activator.
n this presentation Matthias will be talking about how he came to writing reactive applications for fun. He started doing so in March 2013 and has since written the two reactive applications BirdWatch and sse-chat and multiple blog posts explaining these applications in detail. In this talk he will be discussing the underlying architecture he has discovered for building reactive applications using Scala and Play Framework.
Matthias Nehlsen is a technology enthusiast and freelance software engineer from Hamburg, Germany. He had been working in IT operations and project management for a number of years before discovering his passion for writing software. Not too long ago he started writing reactive applications for fun and for his blog.
To view the video see www.parleys.com.
Build Reactive Apps - Get started http://www.typesafe.com/activator.
Hadoop and all it's ecosystem have settled down for good (or bad) in our hearts and / or minds. It's quite old and has proven to be quite reliable for certain kinds of tasks. Yet one problem still remains - writing Map Reduce jobs in plain Java is really a pain. The API is clunky and does it's best to hide the actual algorithm beneath tons of boilerplate.
Luckily there are abstractions on top of it - like the great Cascading library, and the even better Scalding DSL built on top of it.
During this talk we'll execute what looks like a Scala map() but using a few dozen worker nodes, and then explore some of the more advanced features of Scalding - like joins, aggregation tricks and tips on how to build not only Jobs, but entire MapReduce Pipelines.
Konrad is a late-night passionate dev living by the motto "Life is Study!". His favourite discussion topics range from distributed systems and type systems to capybaras. In those rare times he's not coding, he spreads the joy of computer science, through helping local user groups and whitepaper reading clubs.
To view the video visit www.parleys.com.
To get started building reactive applications visit http://www.typesafe.com/activator.
Scala 2.10 was the first language release that provided a public native API for metaprogramming Scala, introducing facilities for compile-time (macros) and runtime (Java-like reflection) metaprogramming. These facilities have brought a lot of feedback, and we've been thinking hard how to make sense of it.
At this point it is clear that dedicated support for metaprogramming is useful. Previously, one had to deal with ad-hoc solutions like textual code generation and command-line scalap invocations. However, now there is a full-fledged model of Scala that accounts for the variety of language constructs and includes a comprehensive, backward-compatible API. However, there's still quite some work to be done in order to make our metaprogramming tools enjoyable. The main issues that remain to be addressed are verbosity and brittleness of the underlying API, difficulties with tool integration, tight coupling with scalac, and potential for confusion caused by leaking implementation details and cryptic error messages.
The goal of Project Palladium is to make metaprogramming easy, ensuring that it doesn't require knowledge of compiler internals, is safe by construction and is portable across a wide range of implementors. Towards that end, we have rethought the metaprogramming APIs along with the accompanying macro engine, keeping existing functionality in place and at the same time fixing fundamental problems intrinsic to the original implementation.
In this talk we will present our progress, showing how easy it is to metaprogram with Palladium, and will outline the place of our developments in the future of Scala.
To view the video visit www.parleys.com.
Build Reactive Apps - get started http://www.typesafe.com/activator.
The power of Scala keeps showing up in expected--and unexpected--places. In this talk, I will share how I used Scala in bioinformatics, neuroscience, online games, mobile applications, and desktop applications.
In bioinformatics, the beauty of Scala really shines. Thanks to the abstraction in the Scala collection framework, creating collection types for DNA, RNA, and Protein Chains is super easy. With the proper collections at my disposal, I was able to implement algorithms such as Sequence Alignment, Genome Assembly, and Gibbs Sampling by focusing on the core ideas of the algorithm and not on the nitty-gritty details. On the top of it, Scala makes dynamic programming, which is fundamental in many bioinformatics algorithms, easy to implement and understand.
Last year, I talked about using brainwaves to play games. Since then, I have taken things up a notch and started working to solve more practical problems such as maintaining attention while performing tasks (something that my age group suffers from a lot). This exposed me to a whole new and exciting world of Digital Signal Processing. This project benefited a lot from Reactive programming techniques in cleaning my code and making it more reliable.
Not to be outdone by the serious work of algorithms, I took the desktop version of Collidium and converted it to an online HTML5 Game using Scala.js. I have also improved my Android game, Wordsteal. I even used Scala with Swing to save a few bucks for our budget-starved Student Store by creating a simple cash register application.
In this talk, I will share many interesting techniques I learned and convey why I continue to be a huge fan of Scala. See you there!
Shadaj is a 13 year old, who loves to program. He has programmed in Logo, NXT Mindstorm, Ruby, Python, and C. However, he loves programming in Scala. Besides programming, he likes Math and Science. When he grows up, he wants to be a robotic scientist. Shadaj hosts his projects on GitHub, and has a channel on Youtube. He has presented at Scala Days 2012 and the Bay Area Scala Enthusiast group showing his Scala projects. When not doing his school work or programming, he plays guitar, sitar, and games, some of which he created.
To view the video visit www.parleys.com.
To get started building reactive apps visit: http://www.typesafe.com/activator.
Scala Puzzlers returns with a twist: not only will we be presenting a brand new set of puzzlers for Scala 2.11 that will challenge you with unexpected and unintuitive behavior and help you learn something about your favorite language in the process.
This time, we've added a key set of tips and recommendations to help you avoid these pitfalls when real deadlines are at stake. That's not the time for head-scratching - better to laugh and learn at ScalaDays 2014!
Andrew is VP of Products for XebiaLabs, providers of the industry-leading release automation solution, Deployit. Andrew is a cloud, service delivery and automation expert and has been part of the shift to more automated application delivery platforms.
In his spare time as a developer, he worked on Multiverse, the open-source STM implementation, contributes to Apache jclouds, the leading cloud library and co-maintains the Scala Puzzlers site.
To view the video visit www.parleys.com.
Build Reactive Apps. Get started at http://www.typesafe.com/activator.
Scala's effectiveness in rapid-prototyping is only one of the properties that make it a fantastic tool for eviscerating Git's guts. Taking advantage of the others allowed The BFG (an alternative to git-filter-branch, written in Scala) to outperform the native ‘git-filter-branch' command by a factor of 50x or more - turning an overnight job into one that takes less than 5 minutes.
This talk will share experiences from building The BFG (successfully prototyped in a single high-stakes journey on the London Underground), highlight properties of Scala that made it possible, and explain the reformed-alcoholic pattern of user behavior.
oberto Tyley is the author of Agit (the Git client for Android devices) and The BFG Repo-Cleaner (a faster, simpler alternative to git-filter-branch), a software developer at The Guardian, and contributor to various open-source projects. He's worked at GitHub, 'invented' animated diffs, and loves explaining things.
Videos available on www.parleys.com.
Build Reactive Apps. Get started at http://www.typesafe.com/activator.
Functional programming (FP) is regularly touted as the way forward for bringing parallel, concurrent, and distributed programming to the mainstream. The popularity of the rationale behind this viewpoint (immutable data transformed by function application) has even lead to a number of object-oriented (OO) programming languages adopting functional features such as lambdas (functions) and thereby function closures. However, despite this established viewpoint of FP as an enabler, reliably distributing function closures over a network, or using them in concurrent environments nonetheless remains a challenge across FP and OO languages.
This talk presents an approach for more principled distributed and concurrent programming by introducing a new closure-like abstraction and type system, called spores, that can guarantee closures to be serializable, thread-safe, or even have general, custom user-defined properties. Crucially, our system is based on the principle of encoding type information corresponding to captured variables in the type of a spore. We'll see the power of the guarantees that this safe foundation for migratable closures facilitates through a case analysis touching upon several real-world frameworks such as Akka and Spark.
To view the video visit www.parlays.com.
In this presentation you will learn how to leverage the features introduced in Akka Persistence: opt-in at-least-once delivery semantics between actors and the ability to recover application state after a crash. Both are implemented by storing immutable facts in a persisted append-only log. We will show you how to create persistent actors using command and event sourcing, replicate events with reliable communication, scale out and improve resilience with clustering. All examples will be available as an Activator template allowing you to get started right away.
Get started building reactive applications with Typesafe Activator. http://www.typesafe.com/activator
To view the video visit www.parleys.com.
Apache Spark has emerged as the next-generation platform for writing Big Data applications. The combination of Spark and the Typesafe Reactive Platform, including Scala, Akka, Play, and Slick, gives Enterprise developers a comprehensive suite of tools for building Certified on Spark applications with minimal effort.
Dean Wampler, Ph.D. is a Consultant for Typesafe, where he specializes in helping clients succeed with Scala and Functional Programming projects. He works with "Big Data" tools like Hadoop, Spark, and Machine Learning libraries, and Reactive tools like Akka and Play. Dean is an author and a frequent conference speaker and organizer. He has a Ph.D. in Physics from the University of Washington.
The DOT (Dependent Object Types) calculus attempts to ground Scala's type system in fewer, but powerful, constructs. In this talk Nada will describe what these constructs are, and how they relate to Scala's current type system. She will also show how DOT simplifies type inference. Finally, Nada will touch upon the challenges in the meta-theory.
To view the video visit www.parleys.com.
As software developers, we learn to abhor maintaining other people's old software. It's old, funky and brittle. In fact, we spend much of our work lives trying to kill it or at the very least marginalize its use, so we can limit our exposure to it. We pity people who have to do it.
This is what we call "legacy software".
But the word "legacy" gets a bad rap. In most other contexts, it has a positive meaning.
Maybe we're just bitter. The average life span of a software system is hardly long enough to even use the word "legacy" to describe it.
How can we turn this word around? How can we leave an actual legacy of our work as software developers?
For the video visit www.parleys.com.
Erik Meijer is a Dutch computer scientist and entrepreneur. From 2000 to early 2013 he was a software architect for Microsoft where he headed the Cloud Programmability Team. He then founded Applied Duality Inc. in 2013. Before that, he was an associate professor at Utrecht University. He received his Ph.D from Nijmegen University in 1992.
The video is available on www.parleys.com.
Most of us have an experience of functional programming that is isolated to small libraries or specific immutable data structures. But can we design our entire application architecture in a purely functional way? Can we do "aspect-oriented" programming with cross-cutting concerns that are compositional and checked by the type system? Yes we can, and in this talk we will look at a conceptually simple recipe for making that happen. We will see that the best things in Scala are Free.
Video Available on www.parleys.com.
The new akka-http module, the successor of spray.io, provides a fast and fully-featured client- and server-side HTTP stack. It allows you to easily build REST/HTTP-based integration layers for connecting your Scala applications to the world.
In this session we'll look into what akka-http brings to the table, how it is used and where it will add the most value in your overall application architecture.
Plenty of code examples will highlight the various client- and server-side APIs as well as give you an idea for what "RESTful" programming with akka-http looks like.
We'll also talk about the improvements it brings over spray and what is on the agenda regarding the transition from Netty to akka-http as the HTTP "driver" for the Play framework.
Video Available on www.parleys.com.
Shark is a SQL engine built on Apache Hive, that replaces Hive's MapReduce execution engine with Apache Spark. Spark's fine-grained resource model and efficient execution engine allow Shark to outperform Hive by over 100x for data stored in memory. However, until now, Shark's performance has been limited by the flexibility of Hive's query optimizer. Catalyst aims to remedy this situation by building a simple yet powerful optimization framework using Scala language features.
Query optimization can greatly improve both the productivity of developers and the performance of the queries that they write. A good query optimizer is capable of automatically rewriting relational queries to execute more efficiently, using techniques such as filtering data early, utilizing available indexes, and even ensuring different data sources are joined in the most efficient order. By performing these transformations, the optimizer not only improves the execution times of relational queries, but also frees the developer to focus on the semantics of their application instead of its performance.
Unfortunately, building an optimizer is an incredibly complex engineering task and thus many open source systems perform only very simple optimizations. Past research [1,2] has attempted to combat this complexity by providing frameworks that allow the creators of optimizers to write possible optimizations as a set of declarative rules. However, the use of such frameworks has required the creation and maintenance of special “optimizer compilers” and forced the burden of learning a complex domain specific language upon those wishing to add features to the optimizer.
Catalyst solves this problem by leveraging Scala's powerful pattern matching and runtime reflection. This framework allows developers to concisely specify complex optimizations, such as pushing filters past joins functionally. Increased conciseness allows our developers both to create new optimizations faster and more easily reason about the correctness of the optimization.
Catalyst also uses the new reflection capabilities in Scala 2.10 to generate custom classes at runtime for storing intermediate results and evaluating complex relational expressions. Doing so allows us to avoid boxing of primitive values and has been shown to improve performance by orders of magnitude in some cases.
[1] Graefe, G. The Cascades Framework for Query Optimization. In Data Engineering Bulletin. Sept. 1995. [2] Goetz Graefe , David J. DeWitt, The EXODUS optimizer generator, Proceedings of the 1987 ACM SIGMOD international conference on Management of data, p.160-172, May 27-29, 1987, San Francisco, California, United States
Video Available on www.parleys.com.
Users of Big (and not so Big) Data roughly divide into three groups, developers like us, traditional data analysts, and a hybrid called data scientists. The analysis prefer SQL, SAS, and similar traditional tools. The scientists (mostly statisticians, really) prefer Python and R, with Julia emerging. The Developers started with Java, but they are being seduced by Scala, because it offers ideal tools for data-centric applications.
The video is available on www.parleys.com.
Over the last year WhitePages has been incrementally converting back-end services from Ruby to Reactive. In this talk they will report on their positive and negative experiences selecting and transitioning to a new set of Reactive technologies and in training our existing Ruby developers to use Scala/Akka.
BoldRadius, CEO, Mike Kelland and his the team lead a discussion on how to pitch the Typesafe Reactive Platform within the enterprise.
To view the video visit www.parlayes.com.
To learn more visit http://go.typesafe.com/.
One of the fundamental problems of I/O is a core problem of communication: How do I know that the recipient is ready to receive my information?
In a pure push model, without taking into consideration Little's Law, it is very easy to produce data at a faster pace than it can be consumed, leading to loss of information, contention on the medium, or even full system failure.
Reactive Streams provide an asynchronous, concurrent, back-pressured/demand-driven solution for that and other problems. We will discuss this and more in this session.
To view the video visit www.parleys.com.
Play 2.3 is a big release with a focus on streamlining client side development and Java 8 support. The future holds many new things including a simpler reactive IO API, and better integration with Akka through akka-http. In this presentation the core developers of Play will showcase how Play 2.3 and future releases will make your code simpler and more fun to develop.
Video available on www.parleys.com.
For more information about Typesafe visit www.typesafe.com.
Martin takes you on a journey to what he thinks of as the core of Scala. The core is built from a moderate number of general and orthogonal concepts that can be combined freely. The parts are simple, but the combinations can be as elaborate as one wants to make them.
When done right, simple parts in the language lead to libraries that have clear interfaces and can be used in flexible ways. He will give examples how the fusion of functional and object-oriented concepts in Scala helps in the design of simple modules that compose well.
The video is available on www.parleys.com.
Viktor Klang, Chief Architect at Typesafe discuss five years of Akka with Dick Wall, Josh Suereth and Seth Tisue.
First Hour: Duncan DeVore - Lessons Learned in Deploying Akka Persistence
Second Hour: Jan Machacek, CTO & Alex Lashford, Senior Developer/Team Leader, Cake Solutions Ltd. - Tuning and Monitoring Akka
First Hour: Derek Wyatt, Platform Developer, Auvik Networks, Inc. - Best Practices The Hard Way: Deploying Actors, Await, and Akka Clustering
Second Hour: Mike Nash, Delivery Executive, BoldRadius Solutions - Do's and Don'ts When Deploying Akka in Production
Lambdas have come to Java! Now that more developers have access to this powerful abstraction, many will wonder about the dynamics of how they work and how to best leverage them in their code. In this webinar, Ryan Knight discusses why lambdas are useful and how to best leverage them in Scala, Java 8, Clojure and JRuby.
Reactive Streams has a lot to offer Play, providing an asynchronous streaming API that is easy to learn and easy to use from both Java and Scala. Play 3.0 will be embracing this new API as the base level IO API, but what implications will this have on Play's architecture? What will happen to iteratees? How much will this impact existing Play applications? This presentation will dive deep into Play's architecture, and show just how reactive streams will be applied to and improve Play.
This session will focus on Gilt's implementation of Play Framework across its architecture--starting with Gilt Live, a real-time page showcasing purchases made in real-time, and eventually branching out to many critical parts of the company's tech organization (from search to inventory status updates). Play has offered Gilt numerous advantages in terms of accessibility, scalability and performance. You'll hear more about lessons learned and the many advantages Play has offered to Gilt, a rapidly-moving eCommerce company with more than eight million users.
In 2013, The Huffington Post made a major decision as part of their new platform architecture to invest heavily in the Typesafe stack, specifically, Play and Akka. In this talk you will learn about how the Huffington Post leverages Akka inside of Play to build highly concurrent, low latency and fault tolerant applications to deal with process workflow and asynchronous integrations to various backend data sources such as MySQL using Slick and Search engines such as Elastic Search.
In this session you will learn architecture strategies to help develop Play and Scala applications on large enterprise projects. The talk will cover strategies to help integrate Play with complex ecosystems and other enterprise development challenges. The secondary objective is to assist designing Play applications that are developed by multiple, distributed, cross-functional teams.
Lessons learned, challenges faced, and the fun we've had transitioning our legacy architecture to Scala and the Play Framework.