Optimove is the Science-first Relationship Marketing Hub

Optimove

optimove

Customer segmentation is a necessary part of the marketing strategy for any industry. Demographics like age, gender, and location provide easy wins for companies looking to personalize their marketing materials. In the next few years, the tools that we use for will give every company a greater understanding of every customer on an individual level. These tools will quickly become the norm for any digital business looking to improve their data analysis. segmentation Still, there are some common misunderstandings about the practice on the whole. Before diving in head-first, consider these five factors: Customer behavior is just as important as customer details Effective segmentation digs deeper. It utilizes customer behavior, not just your run-of-the-mill data. What actions are customers taking once they hit your website? Do their actions resemble those of other customers? Does there seem to be a trend? We do see segmentation by customer actions, but few brands dive into it as deeply as they should. Many companies sort customers based on who abandons their cart on e-commerce sites. In these cases, companies might offer a discount or reach out to ask if they had any questions about the product. But, what if you segmented that group even further? Further segments could include those for customers who have never entered their credit card, customers whose credit card has been denied, or customers who have never entered a single detail after adding a product to their cart. By tracking and sorting customers based on their behavior on your site, you can better inform your marketing materials and custom-craft your messages for each customer type. You can then design your landing pages to target specific customer types. Many landing page builders, such as , let you incorporate segmentation into your landing pages and other marketing materials. Unbounce Automation and machine learning are inherent parts of effective segmentation A big reason so few brands haven’t used segmentation to its full potential is because sorting through all that data can be tedious. It can take days to sift through data by hand and properly categorize each person to ensure your assessments are accurate. And accuracy is important here: you wouldn’t want to send out customer emails only to find that you have miscalculated or missed a data point. Automation and machine learning have re-shaped digital marketing and segmentation in particular. Tools like provide hyper-targeting that examines the customer journey and then automatically optimizes your marketing materials for specific customer types, helping you interact with customers on a more personal level. Optimove’s software Micro-segmentation builds relationships Customers love brands that understand them. That’s why it’s so important to speak to their pain points in every piece of marketing that we create. Customers want to know that companies understand their needs, pains, and desires. They also want to be assured that the product you offer will solve their relevant problems. Micro-segmentation is about sorting your customers into more specific categories. In typical segmentation, you might have customer segments based on who lives in Denver, who has a job title of Vice President, or who is above the age of 50. An example of a micro-segment would be a segment that includes all 3–50+ year old VPs who live in Denver. According to an , 78% of customers stated that they’re more likely to buy from a company that sends them more targeted offers. Building that initial trust is incredibly important — customers who have been buying from a company for 30 or more months than they did on their first purchase. Infosys survey spend 67% more per order Micro-segmentation gives you the opportunity to speak to their biggest concerns and win their trust by helping them to address them. Segment research should inform product development At its core, segmentation begins with learning more about your customers. The more you know about your customers, the more you can tailor your marketing to their unique problems, preferences, and desires. Startups often to find a market that needs solutions. But once a company is sufficiently settled within their market and earning a healthy profit, they often shift their focus to other areas of their business. pivot While no established business is going to do a full-fledged pivot in the same way that a startup would, many could benefit from more customer data involvement in product development. Segmentation data should go beyond marketing; it should also be used to inform product development. Great customer data is the most powerful tool that companies have available to them, but too many continue to operate based on perception rather than data-backed facts. Customer journeys and segments are not static Another big mistake that brands make when segmenting is that once a customer has been placed in a segment, their analysis stops there. These customers will forever remain in that segment — even if additional data is collected in the future. Customer segments can and should change over time. Today’s customers may be in a completely different place in life than they had been a year prior. Continually working to correctly categorize your customer types will make all aspects of your marketing more effective. Personalization is the future Deep segmentation of your audience gives you more opportunities for personalization. It allows you to gain a deeper analysis of each customer and their specific situation and to tailor your sales and marketing efforts specifically to them. While segmentation itself isn’t a new concept in digital marketing, the tools that we have available have allowed for micro-segmentation to become affordable for companies of all sizes.

The 5 Factors to Consider When Segmenting Your Customers

This is about how a grocery store brand leverages the Cross-Cluster Replication (CCR) capability of Apache Doris to separate its data reading and writing workloads. In this case, where the freshness of data guarantees the freshness of groceries, Apache Doris uses Apache Doris as its data warehouse to monitor and analyze its procurement, sale, and stock in real-time for all its stores and supply chains. Why they need CCR A major part of the user's data warehouse (including the ODS, DWD, DWS, and ADS layers) is built within Apache Doris, which employs a micro-batch scheduling mechanism to coordinate data across the data warehouse layers. However, this is pressured by the burgeoning business of the grocery store brand. The data size they have to receive, store, and analyze is getting larger and larger. That means their data warehouse has to handle bigger data writing batches and more frequent data queries. However, task scheduling during query execution might lead to resource preemption, so any resource shortage can easily compromise performance or even cause task failure or system disruption. Naturally, the user thought of separating the reading and writing workloads. Specifically, they want to replicate data from the ADS layer (which is cleaned, transformed, aggregated, and ready to be queried) to a backup cluster dedicated to query services. This is implemented by the CCR in Apache Doris. It prevents abnormal queries from interrupting data writing and ensures cluster stability. Before CCR Before CCR was available, they innovatively adopted the Multi-Catalog feature of Doris for the same purpose. Multi-Catalog allows users to connect Doris to various data sources conveniently. It is actually designed for federated querying, but the user drew inspiration from it. They wrote a script and tried to pull incremental data via Catalog. Their data synchronization pipeline is as follows: They loaded data from the source cluster to the target cluster by regular scheduling tasks. To identify incremental data, they added a last_update_time field to the tables. There were two downsides to this. Firstly, the data freshness of the target cluster was reliant on and hindered by the scheduling tasks. Secondly, for incremental data ingestion, in order to identify incremental data, the import SQL statement for every table has to include the logic to check the last_update_time field; otherwise, the system just deletes and re-imports the entire table. Such requirements increase development complexity and data error rate. CCR in Apache Doris Just when they were looking for a better solution, Apache Doris released CCR in version 2.0. Compared to the alternatives they've tried, CCR in Apache Doris is: Lightweight in design: The data synchronization tasks consume very few machine resources. They run smoothly without reducing Apache Doris's overall performance.


Easy to use: It can be configured by one simple POST request.


Unlimited in migration: Users can raise the upper limit of the data migration capabilities in CCR by optimizing their cluster configuration.


Consistent in data: The DDL statements executed in the source cluster can be automatically synchronized into the target cluster, ensuring data consistency.


Flexible in synchronization: It is able to perform both full data synchronization and incremental data synchronization. To start CCR in Doris simply requires two steps. Step one is to enable binlogs in both the source cluster and the target cluster. Step two is to send the name of the database or table to be replicated. Then, the system will start synchronizing full or incremental data. The detailed workflow is as follows: In the grocery store brand's case, they need to synchronize a few tables from the source cluster to the target cluster, each table having an incremental data size of about 50 million rows. After a month's trial run, the Doris CCR mechanism is proven to be stable and performant: Higher stability and data accuracy: No replication failure has ever occurred during the trial period. Every data row is transferred and landed in the target cluster accurately.


Streamlined workflows:


Before CCR: The user had to write SQL for each table and write data via Catalog. For tables without a last_update_time field, incremental data synchronization can only be implemented by full-table deletion and re-import.


Insert into catalog1.db.destination_table_1 select * from catalog1.db.source_table1 where time > xxx
Insert into catalog1.db.destination_table_2 select * from catalog1.db.source_table2 where time > xxx
…
Insert into catalog1.db.destination_table_x select * from catalog1.db.source_table_x



After CCR: It only requires one POST request to synchronize an entire database.


curl -X POST -H "Content-Type: application/json" -d '{
    "name": "ccr_test",
    "src": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "demo",
    "table": ""
    },
    "dest": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "ccrt",
    "table": ""
    }
}' http://127.0.0.1:9190/create_ccr



