From 1M to 1B Features Per Second: Scaling ShareChat's ML Feature Store

•Download as PPTX, PDF•

0 likes•42 views

ShareChat's Ivan Burmistrov walks through how they built a low latency ML Feature Store based on ScyllaDB which initially failed to meet the scalability requirements and failed on 1 million features per second load, but has been successfully scaled 1000 times to handle 1 billing features per second without scaling the underlying database.

HOSTED BY
From 1M to 1B Features Per Second:
Scaling ShareChat’s ML Feature Store
Ivan Burmistrov
Principal Software Engineer
Andrei Manakov
Staff Software Engineer
ShareChat ShareChat

ScyllaDb Schema (Bad)
CREATE TABLE features (
entity_id string,
tile_time timestamp,
feature_name string,
value blob,
PRIMARY KEY ((entity_id),
tile_time, feature_name))

ScyllaDb Schema (Good)
CREATE TABLE features (
entity_id string,
tile_time timestamp,
features blob,
PRIMARY KEY (entity_id,
tile_time))

Consistent hashing: ingress
nginx.ingress.kubernetes.io/upstream-hash-by: "$bucket-value"
nginx.ingress.kubernetes.io/upstream-hash-by-subset: "true"
nginx.ingress.kubernetes.io/upstream-hash-by-subset-size: "3"

Consistent hashing ingress: path rewriting
nginx.ingress.kubernetes.io/use-regex: "true" nginx.ingress.kubernetes.io/rewrite-
target: /$1 nginx.ingress.kubernetes.io/upstream-hash-by: $2
hosts:
- host: feature-service.internal
paths:
- path: /(method)(/hash-by-.*)

Conclusion
■ Robust proven technologies pay off (ScyllaDB, Flink,...)
■ Every next step is harder than previous one
■ The simplest and practical solution does work
■ The most optimized solution isn’t human-friendly
■ Don’t be scared to fork a lib and adjust it for your system

Ivan Burmistrov
burmistrov.ivan@gmail.com
@isburmistrov
isburmistrov@threads.net
Thank you! Let’s connect.
Andrei Manakov
andection@gmail.com
@AndreyManakov
andection@threads

Similar to From 1M to 1B Features Per Second: Scaling ShareChat's ML Feature Store

Databases for Storage Engineers

Thomas Kejser

Client Killed the Server Star

Pamela Fox

Most modern websites still place a large burden on the server, constantly sending it requests and asking it to do heavy computations. In the brave new world, the client is king and the server is its faithful shadow. In this talk, we'll look at how cutting-edge technology like Gears, HTML5, and Google App Engine can be used to create websites where the caching, storage, and computing is done primarily in the browser/desktop and the server is used merely as a backup store. Presented at Webstock 2009. Original version (not PPTed): http://tr.im/clientkilledserver

Flavius Ștef: Big Rewrites Without Big Risks at I T.A.K.E. Unconference

Mozaic Works

This document discusses strategies for incrementally rewriting software architecture without big risks. It suggests splitting large rewrites into smaller chunks and using techniques like faking functionality until it is implemented, incremental refactoring, and rewriting in small bites. Specific strategies discussed include researching prerequisites, creating proofs of concept, adding unit and performance tests incrementally, and removing dependencies one by one. Choosing the right refactoring is important, and catalogues of refactorings can provide guidance. An incremental process of analyzing, planning, refactoring, testing and integrating changes in small batches is recommended to validate progress toward goals at each step.

Big rewrites without big risks

Flavius Stef

Use React tools for better Angular apps

Martin Hochel

扩展世界上最大的图片Blog社区

yiditushe

The document summarizes the scaling challenges faced by Fotolog, a large photo blogging community. It discusses how Fotolog grew to hosting hundreds of millions of photos and billions of comments. It describes Fotolog's technology stack including their use of MySQL, Memcached, 3Par storage and CDNs. It also outlines some of the MySQL scaling techniques used, such as sharding, replication, table partitioning and optimization.

Fotolog: Scaling the World's Largest Photo Blogging Community

farhan "Frank" mashraqi

WebWorkersCamp 2010

Olivier Gutknecht

Behavior driven oop

Piyush Verma

This document provides an introduction to using traits for behavior-driven object-oriented programming. Traits are described as composable units of behavior that provide method implementations but cannot access or alter state. The document discusses how traits avoid problems with single and multiple inheritance by flattening hierarchies. It also covers specifying traits, creating classes with traits, and resolving conflicts between traits through various approaches like suppression, renaming, or prioritizing class or trait methods.

High-Performance Storage Services with HailDB and Java

sunnygleason

This document summarizes an approach to providing high-performance storage services using Java and HailDB. It discusses using the optimized "guts" of MySQL without needing to go through JDBC and SQL. It presents HailDB as a storage engine alternative to NoSQL options like Voldemort. It describes integrating HailDB with Java using JNA, building a REST API on top called St8, and examples of nifty applications like graph stores and counters. It concludes with discussing future work like improving packaging, online backup, and exploring JNI bindings.

