In the world of social gaming, the classic 2-tier of web application does not cut it anymore. We need new and better solutions.
Follow along the evolution of game servers at Wooga and get an in-depth look into the next-generation backend putting the combined forces of Erlang and Ruby to work. Learn how scalability, reliability, concurrency control and beautiful code do not need to be mutually exclusive.
Open Source Compiler Construction for the JVMTom Lee
This document discusses building a compiler for a simple language called "Awesome" that targets the Java Virtual Machine (JVM). It recommends writing a stub code generator first for quick feedback before building the full compiler. The compiler will use Scala parser combinators to parse the input into an abstract syntax tree (AST) and then walk the AST to generate equivalent JVM bytecode using the Bytecode Engineering Library (BCEL). The document outlines the overall compiler architecture and next steps to expand the language features supported by the compiler.
Java 7 was released in July 2011 with improvements to performance, concurrency, and memory management. Plans for Java 8 include modularity, lambda expressions, and date/time APIs. The Java Community Process is also being improved to increase transparency, participation, and agility through JSR 348. Overall, the Java ecosystem continues to grow with new languages on the JVM and an active community.
Bob McWhirter gave a presentation on TorqueBox, an open-source Ruby application server built on the Java Virtual Machine. Some key points:
- TorqueBox allows Ruby applications like Rails to take advantage of features traditionally provided by Java application servers like scalability, messaging, jobs, and telephony.
- It provides queues for asynchronous processing and scheduling jobs to run on a cron-like schedule directly from Ruby classes.
- The use of the Java VM allows clustering and high availability of Ruby applications in the same way achieved with Java applications.
- All components like queues, jobs, and clustering work seamlessly together since everything is integrated within TorqueBox.
TorqueBox allows Ruby applications to leverage the Java Application Server and Java EE services by running Ruby code on JRuby and integrating it with the underlying Java platform. It provides services like messaging, caching, background jobs, and more to Ruby applications. TorqueBox handles the integration between Ruby frameworks/APIs and the corresponding Java APIs and services, allowing Ruby developers to build enterprise applications that scale.
The document describes Pfm, a PaaS for online game development that provides an easy and inexpensive environment for coding, hosting, and scaling online games. Pfm uses Lua scripting with asynchronous RPC between Lua VMs to allow object interactions across a distributed key-value store. It aims to reduce the costs and difficulties of developing and operating online games.
This document discusses using DataMapper with Infinispan as a clustered NoSQL data store. It covers:
- DataMapper is a Ruby ORM that can use Infinispan as its data adapter through the dm-infinispan-adapter gem.
- Infinispan is a highly scalable, distributed Java cache that provides a data grid. It supports replication, distribution and local caching.
- The dm-infinispan-adapter allows DataMapper objects to be stored in Infinispan, enabling a clustered NoSQL backend for Ruby applications. It generates runtime annotations to integrate with Hibernate Search.
The document discusses the polyglot capabilities of JBoss AS 7 through projects like TorqueBox and Immutant. TorqueBox allows Ruby applications to run on JBoss AS 7, providing services like web applications, background jobs, messaging, and more through integration with Java libraries. Similarly, Immutant aims to enable Clojure applications to run on JBoss AS 7 with analogous services. The goal is to leverage JBoss AS 7 as a platform while allowing developers to choose the best programming language for the task.
Open Source Compiler Construction for the JVMTom Lee
This document discusses building a compiler for a simple language called "Awesome" that targets the Java Virtual Machine (JVM). It recommends writing a stub code generator first for quick feedback before building the full compiler. The compiler will use Scala parser combinators to parse the input into an abstract syntax tree (AST) and then walk the AST to generate equivalent JVM bytecode using the Bytecode Engineering Library (BCEL). The document outlines the overall compiler architecture and next steps to expand the language features supported by the compiler.
Java 7 was released in July 2011 with improvements to performance, concurrency, and memory management. Plans for Java 8 include modularity, lambda expressions, and date/time APIs. The Java Community Process is also being improved to increase transparency, participation, and agility through JSR 348. Overall, the Java ecosystem continues to grow with new languages on the JVM and an active community.
Bob McWhirter gave a presentation on TorqueBox, an open-source Ruby application server built on the Java Virtual Machine. Some key points:
- TorqueBox allows Ruby applications like Rails to take advantage of features traditionally provided by Java application servers like scalability, messaging, jobs, and telephony.
- It provides queues for asynchronous processing and scheduling jobs to run on a cron-like schedule directly from Ruby classes.
- The use of the Java VM allows clustering and high availability of Ruby applications in the same way achieved with Java applications.
- All components like queues, jobs, and clustering work seamlessly together since everything is integrated within TorqueBox.
TorqueBox allows Ruby applications to leverage the Java Application Server and Java EE services by running Ruby code on JRuby and integrating it with the underlying Java platform. It provides services like messaging, caching, background jobs, and more to Ruby applications. TorqueBox handles the integration between Ruby frameworks/APIs and the corresponding Java APIs and services, allowing Ruby developers to build enterprise applications that scale.
The document describes Pfm, a PaaS for online game development that provides an easy and inexpensive environment for coding, hosting, and scaling online games. Pfm uses Lua scripting with asynchronous RPC between Lua VMs to allow object interactions across a distributed key-value store. It aims to reduce the costs and difficulties of developing and operating online games.
This document discusses using DataMapper with Infinispan as a clustered NoSQL data store. It covers:
- DataMapper is a Ruby ORM that can use Infinispan as its data adapter through the dm-infinispan-adapter gem.
- Infinispan is a highly scalable, distributed Java cache that provides a data grid. It supports replication, distribution and local caching.
- The dm-infinispan-adapter allows DataMapper objects to be stored in Infinispan, enabling a clustered NoSQL backend for Ruby applications. It generates runtime annotations to integrate with Hibernate Search.
The document discusses the polyglot capabilities of JBoss AS 7 through projects like TorqueBox and Immutant. TorqueBox allows Ruby applications to run on JBoss AS 7, providing services like web applications, background jobs, messaging, and more through integration with Java libraries. Similarly, Immutant aims to enable Clojure applications to run on JBoss AS 7 with analogous services. The goal is to leverage JBoss AS 7 as a platform while allowing developers to choose the best programming language for the task.
Complex Made Simple: Sleep Better with TorqueBoxbobmcwhirter
The document discusses using TorqueBox, a Ruby application server based on JRuby and JBoss AS7, to deploy a Rails application in production. It compares various deployment options from rolling your own infrastructure to using a platform as a service like Heroku. TorqueBox provides a middle ground where it handles services like caching, background jobs, scheduling, and clustering but still allows customization. The document walks through migrating an existing Rails app's Delayed::Job and caching implementations to use TorqueBox equivalents to simplify the deployment.
TorqueBox: The beauty of Ruby with the power of JBoss. Presented at Devnexus...bobmcwhirter
- Bob McWhirter is the project lead of TorqueBox and a JBoss Fellow.
- TorqueBox allows Ruby web applications to run on the JBoss Application Server using JRuby.
- It provides tight integration with JBoss and allows Ruby applications to take advantage of features like messaging, jobs, and services that are traditionally Java-based.
The document discusses TorqueBox, an application server for Ruby that is built on JBoss Application Server 7 and uses JRuby. It allows Ruby applications to take advantage of features typically found in Java application servers like clustering, caching, messaging, and more. Key features highlighted include support for Ruby web frameworks like Rails and Sinatra, background processing using Resque or DelayedJob, messaging using JMS, long running services, and resource injection. Web sockets support is provided using STOMP and the Stilts framework. The document outlines goals of TorqueBox and provides examples of configuration and usage.
Rocket Fuelled Cucumbers discusses strategies for dealing with slow cucumber test suites, including:
- Using Spork to preload support code to speed up test runs
- Tagging tests to run focused subsets based on features, filenames, or tags
- Distributing tests across multiple servers using Testjour to parallelize testing
- Looking to cloud providers like EC2 to gain additional hardware resources
- Dividing applications and tests along service boundaries to isolate components
TorqueBox - Ultrapassando a fronteira entre Java e RubyBruno Oliveira
The document discusses Java and Ruby programming languages and the TorqueBox framework. It provides an overview of TorqueBox which allows running Ruby on Rails applications on the JBoss Application Server using the JRuby implementation of Ruby. It covers installing and deploying applications with TorqueBox, using features like caching, clustering, and Infinispan for distributed caching.
JRuby is an implementation of the Ruby language that runs on the Java Virtual Machine. It allows Ruby code to access Java libraries and APIs and Java code to call Ruby methods. Some benefits of JRuby include access to mature and stable Java platforms, libraries, and tools as well as improved performance from features like garbage collection. JRuby also allows Java shops to introduce scripting and Ruby skills.
Akka is using the Actors together with STM to create a unified runtime and programming model for scaling both UP (multi-core) and OUT (grid/cloud). Akka provides location transparency by abstracting away both these tangents of scalability by turning them into an ops task. This gives the Akka runtime freedom to do adaptive automatic load-balancing, cluster rebalancing, replication & partitioning
A tour of (advanced) Akka features in 40 minutesJohan Janssen
These are the slides for my Akka presentation at JavaLand in 2017. It covers most Akka features like (remote) actors, clusters, FSM, Akka HTTP and persistence. It's explained on a high level to get an idea on what is possible with Akka.
Explains how to make use of ruby in java-based work environments. There are some hints at .NET equivalents along the way.
This is part 3 of a trilogy of Star Wars-themed ruby talks given at Protegra's SDEC 2011 in Winnipeg, Canada.
Modern Objective-C introduces several syntactic sugars that simplify working with collections and objects in Objective-C, including array, dictionary and boxed expression literals that avoid explicit constructor methods, as well as object subscripting syntax that allows accessing elements in collections using subscript syntax like nsarray[index]. These features help reduce verbosity and make code more readable while still generating the same underlying method calls as before.
When Two Worlds Collide: Java and Ruby in the Enterprisebenbrowning
When Two Worlds Collide: Java and Ruby in the Enterprise is a presentation about using Ruby and Java together in an enterprise environment. It introduces JRuby, which allows Ruby code to run on the Java Virtual Machine and integrate with Java. It then discusses TorqueBox, which allows Ruby applications to run on the JBoss Application Server alongside Java applications. TorqueBox provides Ruby interfaces to enterprise services like messaging, background jobs, caching, and more commonly found in Java application servers. The presentation argues that TorqueBox allows Ruby to be a first-class citizen alongside Java in the enterprise.
The document discusses using RabbitMQ for message queueing. It describes how RabbitMQ uses exchanges, queues, and bindings to route messages from producers to consumers. It provides examples of publishing and consuming messages using Pika and Kombu in Python. It also discusses issues with latency and packet loss and describes plugins like Shovel, STOMP, and Celery that extend RabbitMQ's capabilities.
Automatic Reference Counting (ARC) makes memory management the job of the compiler by inserting retain and release calls. ARC consists of a frontend compiler that inserts the appropriate memory management calls and an optimizer that removes unnecessary calls. ARC supports iOS 5+ and OS X 10.7+ and allows using variable ownership qualifiers like __strong (default), __weak, __unsafe_unretained, and __autoreleasing to avoid retain cycles.
When Ruby Meets Java - The Power of Torqueboxrockyjaiswal
This document discusses TorqueBox, an open source platform that allows Ruby on Rails applications to run on the Java Virtual Machine (JVM) and take advantage of Java libraries and services. It highlights features like scheduling, services, messaging, background jobs, clustering, caching and performance. The document includes code samples and discusses how TorqueBox makes these enterprise features easy to use from Ruby. It also notes some risks of using an emerging technology but says the documentation is good and help is available online.
Wooga has evolved its game architecture over time as its user base grew exponentially. It started with a Ruby backend that worked well for early growth but struggled with scaling. It introduced sharding which helped but led to operational complexity. It then moved static data to MySQL and caching to Redis, alleviating load. As users increased further, it distributed servers and databases across availability zones. The current architecture uses stateful Erlang servers that store session data, reducing database load and improving deployability compared to earlier Ruby approaches. This evolution has allowed Wooga to support over 2 million daily users.
Complex Made Simple: Sleep Better with TorqueBoxbobmcwhirter
The document discusses using TorqueBox, a Ruby application server based on JRuby and JBoss AS7, to deploy a Rails application in production. It compares various deployment options from rolling your own infrastructure to using a platform as a service like Heroku. TorqueBox provides a middle ground where it handles services like caching, background jobs, scheduling, and clustering but still allows customization. The document walks through migrating an existing Rails app's Delayed::Job and caching implementations to use TorqueBox equivalents to simplify the deployment.
TorqueBox: The beauty of Ruby with the power of JBoss. Presented at Devnexus...bobmcwhirter
- Bob McWhirter is the project lead of TorqueBox and a JBoss Fellow.
- TorqueBox allows Ruby web applications to run on the JBoss Application Server using JRuby.
- It provides tight integration with JBoss and allows Ruby applications to take advantage of features like messaging, jobs, and services that are traditionally Java-based.
The document discusses TorqueBox, an application server for Ruby that is built on JBoss Application Server 7 and uses JRuby. It allows Ruby applications to take advantage of features typically found in Java application servers like clustering, caching, messaging, and more. Key features highlighted include support for Ruby web frameworks like Rails and Sinatra, background processing using Resque or DelayedJob, messaging using JMS, long running services, and resource injection. Web sockets support is provided using STOMP and the Stilts framework. The document outlines goals of TorqueBox and provides examples of configuration and usage.
Rocket Fuelled Cucumbers discusses strategies for dealing with slow cucumber test suites, including:
- Using Spork to preload support code to speed up test runs
- Tagging tests to run focused subsets based on features, filenames, or tags
- Distributing tests across multiple servers using Testjour to parallelize testing
- Looking to cloud providers like EC2 to gain additional hardware resources
- Dividing applications and tests along service boundaries to isolate components
TorqueBox - Ultrapassando a fronteira entre Java e RubyBruno Oliveira
The document discusses Java and Ruby programming languages and the TorqueBox framework. It provides an overview of TorqueBox which allows running Ruby on Rails applications on the JBoss Application Server using the JRuby implementation of Ruby. It covers installing and deploying applications with TorqueBox, using features like caching, clustering, and Infinispan for distributed caching.
JRuby is an implementation of the Ruby language that runs on the Java Virtual Machine. It allows Ruby code to access Java libraries and APIs and Java code to call Ruby methods. Some benefits of JRuby include access to mature and stable Java platforms, libraries, and tools as well as improved performance from features like garbage collection. JRuby also allows Java shops to introduce scripting and Ruby skills.
Akka is using the Actors together with STM to create a unified runtime and programming model for scaling both UP (multi-core) and OUT (grid/cloud). Akka provides location transparency by abstracting away both these tangents of scalability by turning them into an ops task. This gives the Akka runtime freedom to do adaptive automatic load-balancing, cluster rebalancing, replication & partitioning
A tour of (advanced) Akka features in 40 minutesJohan Janssen
These are the slides for my Akka presentation at JavaLand in 2017. It covers most Akka features like (remote) actors, clusters, FSM, Akka HTTP and persistence. It's explained on a high level to get an idea on what is possible with Akka.
Explains how to make use of ruby in java-based work environments. There are some hints at .NET equivalents along the way.
This is part 3 of a trilogy of Star Wars-themed ruby talks given at Protegra's SDEC 2011 in Winnipeg, Canada.
Modern Objective-C introduces several syntactic sugars that simplify working with collections and objects in Objective-C, including array, dictionary and boxed expression literals that avoid explicit constructor methods, as well as object subscripting syntax that allows accessing elements in collections using subscript syntax like nsarray[index]. These features help reduce verbosity and make code more readable while still generating the same underlying method calls as before.
When Two Worlds Collide: Java and Ruby in the Enterprisebenbrowning
When Two Worlds Collide: Java and Ruby in the Enterprise is a presentation about using Ruby and Java together in an enterprise environment. It introduces JRuby, which allows Ruby code to run on the Java Virtual Machine and integrate with Java. It then discusses TorqueBox, which allows Ruby applications to run on the JBoss Application Server alongside Java applications. TorqueBox provides Ruby interfaces to enterprise services like messaging, background jobs, caching, and more commonly found in Java application servers. The presentation argues that TorqueBox allows Ruby to be a first-class citizen alongside Java in the enterprise.
The document discusses using RabbitMQ for message queueing. It describes how RabbitMQ uses exchanges, queues, and bindings to route messages from producers to consumers. It provides examples of publishing and consuming messages using Pika and Kombu in Python. It also discusses issues with latency and packet loss and describes plugins like Shovel, STOMP, and Celery that extend RabbitMQ's capabilities.
Automatic Reference Counting (ARC) makes memory management the job of the compiler by inserting retain and release calls. ARC consists of a frontend compiler that inserts the appropriate memory management calls and an optimizer that removes unnecessary calls. ARC supports iOS 5+ and OS X 10.7+ and allows using variable ownership qualifiers like __strong (default), __weak, __unsafe_unretained, and __autoreleasing to avoid retain cycles.
When Ruby Meets Java - The Power of Torqueboxrockyjaiswal
This document discusses TorqueBox, an open source platform that allows Ruby on Rails applications to run on the Java Virtual Machine (JVM) and take advantage of Java libraries and services. It highlights features like scheduling, services, messaging, background jobs, clustering, caching and performance. The document includes code samples and discusses how TorqueBox makes these enterprise features easy to use from Ruby. It also notes some risks of using an emerging technology but says the documentation is good and help is available online.
Wooga has evolved its game architecture over time as its user base grew exponentially. It started with a Ruby backend that worked well for early growth but struggled with scaling. It introduced sharding which helped but led to operational complexity. It then moved static data to MySQL and caching to Redis, alleviating load. As users increased further, it distributed servers and databases across availability zones. The current architecture uses stateful Erlang servers that store session data, reducing database load and improving deployability compared to earlier Ruby approaches. This evolution has allowed Wooga to support over 2 million daily users.
This document summarizes a talk about using replicated databases with Rails applications. It discusses why replication is used, including for load balancing and redundancy. It covers some problems with replicated databases like conflicting primary keys and replication lag. It then discusses different solutions for handling reads and writes with replicated databases in Rails including MySQL Proxy, DBSlayer, and various Rails plugins. It provides examples of how several popular Rails plugins like masochism, data_fabric, and multi_db implement read/write splitting functionality.
This talk wants to sum up the experience of designing, deploying and maintaining an Erlang application targeting the cloud and precisely AWS as hosting infrastructure.
As the application now serves a significantly large user base with a sustained throughput of thousands of games actions per second we're able to analyse retrospectively our engineering and architectural choices and see how Erlang fits in the cloud environment also comparing it to previous experiences of clouds deployments of other platforms.
We'll discuss properties of Erlang as a language and OTP as a framework and how we used them to design a system that is a good cloud citizen. We'll also discuss topics that are still open for a solution.
Erlang and the Cloud: A Fractal Approach to ThroughputWooga
This document summarizes a talk about building scalable systems for the cloud using Erlang. The speaker discusses how Erlang processes with local state (gen_servers) can act as units of throughput that can be composed across cloud computing instances to scale applications. By treating each gen_server as an independent unit of throughput, systems can leverage the elastic computing resources of the cloud in a loosely coupled way to easily scale up as more instances are added. In contrast to traditional monolithic architectures, this approach allows for fractal-like scaling where the overall structure remains similar at different scales.
Using Kubernetes to deliver a “serverless” serviceDoKC
Link: https://youtu.be/C4rlepOPk5o
https://go.dok.community/slack
https://dok.community/
From the DoK Day EU 2022 (https://youtu.be/Xi-h4XNd5tE)
Serverless promises to change the way we consume software. It allows us to potentially pay for only that which we use and can help drive down operational costs to the minimal amount of resources necessary.
Architecting for serverless requires a unique look at app logic and the way it is deployed. It takes a combination of the logical and physical worlds. An architectural pattern has emerged where we can scale ephemeral compute separate from services that need to persist.
We use Kubernetes to deliver exactly this. A “serverless” experience that is driven and enabled by compute pods and storage pods. We also have used our experience running thousands of database clusters on Kubernetes to automate the operational expertise of managing a distributed database.
In this talk, we will take a dive deep into the architecture of our application and share:
* A definition and outline of the challenges of serverless
* How we reworked our logic for a serverless approach
* How we use Kubernetes to gain serverless autoscaling
-----
Jim is a recovering developer turned evangelist who loves useful, cool, cutting-edge tech. He loves to translate and distill complex concepts into compelling, more simple explanations that broader communities can consume. He is an advocate of the developer and an active participant in several open source communities.
The document discusses the evolution of architecture at the gaming company Wooga. It began by using Ruby on Rails with a MySQL database, which worked for low user numbers but struggled as users grew. A second team then used Redis as the main database instead of MySQL for its speed. The teams combined approaches, migrating static data to MySQL and keeping dynamic data in Redis. This allowed scaling to millions of daily users. The architecture evolved further to make servers and databases stateless to improve reliability.
This talk presents a library, registry, supporting the creation of modular Haskell applications in a very approachable way. And since this library actually helps with wiring functions it can be reused in other contexts like creating data generators for property-based testing.
The document discusses helping customers cut costs in their web APIs. It recommends using Goliath, an asynchronous Ruby web server, Beanstalk for work queues, Couchbase for data storage, and HAProxy as a load balancer. This approach was tested on a mobile game API and increased performance from 450 to 1300 requests per second while reducing the number of application servers needed from 4 to 1, cutting costs while improving scalability.
Akka & Scala were chosen as the concurrency framework and programming language respectively for an advertising company to optimize machine utilization and handle high throughput and low latency requirements. Akka provides an actor model for building concurrent and distributed applications, while Scala is a functional programming language that integrates well with Akka and Java. The architecture was refactored over time to use Akka actors and Spray REST services built on top of Akka for asynchronous request handling at scale.
Initially delivered at LA RubyConf 2013, this presentation describes how cutting-edge technology helped to triple performance and drastically cut costs in a mobile social game. Juan Pablo Genovese, a Ruby Architect from Altoros Systems Argentina, explains how, despite the extremely tight budget, the customer managed to:
- go from ~450 req/s to ~1300 req/s
- reduce the number of EC2 application servers from four to one
- provide fast and reliable video uploading and processing
- achieve very easy scaling with automation
while maintaining all the functions of the original RoR app.
Innovation dank DevOps (DevOpsCon Berlin 2015)Wooga
“You build it, you run it!” - Wenn Du als Entwickler weisst, dass Du Deine Software selbst betreiben musst, was bist bereit zu tun, um den späteren Betrieb zu vereinfach?
Bei Wooga haben Dutzende von Teams ihre eigene Antwort auf die Frage gesucht und dabei von den Erfahrungen der anderen Teams gelernt. Herausgekommen ist ein großes Experimentierfeld beim Betrieb von Web Services - und eine technologische Innovation, die uns innerhalb weniger Iterationen von einem simplen LAMP-Stack zu lastabhängig skalierenden stateful Servern auf Basis von Erlang oder Akka gebracht hat.
Jesper Richter-Reichhelm - Continuous Evolution at Wooga - code.talks 2015AboutYouGmbH
- Wooga takes a continuous evolution approach to game development, making iterative improvements through frequent releases and experiments.
- They operate using an OODA loop model of quick cycles of observing user behavior, deciding on improvements, acting by implementing changes, and observing the results again.
- Over time Wooga has evolved its technical stack and approaches, transitioning from stateless to stateful architectures and adopting new languages and technologies as needed to adapt to changing needs.
This document summarizes the key benefits of using the Elixir programming language compared to Ruby for building distributed, fault-tolerant, and highly concurrent applications. It notes that Elixir was developed to take advantage of modern multicore processors and borrowed concepts from Erlang like immutability, pattern matching, and functional programming. Several companies that saw success building large-scale systems with Elixir like Pinterest, Discord, and the NFL are highlighted. Elixir is recommended for projects that require high availability, scalability, or real-time features over Ruby which may require more servers and resources to achieve the same results.
This is a talk that I gave at the San Francisco DevOps meetup on 9/29/15. I talk about how Yelp performs service discovery using SmartStack and Docker.
The document discusses building an app with jQuery and Jaxer, which allows running JavaScript code on both the client-side and server-side. Jaxer provides a server-side JavaScript environment and framework that enables mashups and improving perceived performance by running some code on the server. Functions can be proxied to run on the client or server. The document includes examples of setting up a database and registering a user using Jaxer and JavaScript functions running on both the client and server.
Using Kubernetes to deliver a “serverless” serviceDoKC
Serverless promises to change the way we consume software. It allows us to potentially pay for only that which we use and can help drive down operational costs to the minimal amount of resources necessary.
Architecting for serverless requires a unique look at app logic and the way it is deployed. It takes a combination of the logical and physical worlds. An architectural pattern has emerged where we can scale ephemeral compute separate from services that need to persist.
We use Kubernetes to deliver exactly this. A “serverless” experience that is driven and enabled by compute pods and storage pods. We also have used our experience running thousands of database clusters on Kubernetes to automate the operational expertise of managing a distributed database.
In this talk, we will take a dive deep into the architecture of our application and share:
* A definition and outline of the challenges of serverless
* How we reworked our logic for a serverless approach
* How we use Kubernetes to gain serverless autoscaling
This talk was given by Jim Walker for DoK Day Europe @ KubeCon 2022.
This talk will cover ScyllaDB Architecture from the cluster-level view and zoom in on data distribution and internal node architecture. In the process, we will learn the secret sauce used to get ScyllaDB's high availability and superior performance. We will also touch on the upcoming changes to ScyllaDB architecture, moving to strongly consistent metadata and tablets.
AI in the Workplace Reskilling, Upskilling, and Future Work.pptxSunil Jagani
Discover how AI is transforming the workplace and learn strategies for reskilling and upskilling employees to stay ahead. This comprehensive guide covers the impact of AI on jobs, essential skills for the future, and successful case studies from industry leaders. Embrace AI-driven changes, foster continuous learning, and build a future-ready workforce.
Read More - https://bit.ly/3VKly70
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Keywords: AI, Containeres, Kubernetes, Cloud Native
Event Link: https://meine.doag.org/events/cloudland/2024/agenda/#agendaId.4211
inQuba Webinar Mastering Customer Journey Management with Dr Graham HillLizaNolte
HERE IS YOUR WEBINAR CONTENT! 'Mastering Customer Journey Management with Dr. Graham Hill'. We hope you find the webinar recording both insightful and enjoyable.
In this webinar, we explored essential aspects of Customer Journey Management and personalization. Here’s a summary of the key insights and topics discussed:
Key Takeaways:
Understanding the Customer Journey: Dr. Hill emphasized the importance of mapping and understanding the complete customer journey to identify touchpoints and opportunities for improvement.
Personalization Strategies: We discussed how to leverage data and insights to create personalized experiences that resonate with customers.
Technology Integration: Insights were shared on how inQuba’s advanced technology can streamline customer interactions and drive operational efficiency.
LF Energy Webinar: Carbon Data Specifications: Mechanisms to Improve Data Acc...DanBrown980551
This LF Energy webinar took place June 20, 2024. It featured:
-Alex Thornton, LF Energy
-Hallie Cramer, Google
-Daniel Roesler, UtilityAPI
-Henry Richardson, WattTime
In response to the urgency and scale required to effectively address climate change, open source solutions offer significant potential for driving innovation and progress. Currently, there is a growing demand for standardization and interoperability in energy data and modeling. Open source standards and specifications within the energy sector can also alleviate challenges associated with data fragmentation, transparency, and accessibility. At the same time, it is crucial to consider privacy and security concerns throughout the development of open source platforms.
This webinar will delve into the motivations behind establishing LF Energy’s Carbon Data Specification Consortium. It will provide an overview of the draft specifications and the ongoing progress made by the respective working groups.
Three primary specifications will be discussed:
-Discovery and client registration, emphasizing transparent processes and secure and private access
-Customer data, centering around customer tariffs, bills, energy usage, and full consumption disclosure
-Power systems data, focusing on grid data, inclusive of transmission and distribution networks, generation, intergrid power flows, and market settlement data
Northern Engraving | Modern Metal Trim, Nameplates and Appliance PanelsNorthern Engraving
What began over 115 years ago as a supplier of precision gauges to the automotive industry has evolved into being an industry leader in the manufacture of product branding, automotive cockpit trim and decorative appliance trim. Value-added services include in-house Design, Engineering, Program Management, Test Lab and Tool Shops.
AppSec PNW: Android and iOS Application Security with MobSFAjin Abraham
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
"Scaling RAG Applications to serve millions of users", Kevin GoedeckeFwdays
How we managed to grow and scale a RAG application from zero to thousands of users in 7 months. Lessons from technical challenges around managing high load for LLMs, RAGs and Vector databases.
Getting the Most Out of ScyllaDB Monitoring: ShareChat's TipsScyllaDB
ScyllaDB monitoring provides a lot of useful information. But sometimes it’s not easy to find the root of the problem if something is wrong or even estimate the remaining capacity by the load on the cluster. This talk shares our team's practical tips on: 1) How to find the root of the problem by metrics if ScyllaDB is slow 2) How to interpret the load and plan capacity for the future 3) Compaction strategies and how to choose the right one 4) Important metrics which aren’t available in the default monitoring setup.
How information systems are built or acquired puts information, which is what they should be about, in a secondary place. Our language adapted accordingly, and we no longer talk about information systems but applications. Applications evolved in a way to break data into diverse fragments, tightly coupled with applications and expensive to integrate. The result is technical debt, which is re-paid by taking even bigger "loans", resulting in an ever-increasing technical debt. Software engineering and procurement practices work in sync with market forces to maintain this trend. This talk demonstrates how natural this situation is. The question is: can something be done to reverse the trend?
In our second session, we shall learn all about the main features and fundamentals of UiPath Studio that enable us to use the building blocks for any automation project.
📕 Detailed agenda:
Variables and Datatypes
Workflow Layouts
Arguments
Control Flows and Loops
Conditional Statements
💻 Extra training through UiPath Academy:
Variables, Constants, and Arguments in Studio
Control Flow in Studio
"Choosing proper type of scaling", Olena SyrotaFwdays
Imagine an IoT processing system that is already quite mature and production-ready and for which client coverage is growing and scaling and performance aspects are life and death questions. The system has Redis, MongoDB, and stream processing based on ksqldb. In this talk, firstly, we will analyze scaling approaches and then select the proper ones for our system.
Discover the Unseen: Tailored Recommendation of Unwatched ContentScyllaDB
The session shares how JioCinema approaches ""watch discounting."" This capability ensures that if a user watched a certain amount of a show/movie, the platform no longer recommends that particular content to the user. Flawless operation of this feature promotes the discover of new content, improving the overall user experience.
JioCinema is an Indian over-the-top media streaming service owned by Viacom18.
6. The
scale
is
interesHng
14
billion
requests
/
month
>100,000
DB
operaHons
/
second
>50,000
DB
updates
/
second
7. Wooga’s
approach
to
development
Small
independent
teams
for
each
game
Team
gets
to
choose
tools
and
technologies
Same
team
also
does
ops
a,er
going
live
Culture
of
sharing
Look
around
what
is
there,
pick/adapt
exis;ng
solu;ons,
but
take
ownership
for
what
you
include
9. At
Scale
With
Style
How
we
roll
Server
architectures
How
to
innovate
Mind
the
limits
10. Most
games
use
stateless
applicaHon
servers
Server Database
11. And
then
there’s
sharding
lb
app app app app app app app app app
My My
SQL SQL
slave slave
12. More
app
servers,
more
sharding
lb
app app app app app app app app app
app app app app app app app app app
My My My My My My My My
SQL SQL SQL SQL SQL SQL SQL SQL
slave slave slave slave slave slave slave slave
17. Stateful
game
server
One
process
per
acHve
user
gaming
session
...
holds
the
current
state
and
is
the
only
one
that
can
modify
it
(strong
encapsulaHon)
...
handles
all
API
calls
for
the
given
user
one
a,er
the
other
(concurrency
control
through
actor
model)
...
loads
the
game
state
from
storage
and
writes
it
back
periodically
and
on
process
termina;on
(;meout
=
user
stopped
playing)
18. The
DB
is
no
longer
the
bo`leneck
Stateless Stateful
30.000
22.500
15.000
700
7.500
0
DB
operations
/
second
19. Magic
Land
uses
Erlang
Details:
Awesome
presentaHon
on
the
Magic
Land
game
server
by
@knuHn
&
@hungryblank
h`p://www.slideshare.net/wooga/from-‐0-‐to-‐1000000-‐daily-‐users-‐with-‐erlang
20. At
Scale
With
Style
How
we
roll
Server
architectures
How
to
innovate
Mind
the
limits
21.
22. Erlang
&
Ruby
Erlang
is
great
Concurrent,
robust
Great
for
opera;on
Ruby
is
great
Concise,
expressive,
flexible
Great
for
development
23.
24. Bringing
two
worlds
together
Server Worker
session
sender Worker
session
Worker
...
Worker
receiver
session
Worker
25. Do
you
know
Mongrel2?
Web
Server
that
hooks
up
applicaHons
via
➡ We
chose
the
same
queue
setup
&
message
format
Server Worker
session
sender
Worker
session
Worker
...
Worker
receiver
session
Worker
26.
27. ConnecHng
the
dots
Mongrel2
h`p://mongrel2.org/
protocol
&
ZeroMQ
setup
Erlang:
h`ps://github.com/hungryblank/emongrel2
Ruby
rack-‐mongrel2
fork
hKps://github.com/khiltd/khi-‐rack-‐mongrel2
rack
protocol
hKp://rack.rubyforge.org
Sinatra
hKp://www.sinatrarb.com/
➡ essenHally
we
are
speaking
HTTP
over
ZeroMQ
and
can
hook
up
any
Rack-‐based
Ruby
web
framework
28. Example
controller
in
Ruby
app.game_action '/:actor/fruit_tree/self/shake',
:observable => true,
:affects => [:fruit_trees, :user],
:params => [:x, :y] do
x, y = params[:x], params[:y]
fruit_trees[x, y].shake
end
DSL-‐like
definiHon
of
game
acHon
Skinny
as
controllers
should
be
29. Example
model
in
Ruby
class FruitTree < Tree
property :last_shake_time, :type => Integer, :default => 0
property :collectable_fruit_count, :type => Integer, :default => 0
def shake
raise G8::Error::Validation, "no fruit!" unless carries_fruit?
session.user.xp += 1
session.user.energy -= 1
self.last_shake_time = game_time
self.collectable_fruit_count = config.fruit_count
end
end
Easily
unit
testable
Minimal
amount
of
code
30. Game
state
Game
state
is
split
in
mulHple
parts
user,
map,
fruit_trees
etc.
Erlang
does
not
care
about
content
Serialized
Ruby
objects
Erlang
does
know
mapping
of
state
parts
to
URLs
31. Looking
back
at
the
game
acHon
app.game_action '/:actor/fruit_tree/self/shake',
:observable => true,
:affects => [:fruit_trees, :user],
:params => [:x, :y] do
x, y = params[:x], params[:y]
fruit_trees[x, y].shake
end
Mapping
of
state
parts
to
game
acHons
Worker
knows
mapping
Worker
pushes
mapping
to
Erlang
on
startup
Erlang
can
query
mapping
if
needed