Faster data loading: With CCR, it only takes 3~4 seconds to ingest a day's incremental data, as compared to more than 30 seconds with the Catalog method. As for real-time synchronization, CCR can finish data ingestion in 1 second without reliance on manual updates or regular scheduling. Conclusion Using CCR in Apache Doris, the grocery store brand separates reading and writing workloads into different clusters and thus improves overall system stability. This solution delivers a real-time data synchronization latency of about 1 second. To further ensure normal functioning, it has a real-time monitoring and alerting mechanism so any issue will be notified and attended to instantly, as well as a contingency plan to guarantee uninterrupted query services. It also supports partition-based data synchronization (e.g. ALTER TABLE tbl1 REPLACE PARTITION). With the demonstrated effectiveness of CCR, they are planning to replicate more of their data assets for efficient and secure data usage. CCR is also applicable when you need to build multiple data centers or derive a test dataset from your production environment. For further guidance on CCR, join the Apache Doris community. This is about how a grocery store brand leverages the Cross-Cluster Replication (CCR) capability of Apache Doris to separate its data reading and writing workloads. In this case, where the freshness of data guarantees the freshness of groceries, Apache Doris uses Apache Doris as its data warehouse to monitor and analyze its procurement, sale, and stock in real-time for all its stores and supply chains. Cross-Cluster Replication (CCR) Why they need CCR A major part of the user's data warehouse (including the ODS, DWD, DWS, and ADS layers) is built within Apache Doris, which employs a micro-batch scheduling mechanism to coordinate data across the data warehouse layers. However, this is pressured by the burgeoning business of the grocery store brand. The data size they have to receive, store, and analyze is getting larger and larger. That means their data warehouse has to handle bigger data writing batches and more frequent data queries. However, task scheduling during query execution might lead to resource preemption, so any resource shortage can easily compromise performance or even cause task failure or system disruption. Naturally, the user thought of separating the reading and writing workloads. Specifically, they want to replicate data from the ADS layer (which is cleaned, transformed, aggregated, and ready to be queried) to a backup cluster dedicated to query services. This is implemented by the CCR in Apache Doris. It prevents abnormal queries from interrupting data writing and ensures cluster stability. separating the reading and writing workloads. This is implemented by the CCR in Apache Doris. Before CCR Before CCR was available, they innovatively adopted the Multi-Catalog feature of Doris for the same purpose. Multi-Catalog allows users to connect Doris to various data sources conveniently. It is actually designed for federated querying, but the user drew inspiration from it. They wrote a script and tried to pull incremental data via Catalog. Their data synchronization pipeline is as follows: Multi-Catalog They loaded data from the source cluster to the target cluster by regular scheduling tasks. To identify incremental data, they added a last_update_time field to the tables. There were two downsides to this. Firstly, the data freshness of the target cluster was reliant on and hindered by the scheduling tasks. Secondly, for incremental data ingestion, in order to identify incremental data, the import SQL statement for every table has to include the logic to check the last_update_time field; otherwise, the system just deletes and re-imports the entire table. Such requirements increase development complexity and data error rate. last_update_time last_update_time CCR in Apache Doris Just when they were looking for a better solution, Apache Doris released CCR in version 2.0. Compared to the alternatives they've tried, CCR in Apache Doris is: Lightweight in design: The data synchronization tasks consume very few machine resources. They run smoothly without reducing Apache Doris's overall performance. Easy to use: It can be configured by one simple POST request. Unlimited in migration: Users can raise the upper limit of the data migration capabilities in CCR by optimizing their cluster configuration. Consistent in data: The DDL statements executed in the source cluster can be automatically synchronized into the target cluster, ensuring data consistency. Flexible in synchronization: It is able to perform both full data synchronization and incremental data synchronization. Lightweight in design: The data synchronization tasks consume very few machine resources. They run smoothly without reducing Apache Doris's overall performance. Lightweight in design : The data synchronization tasks consume very few machine resources. They run smoothly without reducing Apache Doris's overall performance. Lightweight in design Easy to use: It can be configured by one simple POST request. Easy to use : It can be configured by one simple POST request. Easy to use POST Unlimited in migration: Users can raise the upper limit of the data migration capabilities in CCR by optimizing their cluster configuration. Unlimited in migration : Users can raise the upper limit of the data migration capabilities in CCR by optimizing their cluster configuration. Unlimited in migration Consistent in data: The DDL statements executed in the source cluster can be automatically synchronized into the target cluster, ensuring data consistency. Consistent in data : The DDL statements executed in the source cluster can be automatically synchronized into the target cluster, ensuring data consistency. Consistent in data Flexible in synchronization: It is able to perform both full data synchronization and incremental data synchronization. Flexible in synchronization : It is able to perform both full data synchronization and incremental data synchronization. Flexible in synchronization To start CCR in Doris simply requires two steps. Step one is to enable binlogs in both the source cluster and the target cluster. Step two is to send the name of the database or table to be replicated. Then, the system will start synchronizing full or incremental data. The detailed workflow is as follows: In the grocery store brand's case, they need to synchronize a few tables from the source cluster to the target cluster, each table having an incremental data size of about 50 million rows. After a month's trial run, the Doris CCR mechanism is proven to be stable and performant: Higher stability and data accuracy: No replication failure has ever occurred during the trial period. Every data row is transferred and landed in the target cluster accurately. Streamlined workflows:


Before CCR: The user had to write SQL for each table and write data via Catalog. For tables without a last_update_time field, incremental data synchronization can only be implemented by full-table deletion and re-import.


Insert into catalog1.db.destination_table_1 select * from catalog1.db.source_table1 where time > xxx
Insert into catalog1.db.destination_table_2 select * from catalog1.db.source_table2 where time > xxx
…
Insert into catalog1.db.destination_table_x select * from catalog1.db.source_table_x



After CCR: It only requires one POST request to synchronize an entire database.


curl -X POST -H "Content-Type: application/json" -d '{
    "name": "ccr_test",
    "src": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "demo",
    "table": ""
    },
    "dest": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "ccrt",
    "table": ""
    }
}' http://127.0.0.1:9190/create_ccr Faster data loading: With CCR, it only takes 3~4 seconds to ingest a day's incremental data, as compared to more than 30 seconds with the Catalog method. As for real-time synchronization, CCR can finish data ingestion in 1 second without reliance on manual updates or regular scheduling. Higher stability and data accuracy: No replication failure has ever occurred during the trial period. Every data row is transferred and landed in the target cluster accurately. Higher stability and data accuracy : No replication failure has ever occurred during the trial period. Every data row is transferred and landed in the target cluster accurately. Higher stability and data accuracy Streamlined workflows: Before CCR: The user had to write SQL for each table and write data via Catalog. For tables without a last_update_time field, incremental data synchronization can only be implemented by full-table deletion and re-import. Insert into catalog1.db.destination_table_1 select * from catalog1.db.source_table1 where time > xxx
Insert into catalog1.db.destination_table_2 select * from catalog1.db.source_table2 where time > xxx
…
Insert into catalog1.db.destination_table_x select * from catalog1.db.source_table_x After CCR: It only requires one POST request to synchronize an entire database. curl -X POST -H "Content-Type: application/json" -d '{
    "name": "ccr_test",
    "src": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "demo",
    "table": ""
    },
    "dest": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "ccrt",
    "table": ""
    }
}' http://127.0.0.1:9190/create_ccr Streamlined workflows: Streamlined workflows: Before CCR: The user had to write SQL for each table and write data via Catalog. For tables without a last_update_time field, incremental data synchronization can only be implemented by full-table deletion and re-import. Before CCR: The user had to write SQL for each table and write data via Catalog. For tables without a last_update_time field, incremental data synchronization can only be implemented by full-table deletion and re-import. Before CCR : The user had to write SQL for each table and write data via Catalog. For tables without a last_update_time field, incremental data synchronization can only be implemented by full-table deletion and re-import. Before CCR last_update_time Insert into catalog1.db.destination_table_1 select * from catalog1.db.source_table1 where time > xxx
Insert into catalog1.db.destination_table_2 select * from catalog1.db.source_table2 where time > xxx
…
Insert into catalog1.db.destination_table_x select * from catalog1.db.source_table_x Insert into catalog1.db.destination_table_1 select * from catalog1.db.source_table1 where time > xxx
Insert into catalog1.db.destination_table_2 select * from catalog1.db.source_table2 where time > xxx
…
Insert into catalog1.db.destination_table_x select * from catalog1.db.source_table_x After CCR: It only requires one POST request to synchronize an entire database. After CCR: It only requires one POST request to synchronize an entire database. After CCR : It only requires one POST request to synchronize an entire database. After CCR POST curl -X POST -H "Content-Type: application/json" -d '{
    "name": "ccr_test",
    "src": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "demo",
    "table": ""
    },
    "dest": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "ccrt",
    "table": ""
    }
}' http://127.0.0.1:9190/create_ccr curl -X POST -H "Content-Type: application/json" -d '{
    "name": "ccr_test",
    "src": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "demo",
    "table": ""
    },
    "dest": {
    "host": "localhost",
    "port": "9030",
    "thrift_port": "9020",
    "user": "root",
    "password": "",
    "database": "ccrt",
    "table": ""
    }
}' http://127.0.0.1:9190/create_ccr Faster data loading: With CCR, it only takes 3~4 seconds to ingest a day's incremental data, as compared to more than 30 seconds with the Catalog method. As for real-time synchronization, CCR can finish data ingestion in 1 second without reliance on manual updates or regular scheduling. Faster data loading : With CCR, it only takes 3~4 seconds to ingest a day's incremental data, as compared to more than 30 seconds with the Catalog method. As for real-time synchronization, CCR can finish data ingestion in 1 second without reliance on manual updates or regular scheduling. Faster data loading 3~4 seconds Conclusion Using CCR in Apache Doris, the grocery store brand separates reading and writing workloads into different clusters and thus improves overall system stability. This solution delivers a real-time data synchronization latency of about 1 second. To further ensure normal functioning, it has a real-time monitoring and alerting mechanism so any issue will be notified and attended to instantly, as well as a contingency plan to guarantee uninterrupted query services. It also supports partition-based data synchronization (e.g. ALTER TABLE tbl1 REPLACE PARTITION ). With the demonstrated effectiveness of CCR, they are planning to replicate more of their data assets for efficient and secure data usage. ALTER TABLE tbl1 REPLACE PARTITION CCR is also applicable when you need to build multiple data centers or derive a test dataset from your production environment. For further guidance on CCR, join the Apache Doris community . Apache Doris community

Streamlining Data Operations: How a Grocery Chain Optimizes Workloads with Apache Doris