Sustainable Agile Development

Gabriele Lana

The document discusses using agile and lean startup methodologies for developing a chess application. It advocates embracing change and continuous learning through techniques like test-driven development, continuous integration, and validating ideas with customers. The document also recommends designing resources and representations to build a flexible domain model using RESTful principles and leveraging technologies like Ajax, Comet, and continuous deployment to speed up the learning process and deployment cycle.

Nodejs - A quick tour (v6)

Felix Geisendörfer

This document provides an overview and introduction to Node.js. It discusses that Node.js is a platform for building scalable network applications using JavaScript and uses non-blocking I/O and event-driven architecture. It was created by Ryan Dahl in 2009 and uses Google's V8 JavaScript engine. Node.js allows building web servers, networking tools and real-time applications easily and efficiently by handling concurrent connections without threads. Some popular frameworks and modules built on Node.js are also mentioned such as Express.js, Socket.IO and over 1600 modules in the npm registry.

Building a Scalable Distributed Stats Infrastructure with Storm and KairosDB

Cody Ray

Building a Scalable Distributed Stats Infrastructure with Storm and KairosDB Many startups collect and display stats and other time-series data for their users. A supposedly-simple NoSQL option such as MongoDB is often chosen to get started... which soon becomes 50 distributed replica sets as volume increases. This talk describes how we designed a scalable distributed stats infrastructure from the ground up. KairosDB, a rewrite of OpenTSDB built on top of Cassandra, provides a solid foundation for storing time-series data. Unfortunately, though, it has some limitations: millisecond time granularity and lack of atomic upsert operations which make counting (critical to any stats infrastructure) a challenge. Additionally, running KairosDB atop Cassandra inside AWS brings its own set of challenges, such as managing Cassandra seeds and AWS security groups as you grow or shrink your Cassandra ring. In this deep-dive talk, we explore how we've used a mix of open-source and in-house tools to tackle these challenges and build a robust, scalable, distributed stats infrastructure.

AtlasCamp 2014: Static Connect Add-ons

Atlassian

Building Atlassian Connect add-ons with client-server frameworks like Express.JS and Play produces powerful add-ons, but requires hosting and database consideration. In contrast, "static" Connect add-ons are easier to write and far simpler to deploy. A static Connect add-on is simply a set of files (including an atlassian-connect.json descriptor) that are web accessible, either through a web server or via deployment to a CDN. Static add-ons have several advantages. First, infinite scalability. Why pay for CPU when you can let the user agent do the work? Second, simple persistence. Why pay for disk when you have local storage and JIRA & Confluence's persistence REST APIs? Third, extreme performance. Let a worldwide CDN serve your files from the nearest edge - it's literally impossible to compete with a static add-on when it comes to performance! Finally, easy caching. Why bother serving requests when your unchanged static files can be cached indefinitely with simple HTTP caching? In this talk I'll highlight the benefits and restrictions of static add-on architecture, and discuss the nuts and bolts of implementing a static add-on. I'll also show off the static add-on skeleton that will get your static add-on development off to a flying start.

Nodejs - A quick tour (v5)

Felix Geisendörfer

Node.js is a JavaScript runtime built on Chrome's V8 engine. It allows JavaScript to be run on the server-side. Node.js avoids blocking I/O operations by using non-blocking techniques and event loops. It provides APIs for common tasks like HTTP servers, filesystem access, and more. While still in development, Node.js has found success in building real-time applications and APIs due to its asynchronous and non-blocking architecture.

Dynamo DB & RDS Deep Dive - AWS India Summit 2012

Amazon Web Services

Amazon DynamoDB and Amazon RDS Deep Dive provides an overview of Amazon DynamoDB and Amazon RDS. It discusses how DynamoDB can provide real-time weather updates, make video gamers happy, and scale to millions of users by delivering billions of page flips through its consistent and predictable performance on solid-state drives with seamless scalability. It also discusses how RDS can remove operational burdens like backups, recovery, patching and upgrades through its managed service allowing developers to focus on their applications.

The Java Content Repository

nobby

The document discusses a content repository, which is a generic API for content storage that provides CRUD functionality as well as versioning, transactions, and search capabilities. It describes how a content repository enforces simplicity, encourages standardization, and improves scalability. Examples of content repository implementations are provided, including Apache Jackrabbit and eXo Platform. Key features of content repositories are explored such as the content model, repository structure with workspaces and nodes/properties, and node type definitions.

Java Tools and Techniques for Solving Tricky Problem

Will Iverson

