We may earn an affiliate commission when you visit our partners.
Daniel Ciocîrlan

In this course, we will learn how to setup serialization for Akka, which will drastically improve the performance of your system. I've taken the undocumented knowledge of serialization and I've packed it into a concentrated course that will familiarize you with Avro, Kryo and Protobuf. You will learn to integrate them in your Akka system, compare them, and even write your own serializers.

Read more

In this course, we will learn how to setup serialization for Akka, which will drastically improve the performance of your system. I've taken the undocumented knowledge of serialization and I've packed it into a concentrated course that will familiarize you with Avro, Kryo and Protobuf. You will learn to integrate them in your Akka system, compare them, and even write your own serializers.

This course is for Scala/Akka programmers who need to improve the performance of their systems. The Java serializer that comes by default is slow, uses a lot of memory and has security vulnerabilities. Any serious Akka development team should move away from Java serialization as soon as possible, and this course will show you how.

You probably know Akka already:

  • it speeds up the development of concurrent applications by as much as 10x

  • its demand has exploded

  • it's a highly marketable skill

  • it's incredibly fun - power in your hands.

I like to get to the point and get things done. This course

  1. deconstructs all concepts into the critical pieces you need

  2. selects the most important ideas and separates them into what's simple but critical and what's powerful

  3. sequences ideas in a way that "clicks" and makes sense throughout the process of learning

  4. applies everything in live code

The end benefits are still much greater:

  • an enhanced knowledge of Akka with integration of serializers

  • a more marketable resume

  • the best performance for your distributed and persistent systems

This course is for established programmers with experience with Scala and Akka at the level of the Rock the JVM courses. I already assume a solid understanding of general programming fundamentals.

This course is NOT for you if

  • you've never written Scala code before

  • you've never worked with Akka

The course is comprehensive, but you'll always see me get straight to the point. So make sure you have a good level of focus and commitment to become a badass programmer.

I believe both theory and practice are important. That's why you'll get lectures with code examples, real life code demos and assignments, plus additional resources, instructions, exercises and solutions.

I've seen that my students are most successful - and my best students work at Google-class companies - when they're guided, but not being told what to do. I have exercises waiting for you, where I offer my (opinionated) guidance but otherwise freedom to experiment and improve upon your code.

Definitely not least, my students are most successful when they have fun along the way.

So join me in this course and let's rock the JVM.

Enroll now

What's inside

Syllabus

Introduction
Welcome
How to Make the Best out of This Course
Scala Recap
Read more

Traffic lights

Read about what's good
what should give you pause
and possible dealbreakers
Teaches Avro, Kryo, and Protobuf, which are useful tools for improving system performance and are highly relevant for distributed systems
Assumes a solid understanding of general programming fundamentals and experience with Scala and Akka at the level of the Rock the JVM courses
Explores custom serialization, which allows developers to tailor serialization processes to their specific needs and optimize performance
Compares Avro, Kryo, and Protobuf, which helps learners choose the most appropriate serialization library for their Akka systems
Includes a serializers smackdown, which gives learners a practical comparison of different serialization techniques and their performance implications
Requires prior experience with Scala and Akka, so learners without this background may find the course challenging

Save this course

Create your own learning path. Save this course to your list so you can find it easily later.
Save

Reviews summary

Akka serialization with scala review

According to learners, this course offers a deep dive into Akka serialization methods like Avro, Kryo, and Protobuf. It's designed to help improve system performance by moving away from default serialization. However, learners are advised that the course requires strong prior experience with Scala and Akka and is not for beginners. The course uses a practical approach with live code demos and hands-on exercises.
Learn Avro, Kryo, Protobuf for Akka systems
"The course covers integrating Avro, Kryo, and Protobuf into your Akka system."
"I learned about different serialization libraries like Kryo and Avro."
"It covers the main techniques needed for Akka serialization including Protobuf."
Features live code demos and practical exercises
"You'll get lectures with code examples, real life code demos."
"There are assignments, additional resources, instructions, exercises and solutions."
"I was guided through exercises where I had freedom to experiment."
Improve Akka system performance significantly
"This course helps drastically improve system performance."
"It's essential for achieving the best performance for your distributed and persistent systems."
"I learned how to move away from slow Java serialization, which is a must for serious Akka dev."
Needs solid prior experience with Scala and Akka
"This course is for established programmers with experience with Scala and Akka."
"It is NOT for you if you've never worked with Akka before."
"You need a solid understanding of Akka at the level of the Rock the JVM courses."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Akka Serialization with Scala with these activities:
Review Akka Remoting and Persistence
Solidify your understanding of Akka Remoting and Persistence, as these concepts are foundational for understanding serialization in distributed Akka systems.
Show steps
  • Review the Akka documentation on Remoting.
  • Review the Akka documentation on Persistence.
  • Implement a simple Akka application using Remoting and Persistence.