Node.js is one of the most widely used programming languages and frameworks and my preferred choice as a software engineer when it comes to building complex back-end structures. Choosing between Node.js and Python can be difficult as they both have their own pros and cons, however, by choosing it you may compromise on something but you can make up for that with different optimizations. This JavaScript framework is used in building high-performance scalable applications. Node.js’ I/O model is event-driven and non-blocking, making it a popular choice for I/O applications. However, just like any other language or framework, Node.js code needs to be written efficiently and optimized to achieve maximum performance. In this article, we’ll look at some of the best ways to optimize Node.js code for increased speed, scalability, and resource efficiency. Let's make a service using Node.js to create ‘QR codes’(CPU-intensive task) to understand how we can use C++ for optimizations. Results for generating 10000 QR codes: C++ single thread: 2960.125ms Nodejs: 19180.051ms Node js code to generate QR codes: Following steps for C++: Step 1: package.json We need to add “gypfile” flag as true and dependencies. Step 2: Create DataProcessingAsyncWorker.h (addon folder) Header file that we will need further. Step 3: Create DataProcessingAsyncWorker.cc (addon folder) Here, we write processing logic. Step 4: Create Addon.cc (addon folder) Here, we have a C++ function (ProcessData), which we can call from javascript and which will execute our main processing logic on a separate thread by adding it to the worker queue. Step 5: Install C++ dependencies Step 6: Create binding.gyp Step 7: Npm install Npm install will build C++ files, and it can be used in node js as follows: And we are done with the code walkthrough! Every request will be added to a new thread. Let's try with 2 concurrent requests for 50,000 and 40,000 codes. Here, we can see the parallel processing of 2 requests on separate threads(Multithreading). We saw how easy it is to optimize node js for CPU-intensive tasks using C++. Source code: https://github.com/riddheshganatra/qrcodenodecpp Node.js is one of the most widely used programming languages and frameworks and my preferred choice as a software engineer when it comes to building complex back-end structures. Choosing between Node.js and Python can be difficult as they both have their own pros and cons, however, by choosing it you may compromise on something but you can make up for that with different optimizations. This JavaScript framework is used in building high-performance scalable applications. Node.js’ I/O model is event-driven and non-blocking, making it a popular choice for I/O applications. However, just like any other language or framework, Node.js code needs to be written efficiently and optimized to achieve maximum performance. In this article, we’ll look at some of the best ways to optimize Node.js code for increased speed, scalability, and resource efficiency. Let's make a service using Node.js to create ‘QR codes’(CPU-intensive task) to understand how we can use C++ for optimizations. Results for generating 10000 QR codes: C++ single thread: 2960.125ms Nodejs: 19180.051ms Node js code to generate QR codes: Following steps for C++: Step 1: package.json Step 1: package.json We need to add “gypfile” flag as true and dependencies. Step 2: Create DataProcessingAsyncWorker.h (addon folder) Step 2: Create DataProcessingAsyncWorker.h (addon folder) Header file that we will need further. Step 3: Create DataProcessingAsyncWorker.cc (addon folder) Step 3: Create DataProcessingAsyncWorker.cc (addon folder) Here, we write processing logic. Step 4: Create Addon.cc (addon folder) Step 4: Create Addon.cc (addon folder) Here, we have a C++ function (ProcessData), which we can call from javascript and which will execute our main processing logic on a separate thread by adding it to the worker queue. Step 5: Install C++ dependencies Step 5: Install C++ dependencies Step 6: Create binding.gyp Step 6: Create binding.gyp Step 7: Npm install Step 7: Npm install Npm install will build C++ files, and it can be used in node js as follows: And we are done with the code walkthrough! Every request will be added to a new thread. Let's try with 2 concurrent requests for 50,000 and 40,000 codes. Here, we can see the parallel processing of 2 requests on separate threads(Multithreading). We saw how easy it is to optimize node js for CPU-intensive tasks using C++. Source code: https://github.com/riddheshganatra/qrcodenodecpp https://github.com/riddheshganatra/qrcodenodecpp

How to Optimize Node.js with C++ Addons

The Noonification: 3 Quick Ways to Optimize RecyclerView (5/14/2024)

3 Quick Ways to Optimize RecyclerView

RecyclerView অপ্টিমাইজ করার 3টি দ্রুত উপায়

3 schnelle Möglichkeiten zur Optimierung von RecyclerView

Tres formas rápidas de optimizar RecyclerView

3 façons rapides d'optimiser RecyclerView

रीसाइक्लरव्यू को अनुकूलित करने के 3 त्वरित तरीके

RecyclerView を最適化する 3 つの簡単な方法

RecyclerView를 최적화하는 3가지 빠른 방법

3 maneiras rápidas de otimizar o RecyclerView

3 быстрых способа оптимизировать RecyclerView

RecyclerView'ı Optimize Etmenin 3 Hızlı Yolu

3 cách nhanh chóng để tối ưu hóa RecyclerView

优化 RecyclerView 的 3 种快速方法

By now, most of us are accustomed to using CSS Custom Properties on projects. Since its introduction in 2017, CSS Custom Properties, also known as CSS variables, have optimised the code we work with and allowed engineers a finer degree of control when managing values within rules. CSS Custom Properties can be tricky to deal with and aren’t always as intuitive as one might hope. However, when used right, they can significantly reduce boilerplate code and keep things efficient, making our work more productive. While the approach below is not perfect, it works well when writing CSS for building projects. Why Use CSS Custom Properties As far as my experience goes, I can only think of three possible reasons to implement a CSS Variable: We want to use a given value in more than one place,


We know that a value will change in the future and want to reduce our efforts for refactoring,


We need to store dynamic values from JS execution. With this in mind, we can be more assertive about our use cases. Point 3 is less of a concern for this article, but points 1 and 2 are essential. Let's illustrate this using the familiar HTML button element. The Infamous Button Buttons are notoriously tricky to style consistently for such a simple HTML element. Perhaps it’s because they have several different states and applications, regardless - it's usually the first component we Frontend Engineers take on when it comes to a fresh build. Let's have a look at how we could write the style for a button using CSS Custom Properties: :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
 --button-bg: var(--color-primary);
 --button-color: var(--color-text-inverted);
 --button-border: var(--color-border);

 align-items: center;
 background-color: var(--button-bg);
 border: 1px solid var(--button-border);
 color: var(--button-color);
 display: inline-flex;
 line-height: 1;
} As far as this example goes, from a technical standpoint, it’s great. It’s clean and straightforward and would get a 👍 from me in a code review. But could we optimise it further? Well, yes. The var() function in CSS is pretty nifty…we’re used to using it in a somewhat one-dimensional way by just rendering out a value; however, it can be more dynamic. The way to do this is by using a fallback value. If we considered the above example, we could rewrite it like so: :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
  align-items: center;
  background-color: var(--button-bg, var(--color-primary));
  border: 2px solid var(--button-border, var(--color-border));
  color: var(--button-color, var(--color-text-inverted));
  cursor: pointer;
  display: inline-flex;
  line-height: 1;
  padding-block: 0.875rem;
  padding-inline: 1rem;
} This is far cleaner and will lead to the same outcomes as the previous example - with less boilerplate code. Overriding it in a variation makes each locally scoped CSS Variable (effectively) optional. We can easily now optionally define the variables defined in .button as separate variations: .button:where(.button-secondary) {
  --button-bg: orange;
  --button-border: teal;
}

.button:where(.button-tertiary) {
  --button-bg: teal;
  --button-border: orange;
} Although this technique is not revolutionary, we care how many lines of compressed text are heading over the wire. The less physical memory a CSS file takes up, the better, which ultimately translates to how many lines of CSS exist. In the first example, we’re looking at almost double the amount of code to achieve the same thing in our optimised example. This compound effect has an influential impact on performance and further improves readability and developer experience. If you'd like to play around a bit further, feel free to fork the following Code Pen: https://codepen.io/iamdainemawer/pen/NWmQZMz Support Since April 2017, according to Google Baseline, this feature is well-supported across all major browsers. If you're interested to learn more about Baseline, read my post about Google Baseline and Its Impact You can check for browser support by adding the following statement to your CSS stylesheets: @supports(--css: variable) {} Can I Use - CSS Nesting
CSS Specification - CSS Nesting Module Resources MDN - CSS Custom Properties
CSS Variables Polyfill By now, most of us are accustomed to using CSS Custom Properties on projects. Since its introduction in 2017, CSS Custom Properties, also known as CSS variables, have optimised the code we work with and allowed engineers a finer degree of control when managing values within rules. CSS Custom Properties can be tricky to deal with and aren’t always as intuitive as one might hope. However, when used right, they can significantly reduce boilerplate code and keep things efficient, making our work more productive. While the approach below is not perfect, it works well when writing CSS for building projects. Why Use CSS Custom Properties As far as my experience goes, I can only think of three possible reasons to implement a CSS Variable: We want to use a given value in more than one place, We know that a value will change in the future and want to reduce our efforts for refactoring, We need to store dynamic values from JS execution. We want to use a given value in more than one place, We want to use a given value in more than one place, We know that a value will change in the future and want to reduce our efforts for refactoring, We know that a value will change in the future and want to reduce our efforts for refactoring, We need to store dynamic values from JS execution. We need to store dynamic values from JS execution. With this in mind, we can be more assertive about our use cases. Point 3 is less of a concern for this article, but points 1 and 2 are essential. Let's illustrate this using the familiar HTML button element. The Infamous Button Buttons are notoriously tricky to style consistently for such a simple HTML element. Perhaps it’s because they have several different states and applications, regardless - it's usually the first component we Frontend Engineers take on when it comes to a fresh build. Let's have a look at how we could write the style for a button using CSS Custom Properties: :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
 --button-bg: var(--color-primary);
 --button-color: var(--color-text-inverted);
 --button-border: var(--color-border);

 align-items: center;
 background-color: var(--button-bg);
 border: 1px solid var(--button-border);
 color: var(--button-color);
 display: inline-flex;
 line-height: 1;
} :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
 --button-bg: var(--color-primary);
 --button-color: var(--color-text-inverted);
 --button-border: var(--color-border);

 align-items: center;
 background-color: var(--button-bg);
 border: 1px solid var(--button-border);
 color: var(--button-color);
 display: inline-flex;
 line-height: 1;
} As far as this example goes, from a technical standpoint, it’s great. It’s clean and straightforward and would get a 👍 from me in a code review. But could we optimise it further? Well, yes. The var() function in CSS is pretty nifty…we’re used to using it in a somewhat one-dimensional way by just rendering out a value; however, it can be more dynamic. The way to do this is by using a fallback value . var() fallback value If we considered the above example, we could rewrite it like so: :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
  align-items: center;
  background-color: var(--button-bg, var(--color-primary));
  border: 2px solid var(--button-border, var(--color-border));
  color: var(--button-color, var(--color-text-inverted));
  cursor: pointer;
  display: inline-flex;
  line-height: 1;
  padding-block: 0.875rem;
  padding-inline: 1rem;
} :root {
 --color-primary: purple;
 --color-text: black;
 --color-text-inverted: white;
 --color-border: gray;
}

.button {
  align-items: center;
  background-color: var(--button-bg, var(--color-primary));
  border: 2px solid var(--button-border, var(--color-border));
  color: var(--button-color, var(--color-text-inverted));
  cursor: pointer;
  display: inline-flex;
  line-height: 1;
  padding-block: 0.875rem;
  padding-inline: 1rem;
} This is far cleaner and will lead to the same outcomes as the previous example - with less boilerplate code. Overriding it in a variation makes each locally scoped CSS Variable (effectively) optional. We can easily now optionally define the variables defined in .button as separate variations: .button:where(.button-secondary) {
  --button-bg: orange;
  --button-border: teal;
}

.button:where(.button-tertiary) {
  --button-bg: teal;
  --button-border: orange;
} .button:where(.button-secondary) {
  --button-bg: orange;
  --button-border: teal;
}