Most Java software problems come from the little “broken windows” – a null pointer here or there. Sometimes, however, you find yourself in a nasty section of town, with the heap, stack, and permgen brutally fighting for memory. Threads in nasty knife fights over resources. Sometimes just plain freaky things – how did I wind up with 1.5GB of HashSet allocations? In this edition of CSI: Seattle Java Edition, we’ll look at the tools available to combat these nasty foes and even see some of them in action – we will blow up a lot of application servers and JVMs in the process, with graphic results.

Aop clustering

pratap kumar dheergasi

The document discusses using AOP (aspect-oriented programming) for JVM-level clustering. It describes how Open Terracotta uses AOP techniques like bytecode instrumentation to provide transparent clustering without changes to application code. Key aspects discussed include maintaining shared state across nodes by replicating fields, and maintaining thread coordination through intercepting synchronized blocks and wait/notify calls. The document argues that JVM-level clustering addresses issues with traditional clustering approaches and provides a simpler programming model.

Node.js Enterprise Middleware

Behrad Zari

This document discusses Node.js as an enterprise middleware platform. It provides context on soft real-time applications and cloud computing needs. Node.js uses an event-driven, non-blocking I/O model with callbacks to achieve high concurrency levels. Its use of JavaScript and modular package ecosystem allow for rapid development. Key benefits highlighted include performance, scalability, agility, and cost savings. Success stories from companies like PayPal, LinkedIn, and Yahoo adopting Node.js are also mentioned.

Similar to From 1M to 1B Features Per Second: Scaling ShareChat's ML Feature Store (20)

Databases for Storage Engineers

Client Killed the Server Star

Flavius Ștef: Big Rewrites Without Big Risks at I T.A.K.E. Unconference

Big rewrites without big risks

Use React tools for better Angular apps

扩展世界上最大的图片Blog社区

Fotolog: Scaling the World's Largest Photo Blogging Community

WebWorkersCamp 2010

Behavior driven oop

High-Performance Storage Services with HailDB and Java

Sustainable Agile Development

Nodejs - A quick tour (v6)

Building a Scalable Distributed Stats Infrastructure with Storm and KairosDB

AtlasCamp 2014: Static Connect Add-ons

Nodejs - A quick tour (v5)

Dynamo DB & RDS Deep Dive - AWS India Summit 2012

The Java Content Repository

Java Tools and Techniques for Solving Tricky Problem

Aop clustering

Node.js Enterprise Middleware

More from ScyllaDB

Unconventional Methods to Identify Bottlenecks in Low-Latency and High-Throug...

ScyllaDB

In this presentation, we explore how standard profiling and monitoring methods may fall short in identifying bottlenecks in low-latency data ingestion workflows. Instead, we showcase the power of simple yet clever methods that can uncover hidden performance limitations. Attendees will discover unconventional techniques, including clever logging, targeted instrumentation, and specialized metrics, to pinpoint bottlenecks accurately. Real-world use cases will be presented to demonstrate the effectiveness of these methods. By the end of the session, attendees will be equipped with alternative approaches to identify bottlenecks and optimize their low-latency data ingestion workflows for high throughput.

Mitigating the Impact of State Management in Cloud Stream Processing Systems

ScyllaDB

Stream processing is a crucial component of modern data infrastructure, but constructing an efficient and scalable stream processing system can be challenging. Decoupling compute and storage architecture has emerged as an effective solution to these challenges, but it can introduce high latency issues, especially when dealing with complex continuous queries that necessitate managing extra-large internal states. In this talk, we focus on addressing the high latency issues associated with S3 storage in stream processing systems that employ a decoupled compute and storage architecture. We delve into the root causes of latency in this context and explore various techniques to minimize the impact of S3 latency on stream processing performance. Our proposed approach is to implement a tiered storage mechanism that leverages a blend of high-performance and low-cost storage tiers to reduce data movement between the compute and storage layers while maintaining efficient processing. Throughout the talk, we will present experimental results that demonstrate the effectiveness of our approach in mitigating the impact of S3 latency on stream processing. By the end of the talk, attendees will have gained insights into how to optimize their stream processing systems for reduced latency and improved cost-efficiency.

Measuring the Impact of Network Latency at Twitter

ScyllaDB

Architecting a High-Performance (Open Source) Distributed Message Queuing Sys...

ScyllaDB

BlazingMQ is a new open source* distributed message queuing system developed at and published by Bloomberg. It provides highly-performant queues to applications for asynchronous, efficient, and reliable communication. This system has been used at scale at Bloomberg for eight years, where it moves terabytes of data and billions of messages across tens of thousands of queues in production every day. BlazingMQ provides highly-available, fault-tolerant queues courtesy of replication based on the Raft consensus algorithm. In addition, it provides a rich set of enterprise message routing strategies, enabling users to implement a variety of scenarios for message processing. Written in C++ from the ground up, BlazingMQ has been architected with low latency as one of its core requirements. This has resulted in some unique design and implementation choices at all levels of the system, such as its lock-free threading model, custom memory allocators, compact wire protocol, multi-hop network topology, and more. This talk will provide an overview of BlazingMQ. We will then delve into the system’s core design principles, architecture, and implementation details in order to explore the crucial role they play in its performance and reliability. *BlazingMQ will be released as open source between now and P99 (exact timing is still TBD)