Read 'Akka in Action'
Gain a deeper understanding of Akka concepts and best practices, which will provide a solid foundation for learning about Akka serialization.
View Akka in Action on Amazon
Show steps
  • Read the chapters related to actors and concurrency.
  • Read the chapters related to distributed systems and fault tolerance.
  • Take notes on key concepts and examples.
Follow Avro, Kryo, and Protobuf Tutorials
Familiarize yourself with Avro, Kryo, and Protobuf through hands-on tutorials, which will help you understand how they work and how to integrate them with Akka.
Show steps
  • Find tutorials for Avro serialization in Scala.
  • Find tutorials for Kryo serialization in Scala.
  • Find tutorials for Protobuf serialization in Scala.
  • Implement the examples in the tutorials.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Implement Custom Serializers
Practice writing custom serializers for Akka messages, which will deepen your understanding of the serialization process and allow you to optimize performance for your specific use cases.
Show steps
  • Identify complex Akka messages that could benefit from custom serialization.
  • Implement custom serializers for those messages.
  • Test the performance of the custom serializers.
  • Compare the performance to Java serialization.
Write a Blog Post Comparing Serializers
Solidify your understanding of the different serializers by writing a blog post comparing their performance, features, and trade-offs.
Show steps
  • Research the performance characteristics of Avro, Kryo, and Protobuf.
  • Compare the features and trade-offs of each serializer.
  • Write a blog post summarizing your findings.
  • Publish the blog post online.
Serialization Performance Benchmarking
Conduct performance benchmarks of different serialization methods with Akka to empirically determine the fastest and most efficient options for various data structures and message types.
Show steps
  • Set up an Akka project with representative message types.
  • Implement serialization using Java, Kryo, Avro, and Protobuf.
  • Write benchmark tests to measure serialization and deserialization times.
  • Analyze the results and identify performance bottlenecks.
Read 'Designing Data-Intensive Applications'
Gain a broader understanding of data serialization and distributed systems, which will help you make informed decisions about serialization strategies in Akka.
View Secret Colors on Amazon
Show steps
  • Read the chapters related to data formats and serialization.
  • Read the chapters related to distributed systems.
  • Take notes on key concepts and examples.

Career center