.button:where(.button-tertiary) {
  --button-bg: teal;
  --button-border: orange;
} Although this technique is not revolutionary, we care how many lines of compressed text are heading over the wire. The less physical memory a CSS file takes up, the better, which ultimately translates to how many lines of CSS exist. In the first example, we’re looking at almost double the amount of code to achieve the same thing in our optimised example. This compound effect has an influential impact on performance and further improves readability and developer experience. If you'd like to play around a bit further, feel free to fork the following Code Pen: https://codepen.io/iamdainemawer/pen/NWmQZMz https://codepen.io/iamdainemawer/pen/NWmQZMz Support Since April 2017, according to Google Baseline , this feature is well-supported across all major browsers. If you're interested to learn more about Baseline, read my post about Google Baseline and Its Impact Google Baseline Google Baseline and Its Impact You can check for browser support by adding the following statement to your CSS stylesheets: @supports(--css: variable) {} @supports(--css: variable) {} Can I Use - CSS Nesting CSS Specification - CSS Nesting Module Can I Use - CSS Nesting Can I Use - CSS Nesting CSS Specification - CSS Nesting Module CSS Specification - CSS Nesting Module Resources MDN - CSS Custom Properties CSS Variables Polyfill MDN - CSS Custom Properties MDN - CSS Custom Properties CSS Variables Polyfill CSS Variables Polyfill

Using CSS Custom Properties To Optimize Styling Efficiency and Readability

Essential Entity Framework Core Tips: How to Optimize Performance, Streamline Queries, and More

This is paper is available on arxiv under CC 4.0 DEED license. Authors: (1) Leah Chrestien, Czech Technical University in Prague; (2) Tomá˘s Pevný, Czech Technical University in Prague, and Gen Digital, Inc.; (3) Stefan Edelkamp, Czech Technical University in Prague; (4) Antonín Komenda, Czech Technical University in Prague. Table of Links Abstract & Introduction Preliminaries Conditions on strictly optimally efficient heuristic Loss functions Related Work Experiments Conclusion and References Appendix 7 Conclusion The motivation of this paper stemmed from the observation that even the cost-to-goal, considered to be an optimal heuristic, fails to guarantee a strictly optimally efficient search. Since a large body of existing research optimizes this quantity, we are effectively lost with respect to what should be optimized. To fill this gap, we have stated the necessary and sufficient conditions guaranteeing the forward search to be strictly optimally efficient. These conditions show that the absolute value of the heuristic is not important, but that the ranking of states in the Open list is what controls the efficiency. Ranking can be optimized by minimizing the ranking loss functions, but its concrete implementation needs to correspond to a variant of the forward search. In case of mismatch, the resulting heuristic can perform poorly, which has been demonstrated when the heuristic optimized for BGFS search was used with A* search. The other benefit of ranking losses is that from the point of view of statistical learning theory, they solve a simpler problem than ubiquitous regression in estimating the cost-to-goal. We do not question the existence of a strictly optimally efficient heuristic. Given our experiments, we believe that if the space of heuristic functions over which the loss is optimized is sufficiently rich, the result will be sufficiently close to the optimal for the needs of the search. 7.1 Acknowledgements This work has been supported by project numbers 22-32620S and 22-30043S from Czech Science Foundation and OP VVV project CZ.02.1.01/0.0/0.0/16_019/0000765 "Research Center for Informatics". This work has also received funding from the European Union’s Horizon Europe Research and Innovation program under the grant agreement TUPLES No 101070149. References [1] Forest Agostinelli, Stephen McAleer, Alexander Shmakov, and Pierre Baldi. Solving the rubik’s cube with deep reinforcement learning and search. Nature Machine Intelligence, 1(8):356–363, 2019. [2] Thomas Anthony, Zheng Tian, and David Barber. Thinking fast and slow with deep learning and tree search. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett, editors, Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 5360–5370, 2017. [3] Shahab Jabbari Arfaee, Sandra Zilles, and Robert C Holte. Learning heuristic functions for large state spaces. Artificial Intelligence, 175(16-17):2075–2098, 2011. [4] Jeff Bezanson, Alan Edelman, Stefan Karpinski, and Viral B Shah. Julia: A fresh approach to numerical computing. SIAM review, 59(1):65–98, 2017. [5] Mohak Bhardwaj, Sanjiban Choudhury, and Sebastian Scherer. Learning heuristic search via imitation. In Conference on Robot Learning, pages 271–280. PMLR, 2017. [6] Blai Bonet and Héctor Geffner. Planning as heuristic search. Artificial Intelligence. 2001 Jun; 129 (1-2): 5-33., 2001. [7] Vladimir Cherkassky, Xuhui Shao, Filip M Mulier, and Vladimir N Vapnik. Model complexity control for regression using vc generalization bounds. IEEE transactions on Neural Networks, 10(5):1075–1089, 1999. [8] Leah Chrestien, Tomáš Pevný, Antonín Komenda, and Stefan Edelkamp. Heuristic search planning with deep neural network using imitation, attention and curriculum learning. In PRLIJCAI workshop, 2021. [9] Lukás Chrpa. Combining learning techniques for classical planning: Macro-operators and entanglements. In ICTAI, pages 79–86. IEEE Computer Society, 2010. [10] Rina Dechter and Judea Pearl. The optimality of A* revisited. In Michael R. Genesereth, editor, AAAI, pages 95–99. AAAI Press, 1983. [11] Edsger W. Dijkstra. A note on two problems in connexion with graphs. Numerische Mathematik, 1:269–271, 1959. [12] Stefan Edelkamp. Automated creation of pattern database search heuristics. In Model Checking and Artificial Intelligence, pages 35–50, 2006. [13] Stefan Edelkamp and Stefan Schrödl. Heuristic Search - Theory and Applications. Academic Press, 2012. [14] Ariel Felner, Uzi Zahavi, Robert Holte, Jonathan Schaeffer, Nathan Sturtevant, and Zhifu Zhang. Inconsistent heuristics in theory and practice. Artificial Intelligence, 175(9):1570–1603, 2011. [15] Dieqiao Feng, Carla P. Gomes, and Bart Selman. Solving hard AI planning instances using curriculum-driven deep reinforcement learning. In Christian Bessiere, editor, Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence, IJCAI 2020, pages 2198–2205. ijcai.org, 2020. [16] Patrick Ferber, Malte Helmert, and Jörg Hoffmann. Neural network heuristics for classical planning: A study of hyperparameter space. In ECAI, pages 2346–2353. IOS Press, 2020. [17] Santiago Franco, Álvaro Torralba, Levi H. S. Lelis, and Mike Barley. On creating complementary pattern databases. In IJCAI, pages 4302–4309, 2017. [18] Caelan Reed Garrett, Leslie Pack Kaelbling, and Tomás Lozano-Pérez. Learning to rank for synthesizing planning heuristics. page 3089–3095, 2016. [19] Edward Groshev, Aviv Tamar, Maxwell Goldstein, Siddharth Srivastava, and Pieter Abbeel. Learning generalized reactive policies using deep neural networks. 2018. [20] Arthur Guez, Théophane Weber, Ioannis Antonoglou, Karen Simonyan, Oriol Vinyals, Daan Wierstra, Rémi Munos, and David Silver. Learning to search with mctsnets. In International conference on machine learning, pages 1822–1831. PMLR, 2018. [21] Peter E Hart, Nils J Nilsson, and Bertram Raphael. A formal basis for the heuristic determination of minimum cost paths. IEEE transactions on Systems Science and Cybernetics, 4(2):100–107, 1968. [22] Patrik Haslum, Adi Botea, Malte Helmert, Blai Bonet, and Sven Koenig. Domain-independent construction of pattern database heuristics for cost-optimal planning. In AAAI, pages 1007–1012, 2007. [23] Malte Helmert and Gabriele Röger. How good is almost perfect? In AAAI, pages 944–949. AAAI Press, 2008. [24] Robert C. Holte and Sandra Zilles. On the optimal efficiency of cost-algebraic A. In The Thirty-Third AAAI Conference on Artificial Intelligence, AAAI 2019, pages 2288–2295. AAAI Press, 2019. [25] Michael Katz, Shirin Sohrabi, Horst Samulowitz, and Silvan Sievers. Delfi: Online planner selection for cost-optimal planning. IPC-9 planner abstracts, pages 57–64, 2018. [26] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014. [27] Donald E Knuth and Ronald W Moore. An analysis of alpha-beta pruning. Artificial intelligence, 6(4):293–326, 1975. [28] Richard E. Korf. Iterative-deepening-A*: An optimal admissible tree search. In IJCAI, pages 1034–1036. Morgan Kaufmann, 1985. [29] Richard E Korf. Macro-operators: A weak method for learning. Artificial intelligence, 26(1):35–77, 1985. [30] Šimon Mandlík, Matej Ra ˇ cinsk ˇ y, Viliam Lis ` y, and Tomáš Pevn ` y. Jsongrinder. jl: automated ` differentiable neural architecture for embedding arbitrary json data. Journal of Machine Learning Research, 23(298):1–5, 2022. [31] Drew V. McDermott. A heuristic estimator for means-ends analysis in planning. In AIPS, pages 142–149. AAAI, 1996. [32] David Ménager, Dongkyu Choi, Mark Roberts, and David W. Aha. Learning planning operators from episodic traces. In 2018 AAAI Spring Symposia. AAAI Press, 2018. [33] Ionut Moraru, Stefan Edelkamp, Santiago Franco, and Moisés Martínez. Simplifying automated pattern selection for planning with symbolic pattern databases. In KI, pages 249–263, 2019. [34] Christian Muise. Collection of pddl files of classical problems. https://github.com/AI-Planning/classical-domains, 2023. [35] XuanLong Nguyen, Martin J Wainwright, and Michael I Jordan. On surrogate loss functions and f-divergences. The Annals of Statistics, pages 876–904, 2009. [36] Laurent Orseau, Levi Lelis, Tor Lattimore, and Théophane Weber. Single-agent policy tree search with guarantees. Advances in Neural Information Processing Systems, 31, 2018. [37] Laurent Orseau and Levi HS Lelis. Implementation of the algorithms described in "policyguided heuristic search with guarantees" by l. orseau and l. lelis, published at aaai’21. https://github.com/levilelis/h-levin, 2021. [38] Laurent Orseau and Levi HS Lelis. Policy-guided heuristic search with guarantees. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pages 12382–12390, 2021. [39] Arthur L Samuel. Some studies in machine learning using the game of checkers. ii—recent progress. IBM Journal of research and development, 11(6):601–617, 1967. [40] Max-Philipp B. Schrader. gym-sokoban. https://github.com/mpSchrader/gym-sokoban, 2018. [41] Jendrik Seipp, Florian Pommerening, and Malte Helmert. New optimization functions for potential heuristics. In ICAPS, 2015. [42] Jendrik Seipp and Silvan Sievers. Fast downward stone soup 2023. [43] Jendrik Seipp, Álvaro Torralba, and Jörg Hoffmann. PDDL generators. https://doi.org/10.5281/zenodo.6382173, 2022. [44] William Shen. Strips-hgn. https://github.com/williamshen-nz/STRIPS-HGN, 2021. [45] William Shen, Felipe Trevizan, and Sylvie Thiébaux. Learning domain-independent planning heuristics with hypergraph networks. In ICAPS, volume 30, pages 574–584, 2020. [46] David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. nature, 550(7676):354–359, 2017. [47] Kristian Smith. Maze creator / solver. https://github.com/ravenkls/Maze-Generator-and Solver, 2022. [48] Gustav Sourek, Vojtech Aschenbrenner, Filip Zelezny, Steven Schockaert, and Ondrej Kuzelka. Lifted relational neural networks: Efficient learning of latent relational structures. Journal of Artificial Intelligence Research, 62:69–100, 2018. [49] Simon Ståhlberg, Blai Bonet, and Hector Geffner. Learning general optimal policies with graph neural networks: Expressive power, transparency, and limits. In Akshat Kumar, Sylvie Thiébaux, Pradeep Varakantham, and William Yeoh, editors, Proceedings of the Thirty-Second International Conference on Automated Planning and Scheduling, ICAPS 2022, Singapore (virtual), June 13-24, 2022, pages 629–637. AAAI Press, 2022. [50] Ingo Steinwart. Consistency of support vector machines and other regularized kernel classifiers. IEEE transactions on information theory, 51(1):128–142, 2005. [51] Takeshi Takahashi, He Sun, Dong Tian, and Yebin Wang. Learning heuristic functions for mobile robot path planning using deep neural networks. In ICAPS, volume 29, pages 764–772, 2019. [52] Alvaro Torralba, Vidal Alcázar, Daniel Borrajo, Peter Kissmann, and Stefan Edelkamp. SymBA*: A symbolic bidirectional A* planner. In International Planning Competition, pages 105–108, 2014. [53] Sam Toyer, Sylvie Thiébaux, Felipe Trevizan, and Lexing Xie. Asnets: Deep learning for generalised planning. Journal of Artificial Intelligence Research, 68:1–68, 2020. [54] Vladimir Vapnik. Principles of risk minimization for learning theory. Advances in neural information processing systems, 4, 1991. [55] Marin Vlastelica, Michal Rolinek, and Georg Martius. Neuro-algorithmic policies enable fast combinatorial generalization. In International Conference on Machine Learning, pages 10575– 10585. PMLR, 2021. [56] Xuemei Wang. Learning planning operators by observation and practice. In Kristian J. Hammond, editor, AIPS, pages 335–340. AAAI, 1994. [57] Christopher Wilt and Wheeler Ruml. When does weighted A* fail? In International Symposium on Combinatorial Search, volume 3, 2012. [58] Christopher Makoto Wilt and Wheeler Ruml. Effective heuristics for suboptimal best-first search. J. Artif. Intell. Res., 57:273–306, 2016. [59] Yuehua Xu, Alan Fern, and Sungwook Yoon. Learning linear ranking functions for beam search with application to planning. Journal of Machine Learning Research, 10(7), 2009. [60] Ryo Yonetani, Tatsunori Taniai, Mohammadamin Barekatain, Mai Nishimura, and Asako Kanezaki. Path planning using neural A* search. In International Conference on Machine Learning, pages 12029–12039. PMLR, 2021. [61] Ziqi Zhang and Florian Geißer. Extending graph neural networks for generalized stochastic planning. In Bridging the Gap Between AI Planning and Reinforcement Learning. 2021. [62] Tan Zhi-Xuan. PDDL. jl: An Extensible Interpreter and Compiler Interface for Fast and Flexible AI Planning. PhD thesis, Massachusetts Institute of Technology, 2022. [63] Juntang Zhuang, Tommy Tang, Yifan Ding, Sekhar C Tatikonda, Nicha Dvornek, Xenophon Papademetris, and James Duncan. Adabelief optimizer: Adapting stepsizes by the belief in observed gradients. Advances in neural information processing systems, 33:18795–18806, 2020.

Optimize Planning Heuristics to Rank, not to Estimate Cost-to-Goal: Conclusion and References

Optimize Planning Heuristics to Rank, not to Estimate Cost-to-Goal: Experiments

Optimize Planning Heuristics to Rank, not to Estimate Cost-to-Goal: Appendix

Optimize Planning Heuristics to Rank, not to Estimate Cost-to-Goal: Loss functions

Optimize Planning Heuristics to Rank: Conditions on Strictly Optimally Efficient Heuristic

This is paper is available on arxiv under CC 4.0 DEED license. Authors: (1) Leah Chrestien, Czech Technical University in Prague; (2) Tomá˘s Pevný, Czech Technical University in Prague, and Gen Digital, Inc.; (3) Stefan Edelkamp, Czech Technical University in Prague; (4) Antonín Komenda, Czech Technical University in Prague. Table of Links Abstract & Introduction Preliminaries Conditions on strictly optimally efficient heuristic Loss functions Related Work Experiments Conclusion and References Appendix 5 Related Work The closest work to ours is [36, 38], which adjusts heuristic value by a policy estimated from the neural network. The theory therein has the same motivation, to minimize the number of expanded states, though it is more complicated than the theory presented here. For efficiency, [38] needs to modify the GBFS such that search nodes store policy and probability of reaching the node from the start. Moreover, in some variants (used in the experimental comparison below) the neural network has to estimate both heuristic value and policy. Inspired by statistical surveys of heuristic functions in [57, 58], [18] proposes to optimize the rank of states preserving order defined by the true cost-to-goal. The formulation is therefore valid only for GBFS and not for A* search. Ties are not resolved, which means the strict optimal efficiency cannot be guaranteed. Similarly, heuristic values for domains where all actions have zero cost cannot be optimized. Lastly and importantly, the need to know the true cost-to-goal for all states in the training set greatly increases the cost of its construction as discussed above. From Bellman’s equation [49] arrives at the requirement that the smallest heuristic value of child nodes has to be smaller than that of the parent node. The resulting loss is regularized with L1 forcing the value of the heuristic to be close to cost-to-goal. In [5], A* is viewed as a Markov Decision Process with the Q-function equal to the number of steps of A* reaching the solution. This detaches the heuristic values from the cost-to-goal cost, but it does not solve the problem with dead-ends and ties, since the optimization is done by minimizing L2 loss. Symmetry of L2 (and of L1) loss are discussed in [51], as it does not promote the admissibility of the heuristic. It suggests asymmetric L1 loss with different weights on the left and right parts, but this does not completely solve the problem of estimating cost-to-goal (for example with ties, dead-ends). Parameters of potential heuristics [41] are optimized by linear programming for each problem instance to meet admissibility constraints while helping the search. On contrary, this work focuses on the efficiency of the search for many problem instances but cannot guarantee admissibility in general. Combining neural networks with discrete search algorithms, such that they become an inseparable part of the architecture is proposed in [55] and [60]. The gradient with respect to parameters has to be propagated through the search algorithm which usually requires both approximation and the search algorithm to be executed during every inference. A large body of literature [2, 15, 20, 46] improves the Monte Carlo Tree Search (MCTS), which has the advantage to suppress the noise in estimates of the solution costs. These methods proposed there are exclusive to MCTS and do not apply to variants of the forward search algorithm. Similarly, a lot of works [5, 8, 16, 19, 45, 53, 61] investigate architectures of neural networks implementing the heuristic function h(s, θ), ideally for arbitrary planning problems. We use [8, 45] to implement h(s, θ), but remind our readers that our interest is the loss function minimized when optimizing θ. Finally, [1] proposes to construct a training set similarly to pattern databases [12] by random backward movements from the goal state and to adapt A* for multi-core processors by expandingk > 1 states in each iteration. These improvements are independent of those proposed here and can be combined.

Optimize Planning Heuristics to Rank, not to Estimate Cost-to-Goal: Related Work

Optimize Planning Heuristics to Rank, not to Estimate Cost-to-Goal: Preliminaries

Optimize Planning Heuristics to Rank, not to Estimate Cost-to-Goal: Abstract & Intro

My journey on the current project started in October 2022 and this one is quite challenging. One of these challenges was the performance optimization area. Today, I would like to shine some light on this topic and share my experience. We will start from the basic concepts, look into the Web Vitals and core metrics for measuring the page loading, briefly walk through the topic of how a browser makes pixels on the screen from your code, and talk about optimization techniques. Importance of Application Loading Speed in User Experience First things first - let's explore the reasons why we should care about loading optimization: Improved load time enhances the user experience, keeps them engaged, and makes them less prone to shifting to another site. There are a lot of similar applications, and if you want to engage a user in your application, you have to have a fast-loaded application; Sites with faster loading times have higher conversion rates, impacting sales and registrations in e-commerce and other online businesses. Some companies researched how loading speed impacts sales for a business, and the results were quite impressive. Even a one-second delay can result in a 7% reduction in conversions, and 40% of users will abandon a website if it takes more than three seconds to load; Search engines like Google consider page load speed as a ranking factor in their algorithms, affecting the site visibility in search engine results. You have to be fast if you want to be at the top of Google search. This is one of the many factors impacting the website rank. Basic Concepts Overview of Web Vitals The first thing to discuss is Web Vitals. It's a pack of three metrics that the Google team formed. They are considered to be the most important metrics and vectors for improvement in the performance landscape. These metric values are fair only for the 75th percentile of users. It means that most of your users meet these metrics. The first one - the Largest Contentful Paint. In our topic, it is the most important one, and we will explore it in detail a little bit later. The Interaction to Next Paint is a metric showing how fast your page responds to a user's actions - click with the mouse, tap on the touchscreen, press a key on a keyboard or onscreen keyboard. This is the time when the browser begins processing event handlers in response to that action. And last but not least is the Cumulative Layout Shift. This metric shows how is unstable your UI - how many element shifts you have. The values are calculated with a special formula, but we are not going to reveal it. Understanding Largest Contentful Paint (LCP) and why it matters Okay, let's dive into the LCP metric and why it matters. It reports the render time of the largest image or text block visible in the viewport, relative to when the user first navigated to the page. To provide a good user experience, sites should strive to have the LCP of or less. LCP includes any unload time from the previous page, connection setup time, redirect time, and Time To First Byte, which can all be significant when measured in the field and can lead to differences between field and lab measurements. Let's see some examples of LCP calculation. You can see the loading page, and most of the time the LCP element is considered a big text block. However, after the image loading, the LCP element changed to the image. 2.5 seconds The second example is pretty much the same - while the future LCP elements are loading, some other text blocks are considered the largest on the page. In these examples, there are two similar situations - the LCP element loaded faster than other elements. Quick Look into the Critical Rendering Path (CRP) The Critical Rendering Path, or CRP, is the sequence of steps the browser goes through to convert the code of a web page into actual pixels on the screen. Understanding the CRP is essential for improving a page's load speed and overall performance. So, let's break it down further: When a user opens a web page, the browser starts by fetching the HTML content; The HTML is then parsed into a tree-like structure called the Document Object Model (DOM). This represents the structure of the webpage; Parallel to this, the browser fetches and parses style information, which includes CSS linked within the HTML, building the CSS Object Model (CSSOM) - which is a map of the site's visual rules; Once both DOM and CSSOM are built, the browser combines them into a Render Tree. This structure only includes visible elements and their styles; Based on the Render Tree, the browser then performs the Layout process, also known as reflow, calculating where each element should appear on the screen; The final step is the Painting, where the browser turns each node in the Render Tree into actual on-screen pixels; Any slowdown or blockage in these steps can delay the rendering of the page, causing a poor user experience. That's why it's crucial to optimize the CRP; Strategies & Techniques Now, we will look into the strategies and techniques, that can help us optimize our application. These are not all techniques in the world - just a part of them. Discussion of different caching methods We are starting from the cache. So, what exactly is caching? Think of caching as a high-speed memory storing temporary data that you're likely to need again. By storing this information in a cache - it drastically reduces the need to re-fetch the data from its source or reprocess a computation, hence saving precious time. There are several types of caching: . This stores static files, like CSS, JavaScript, and images, right in the user's browser; Browser Caching . This involves serving pre-generated responses to identical API requests straight from the cache rather than executing database queries each time; Server-Side Caching . This involves temporarily storing the results of a database query so that if identical queries are made, the result can be quickly retrieved from the cache rather than executing the query all over again; Database Caching How do we implement caching? We begin by identifying which assets or computations are costly and don't change frequently, making them ideal candidates for caching. Then, we choose the caching technique best suited based on our findings. Using CDN for faster content delivery Let's switch gears for a moment and discuss another effective strategy for speeding up web application performance - the use of a Content Delivery Network, commonly known as a CDN. So, what exactly is a CDN? At its simplest, a CDN is a network of servers spread out geographically, designed to deliver web content to users more quickly and efficiently. The content that a CDN caches usually includes images, stylesheets, JavaScript files, and more. So you might ask, how does a CDN actually work? The principle behind it is quite straightforward: the CDN will deliver the content from the server closest to the end user, significantly reducing the response time. Imagine you have users accessing your application from different parts of the world, and your server is somewhere in the US, and your application is accessible from any part of the world. Without a CDN, every request has to travel all the way to the US. But with a CDN, if a user is accessing from Spain, their request will be served by a server closest to Spain, drastically reducing the latency. Explaining asynchronous loading Normally, when a browser processes a webpage, it goes line by line, executing each function or loading every resource as it comes across them. This method is what we refer to as 'synchronous' because everything is happening in a specified order, one after the other. Asynchronous, on the other hand, fundamentally breaks this chain. It allows the browser to continue processing other elements of your webpage while it has kicked off resource-intensive operations, like fetching data from an API or loading images. Remember CRP? Actually, JavaScript is a render-blocking resource as a CSS, and this is why it's important to load JavaScript asynchronously. Here we have several examples of how can you connect our scripts to the webpage. As a default behavior, our script interrupts the HTML parsing, hence the DOM construction. And if you remember the CRP process, the DOM construction must be completed if we want to get actual on-screen pixels - we need to do it as fast as we can to provide a good user experience. A browser meets the script and starts to load it, and right after it has been loaded - executes. So, for this problem, we have two solutions - and attributes. As you can see, the script with both attributes loads asynchronously, but there is a pitfall - we still interrupt our HTML parsing with script execution, so for this purpose, it’s better to use because the script will be executed only after the HTML parsing is finished. async defer async defer Image and Video Optimal Formatting and Loading Moving on to another essential aspect of web performance - the optimal formatting and loading of images and videos. Multimedia content like images and videos can significantly impact the loading speed of your application due to its usually large file size. Therefore, optimizing these elements is crucial to enhance speed and performance. For images, we need to consider the most suitable format for a particular case. It can be JPEG, PNG, or SVG. For any media file, use compression tools to reduce file sizes without losing too much quality, or use files with less size. Do not forget to use lazy loading - it helps to not load files until they appear on the user's viewport. Importance of Minifying CSS, JavaScript, and HTML Minification is a simple and effective method to increase your web application performance without affecting its functionality and it must be included as a part of an application build process. Minification refers to the process of removing unnecessary or redundant data from your code files without affecting their functionality. This can include white spaces, line breaks, comments, and even variable names in some cases. So, why is minification so important? The primary benefit of minification is decreasing your file sizes. Smaller files mean less data needs to be transferred over the network, leading to quicker load times and less data usage for the end user. If your files are small, the browser can parse and compile them more quickly, improving the overall performance. In addition to this, it helps to reduce network bandwidth usage. Bundle reduction and dependencies management An important factor impacting the performance of your web application is the size of your JavaScript bundles. Your final bundle consists of your code and application dependencies/packages. And if you do not manage them properly, in the future, it becomes a big problem. This is an important part of the optimization of loading time. Here we have some techniques, which can help to reduce a bundle and helps to manage application dependencies: . Here, you divide your code into smaller chunks which are then loaded on demand or in parallel. By only loading the minimum necessary code for a particular page, you can drastically speed up the initial load time. This technique is also called lazy loading; Code Splitting . This technique helps you eliminate dead or unused codes from the final bundle. Modern bundlers offer built-in support for tree shaking. However, it mainly works with ES6 module syntax — so make sure you’re using and , not ; Tree shaking import export require . Try to only import the functions or components you need, rather than the entire library; Only import what you need . Updates often include optimizations and the removal of unnecessary or deprecated features; Regularly update dependencies . Use tools such as Webpack Bundle Analyzer to determine which dependencies are adding significant weight to your bundles, and consider whether they are truly necessary; Audit your dependencies . Use lighter alternatives of the libraries you use. For example, Preact is a lighter alternative to React, and day.js is a compressed version of moment.js, which is much bigger. For smaller projects or individual components, this approach can significantly reduce bundle size; Use lighter alternatives Make sure that there are no duplicate dependencies in your bundle. My personal experience and results Now, after all of the theory, I will present my personal experience in this field. For example, we will take a look at a project where I'm currently working on. When I entered the project, it was about October 2022, the LCP was at the 75th percentile. As we discussed earlier, it's not so good. Then, our management team set a goal to be in the green zone for LCP - it's up to 2.5 seconds. I took this task and started analyzing what was going on. The first thing that I revealed was the enormous size of a bundle - . The reason was simple - there was no code splitting and lazy loading, it was just one big JS file with all project code. Only our project code was 6 MB and 2 MB for dependencies. After the optimizations, it was really hard, I reduced the initial script to . What did we do with dependencies? We migrated some packages to more lightweight ones, some of them were deleted, and another part was removed from the initial script due to code splitting and tree shaking. So, it was reduced to . Plus to this, we cached all static resources for several weeks, due to our releases and enhanced our geographical distribution. And one more thing, we did some code optimizations to reduce long tasks that block our main thread. Finally, after a long way, we got LCP for the 75th percentile of users. 3.3 seconds almost 8 MB 300 KB 1.1 MB 1.9-second Possible questions you might ask Q: If I have a small project, that has already started, how much effort should I put into the possible optimizations bailouts in the future? A: Even for small projects, it's beneficial to set a good foundation for possible optimizations in the future. However, the level of effort would depend on your project's complexity, business domain, and future growth projections. If there's potential for your project to scale or complex features to be added, it's better to consider optimization early on. Conversely, if the project is expected to remain small and simple, you might choose to apply basic optimization practices without heavily investing time upfront. Q: How to sell the idea of optimization to a business? A: You can emphasize the direct benefits to the business. For instance, website optimization can lead to faster loading times, which can enhance user satisfaction and experience, reduce bounce rates, and potentially increase conversions and business profits. Furthermore, it's beneficial to the business's SEO efforts as search engines factor in page load speed in their ranking algorithms. In addition to this, it's better to provide measurable results rather than hypothetical ones. Q: How small my bundles should be to achieve code splitting benefits? A: There isn't a one-size-fits-all answer to this as it can depend largely on your application's needs and structure. However, a general rule of thumb provided by the Webpack documentation suggests aiming for an initial bundle split point of under 244KB (compressed). But remember, the ultimate goal is to only load what's required at any given time, improving the initial page load. Q: Which else tools can be helpful for analyzing my current statement? A: I have mentioned two of them: Webpuck Bundle Analyzer and Lighthouse. But it's good to know that Chrome DevTools can also be useful. For a performance tab that gives you more insight into what's happening when your site loads. But use it only for investigations, not for the source of truth - real data should be collected from real users. Conclusions Today we have discussed a little part of the big picture of optimizations. We have seen some important metrics and ways to enhance the user experience and loading application. In conclusion to my speech, I would like to give some advice or some kind of a roadmap if you want to improve the loading speed of your application: . The Lighthouse extension and Webpuck bundler analyzer can help you; Analyze your project . We discussed some of them but the world of optimizations does not only consist of them; Apply the most suitable techniques for your case . Store the core metrics for your project and regularly check them. It's very important to collect them from real users rather than local testing. Continuously measuring Remember, optimizing application load speed is an ongoing process and requires continuous monitoring.

How to Optimize the Loading of Your Web Application

This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaoyu Ai, School of Electrical Engineering & Telecommunications, University of New South Wales, Sydney, NSW 2052, Australia; (2) Robert Malaney, School of Electrical Engineering & Telecommunications, University of New South Wales, Sydney, NSW 2052, Australia. Table of Links Abstract & Introduction System Overview Overcoming the limitation of key reconciliation Final Key Rate Experimental Results Discussion Conclusion & References Appendix VII. CONCLUSION In this work, we have carried out a full-blown analysis and experimental implementation of a Slice Reconciliation scheme applied to a specific CV QKD protocol (with post-selection) under simulated channel conditions anticipated for satelliteto-Earth channels. We have provided the optimal solution for the classical reconciliation process for this CV-QKD protocol in the context of massive parallelisation under the finite key regime. More specifically, we have identified the optimal block length when a large-code block is to be subdivided so as to improve the final secure key rate in bits per second. Although our results were based on a specific CV-QKD protocol and a specific GPU architecture, the type of analysis we have introduced here will apply in general terms a large suite of CV-QKD protocols run over any form of architecture that offers massive parallelisation. Our results, therefore, pave the way to optimal reconciliation system design for a wide range of practical CV-QKD systems that operate in the finite key regime. As the demand on the finite key size grows (better security thresholds), and technology advances lead to larger quantum signalling rates, the importance of optimised multithreaded CV-QKD reconciliation will grow. REFERENCES [1] N. Hosseinidehaj, Z. Babar, R. Malaney, S. X. Ng, and L. Hanzo, “Satellite-Based Continuous-Variable Quantum Communications: Stateof-the-Art and a Predictive Outlook,” IEEE Communications Surveys & Tutorials, vol. 21, no. 1, 881–919, 2018. [2] C. H. Bennett and G. Brassard, “Quantum Cryptography: Public Key Distribution and Coin Tossing,” in Proceedings of IEEE International Conference on Computers, Systems and Signal Processing,, vol. 175, 8, 1984. [3] H. Weinfurter, “Quantum Communication Experiments with Discrete Variables,” Quantum Information: From Foundations to Quantum Technology Applications, 369–381, 2016. [4] L. Gy ¨ongy ¨osi, L. Bacsardi, and S. Imre, “A Survey on Quantum Key Distribution,” Infocommunications Journal, vol. 11, no. 2, 14–21, 2019. [5] S. Pirandola, U. L. Andersen, L. Banchi, M. Berta, D. Bunandar, R. Colbeck, D. Englund, T. Gehring, C. Lupo, C. Ottaviani, et al., “Advances in Quantum Cryptography,” Advances in Optics and Photonics, vol. 12, no. 4, 1012–1236, 2020. [6] B. Korzh, C. C. W. Lim, R. Houlmann, N. Gisin, M. J. Li, D. Nolan, B. Sanguinetti, R. Thew, and H. Zbinden, “Provably Secure and Practical Quantum Key Distribution over 307 km of Optical Fibre,” Nature Photonics, vol. 9, no. 3, 163–168, 2015. [7] T. A. Eriksson, T. Hirano, B. J. Puttnam, G. Rademacher, R. S. Lu´ıs, M. Fujiwara, R. Namiki, Y. Awaji, M. Takeoka, N. Wada, et al., “Wavelength Division Multiplexing of Continuous Variable Quantum Key Distribution and 18.3 Tbit/s Data Channels,” Communications Physics, vol. 2, no. 1, 1–8, 2019. [8] S.-Y. Shen, M.-W. Dai, X.-T. Zheng, Q.-Y. Sun, G.-C. Guo, and Z.- F. Han, “Free-Space Continuous-Variable Quantum Key Distribution of Unidimensional Gaussian Modulation Using Polarized Coherent States in an Urban Environment,” Physical Review A, vol. 100, 012325, 2019. [9] L. Gyongyosi and S. Imre, “Secret Key Rates of Free-Space Optical Continuous-Variable Quantum Key Distribution,” International Journal of Communication Systems, vol. 32, no. 18, e4152, 2019. [10] P. Jouguet, S. Kunz-Jacques, and A. Leverrier, “Long-Distance Continuous-Variable Quantum Key Distribution with a Gaussian Modulation,” Physical Review A, vol. 84, no. 6, 062317, 2011. [11] P. Jouguet, S. Kunz-Jacques, T. Debuisschert, S. Fossier, E. Diamanti, R. All´eaume, R. Tualle-Brouri, P. Grangier, A. Leverrier, P. Pache, et al., “Field Test of Classical Symmetric Encryption with Continuous Variables Quantum Key Distribution,” Optics Express, vol. 20, no. 13, 14030–14041, 2012. [12] Q. Liao, Y. Guo, D. Huang, P. Huang, and G. Zeng, “Long-Distance Continuous-Variable Quantum Key Distribution Using Non-Gaussian State-Discrimination Detection,” New Journal of Physics, vol. 20, no. 2, 023015, 2018. [13] D. Guo, C. He, T. Guo, Z. Xue, Q. Feng, and J. Mu, “Comprehensive High-Speed Reconciliation for Continuous-Variable Quantum Key Distribution,” Quantum Information Processing, vol. 19, no. 9, 1–19, 2020. [14] Y. Zhang, Z. Chen, S. Pirandola, X. Wang, C. Zhou, B. Chu, Y. Zhao, B. Xu, S. Yu, and H. Guo, “Long-Distance Continuous-Variable Quantum Key Distribution over 202.81 km of Fiber,” Physical Review Letters, vol. 125, no. 1, 010502, 2020. [15] A. Leverrier, F. Grosshans, and P. Grangier, “Finite-Size Analysis of a Continuous-Variable Quantum Key Distribution,” Physical Review A, vol. 81, no. 6, 062343, 2010. [16] F. Furrer, T. Franz, M. Berta, A. Leverrier, V. B. Scholz, M. Tomamichel, and R. F. Werner, “Continuous Variable Quantum Key Distribution: Finite-Key Analysis of Composable Security against Coherent Attacks,” Physical Review Letters, vol. 109, no. 10, 100502, 2012. [17] S. Kish, E. Villase˜nor, R. Malaney, K. Mudge, and K. Grant, “Feasibility Assessment for Practical Continuous Variable Quantum Key Distribution over the Satellite-to-Earth Channel,” Quantum Engineering, vol. 2, no. 3, e50, 2020. [18] M. Tomamichel, C. C. W. Lim, N. Gisin, and R. Renner, “Tight FiniteKey Analysis for Quantum Cryptography,” Nature Communications, vol. 3, no. 1, 1–6, 2012. [19] Z. Yuan, A. Plews, R. Takahashi, K. Doi, W. Tam, A. Sharpe, A. Dixon, E. Lavelle, J. Dynes, A. Murakami, et al., “10-Mb/s Quantum Key Distribution,” Journal of Lightwave Technology, vol. 36, no. 16, 3427– 3433, 2018. [20] S.-K. Liao, W.-Q. Cai, W.-Y. Liu, L. Zhang, Y. Li, J.-G. Ren, J. Yin, Q. Shen, Y. Cao, Z.-P. Li, et al., “Satellite-to-Ground Quantum Key Distribution,” Nature, vol. 549, no. 7670, 43–47, 2017. [21] D. Lin, D. Huang, P. Huang, J. Peng, and G. Zeng, “High Performance Reconciliation for Continuous-Variable Quantum Key Distribution with LDPC Code,” International Journal of Quantum Information, vol. 13, no. 02, 1550010, 2015. [22] X. Wang, Y. Zhang, S. Yu, B. Xu, Z. Li, and H. Guo, “Efficient Rate-Adaptive Reconciliation for Continuous-Variable Quantum Key Distribution,” Quantum Information & Computation, vol. 17, no. 13– 14, 1123–1134, 2017. [23] C. Zhou, X. Wang, Y. Zhang, Z. Zhang, S. Yu, and H. Guo, “ContinuousVariable Quantum Key Distribution with Rateless Reconciliation Protocol,” Physical Review Applied, vol. 12, no. 5, 054013, 2019. [24] M. Milicevic, C. Feng, L. M. Zhang, and P. G. Gulak, “Quasi-Cyclic Multi-Edge LDPC Codes for Long-Distance Quantum Cryptography,” NPJ Quantum Information, vol. 4, no. 1, 1–9, 2018. [25] S.-S. Yang, Z.-G. Lu, and Y.-M. Li, “High-Speed Post-Processing in Continuous-Variable Quantum Key Distribution Based on FPGA Implementation,” Journal of Lightwave Technology, vol. 38, no. 15, 3935–3941, 2020. [26] H. Li and Y. Pang, “FPGA-Accelerated Quantum Computing Emulation and Quantum Key Distillation,” IEEE Micro, vol. 41, no. 4, 49–57, 2021. [27] C. Weedbrook, A. M. Lance, W. P. Bowen, T. Symul, T. C. Ralph, and P. K. Lam, “Quantum Cryptography without Switching,” Physical Review Letters, vol. 93, no. 17, 170504, 2004. [28] N. Hosseinidehaj, A. M. Lance, T. Symul, N. Walk, and T. C. Ralph, “Finite-Size Effects in Continuous-Variable Quantum Key Distribution with Gaussian Postselection,” Physical Review A, vol. 101, no. 5, 052335, 2020. [29] D. Dequal, L. T. Vidarte, V. R. Rodriguez, G. Vallone, P. Villoresi, A. Leverrier, and E. Diamanti, “Feasibility of Satellite-to-Ground Continuous-Variable Quantum Key Distribution,” NPJ Quantum Information, vol. 7, no. 1, 1–10, 2020. [30] M. Bloch, A. Thangaraj, and S. W. McLaughlin, “Efficient Reconciliation of Correlated Continuous Random Variables Using LDPC Codes,” arXiv preprint cs/0509041, 2005. [31] P. Jouguet, D. Elkouss, and S. Kunz-Jacques, “High-Bit-Rate Continuous-Variable Quantum Key Distribution,” Physical Review A, vol. 90, no. 4, 042329, 2014. [32] H. Mani, T. Gehring, P. Grabenweger, B. Omer, C. Pacher, and ¨ U. L. Andersen, “Multiedge-Type Low-Density Parity-Check Codes for Continuous-Variable Quantum Key Distribution,” Physical Review A, vol. 103, no. 6, 062419, 2021. [33] H. Imai and S. Hirakawa, “A New Multilevel Coding Method Using Error-Correcting Codes,” IEEE Transactions on Information Theory, vol. 23, no. 3, 371–377, 1977. [34] U. Wachsmann, R. F. Fischer, and J. B. Huber, “Multilevel codes: Theoretical concepts and practical design rules,” IEEE Transactions on Information Theory, vol. 45, no. 5, 1361–1391, 1999. [35] R. D. Wesel, X. Liu, J. M. Cioffi, and C. Komninakis, “Constellation Labeling for Linear Encoders,” IEEE Transactions on Information Theory, vol. 47, no. 6, 2417–2431, 2001. [36] M. Bloch, A. Thangaraj, S. W. McLaughlin, and J.-M. Merolla, “LDPCBased Gaussian Key Reconciliation,” in IEEE Information Theory Workshop-ITW’06 Punta del Este, 116–120, IEEE, 2006. [37] A. Leverrier, R. All´eaume, J. Boutros, G. Z´emor, and P. Grangier, “Multidimensional Reconciliation for a Continuous-Variable Quantum Key Distribution,” Physical Review A, vol. 77, no. 4, 042325, 2008. [38] J. Fiur´aˇsek and N. J. Cerf, “Gaussian Postselection and Virtual Noiseless Amplification in Continuous-Variable Quantum Key Distribution,” Physical Review A, vol. 86, no. 6, 060302, 2012. [39] F. Darema, “The SPMD Model: Past, Present and Future,” in European Parallel Virtual Machine/Message Passing Interface Users’ Group Meeting, 1–1, Springer, 2001. [40] M. Pharr and W. R. Mark, “A SPMD Compiler for High-Performance CPU Programming,” in Innovative Parallel Computing (InPar), 1–13, IEEE, 2012. [41] J. Lodewyck, M. Bloch, R. Garc´ıa-Patr ´on, S. Fossier, E. Karpov, E. Diamanti, T. Debuisschert, N. J. Cerf, R. Tualle-Brouri, S. W. McLaughlin, et al., “Quantum Key Distribution over 25 km with an AllFiber Continuous-Variable System,” Physical Review A, vol. 76, no. 4, 042305, 2007. [42] F. Laudenbach, C. Pacher, C.-H. F. Fung, A. Poppe, M. Peev, B. Schrenk, M. Hentschel, P. Walther, and H. H ¨ubel, “Continuous-Variable Quantum Key Distribution with Gaussian Modulation—The Theory of Practical Implementations,” Advanced Quantum Technologies, vol. 1, no. 1, 1800011, 2018. [43] Y. Polyanskiy, H. V. Poor, and S. Verd ´u, “Channel Coding Rate in the Finite Blocklength Regime,” IEEE Transactions on Information Theory, vol. 56, no. 5, 2307–2359, 2010. [44] D. Slepian and J. Wolf, “Noiseless Coding of Correlated Information Sources,” IEEE Transactions on Information Theory, vol. 19, no. 4, 471–480, 1973. [45] T. Richardson and R. Urbanke, Modern Coding Theory. Cambridge University Press, 2008. [46] X. Ai, R. Malaney, and S. X. Ng, “A Reconciliation Strategy for RealTime Satellite-Based QKD,” IEEE Communications Letters, vol. 24, no. 5, 1062–1066, 2020. [47] S.-Y. Chung, T. J. Richardson, and R. L. Urbanke, “Analysis of SumProduct Decoding of Low-Density Parity-Check Codes Using a Gaussian Approximation,” IEEE Transactions on Information Theory, vol. 47, no. 2, 657–670, 2001. [48] V. A. Chandrasetty and S. M. Aziz, “FPGA Implementation of an LDPC Decoder Using a Reduced Complexity Message Passing Algorithm,” Journal of Networks, vol. 6, no. 1, 36, 2011. [49] A. Leverrier, “Composable Security Proof for Continuous-Variable Quantum Key Distribution with Coherent States,” Physical Review Letters, vol. 114, no. 7, 070501, 2015. [50] C. Lupo, C. Ottaviani, P. Papanastasiou, and S. Pirandola, “ContinuousVariable Measurement-Device-Independent Quantum Key Distribution: Composable Security against Coherent Attacks,” Physical Review A, vol. 97, no. 5, 052327, 2018. [51] N. Hosseinidehaj, N. Walk, and T. C. Ralph, “Optimal Realistic Attacks in Continuous-Variable Quantum Key Distribution,” Physical Review A, vol. 99, no. 5, 052336, 2019. [52] S. Pirandola, “Limits and Security of Free-Space Quantum Communications,” Physical Review Research, vol. 3, no. 1, 013279, 2021. [53] S. Pirandola, “Satellite Quantum Communications: Fundamental Bounds and Practical Security,” Physical Review Research, vol. 3, no. 2, 023130, 2021. [54] J. H. Mathews and K. D. Fink, Numerical Methods Using MATLAB, vol. 4. Pearson Prentice Hall Upper Saddle River, NJ, 2004. [55] A. Leverrier, “Security of Continuous-Variable Quantum Key Distribution via a Gaussian de Finetti Reduction,” Physical Review Letters, vol. 118, no. 20, 200501, 2017. [56] E. Villase˜nor, R. Malaney, K. A. Mudge, and K. J. Grant, “Atmospheric Effects on Satellite-to-Ground Quantum Key Distribution Using Coherent States,” in GLOBECOM 2020-2020 IEEE Global Communications Conference, 1–6, IEEE, 2020. [57] J. Mateo, Efficient Information Reconciliation for Quantum Key Distribution. PhD thesis, Universidad Politecnica de Madrid, 2011. [58] T. Tian, C. R. Jones, J. D. Villasenor, and R. D. Wesel, “Selective Avoidance of Cycles in Irregular LDPC Code Construction,” IEEE Transactions on Communications, vol. 52, no. 8, 1242–1247, 2004. [59] D. V. Nguyen, S. K. Chilappagari, M. W. Marcellin, and B. Vasic, “On the Construction of Structured LDPC Codes Free of Small Trapping Sets,” IEEE Transactions on Information Theory, vol. 58, no. 4, 2280– 2302, 2012. [60] S. Landner and O. Milenkovic, “Algorithmic and Combinatorial Analysis of Trapping Sets in Structured LDPC Codes,” in International Conference on Wireless Networks, Communications and Mobile Computing, vol. 1, 630–635, IEEE, 2005. [61] X. Wang, Y. Zhang, S. Yu, and H. Guo, “High Speed Error Correction for Continuous-Variable Quantum Key Distribution with Multi-Edge Type LDPC Code,” Scientific Reports, vol. 8, no. 1, 1–7, 2018. [62] Y. Li, X. Zhang, Y. Li, B. Xu, L. Ma, J. Yang, and W. Huang, “HighThroughput GPU Layered Decoder of Quasi-Cyclic Multi-Edge Type Low Density Parity Check Codes in Continuous-Variable Quantum Key Distribution Systems,” Scientific Reports, vol. 10, no. 1, 1–11, 2020. [63] F. Grosshans, “Collective Attacks and Unconditional Security in Continuous Variable Quantum Key Distribution,” Physical Review Letters, vol. 94, 020504, 2005. [64] M. Navascu´es, F. Grosshans, and A. Acin, “Optimality of Gaussian Attacks in Continuous-Variable Quantum Cryptography,” Physical Review Letters, vol. 97, no. 19, 190502, 2006. [65] S. Fossier, E. Diamanti, T. Debuisschert, R. Tualle-Brouri, and P. Grangier, “Improvement of Continuous-Variable Quantum Key Distribution Systems by Using Optical Preamplifiers,” Journal of Physics B: Atomic, Molecular and Optical Physics, vol. 42, no. 11, 114014, 2009. [66] P. Jouguet, S. Kunz-Jacques, E. Diamanti, and A. Leverrier, “Analysis of Imperfections in Practical Continuous-Variable Quantum Key Distribution,” Physical Review A, vol. 86, no. 3, 032309, 2012.

Optimised Multithreaded CV-QKD Reconciliation for Global Quantum Networks: Conclusion & References

This paper is available on arxiv under CC 4.0 license. Authors: (1) Xiaoyu Ai, School of Electrical Engineering & Telecommunications, University of New South Wales, Sydney, NSW 2052, Australia; (2) Robert Malaney, School of Electrical Engineering & Telecommunications, University of New South Wales, Sydney, NSW 2052, Australia. Table of Links Abstract & Introduction System Overview Overcoming the limitation of key reconciliation Final Key Rate Experimental Results Discussion Conclusion & References Appendix VI. DISCUSSION CV-QKD. High-speed implementations realised in [61], [62] have used multidimensional reconciliation [37]. This multidimensional scheme is preferred for low SNR - but not so for the higher SNRs available via the Gaussian post-selection technique - a technique likely to be more useful in the satellite context [1]. 1) Reconciliation schemes for satellite-based In CV-QKD, Alice and Bob have to discard a block of reconciled bits if they detect a reconciliation failure (coding error) for that block. To compensate for the discarded bits, additional quantum signals need to be transmitted and reconciled, causing unwanted delays. Such delays can be problematic for satellitebased systems since the satellite is not always visible to the ground station. The FPGA-based reconciliation of [25] may suffer from this problem due to limited precision of arithmetic operations leading to higher reconciliation failures. As shown in many GPU-based works (including this work), GPU-based reconciliation offers less probability of reconciliation failure. 2) Low probability of reconciliation failures.

Stories, News & Mentions about OPTIMOVE

Optimove’s Stories on HackerNoon