Noise Canceling RUM by Tim Vereecke, Akamai

ScyllaDB

Noisy Real User Monitoring (RUM) data can ruin your P99! We introduce a fresh concept called ""Human Visible Navigations"" (HVN) to tackle this risk; we focus on the experiences you actually care about when talking about the speed of our sites: - Human: We exclude noise coming from bots and synthetic measurements. - Visible: We remove any partial or fully hidden experiences. These tend to be very slow but users don’t see this slowness. - Navigations: We ignore lightning fast back-forward navigations which usually have few optimisation opportunities. Adopting Human Visible Navigations provides you with these key benefits: - Fewer changes staying below the radar - Fewer data fluctuations - Fewer blindspots when finding bottlenecks - Better correlation with business metrics This is supported by plenty of real world examples coming from the world's largest scale modeling site (6M Monthly visits) in combination with aggregated data from the brand new rumarchive.com (open source) After attending this session; your P99 and other percentiles will become less noisy and easier to tune!

Running a Go App in Kubernetes: CPU Impacts

ScyllaDB

Always-on Profiling of All Linux Threads, On-CPU and Off-CPU, with eBPF & Con...

ScyllaDB

In this session, Tanel introduces a new open source eBPF tool for efficiently sampling both on-CPU events and off-CPU events for every thread (task) in the OS. Linux standard performance tools (like perf) allow you to easily profile on-CPU threads doing work, but if we want to include the off-CPU timing and reasons for the full picture, things get complicated. Combining eBPF task state arrays with periodic sampling for profiling allows us to get both a system-level overview of where threads spend their time, even when blocked and sleeping, and allow us to drill down into individual thread level, to understand why.

Performance Budgets for the Real World by Tammy Everts

ScyllaDB

Performance budgets have been around for more than ten years. Over those years, we’ve learned a lot about what works, what doesn’t, and what we need to improve. In this session, Tammy revisits old assumptions about performance budgets and offers some new best practices. Topics include: • Understanding performance budgets vs. performance goals • Aligning budgets with user experience • Pros and cons of Core Web Vitals • How to stay on top of your budgets to fight regressions

Using Libtracecmd to Analyze Your Latency and Performance Troubles

ScyllaDB

Trying to figure out why your application is responding late can be difficult, especially if it is because of interference from the operating system. This talk will briefly go over how to write a C program that can analyze what in the Linux system is interfering with your application. It will use trace-cmd to enable kernel trace events as well as tracing lock functions, and it will then go over a quick tutorial on how to use libtracecmd to read the created trace.dat file to uncover what is the cause of interference to you application.

Reducing P99 Latencies with Generational ZGC

ScyllaDB

With the low-latency garbage collector ZGC, GC pause times are no longer a big problem in Java. With sub-millisecond pause times there are instead other things in the GC and JVM that can cause application threads to experience unexpected latencies. This talk will dig into a specific use where the GC pauses are no longer the cause of unexpected latencies and look at how adding generations to ZGC help lower the p99 application latencies.

5 Hours to 7.7 Seconds: How Database Tricks Sped up Rust Linting Over 2000X

ScyllaDB

Linters are a type of database! They are a collection of lint rules — queries that look for rule violations to report — plus a way to execute those queries over a source code dataset. This is a case study about using database ideas to build a linter that looks for breaking changes in Rust library APIs. Maintainability and performance are key: new Rust releases tend to have mutually-incompatible ways of representing API information, and we cannot afford to reimplement and optimize dozens of rules for each Rust version separately. Fortunately, databases don't require rewriting queries when the underlying storage format or query plan changes! This allows us to ship massive optimizations and support multiple Rust versions without making any changes to the queries that describe lint rules. Ship now, optimize later"" can be a sustainable development practice after all — join us to see how!

How Netflix Builds High Performance Applications at Global Scale

ScyllaDB

Conquering Load Balancing: Experiences from ScyllaDB Drivers

ScyllaDB

Load balancing seems simple on the surface, with algorithms like round-robin, but the real world loves throwing curveballs. Join me in this session as we delve into the intricacies of load balancing within ScyllaDB Drivers. Discover firsthand experiences from our journey in driver development, where we employed the Power of Two Choices algorithm, optimized the implementation of load balancing in Rust Driver, mitigated cloud costs through zone-aware load balancing and combated the issue of overloading a particular core of ScyllaDB. Be prepared to delve into the practical and theoretical aspects of load balancing, gaining valuable insights along the way.

Interaction Latency: Square's User-Centric Mobile Performance Metric

ScyllaDB

Mobile performance metrics often take inspiration from the backend world and measure resource usage (CPU usage, memory usage, etc) and workload durations (how long a piece of code takes to run). However, mobile apps are used by humans and the app performance directly impacts their experience, so we should primarily track user-centric mobile performance metrics. Following the lead of tech giants, the mobile industry at large is now adopting the tracking of app launch time and smoothness (jank during motion). At Square, our customers spend most of their time in the app long after it's launched, and they don't scroll much, so app launch time and smoothness aren't critical metrics. What should we track instead? This talk will introduce you to Interaction Latency, a user-centric mobile performance metric inspired from the Web Vital metric Interaction to Next Paint"" (web.dev/inp). We'll go over why apps need to track this, how to properly implement its tracking (it's tricky!), how to aggregate this metric and what thresholds you should target.

How to Avoid Learning the Linux-Kernel Memory Model

ScyllaDB

The Linux-kernel memory model (LKMM) is a powerful tool for developing highly concurrent Linux-kernel code, but it also has a steep learning curve. Wouldn't it be great to get most of LKMM's benefits without the learning curve? This talk will describe how to do exactly that by using the standard Linux-kernel APIs (locking, reference counting, RCU) along with a simple rules of thumb, thus gaining most of LKMM's power with less learning. And the full LKMM is always there when you need it!

99.99% of Your Traces are Trash by Paige Cruz

ScyllaDB

Distributed tracing is still finding its footing in many organizations today, one challenge to overcome is the data volume - keeping 100% of your traces is expensive and unnecessary. Enter sampling - head vs tail how do you decide? Let’s look at the design of Sifter and get familiar with why tail-based sampling is the way to enact a cost-effective tracing solution while actually increasing the system’s observability.

Square's Lessons Learned from Implementing a Key-Value Store with Raft

ScyllaDB

To put it simply, Raft is used to make a use case (e.g., key-value store, indexing system) more fault tolerant to increase availability using replication (despite server and network failures). Raft has been gaining ground due to its simplicity without sacrificing consistency and performance. Although we'll cover Raft's building blocks, this is not about the Raft algorithm; it is more about the micro-lessons one can learn from building fault-tolerant, strongly consistent distributed systems using Raft. Things like majority agreement rule (quorum), write-ahead log, split votes & randomness to reduce contention, heartbeats, split-brain syndrome, snapshots & logs replay, client requests dedupe & idempotency, consistency guarantees (linearizability), leases & stale reads, batching & streaming, parallelizing persisting & broadcasting, version control, and more! And believe it or not, you might be using some of these techniques without even realizing it! This is inspired by Raft paper (raft.github.io), publications & courses on Raft, and an attempt to implement a key-value store using Raft as a side project.

Making Python 100x Faster with Less Than 100 Lines of Rust

ScyllaDB

A Deep Dive Into Concurrent React by Matheus Albuquerque

ScyllaDB

The Latency Stack: Discovering Surprising Sources of Latency

ScyllaDB

Usually, when an API call is slow, developers blame ourselves and our code. We held a lock too long, or used a blocking operation, or built an inefficient query. But often, the simple picture of latency as “the time a server takes to process a message” hides a great deal of end-to-end complexity. Debugging tail latencies requires unpacking the abstractions that we normally ignore: virtualization, hidden queues, and network behavior. In this talk, I’ll describe how developers can diagnose more sources of delay and failure by building a more realistic and broad understanding of networked services. I’ll give some real-world cases when high end-to-end latency or elevated failure rates occurred due to factors we ordinarily might not even measure. Some examples include TCP SYN retransmission; virtualization on the client; and surprising behavior from AWS load balancers. Unfortunately, many measurement techniques don’t cover anything but the portion most directly under developer control. But developers can do better by comparing multiple measurements, applying Little’s law, investing in eBPF probes, and paying attention to the network layer. Understanding API performance to find and fix issues faster ultimately means understanding the entire stack: the client, your code, and the underlying infrastructure.

More from ScyllaDB (20)

Unconventional Methods to Identify Bottlenecks in Low-Latency and High-Throug...

Mitigating the Impact of State Management in Cloud Stream Processing Systems

Measuring the Impact of Network Latency at Twitter

Architecting a High-Performance (Open Source) Distributed Message Queuing Sys...

Noise Canceling RUM by Tim Vereecke, Akamai

Running a Go App in Kubernetes: CPU Impacts

Always-on Profiling of All Linux Threads, On-CPU and Off-CPU, with eBPF & Con...

Performance Budgets for the Real World by Tammy Everts

Using Libtracecmd to Analyze Your Latency and Performance Troubles

Reducing P99 Latencies with Generational ZGC

5 Hours to 7.7 Seconds: How Database Tricks Sped up Rust Linting Over 2000X

How Netflix Builds High Performance Applications at Global Scale

Conquering Load Balancing: Experiences from ScyllaDB Drivers

Interaction Latency: Square's User-Centric Mobile Performance Metric

How to Avoid Learning the Linux-Kernel Memory Model

99.99% of Your Traces are Trash by Paige Cruz

Square's Lessons Learned from Implementing a Key-Value Store with Raft

Making Python 100x Faster with Less Than 100 Lines of Rust

A Deep Dive Into Concurrent React by Matheus Albuquerque

The Latency Stack: Discovering Surprising Sources of Latency

Recently uploaded

K2G - Insurtech Innovation EMEA Award 2024

The Digital Insurer

Scaling Connections in PostgreSQL Postgres Bangalore(PGBLR) Meetup-2 - Mydbops

Mydbops

This presentation, delivered at the Postgres Bangalore (PGBLR) Meetup-2 on June 29th, 2024, dives deep into connection pooling for PostgreSQL databases. Aakash M, a PostgreSQL Tech Lead at Mydbops, explores the challenges of managing numerous connections and explains how connection pooling optimizes performance and resource utilization. Key Takeaways: * Understand why connection pooling is essential for high-traffic applications * Explore various connection poolers available for PostgreSQL, including pgbouncer * Learn the configuration options and functionalities of pgbouncer * Discover best practices for monitoring and troubleshooting connection pooling setups * Gain insights into real-world use cases and considerations for production environments This presentation is ideal for: * Database administrators (DBAs) * Developers working with PostgreSQL * DevOps engineers * Anyone interested in optimizing PostgreSQL performance Contact info@mydbops.com for PostgreSQL Managed, Consulting and Remote DBA Services

Knowledge and Prompt Engineering Part 2 Focus on Prompt Design Approaches

Earley Information Science

In this follow-up session on knowledge and prompt engineering, we will explore structured prompting, chain of thought prompting, iterative prompting, prompt optimization, emotional language prompts, and the inclusion of user signals and industry-specific data to enhance LLM performance. Join EIS Founder & CEO Seth Earley and special guest Nick Usborne, Copywriter, Trainer, and Speaker, as they delve into these methodologies to improve AI-driven knowledge processes for employees and customers alike.

MYIR Product Brochure - A Global Provider of Embedded SOMs & Solutions

Linda Zhang

This brochure gives introduction of MYIR Electronics company and MYIR's products and services. MYIR Electronics Limited (MYIR for short), established in 2011, is a global provider of embedded System-On-Modules (SOMs) and comprehensive solutions based on various architectures such as ARM, FPGA, RISC-V, and AI. We cater to customers' needs for large-scale production, offering customized design, industry-specific application solutions, and one-stop OEM services. MYIR, recognized as a national high-tech enterprise, is also listed among the "Specialized and Special new" Enterprises in Shenzhen, China. Our core belief is that "Our success stems from our customers' success" and embraces the philosophy of "Make Your Idea Real, then My Idea Realizing!"

@Call @Girls Pune 0000000000 Riya Khan Beautiful Girl any Time

amitchopra0215

@Call @Girls Guwahati 🚒 XXXXXXXXXX 🚒 Priya Sharma Beautiful And Cute Girl any...

kantakumariji156

What's Next Web Development Trends to Watch.pdf

SeasiaInfotech2

UiPath Community Day Kraków: Devs4Devs Conference

UiPathCommunity

We are honored to launch and host this event for our UiPath Polish Community, with the help of our partners - Proservartner! We certainly hope we have managed to spike your interest in the subjects to be presented and the incredible networking opportunities at hand, too! Check out our proposed agenda below 👇👇 08:30 ☕ Welcome coffee (30') 09:00 Opening note/ Intro to UiPath Community (10') Cristina Vidu, Global Manager, Marketing Community @UiPath Dawid Kot, Digital Transformation Lead @Proservartner 09:10 Cloud migration - Proservartner & DOVISTA case study (30') Marcin Drozdowski, Automation CoE Manager @DOVISTA Pawel Kamiński, RPA developer @DOVISTA Mikolaj Zielinski, UiPath MVP, Senior Solutions Engineer @Proservartner 09:40 From bottlenecks to breakthroughs: Citizen Development in action (25') Pawel Poplawski, Director, Improvement and Automation @McCormick & Company Michał Cieślak, Senior Manager, Automation Programs @McCormick & Company 10:05 Next-level bots: API integration in UiPath Studio (30') Mikolaj Zielinski, UiPath MVP, Senior Solutions Engineer @Proservartner 10:35 ☕ Coffee Break (15') 10:50 Document Understanding with my RPA Companion (45') Ewa Gruszka, Enterprise Sales Specialist, AI & ML @UiPath 11:35 Power up your Robots: GenAI and GPT in REFramework (45') Krzysztof Karaszewski, Global RPA Product Manager 12:20 🍕 Lunch Break (1hr) 13:20 From Concept to Quality: UiPath Test Suite for AI-powered Knowledge Bots (30') Kamil Miśko, UiPath MVP, Senior RPA Developer @Zurich Insurance 13:50 Communications Mining - focus on AI capabilities (30') Thomasz Wierzbicki, Business Analyst @Office Samurai 14:20 Polish MVP panel: Insights on MVP award achievements and career profiling

7 Most Powerful Solar Storms in the History of Earth.pdf

Enterprise Wired

Research Directions for Cross Reality Interfaces

Mark Billinghurst

Observability For You and Me with OpenTelemetry

Eric D. Schabell

Are you interested in dipping your toes in the cloud native observability waters, but as an engineer you are not sure where to get started with tracing problems through your microservices and application landscapes on Kubernetes? Then this is the session for you, where we take you on your first steps in an active open-source project that offers a buffet of languages, challenges, and opportunities for getting started with telemetry data. The project is called openTelemetry, but before diving into the specifics, we’ll start with de-mystifying key concepts and terms such as observability, telemetry, instrumentation, cardinality, percentile to lay a foundation. After understanding the nuts and bolts of observability and distributed traces, we’ll explore the openTelemetry community; its Special Interest Groups (SIGs), repositories, and how to become not only an end-user, but possibly a contributor.We will wrap up with an overview of the components in this project, such as the Collector, the OpenTelemetry protocol (OTLP), its APIs, and its SDKs. Attendees will leave with an understanding of key observability concepts, become grounded in distributed tracing terminology, be aware of the components of openTelemetry, and know how to take their first steps to an open-source contribution! Key Takeaways: Open source, vendor neutral instrumentation is an exciting new reality as the industry standardizes on openTelemetry for observability. OpenTelemetry is on a mission to enable effective observability by making high-quality, portable telemetry ubiquitous. The world of observability and monitoring today has a steep learning curve and in order to achieve ubiquity, the project would benefit from growing our contributor community.

Transcript: Details of description part II: Describing images in practice - T...

BookNet Canada

This presentation explores the practical application of image description techniques. Familiar guidelines will be demonstrated in practice, and descriptions will be developed “live”! If you have learned a lot about the theory of image description techniques but want to feel more confident putting them into practice, this is the presentation for you. There will be useful, actionable information for everyone, whether you are working with authors, colleagues, alone, or leveraging AI as a collaborator. Link to presentation recording and slides: https://bnctechforum.ca/sessions/details-of-description-part-ii-describing-images-in-practice/ Presented by BookNet Canada on June 25, 2024, with support from the Department of Canadian Heritage.

How Social Media Hackers Help You to See Your Wife's Message.pdf

HackersList

find out more about the role of autonomous vehicles in facing global challenges

huseindihon

DealBook of Ukraine: 2024 edition

Yevgen Sysoyev

GDG Cloud Southlake #34: Neatsun Ziv: Automating Appsec

James Anderson

The lecture titled "Automating AppSec" delves into the critical challenges associated with manual application security (AppSec) processes and outlines strategic approaches for incorporating automation to enhance efficiency, accuracy, and scalability. The lecture is structured to highlight the inherent difficulties in traditional AppSec practices, emphasizing the labor-intensive triage of issues, the complexity of identifying responsible owners for security flaws, and the challenges of implementing security checks within CI/CD pipelines. Furthermore, it provides actionable insights on automating these processes to not only mitigate these pains but also to enable a more proactive and scalable security posture within development cycles. The Pains of Manual AppSec: This section will explore the time-consuming and error-prone nature of manually triaging security issues, including the difficulty of prioritizing vulnerabilities based on their actual risk to the organization. It will also discuss the challenges in determining ownership for remediation tasks, a process often complicated by cross-functional teams and microservices architectures. Additionally, the inefficiencies of manual checks within CI/CD gates will be examined, highlighting how they can delay deployments and introduce security risks. Automating CI/CD Gates: Here, the focus shifts to the automation of security within the CI/CD pipelines. The lecture will cover methods to seamlessly integrate security tools that automatically scan for vulnerabilities as part of the build process, thereby ensuring that security is a core component of the development lifecycle. Strategies for configuring automated gates that can block or flag builds based on the severity of detected issues will be discussed, ensuring that only secure code progresses through the pipeline. Triaging Issues with Automation: This segment addresses how automation can be leveraged to intelligently triage and prioritize security issues. It will cover technologies and methodologies for automatically assessing the context and potential impact of vulnerabilities, facilitating quicker and more accurate decision-making. The use of automated alerting and reporting mechanisms to ensure the right stakeholders are informed in a timely manner will also be discussed. Identifying Ownership Automatically: Automating the process of identifying who owns the responsibility for fixing specific security issues is critical for efficient remediation. This part of the lecture will explore tools and practices for mapping vulnerabilities to code owners, leveraging version control and project management tools. Three Tips to Scale the Shift Left Program: Finally, the lecture will offer three practical tips for organizations looking to scale their Shift Left security programs. These will include recommendations on fostering a security culture within development teams, employing DevSecOps principles to integrate security throughout the development

What's New in Copilot for Microsoft365 May 2024.pptx

Stephanie Beckett

@Call @Girls Thiruvananthapuram 🚒 XXXXXXXXXX 🚒 Priya Sharma Beautiful And Cu...

kantakumariji156

Recent Advancements in the NIST-JARVIS Infrastructure

KAMAL CHOUDHARY

20240705 QFM024 Irresponsible AI Reading List June 2024

Matthew Sinclair

Recently uploaded (20)

K2G - Insurtech Innovation EMEA Award 2024

Scaling Connections in PostgreSQL Postgres Bangalore(PGBLR) Meetup-2 - Mydbops

Knowledge and Prompt Engineering Part 2 Focus on Prompt Design Approaches

MYIR Product Brochure - A Global Provider of Embedded SOMs & Solutions

@Call @Girls Pune 0000000000 Riya Khan Beautiful Girl any Time

@Call @Girls Guwahati 🚒 XXXXXXXXXX 🚒 Priya Sharma Beautiful And Cute Girl any...

What's Next Web Development Trends to Watch.pdf

UiPath Community Day Kraków: Devs4Devs Conference

7 Most Powerful Solar Storms in the History of Earth.pdf

Research Directions for Cross Reality Interfaces

Observability For You and Me with OpenTelemetry

Transcript: Details of description part II: Describing images in practice - T...

How Social Media Hackers Help You to See Your Wife's Message.pdf

find out more about the role of autonomous vehicles in facing global challenges

DealBook of Ukraine: 2024 edition

GDG Cloud Southlake #34: Neatsun Ziv: Automating Appsec

What's New in Copilot for Microsoft365 May 2024.pptx

@Call @Girls Thiruvananthapuram 🚒 XXXXXXXXXX 🚒 Priya Sharma Beautiful And Cu...

Recent Advancements in the NIST-JARVIS Infrastructure

20240705 QFM024 Irresponsible AI Reading List June 2024

From 1M to 1B Features Per Second: Scaling ShareChat's ML Feature Store

1. HOSTED BY From 1M to 1B Features Per Second: Scaling ShareChat’s ML Feature Store Ivan Burmistrov Principal Software Engineer Andrei Manakov Staff Software Engineer ShareChat ShareChat

2. Context

3. Moj, a short video app

4. What are the features anyway?

5. The story

6. The architecture

7. Tiles

8. Tiles

9. High-level architecture

10. Why it failed?

11. ScyllaDb Schema (Bad) CREATE TABLE features ( entity_id string, tile_time timestamp, feature_name string, value blob, PRIMARY KEY ((entity_id), tile_time, feature_name))

12. Tiling Configuration (Bad)

13. Let’s do some math

14. Optimisations

15. ScyllaDb Schema (Good) CREATE TABLE features ( entity_id string, tile_time timestamp, features blob, PRIMARY KEY (entity_id, tile_time))

16. Tiling Configuration (Good)

17. Compaction Strategy

18. 4x Scylla Would Be Enough?

19. Cache locality

20. Consistent hashing

21. Consistent hashing: ingress nginx.ingress.kubernetes.io/upstream-hash-by: "$bucket-value" nginx.ingress.kubernetes.io/upstream-hash-by-subset: "true" nginx.ingress.kubernetes.io/upstream-hash-by-subset-size: "3"

22. Consistent hashing: ingress

23. Consistent hashing: subset

24. Consistent hashing ingress: path rewriting nginx.ingress.kubernetes.io/use-regex: "true" nginx.ingress.kubernetes.io/rewrite- target: /$1 nginx.ingress.kubernetes.io/upstream-hash-by: $2 hosts: - host: feature-service.internal paths: - path: /(method)(/hash-by-.*)

25. Consistent hashing: ingress

26. Improve cache locality: 27 deployments

27. Improve cache locality: 27 deployments

28. What’s next?

29. Envoy proxy

30. Feature Service Optimisation

31. Envoy proxy - result

32. Conclusion ■ Robust proven technologies pay off (ScyllaDB, Flink,...) ■ Every next step is harder than previous one ■ The simplest and practical solution does work ■ The most optimized solution isn’t human-friendly ■ Don’t be scared to fork a lib and adjust it for your system

33. Ivan Burmistrov burmistrov.ivan@gmail.com @isburmistrov isburmistrov@threads.net Thank you! Let’s connect. Andrei Manakov andection@gmail.com @AndreyManakov andection@threads

From 1M to 1B Features Per Second: Scaling ShareChat's ML Feature Store

More Related Content

Similar to From 1M to 1B Features Per Second: Scaling ShareChat's ML Feature Store

Similar to From 1M to 1B Features Per Second: Scaling ShareChat's ML Feature Store (20)

More from ScyllaDB

More from ScyllaDB (20)

Recently uploaded

Recently uploaded (20)

From 1M to 1B Features Per Second: Scaling ShareChat's ML Feature Store