Learners who complete Akka Serialization with Scala will develop knowledge and skills that may be useful to these careers:
Performance Engineer
Performance engineers analyze and optimize the performance of software systems. This course on Akka Serialization with Scala fits directly into the work of a performance engineer. The course's primary focus is on improving system performance through serialization techniques like Avro, Kryo, and Protobuf. Performance engineers can use the knowledge gained from this course to identify and resolve performance bottlenecks related to data serialization in Akka applications, as well as writing custom serializers. This course would be an excellent tool to have to properly tune data handling systems.
Distributed Systems Engineer
Distributed systems engineers design, develop, and maintain distributed computing systems. This course on Akka Serialization with Scala is directly applicable to a distributed systems engineer's work. The course focuses on serialization techniques like Avro, Kryo, and Protobuf, which are critical for optimizing communication and data transfer in distributed systems. By mastering these techniques, distributed systems engineers can improve the performance, reliability, and scalability of their systems. This course will also teach one how to write their own serializers.
Site Reliability Engineer
Site reliability engineers focus on ensuring the reliability, availability, and performance of production systems. This course on Akka Serialization with Scala can greatly benefit site reliability engineers. It focuses on serialization techniques like Avro, Kryo, and Protobuf, which are crucial for optimizing data handling in distributed systems. By mastering these techniques, site reliability engineers can improve system performance of Akka-based systems. The custom serializers module will also enhance the understanding of performance tuning.
Software Architect
Software architects design the overall structure of software systems. This course on Akka Serialization with Scala benefits software architects who need to ensure high performance in Akka-based systems. The course teaches serialization techniques like Avro, Kryo, and Protobuf, which are crucial for optimizing data handling and communication between components. By understanding these techniques, software architects can make informed decisions about the system's architecture. Architects can gain even deeper understanding of performance tuning by writing custom serializers.
Technical Lead
Technical leads are responsible for the technical direction and implementation of software projects. This course on Akka Serialization with Scala helps technical leads ensure high performance in Akka-based systems. The course covers serialization techniques like Avro, Kryo, and Protobuf, which are crucial for optimizing data handling and communication. Technical leads can use this knowledge to guide their teams in building efficient and scalable applications. In particular, this course on custom serializers will enhance the technical lead's understanding.
Backend Developer
Backend developers are responsible for the server-side logic and databases that power applications. This course on Akka Serialization with Scala helps backend developers optimize the performance of their Akka systems. The course teaches serialization techniques like Avro, Kryo, and Protobuf, which are essential for efficient data handling. By mastering these techniques, backend developers can improve the speed and scalability of their applications, especially in distributed environments. Moreover, the ability to write custom serializers gives a backend developer finer control over data processing.
Lead Developer
A lead developer guides a team of developers and oversees software projects. This course on Akka Serialization with Scala is helpful for lead developers who are working on Akka-based projects. The course provides an understanding of serialization techniques like Avro, Kryo, and Protobuf, which are essential for optimizing the performance of distributed systems. By mastering these techniques, lead developers can guide their teams in building efficient, scalable, and reliable applications. With this course, they will also learn about custom serializers.
Application Developer
Application developers design and build software applications. This course on Akka Serialization with Scala can help application developers working on high-performance systems. The course focuses on improving performance through serialization, using Avro, Kryo, and Protobuf. By learning to integrate these serializers, application developers can enhance the efficiency of data handling in their applications. Plus, the ability to write custom serializers provides additional control over performance optimization. Application developers should consider this class if they want to improve Akka performance.
Software Engineer
A software engineer designs, develops, and tests software applications. This course on Akka Serialization with Scala may be useful for software engineers working on high-performance, distributed systems. The course focuses on improving system performance through serialization techniques using Avro, Kryo, and Protobuf. By understanding and implementing these serialization methods, software engineers can optimize data transfer and storage within Akka-based applications. The course also teaches how to write custom serializers, providing further control over performance tuning.
Principal Engineer
Principal engineers are senior technical leaders responsible for driving innovation and setting technical direction. Principal engineers can benefit from the course and gain a deeper understanding of serialization techniques. By gaining a comprehensive knowledge of Avro, Kryo, Protobuf and custom serializers, Principal Engineers gain insights into the overall system architecture and performance. By mastering serialization, an application can optimize data handling within the overall system.
DevOps Engineer
DevOps engineers automate and streamline software development and deployment processes. This course may be useful for DevOps engineers working with Akka-based systems. The course's coverage of serialization techniques like Avro, Kryo, and Protobuf is directly relevant to optimizing data handling and transfer in Akka deployments. By understanding these techniques, DevOps engineers can improve the efficiency and reliability of their deployment pipelines. They will also learn about custom serializers, which enhances their understanding of performance tuning.
Data Engineer
Data engineers build and maintain the infrastructure for data storage and processing. This course may be useful for data engineers working with Akka. As the course covers serialization techniques like Avro and Protobuf, it can help data engineers optimize data pipelines within Akka systems. This optimization is crucial for efficient data processing and storage. The course provides hands-on experience with integrating these serializers, enabling data engineers to improve the performance of their data infrastructure, and to write their own serializers.
Platform Engineer
Platform engineers build and maintain the underlying platform infrastructure for software applications. This course on Akka Serialization with Scala may be useful for platform engineers working with Akka. By learning about techniques like Avro, Kryo, and Protobuf, the platform engineer learns how to deliver platform components in an efficient manner to end users. The course also dives into custom serializers, which is a deep dive into performance optimization.
Systems Architect
Systems architects design and oversee the implementation of complex systems. This course may be useful for systems architects. It dives into serialization methods tailored for Akka, such as Avro, Kryo, and Protobuf, offering critical insights for optimizing system performance. Knowing how to integrate and compare these serializers enables systems architects to make informed decisions about data handling within the system architecture. This course also covers custom serializers, which enhances understanding of performance tuning.
Cloud Engineer
Cloud engineers manage and maintain cloud infrastructure and services. This course may be useful for cloud engineers working with Akka-based applications in the cloud. The course teaches serialization techniques like Avro, Kryo, and Protobuf, which are crucial for optimizing data transfer and storage in distributed cloud environments. By understanding and implementing these techniques, cloud engineers can ensure efficient and scalable Akka deployments. The course also covers custom serializers, which enhances the understanding of performance optimization within cloud infrastructure.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Akka Serialization with Scala.
Provides a comprehensive overview of Akka, including actors, concurrency, fault tolerance, and distributed systems. It offers practical examples and guidance on building robust and scalable applications with Akka. While not solely focused on serialization, it provides valuable context and background knowledge for understanding the role of serialization in Akka. It useful reference for understanding Akka concepts.
Provides a broad overview of the challenges and solutions involved in building data-intensive applications. While it doesn't focus specifically on Akka serialization, it covers topics such as data formats, serialization, and distributed systems, which are relevant to the course. It is more valuable as additional reading to provide a broader context for the course material. It is commonly used as a reference by industry professionals.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser