vAisualis in the Tech for Film-TV Industry

vAisual

vaisual

This paper is available on Arxiv under CC 4.0 license. Authors: (1) Mykola Makhortykh, Institute of Communication and Media Studies, University of Bern; (2) Aleksandra Urman, Social Computing Group, University of Zurich; (3) Roberto Ulloa, GESIS – Leibniz-Institute for the Social Sciences. Table of Links Author Note Abstract Theoretical background Methodology Findings Conclusion and References Methodology Data collection To investigate how COVID-19 is framed visually via search engines, we collected data from five search engines: Bing, DuckDuckGo, Google, Yandex, and Yahoo. We selected these search engines because they are the ones with the largest share of the international search market (Statcounter 2020) or dominate their major local markets (e.g., Yandex in the case of Russia). To collect the data, we used a novel algorithmic auditing approach based on large-scale simulation of user browsing behavior via virtual agents (Ulloa, Makhortykh and Urman 2022). Virtual agents are software programs which can mimic user behavior (e.g., by entering URLs in the browser). Unlike earlier studies (e.g., Unkel and Haim 2019; Hannak et al. 2013) that rely on crowdsourced user data or small-scale simulations of browser behavior, our approach allows scaling the analysis to make it more robust and also permits conducting it in a controlled environment. The latter feature allowed us to investigate how image search results related to COVID-19 are filtered and ranked under a default - i.e., non-personalized - conditions. The data were collected on February 26, 2020, two weeks before the World Health Organization declared COVID-19 a pandemic. We deployed 83 machines from the Amazon Web Services Frankfurt cluster with each machine hosting two virtual agents (one on Firefox and another on Chrome). The agents imitated three sessions of user browsing behavior and were evenly distributed among the search engines, so each search engine was queried by 33/34 agents. All agents started each session simultaneously and used image search for the term “coronavirus” in English (session 1), Russian (session 2) and Mandarin Chinese (session 3; simplified characters were used). Then, the agents navigated through the result page(s) to retrieve links to the first 50 images from HTML. Following each session, the browsers were cleaned to prevent previous searches from affecting the latter queries. We removed the data that can be accessed by the search engine’s JavaScript (e.g., cookies) and the data accessible by the browser (e.g., browsing history). Data analysis To analyze collected data, we used qualitative framing analysis based on the generic frame typology developed by Semetko and Valkenburg (2000). The typology includes five types of frames: 1) conflict: frames emphasizing conflict between individuals, groups, or institutions; 2) human interest: frames bringing a human face or an emotional angle to the presentation of an issue/problem; 3) economic consequences: frames reporting an event or problem in terms of its economic consequences; 4) morality: frames putting the event or issue in the context of religious tenets or moral prescriptions; 5) responsibility: frames presenting an issue in such a way as to attribute responsibility for its cause/solution to either the government or to an individual/group. Similar to Kee, Faridah and Normah (2010), we adopted a set of 20 questions used by Semetko and Valkenburg (2000) to measure the strength of the frames for each individual image we analyzed. Each question could be responded with either “yes” or “no”; the responses were used to measure the strength of the respective frame. The frame strength was calculated by summing the responses to the related questions (e.g., five questions for the human interest frame and the three questions for the economic one) which were quantified proportionally (e.g., each “yes” answer for one of the five human interest questions added 0.2 to the strength of the human interest frame for the respective image as it contained five questions, whereas for the economic frame questions each “yes” answer contributed 0.33 proportional to three questions). For the analysis, we looked at the 50 most frequent images among the search results acquired by the agents querying the same search engine. These images were coded by the three authors of the chapter. The coding was then checked for consistency by one of the coders and the disagreements between the coders were discussed and consensus-coded. This paper is available on under a CC 4.0 license. Arxiv

The Visual Framing of COVID-19 on Search Engines

The TechBeat: Mastering the Craft of Transforming Data into Engaging Visual Narratives in User Interfaces (5/5/2024)

In these intensely competitive times, every application needs to be aesthetically appealing in addition to providing seamless functionality to satisfy the users. If an app does not function properly because of a visual interface error or if the site is unreadable, users may uninstall or leave the app. This can ultimately lead to a loss of customers and a drop in revenues. To avoid this and ensure the best possible user experience, companies are prioritizing visual regression testing. Let us study a couple of examples of visual regression testing to understand its importance: When you click on a drop-down image the menu does not slide down after adding more options.
You have reworked the complete layout of the page, and the submit button on the page is broken. These UI errors need to be fixed since changes in the elements can lead to the breakdown of the visual aesthetics. These illustrations clearly highlight the importance of conducting thorough visual regression testing before software releases. Visual regression testing checks the UI of an application after code changes and ensures that these different visual elements, like buttons, images, and text, all render correctly. Through this blog, we will examine visual regression, the different techniques used, the challenges testers face when performing the tests, and the best practices to overcome them. Common Visual Regression Techniques Visual testing ensures that visual glitches are identified early and do not spill over to the production stage. Let us now briefly examine the commonly used methods for regression testing: Manual visual testing: In this method, testers manually compare UI screenshots before and after making changes in the code.
Comparing layouts: It requires comparing the UI layout before and after changes are made and accounts for changes in the UI’s font, color, and other visual elements.
Comparing pixel-by-pixel: Used to test small, complex UI elements, this method involves comparing the UI’s pixels before and after changes.
Structural comparison: It compares the UI’s Document Object Model (DOM) before and after making changes.
Inserting visual checkpoints: In this technique, checkpoints are inserted into the UI to check the UI’s visual state at specific points in time. Manual Regression Testing Manual regression testing is recommended in the early testing stages when the UI is unstable. It is suitable for ad hoc testing and conducting quick on-the-spot checks. In this method, the testers manually check the layout and appearance of the visual elements. It involves taking the latest screenshots and comparing them with baseline screenshots to unearth any gaps. Benefits of Automated Visual Regression Testing Over Manual Methods The manual technique can be time-consuming and lead to a waste of resources because of its repetitive nature. The scale of manual testing grows with every new feature addition, thereby increasing the time spent by a human tester pouring over screenshots to identify bugs. It is impractical to manually conduct visual regression testing when there are tight deadlines to meet. In contrast, automated visual regression testing helps you automate repetitive tasks like checking the page following every code change. Even with the heavy initial investment, automated testing, especially with AI-powered features, helps you save time and money in the long run. Though automated visual regression testing reaps many benefits for testers and developers, it has to be properly implemented if they are to receive its benefits. Let us examine the best practices that go into a proper visual regression testing process. What To Remember While Conducting Visual Regression Testing Following these best practices will help optimize your automated visual regression testing process and help you gain its maximum benefits: Develop Appropriate Test Scenarios Clearly define what to record in the snapshots and the time to take them while testing. Remember to include user interactions in such scenarios since the applications will need to deal with them in the real world. Validate the Entire UI Page Instead of only validating individual components, ensure to validate the entire UI page. This practice will increase the test coverage and improve it. Pick the Right Automated Tool The visual regression testing tool you choose should be capable of ignoring false positives. It should be able to take care of pixel offsets, anti-aliasing, and other issues while ensuring the tests don’t fail. The automated algorithm must be able to analyze the page’s structure and perform layout comparisons. It should also be able to take care of content that is dynamic and moving. Compare Screenshots Testers should compare screenshots with recent ones to identify the disparities. This will help ensure that the UI remains the same, improving the user experience and product quality. Identify and Resolve Bugs Ensure to resolve bugs that the testing tool identifies or send them to the respective developers for fixing them. Remember to update screenshots to be used as a baseline for future regression tests after it is done. Choose the Right Situation To Perform Automated Testing Automated visual regression testing may not be appropriate for all scenarios. In some situations, using a combination of manual and automated methods is advisable. For example, when new features are added, they can be validated using an automation technique and then checked manually. Conduct a Detailed Review A team of reviewers or a single reviewer can examine how adjustments are made without causing interruptions in the desired outcome and make a report accordingly. Learn From Your Mistakes Learning from your successes and failures is crucial in visual regression testing. You need to identify the root causes and impacts of the visual changes detected by your tool. Testers must also identify false negatives and positives and adjust the tool settings and test cases accordingly. Conclusion In conclusion, successful implementation of visual regression testing in Agile teams requires a holistic approach that encompasses automation, collaboration, scalability, and comprehensive analysis. Visual regression testing can be a game-changer if you choose an appropriate automated testing tool with the right features and advantages. By adhering to these best practices, Agile teams can effectively leverage visual regression testing to deliver high-quality user interfaces in an iterative and efficient manner. In these intensely competitive times, every application needs to be aesthetically appealing in addition to providing seamless functionality to satisfy the users. If an app does not function properly because of a visual interface error or if the site is unreadable, users may uninstall or leave the app. This can ultimately lead to a loss of customers and a drop in revenues. To avoid this and ensure the best possible user experience, companies are prioritizing visual regression testing . visual regression testing Let us study a couple of examples of visual regression testing to understand its importance: Let us study a couple of examples of visual regression testing to understand its importance: When you click on a drop-down image the menu does not slide down after adding more options. You have reworked the complete layout of the page, and the submit button on the page is broken. When you click on a drop-down image the menu does not slide down after adding more options. You have reworked the complete layout of the page, and the submit button on the page is broken. These UI errors need to be fixed since changes in the elements can lead to the breakdown of the visual aesthetics. These illustrations clearly highlight the importance of conducting thorough visual regression testing before software releases. Visual regression testing checks the UI of an application after code changes and ensures that these different visual elements, like buttons, images, and text, all render correctly. Through this blog, we will examine visual regression, the different techniques used, the challenges testers face when performing the tests, and the best practices to overcome them. Common Visual Regression Techniques Visual testing ensures that visual glitches are identified early and do not spill over to the production stage. Let us now briefly examine the commonly used methods for regression testing: Manual visual testing: In this method, testers manually compare UI screenshots before and after making changes in the code. Comparing layouts: It requires comparing the UI layout before and after changes are made and accounts for changes in the UI’s font, color, and other visual elements. Comparing pixel-by-pixel: Used to test small, complex UI elements, this method involves comparing the UI’s pixels before and after changes. Structural comparison: It compares the UI’s Document Object Model (DOM) before and after making changes. Inserting visual checkpoints: In this technique, checkpoints are inserted into the UI to check the UI’s visual state at specific points in time. Manual visual testing: In this method, testers manually compare UI screenshots before and after making changes in the code. Manual visual testing: Comparing layouts: It requires comparing the UI layout before and after changes are made and accounts for changes in the UI’s font, color, and other visual elements. Comparing layouts: Comparing pixel-by-pixel: Used to test small, complex UI elements, this method involves comparing the UI’s pixels before and after changes. Comparing pixel-by-pixel: Structural comparison: It compares the UI’s Document Object Model (DOM) before and after making changes. Structural comparison: Inserting visual checkpoints: In this technique, checkpoints are inserted into the UI to check the UI’s visual state at specific points in time. Inserting visual checkpoints: Manual Regression Testing Manual regression testing is recommended in the early testing stages when the UI is unstable. It is suitable for ad hoc testing and conducting quick on-the-spot checks. In this method, the testers manually check the layout and appearance of the visual elements. It involves taking the latest screenshots and comparing them with baseline screenshots to unearth any gaps. Benefits of Automated Visual Regression Testing Over Manual Methods The manual technique can be time-consuming and lead to a waste of resources because of its repetitive nature. The scale of manual testing grows with every new feature addition, thereby increasing the time spent by a human tester pouring over screenshots to identify bugs. It is impractical to manually conduct visual regression testing when there are tight deadlines to meet. In contrast, automated visual regression testing helps you automate repetitive tasks like checking the page following every code change. Even with the heavy initial investment, automated testing, especially with AI-powered features, helps you save time and money in the long run. Though automated visual regression testing reaps many benefits for testers and developers, it has to be properly implemented if they are to receive its benefits. Let us examine the best practices that go into a proper visual regression testing process. What To Remember While Conducting Visual Regression Testing Following these best practices will help optimize your automated visual regression testing process and help you gain its maximum benefits: Develop Appropriate Test Scenarios Clearly define what to record in the snapshots and the time to take them while testing. Remember to include user interactions in such scenarios since the applications will need to deal with them in the real world. Validate the Entire UI Page Instead of only validating individual components, ensure to validate the entire UI page. This practice will increase the test coverage and improve it. Pick the Right Automated Tool The visual regression testing tool you choose should be capable of ignoring false positives. It should be able to take care of pixel offsets, anti-aliasing, and other issues while ensuring the tests don’t fail. The automated algorithm must be able to analyze the page’s structure and perform layout comparisons. It should also be able to take care of content that is dynamic and moving. Compare Screenshots Testers should compare screenshots with recent ones to identify the disparities. This will help ensure that the UI remains the same, improving the user experience and product quality. Identify and Resolve Bugs Ensure to resolve bugs that the testing tool identifies or send them to the respective developers for fixing them. Remember to update screenshots to be used as a baseline for future regression tests after it is done. Choose the Right Situation To Perform Automated Testing Automated visual regression testing may not be appropriate for all scenarios. In some situations, using a combination of manual and automated methods is advisable. For example, when new features are added, they can be validated using an automation technique and then checked manually. Conduct a Detailed Review A team of reviewers or a single reviewer can examine how adjustments are made without causing interruptions in the desired outcome and make a report accordingly. Learn From Your Mistakes Learning from your successes and failures is crucial in visual regression testing. You need to identify the root causes and impacts of the visual changes detected by your tool. Testers must also identify false negatives and positives and adjust the tool settings and test cases accordingly. Conclusion In conclusion, successful implementation of visual regression testing in Agile teams requires a holistic approach that encompasses automation, collaboration, scalability, and comprehensive analysis. Visual regression testing can be a game-changer if you choose an appropriate automated testing tool with the right features and advantages. By adhering to these best practices, Agile teams can effectively leverage visual regression testing to deliver high-quality user interfaces in an iterative and efficient manner.

Optimal Strategies for Integrating Visual Regression Testing into Agile Teams

Authors:
(1) Rui Cao, Singapore Management University;
(2) Ming Shan Hee, Singapore University of Design and Technology;
(3) Adriel Kuek, DSO National Laboratories;
(4) Wen-Haw Chong, Singapore Management University;
(5) Roy Ka-Wei Lee, Singapore University of Design and Technology
(6) Jing Jiang, Singapore Management University. Table of Links Abstract and Introduction Related Work Preliminary Proposed Method Experiment Conclusion and References Appendix 3 PRELIMINARY We formally define our task and briefly review the use of pre-trained vision-language models (PVLMs) for zero-shot visual question answering (VQA). At the end of the section, we provide a brief introduction to the specific PVLM utilized in our work. In this work, we use the recently released BLIP-2 model [15] as the PVLM, as it has demonstrated good performance in zero-shot VQA. The BLIP-2 model is composed of a frozen pre-trained image encoder, a frozen pre-trained language model, and a lightweight Querying Transformer, which is responsible for bridging the modality gap. It is worth noting that the BLIP-2 model can be replaced with any other PVLM that is capable of zero-shot VQA. This paper is available on arxiv under CC 4.0 license. Authors: (1) Rui Cao, Singapore Management University; (2) Ming Shan Hee, Singapore University of Design and Technology; (3) Adriel Kuek, DSO National Laboratories; (4) Wen-Haw Chong, Singapore Management University; (5) Roy Ka-Wei Lee, Singapore University of Design and Technology (6) Jing Jiang, Singapore Management University. Authors: Authors: (1) Rui Cao, Singapore Management University; (2) Ming Shan Hee, Singapore University of Design and Technology; (3) Adriel Kuek, DSO National Laboratories; (4) Wen-Haw Chong, Singapore Management University; (5) Roy Ka-Wei Lee, Singapore University of Design and Technology (6) Jing Jiang, Singapore Management University. Table of Links Abstract and Introduction Abstract and Introduction Related Work Related Work Preliminary Preliminary Proposed Method Proposed Method Experiment Experiment Conclusion and References Conclusion and References Appendix Appendix 3 PRELIMINARY We formally define our task and briefly review the use of pre-trained vision-language models (PVLMs) for zero-shot visual question answering (VQA). At the end of the section, we provide a brief introduction to the specific PVLM utilized in our work. In this work, we use the recently released BLIP-2 model [15] as the PVLM, as it has demonstrated good performance in zero-shot VQA. The BLIP-2 model is composed of a frozen pre-trained image encoder, a frozen pre-trained language model, and a lightweight Querying Transformer, which is responsible for bridging the modality gap. It is worth noting that the BLIP-2 model can be replaced with any other PVLM that is capable of zero-shot VQA. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Zero-Shot Visual Question Answering with PVLMs

Mastering the Craft of Transforming Data into Engaging Visual Narratives in User Interfaces

Python Bokeh is one of the best Python packages for data visualization. Today, we are going to see some Python Bokeh Examples. I have also provided the Python Bokeh project source code on GitHub. Learn this easy visualization tool and add it to your Python stack. What is Python Bokeh? Python is a data visualization tool, or we can also say Python Bokeh is used to plot various types of graphs. There are various other graph plotting libraries like matplotlib, but Python Bokeh graphs are dynamic in nature, which means you can interact with the generated graph. See the below examples… Bokeh Installation 💻: Python Bokeh can be easily installed using PIP. You can install the Python Bokeh easily by running the command: pip install bokeh Now everything is ready, let’s go through the examples 🏃‍♂️… 1. LinePlot from bokeh.plotting import figure, show, output_notebook
x = [1, 2, 3, 4, 5]
y = [4, 5, 5, 7, 3]
p = figure(title="{LinePlot Python Bokeh Example")
p.line(x, y, line_width=2)
output_notebook()
show(p) | | Live Preview Source Code 🌿 Contribute 2. Scatter Plot from bokeh.plotting import figure, show, output_notebook
x = [1, 2, 3, 4, 5]
y = [4, 5, 5, 7, 3]
p = figure(title="Scatter Plot Python Bokeh Example by PratikPathak.com")
p.circle(x, y, size=10, color="navy", alpha=0.5)
output_notebook()
show(p) 3. Bar Chart from bokeh.plotting import figure, show, output_notebook
categories = ["A", "B", "C", "D", "E"]
values = [10, 15, 8, 12, 6]
p = figure(x_range=categories, title="Bar Chart Python Bokeh Example by PratikPathak.com")
p.vbar(x=categories, top=values, width=0.9)
output_notebook()
show(p) 4. Histogram from bokeh.plotting import figure, show, output_notebook
import numpy as np
data = np.random.normal(0, 1, 1000)
p = figure(title="Histogram Python Bokeh Example by PratikPathak.com")
p.hist(data, bins=30, color="navy", alpha=0.5)
output_notebook()
show(p) 5. Pie Chart from bokeh.plotting import figure, show, output_notebook
labels = ["A", "B", "C", "D"]
values = [10, 15, 8, 12]
p = figure(title="Pie Chart Python Bokeh Example by PratikPathak.com")
p.wedge(x=0, y=0, radius=0.4, start_angle=0.6, end_angle=2.6, color=["red", "green", "blue", "yellow"], legend_label=labels)
output_notebook()
show(p) | | Live Preview Source Code 🌿 Contribute 6. Time Series Plot from bokeh.plotting import figure, show, output_notebook
from datetime import datetime, timedelta
start = datetime(2023, 1, 1)
end = start + timedelta(days=30)
x = [start + timedelta(days=i) for i in range((end-start).days)]
y = [10, 15, 8, 12, 6, 18, 9, 14, 7, 11, 5, 16, 8, 13, 6]
p = figure(x_axis_type="datetime", title="Time Series Plot Python Bokeh Example by PratikPathak.com")
p.line(x, y, line_width=2)
output_notebook()
show(p) 7. Linked Brushing from bokeh.plotting import figure, show, output_notebook
from bokeh.models import ColumnDataSource
x1 = [1, 2, 3, 4, 5]
y1 = [4, 5, 5, 7, 3]
x2 = [2, 3, 4, 5, 6]
y2 = [2, 4, 6, 8, 4]
source = ColumnDataSource(data=dict(x1=x1, y1=y1, x2=x2, y2=y2))
p1 = figure(title="Scatter Plot 1")
p1.circle('x1', 'y1', source=source)
p2 = figure(title="Scatter Plot 2 Python Bokeh Example by PratikPathak.com")
p2.circle('x2', 'y2', source=source)
output_notebook()
show(p1, p2) 8. Hover Tooltips from bokeh.plotting import figure, show, output_notebook
from bokeh.models import HoverTool
x = [1, 2, 3, 4, 5]
y = [4, 5, 5, 7, 3]
p = figure(title="Hover Tooltips Python Bokeh Example by PratikPathak.com")
p.circle(x, y, size=15, fill_color="navy", line_color="white", alpha=0.5)
hover = HoverTool(tooltips=[("(x,y)", "(@x, @y)")])
p.add_tools(hover)
output_notebook()
show(p) 9. Annotations from bokeh.plotting import figure, show, output_notebook
from bokeh.models import Arrow, VectorRenderer, Label
x = [1, 2, 3, 4, 5]
y = [4, 5, 5, 7, 3]
p = figure(title="Annotations Python Bokeh Example by PratikPathak.com")
p.circle(x, y, size=15, fill_color="navy", line_color="white", alpha=0.5)
arrow = Arrow(x_start=2, y_start=4, x_end=3, y_end=5, line_width=2, line_color="red")
label = Label(x=3, y=6, text="This is a label", render_mode='css', border_line_color='black', border_line_alpha=1.0, background_fill_color='white', background_fill_alpha=0.5)
p.add_layout(arrow)
p.add_layout(label)
output_notebook()
show(p) 10. Custom Glyphs from bokeh.plotting import figure, show, output_notebook
from bokeh.models.glyphs import Asterisk
x = [1, 2, 3, 4, 5]
y = [4, 5, 5, 7, 3]
p = figure(title="Custom Glyphs Python Bokeh Example by PratikPathak.com")
p.add_glyph(x, y, Asterisk(size=20, line_color="red", fill_color="yellow"))
output_notebook()
show(p) | | Live Preview Source Code 🌿 Contribute 11. Gridlines and Axes from bokeh.plotting import figure, show, output_notebook
x = [1, 2, 3, 4, 5]
y = [4, 5, 5, 7, 3]
p = figure(title="Gridlines and Axes Python Bokeh Example by PratikPathak.com", x_range=(0, 6), y_range=(0, 8))
p.grid.grid_line_color = "grey"
p.grid.grid_line_dash = [6, 4]
p.xaxis.axis_label = "X-axis"
p.yaxis.axis_label = "Y-axis"
p.line(x, y, line_width=2)
output_notebook()
show(p) 12. Legend from bokeh.plotting import figure, show, output_notebook
x1 = [1, 2, 3, 4, 5]
y1 = [4, 5, 5, 7, 3]
x2 = [2, 3, 4, 5, 6]
y2 = [2, 4, 6, 8, 4]
p = figure(title="Legend Python Bokeh Example by PratikPathak.com")
p.line(x1, y1, line_width=2, color="red", legend_label="Line 1")
p.line(x2, y2, line_width=2, color="blue", legend_label="Line 2")
p.legend.location = "top_left"
output_notebook()
show(p) 13. Categorical Plots from bokeh.plotting import figure, show, output_notebook
fruits = ["Apples", "Pears", "Nectarines", "Plums", "Grapes", "Strawberries"]
counts = [5, 3, 4, 2, 4, 6]
p = figure(x_range=fruits, title="Categorical Plots Python Bokeh Example by PratikPathak.com")
p.vbar(x=fruits, top=counts, width=0.9)
p.xaxis.axis_label = "Fruit"
p.yaxis.axis_label = "Count"
p.xaxis.axis_label_text_font_size = "12pt"
p.yaxis.axis_label_text_font_size = "12pt"
output_notebook()
show(p) 14. Subplots from bokeh.plotting import figure, show, output_notebook
from bokeh.layouts import gridplot
x1 = [1, 2, 3, 4, 5]
y1 = [4, 5, 5, 7, 3]
x2 = [2, 3, 4, 5, 6]
y2 = [2, 4, 6, 8, 4]
p1 = figure(title="Scatter Plot 1 Python Bokeh Example by PratikPathak.com")
p1.circle(x1, y1, size=10, color="navy", alpha=0.5)
p2 = figure(title="Scatter Plot 2 Python Bokeh Example by PratikPathak.com")
p2.circle(x2, y2, size=10, color="red", alpha=0.5)
grid = gridplot([[p1, p2]], plot_width=400, plot_height=400)
output_notebook()
show(grid) 15. Interactive Plots from bokeh.plotting import figure, show, output_notebook
from bokeh.models import ColumnDataSource, HoverTool, BoxSelectTool
import numpy as np
x = np.random.random(1000)
y = np.random.random(1000)
source = ColumnDataSource(data=dict(x=x, y=y))
p = figure(title="Interactive Plots Python Bokeh Example by PratikPathak.com", tools="hover,box_select")
p.circle('x', 'y', source=source, size=3, color="navy", alpha=0.5)
hover = HoverTool(tooltips=[("(x,y)", "(@x, @y)")])
p.add_tools(hover)
output_notebook()
show(p) | | Live Preview Source Code 🌿 Contribute 16. Linked Panning and Zooming from bokeh.plotting import figure, show, output_notebook
from bokeh.models import Range1d
x1 = [1, 2, 3, 4, 5]
y1 = [4, 5, 5, 7, 3]
x2 = [2, 3, 4, 5, 6]
y2 = [2, 4, 6, 8, 4]
p1 = figure(title="Scatter Plot 1 Python Bokeh Example by PratikPathak.com", x_range=Range1d(0, 6), y_range=Range1d(0, 8))
p1.circle(x1, y1, size=10, color="navy", alpha=0.5)
p2 = figure(title="Scatter Plot 2 Python Bokeh Example by PratikPathak.com", x_range=p1.x_range, y_range=p1.y_range)
p2.circle(x2, y2, size=10, color="red", alpha=0.5)
output_notebook()
show(p1, p2) 17. Linked Axis Ranges from bokeh.plotting import figure, show, output_notebook
from bokeh.models import Range1d
x1 = [1, 2, 3, 4, 5]
y1 = [4, 5, 5, 7, 3]
x2 = [2, 3, 4, 5, 6]
y2 = [2, 4, 6, 8, 4]
p1 = figure(title="Scatter Plot 1", x_range=(0, 6), y_range=(0, 8))
p1.circle(x1, y1, size=10, color="navy", alpha=0.5)
p2 = figure(title="Scatter Plot 2", x_range=p1.x_range, y_range=p1.y_range)
p2.circle(x2, y2, size=10, color="red", alpha=0.5)
output_notebook()
show(p1, p2) 18. DateTime Axis from bokeh.plotting import figure, show, output_notebook
from datetime import datetime, timedelta
start = datetime(2023, 1, 1)
end = start + timedelta(days=30)
x = [start + timedelta(days=i) for i in range((end-start).days)]
y = [10, 15, 8, 12, 6, 18, 9, 14, 7, 11, 5, 16, 8, 13, 6]
p = figure(x_axis_type="datetime", title="Datetime Axis Python Bokeh Example by PratikPathak.com")
p.line(x, y, line_width=2)
output_notebook()
show(p) 19. Heatmap from bokeh.plotting import figure, show, output_notebook
import numpy as np
data = np.random.rand(10, 10)
p = figure(title="Heatmap Python Bokeh Example by PratikPathak.com")
p.image(image=[data], x=0, y=0, dw=10, dh=10, palette="Viridis256")
output_notebook()
show(p) 20. Streamgraph from bokeh.plotting import figure, show, output_notebook
from bokeh.models import ColumnDataSource
import numpy as np
# Generate some sample data
x = np.linspace(0, 10, 100)
y1 = np.cumsum(np.random.randn(100))
y2 = np.cumsum(np.random.randn(100))
y3 = np.cumsum(np.random.randn(100))
y4 = np.cumsum(np.random.randn(100))
y5 = np.cumsum(np.random.randn(100))
source = ColumnDataSource(data=dict(x=x, y1=y1, y2=y2, y3=y3, y4=y4, y5=y5))
p = figure(title="Streamgraph Python Bokeh Example by PratikPathak.com")
p.area(x='x', y1='y1', y2='y2', y3='y3', y4='y4', y5='y5', source=source, line_color=None)
output_notebook()
show(p) | | Live Preview Source Code 🌿 Contribute 21. Polar Plot from bokeh.plotting import figure, show, output_notebook
import numpy as np
r = np.linspace(0.1, 1, 10)
theta = np.linspace(0, 2*np.pi, 10)
p = figure(title="Polar Plot Python Bokeh Example by PratikPathak.com", plot_width=600, plot_height=600, x_range=(-1.2, 1.2), y_range=(-1.2, 1.2), toolbar_location=None)
p.polar(r, theta, color="navy", alpha=0.5, line_width=2)
output_notebook()
show(p) 22. Donut Chart from bokeh.plotting import figure, show, output_notebook
from bokeh.models import ColumnDataSource
labels = ["A", "B", "C", "D"]
values = [10, 15, 8, 12]
source = ColumnDataSource(data=dict(labels=labels, values=values))
p = figure(title="Donut Chart Python Bokeh Example by PratikPathak.com", x_range=labels)
p.wedge(x=0, y=1, radius=0.4, start_angle=0.6, end_angle=2.6, color=["red", "green", "blue", "yellow"], legend_field="labels")
p.wedge(x=0, y=1, inner_radius=0.3, outer_radius=0.4, start_angle=0.6, end_angle=2.6, color="white")
p.axis.visible = False
p.grid.grid_line_color = None
output_notebook()
show(p) 23. Treemap from bokeh.plotting import figure, show, output_notebook
from bokeh.models import TreemapRenderer, ColumnDataSource
import pandas as pd

# Sample data
data = pd.DataFrame({
    'label': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'],
    'parent': ['', 'A', 'A', 'B', 'B', 'C', 'C', 'D'],
    'value': [10, 5, 4, 3, 2, 1, 1, 1]
})

source = ColumnDataSource(data)
p = figure(title="Treemap Python Bokeh Example by PratikPathak.com")
treemap = TreemapRenderer(
    source=source,
    label='label',
    parent='parent',
    value='value',
    color_discrete_sequence=["#e6550d", "#3182bd", "#31a354", "#756bb1", "#636363", "#9e9ac8", "#de2d26", "#fd8d3c"],
)
p.add_layout(treemap)
output_notebook()
show(p) If you get any error, make sure you have installed Python pandas by using the “pip install pandas” command 24. Network Plot from bokeh.plotting import figure, show, output_notebook
from bokeh.models import ColumnDataSource, HoverTool, NodesAndLinkedEdges
import networkx as nx

# Sample data
nodes = ['A', 'B', 'C', 'D', 'E', 'F']
edges = [('A', 'B'), ('A', 'C'), ('B', 'D'), ('B', 'E'), ('C', 'F')]
G = nx.Graph()
G.add_nodes_from(nodes)
G.add_edges_from(edges)

node_positions = nx.spring_layout(G)
node_x = [node_positions[node][0] for node in G.nodes()]
node_y = [node_positions[node][1] for node in G.nodes()]
node_color = ['red', 'green', 'blue', 'yellow', 'purple', 'orange']

source = ColumnDataSource(data=dict(
    x=node_x,
    y=node_y,
    color=node_color,
    node=nodes
))

p = figure(title="Network Plot Python Bokeh Example by PratikPathak.com", x_range=(-1.1, 1.1), y_range=(-1.1, 1.1))
p.add_tools(HoverTool(tooltips=[("Node", "@node")]))
p.circle('x', 'y', size=15, color='color', source=source)

edge_x = []
edge_y = []
for start, end in edges:
    x0, y0 = node_positions[start]
    x1, y1 = node_positions[end]
    edge_x.append(x0)
    edge_x.append(x1)
    edge_x.append(None)
    edge_y.append(y0)
    edge_y.append(y1)
    edge_y.append(None)

p.multi_line(edge_x, edge_y, color="black", alpha=0.5, line_width=1)

output_notebook()
show(p) 25. Sankey Diagram from bokeh.plotting import figure, show, output_notebook
from bokeh.models import Sankey, ColumnDataSource

# Sample data
flows = [
    ('A', 'X', 5),
    ('B', 'X', 3),
    ('A', 'Y', 2),
    ('B', 'Y', 4),
    ('X', 'C', 4),
    ('X', 'D', 3),
    ('Y', 'C', 2),
    ('Y', 'D', 4)
]

source = ColumnDataSource(data=dict(
    source=[flow[0] for flow in flows],
    target=[flow[1] for flow in flows],
    value=[flow[2] for flow in flows]
))

p = figure(plot_width=800, plot_height=400, title="Sankey Diagram Python Bokeh Example by PratikPathak.com")
sankey = Sankey(source=source, label_text_color="white", label_text_font_size="8pt")
p.renderers.append(sankey)

output_notebook()
show(p) | | Live Preview Source Code 🌿 Contribute 26. Chord Diagram from bokeh.plotting import figure, show, output_notebook
from bokeh.models import ColumnDataSource, CategoricalColorMapper
import numpy as np

# Sample data
nodes = ['A', 'B', 'C', 'D', 'E', 'F']
connections = [
    ('A', 'B', 0.5), ('A', 'C', 0.3), ('A', 'D', 0.2),
    ('B', 'C', 0.4), ('B', 'D', 0.3), ('B', 'E', 0.3),
    ('C', 'D', 0.2), ('C', 'E', 0.3), ('C', 'F', 0.5),
    ('D', 'E', 0.2), ('D', 'F', 0.3), ('E', 'F', 0.4)
]

source = ColumnDataSource(data=dict(
    start=np.array([con[0] for con in connections]),
    end=np.array([con[1] for con in connections]),
    value=np.array([con[2] for con in connections])
))

p = figure(title="Chord Diagram Python Bokeh Example by PratikPathak.com", plot_width=800, plot_height=800)
chord = p.chord(
    source=source, 
    start_angle=np.pi / 2,
    direction="clockwise",
    colors=CategoricalColorMapper(factors=nodes, palette="Spectral11")
)

output_notebook()
show(p) How to Contribute? Feel free to open a PR request on our GitHub repo. Steps to contribute: Fork the repo Make changes in the Forked repo and save Open a Pull Request That’s it 😄! 🌿 Contribute Conclusion In this Repo, I have shared 25+ Python Bokeh examples that can help you learn Python Bokeh. Feel free to contribute to our GitHub repo and keep it updated. Also published . here

Getting Started With Python Bokeh: 25+ Data Visualization Examples With Source Code

Analysis of Network Graphs: Visualizing Hamilton Characters as a Social Network

নেটওয়ার্ক গ্রাফের বিশ্লেষণ: একটি সামাজিক নেটওয়ার্ক হিসাবে হ্যামিল্টন চরিত্রগুলিকে ভিজ্যুয়ালাইজ করা

Analyse von Netzwerkgraphen: Visualisierung der Hamilton-Charaktere als soziales Netzwerk

Análisis de gráficos de red: visualización de personajes de Hamilton como una red social

Analyse des graphiques de réseau : visualiser les personnages de Hamilton en tant que réseau social

नेटवर्क ग्राफ़ का विश्लेषण: हैमिल्टन के पात्रों को एक सामाजिक नेटवर्क के रूप में देखना

ネットワーク グラフの分析: ハミルトンの登場人物をソーシャル ネットワークとして視覚化する

네트워크 그래프 분석: 해밀턴 캐릭터를 소셜 네트워크로 시각화

Análise de gráficos de rede: visualizando personagens de Hamilton como uma rede social

Анализ сетевых графов: визуализация персонажей Гамильтона как социальной сети

Ağ Grafiklerinin Analizi: Hamilton Karakterlerinin Sosyal Ağ Olarak Görselleştirilmesi

Phân tích biểu đồ mạng: Trực quan hóa các nhân vật Hamilton như một mạng xã hội

网络图分析：将汉密尔顿特征可视化为社交网络

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com;
(2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com;
(3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. Table of Links Abstract and Introduction
Problem Setup and Related Work
HyperTransformer
Experiments
Conclusion and References
A Example of a Self-Attention Mechanism For Supervised Learning
B Model Parameters
C Additional Supervised Experiments
D Dependence On Parameters and Ablation Studies
E Attention Maps of Learned Transformer Models
F Visualization of The Generated CNN Weights
G Additional Tables and Figures F VISUALIZATION OF THE GENERATED CNN WEIGHTS. Figures 9 and 10 show the examples of the CNN kernels that are generated by a single-head, 1- layer transformer for a simple 2-layer CNN model with 9 × 9 stride-4 kernels. Different figures correspond to different approaches to re-assembling the weights from the generated slices: using “output” allocation or “spatial” allocation (see Section 3.1 in the main text for more information). Notice that “spatial” weight allocation produces more homogeneous kernels for the first layer when compared to the “output” allocation. In both figures we show the difference of the final generated kernels for 3 variants: model with both layers generated, one generated and one trained and both trained. Trained layers are always fixed for the inference for all the episodes, but the generated layers vary, albeit not significantly. In Figures 11 and 12 we show the generated kernels for two different episodes and, on the right, the difference between them. It appears that the generated convolutional kernel change withing 10 − 15% form episode to episode. This paper is available on arxiv under CC 4.0 license. Authors: (1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com; (2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com; (3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. This paper is available on arxiv under CC 4.0 license. Authors: (1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com; (2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com; (3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. Table of Links Abstract and Introduction Problem Setup and Related Work HyperTransformer Experiments Conclusion and References A Example of a Self-Attention Mechanism For Supervised Learning B Model Parameters C Additional Supervised Experiments D Dependence On Parameters and Ablation Studies E Attention Maps of Learned Transformer Models F Visualization of The Generated CNN Weights G Additional Tables and Figures Abstract and Introduction Abstract and Introduction Problem Setup and Related Work Problem Setup and Related Work HyperTransformer HyperTransformer Experiments Experiments Conclusion and References Conclusion and References A Example of a Self-Attention Mechanism For Supervised Learning A Example of a Self-Attention Mechanism For Supervised Learning B Model Parameters B Model Parameters C Additional Supervised Experiments C Additional Supervised Experiments D Dependence On Parameters and Ablation Studies D Dependence On Parameters and Ablation Studies E Attention Maps of Learned Transformer Models E Attention Maps of Learned Transformer Models F Visualization of The Generated CNN Weights F Visualization of The Generated CNN Weights G Additional Tables and Figures G Additional Tables and Figures F VISUALIZATION OF THE GENERATED CNN WEIGHTS. Figures 9 and 10 show the examples of the CNN kernels that are generated by a single-head, 1- layer transformer for a simple 2-layer CNN model with 9 × 9 stride-4 kernels. Different figures correspond to different approaches to re-assembling the weights from the generated slices: using “output” allocation or “spatial” allocation (see Section 3.1 in the main text for more information). Notice that “spatial” weight allocation produces more homogeneous kernels for the first layer when compared to the “output” allocation. In both figures we show the difference of the final generated kernels for 3 variants: model with both layers generated, one generated and one trained and both trained. Trained layers are always fixed for the inference for all the episodes, but the generated layers vary, albeit not significantly. In Figures 11 and 12 we show the generated kernels for two different episodes and, on the right, the difference between them. It appears that the generated convolutional kernel change withing 10 − 15% form episode to episode.

HyperTransformer: F Visualization of The Generated CNN Weights

https://youtu.be/0WH9oiYMS3M?embedable=true Introduction JWT authentication and session authentication are ways to authenticate users of your web app. In this article, we will explain the details of JWT, its structure, and its pros and cons. JWT stands for , and it is a commonly used stateless user authentication used to securely transmit information between client and server in a JSON format. JSON Web Token standard A JWT is encoded and not encrypted by default. It is digitally signed using a secret key known only to the server. It can be encrypted, but for this article, we will focus on signed, non-encrypted tokens. Structure of JWT A JSON Web Token consists of 3 parts separated by a period.
The header, the payload, and the signature.
Each section is base64 encoded. Header The header consists of a token type, which is JWT, and the signing algorithm used, such as HMAC SHA256 or RSA. { 
  "typ": "JWT",    
  "alg": "HS256"
} Payload The payload consists of the claims. Claims are statements about the user and additional data. For example, we have the time the token was issued. We also have its expiration time because tokens should expire. {
"iss": "example_issuer",
"sub": "user_id123",
"exp": 1644768000,
"iat": 1644744000
} Signature The signature is the most important part of a JWT. It is calculated using the header, the payload, and the secret, which are fed to the signing algorithm to use. signature = HMAC-SHA256(base64urlEncode(header) + "." + base64urlEncode(payload), secret_salt ) Steps The steps involved in a typical JWT authorization flow are as follows: The user signs in using a username and password or using, for example, Google or Facebook. The server verifies the provided credentials. 1- Authentication: The server will generate the JWT and send it to the client, which stores it for future use. 2- Token Generation & sending token to client: When the client wants to access a protected resource on the server, it sends the JWT in the Authorization header of the HTTP request. 3-Sending the Token to server: axios.get(URL, {
    headers: {
        'Authorization': 'Bearer ' + token,
    },
}) The server receives the request and verifies the JWT by checking its signature using the secret key that was used to sign it.
If the JWT is valid, the server extracts the information contained in it and uses it to determine what actions the user is authorized to perform. 4-Verifying the Token: If the user is authorized to access the resource, the server returns the requested data. If the user is not authorized, the server returns an error message. 5- Authorizing the Request: Advantages Lightweight Portable: It can be processed on multiple platforms, including web and mobile. JSON parsers are common in most programming languages. Protected against tampering because of the secret key stored on the server side. The server does not need to store any session information because of the stateless nature of the JWT token. Disadvantages On the server side, you should manually mark non-expired JWT as invalid on logout. A JWT can still be valid even after it has been deleted from the client. A method used is token blacklisting, which involves maintaining a list of invalidated tokens on the server side, preventing their reuse for authentication. For signed, nonencrypted tokens, we should not store sensitive info because JWT is protected against tampering but can be decoded and read by anyone. Can provide full access if intercepted. That’s why JWTs on the client side should be stored somewhere secure, for example, in the browser in an HttpOnly cookie.

JWT Explained in 4 Minutes, With Visuals

In the rapidly evolving digital landscape, data visualization plays a crucial role in understanding complex data sets and making informed decisions. Real-time data visualization, which updates dynamically to reflect live data feeds, is particularly powerful for monitoring systems, financial markets, social media trends, and more. This comprehensive guide explores how to leverage React, alongside Highcharts, a versatile charting library, to create real-time charts and graphs that are both engaging and informative. Understanding the Importance of Real-Time Data Visualization Real-time data visualization transforms static data presentations into vibrant, continuously updating streams of information. This dynamic approach to data visualization is critical in scenarios where the timely interpretation of data can lead to actionable insights, improved user engagement, or even competitive advantages. Examples include: Stock market traders rely on real-time charts to make quick buy or sell decisions based on the latest market movements. Financial Dashboards: Industries use real-time graphs to monitor the performance and health of Internet of Things (IoT) devices, ensuring timely maintenance and operations. IoT Device Monitoring: Brands track social media sentiment and engagement in real-time to respond to trends, manage crises, or capitalize on viral moments. Social Media Analytics: Fans and coaches use real-time data to analyze game performance, make strategic decisions, and enhance viewer engagement. Sports Analytics: Step-by-Step Guide to Implementing Real-Time Charts in React with Highcharts Creating a real-time chart involves setting up a WebSocket server for live data feeds and integrating Highcharts in a React application to visualize the data. Let's dive into a detailed implementation. Step 1: Bootstrap Your React Application Start by creating a new React application: npm create vite@latest Step 2: Install Highcharts and Its React Wrapper Highcharts is not only powerful but also easy to integrate with React through its official wrapper: npm install highcharts highcharts-react-official Step 3: Set Up a WebSocket Server For this guide, we'll simulate a WebSocket server that emits random data points, mimicking a live data feed. This server is crucial for demonstrating real-time data flow. Create a Simple WebSocket Server: In a new directory or within your project, set up a basic WebSocket server using the library. ws Server Code: Create a file, inside it lets write script that periodically sends random data to connected clients: server.js const WebSocket = require('ws');
// Create a WebSocket server that listens on port 8080. This server will accept WebSocket connections on this port.
const wss = new WebSocket.Server({ port: 8080 });

// Listen for 'connection' events on the WebSocket server. These events are emitted whenever a new client connects to the server.
wss.on('connection', ws => {
    console.log('New client connected!');

    // Use setInterval to create a loop that executes the given function every 3000 milliseconds (3 seconds).
    setInterval(() => {
        // Create an object named 'data' with two properties:
        // 'value' - a random number between 0 and 100,
        // 'timestamp' - the current date and time.
        const data = {
            value: Math.random() * 100,
            timestamp: new Date()
        };

        // Convert the 'data' object to a JSON string and send it to the connected client.
        // The 'ws.send' method is used to send data to a client through the WebSocket connection.
        ws.send(JSON.stringify(data));
    }, 3000); // Update every second
});

console.log('WebSocket server running on port 8080'); Start Your Server: Run your WebSocket server: node server.js Step 4: Integrating Highcharts in React Now, let's use Highcharts in our React application to visualize the real-time data. : Modify App.jsx Import Highcharts and the HighchartsReact component. Establish a WebSocket connection to receive live data and update the chart accordingly: import { useState, useEffect } from 'react';
import Highcharts from 'highcharts';
import HighchartsReact from 'highcharts-react-official';

const App = () => {
    const [data, setData] = useState([]);

    useEffect(() => {
        const ws = new WebSocket('ws://localhost:8080');

        // Connection opened
        ws.onopen = () => console.log('WebSocket Connected');

        // Listen for messages
        ws.onmessage = (event) => {
            try {
                const receivedData = JSON.parse(event.data);
                // Convert timestamp to milliseconds since the Unix epoch
                const timestamp = new Date(receivedData.timestamp).getTime();
                const value = receivedData.value;
                const newDataPoint = [timestamp, value]; // Create the Highcharts-expected format

                setData((currentData) => {
                    const newData = [...currentData, newDataPoint];
                    // Sort by timestamp, which is the first element of each data point array.
                    // Also we need to keep only last 15 data points. Otherwise chart will get messy.
                    return newData.sort((a, b) => a[0] - b[0]).slice(-15);
                });
            } catch (error) {
                console.error('Error parsing message data:', error);
            }
        };

        // Listen for possible errors
        ws.onerror = (error) => console.error('WebSocket Error:', error);

        // Clean up function
        return () => {
            if (ws.readyState === WebSocket.OPEN) {
                ws.close();
                console.log('WebSocket Disconnected');
            }
        };
    }, []);

    // Chart configuration options
    const chartOptions = {
        chart: {
            type: 'spline', // Defines the chart type as a spline (smoothed line chart)
            animation: Highcharts.svg, // Enable animation for SVG elements
            marginRight: 10, // Margin on the right side of the chart
        },
        time: {
            useUTC: false, // Use local time instead of UTC
        },
        title: {
            text: 'Live Data Stream', // Chart title
        },
        xAxis: {
            type: 'datetime', // Configure x-axis to display dates and times
            tickPixelInterval: 150, // Distance between each tick mark on the x-axis
        },
        yAxis: {
            title: {
                text: 'Value', // y-axis title
            },
        },
        legend: {
            enabled: false, // Disable chart legend
        },
        series: [{
            name: 'Live Data', // Series name
            data: data, // Chart data sourced from the state
        }],
    };

    return (
        <div
            style={{
                width: '700px',
                height: '400px',
                borderRadius: '8px',
                boxShadow: '0 4px 8px rgba(0, 0, 0, 0.1)',
                backgroundColor: 'white',
                padding: '10px'
            }}
        >
            <HighchartsReact highcharts={Highcharts} options={chartOptions} />
        </div>
    );
};

export default App; That what we get as a result: Line chart gets update every 3 seconds. Wrapping up Diving into real-time data visualization with React and Highcharts opens a world of possibilities for developers and data enthusiasts alike. To bridge the gap between theory and practice, I have made the entire project available on . This not only allows you to explore the intricacies of the code but also encourages you to experiment, adapt, and possibly enhance it according to your unique needs or curiosity. Cheers ! GitHub

Building Engaging Real-Time Data Visualizations In React With Highcharts

With ChatGPT's assistance, we can effortlessly generate and edit diagrams directly within the chat interface. However, visualizing these diagrams requires copying and pasting the code into the Mermaid editor. Introducing the , your solution to seamless diagram creation and visualization in the chat interface. HueHive diagram generator Creating Diagrams Using ChatGPT ChatGPT has proven to be more than just a conversational agent. You can now leverage it to generate Mermaid diagrams on the fly. Whether you're sketching out a software architecture, outlining a business process, or visualizing data flow, can assist you in turning your ideas into clear and concise diagrams. I tried it for multiple use cases and noticed that it works by just explaining the process and architecture to chatGPT. LLMs Visualizing Diagrams in the Chat Screen One of the problems with ChatGPT is that you can't see the visualization if you are generating diagrams, and it becomes hard to iterate without visualization. The second problem is to come up with a prompt to make sure the diagram is generated properly. I have seen that without enough context, the syntax is incorrect. One of the unique features of using Huehive for Mermaid diagrams is the ability to instantly visualize the generated diagrams within the chat screen. Gone are the days of switching between tools or platforms—now, you can seamlessly see your ideas come to life as ChatGPT interprets and renders your Mermaid diagrams in real time, right there in the conversation. Editing Diagrams You can edit the diagrams for smaller changes. Once you have the high-level diagram with correct syntax, it becomes a lot easier to change the diagram to your preference. For more complex changes, you follow up with Chat Assistant itself. Opening Diagrams in Mermaid Editor For users who prefer a more comprehensive editing experience, HueHive facilitates a seamless transition by allowing you to open generated diagrams in the Mermaid editor. This offers a rich editing environment where you can fine-tune every aspect of your diagram with precision, bringing together the best of both AI assistance and traditional diagram editing. You can also download it in different formats. Conclusion As we explore the capabilities of ChatGPT in diagram creation, visualization, and editing, it becomes evident that the synergy between artificial intelligence and visual representation is opening up new avenues for creativity and efficiency. The power to effortlessly craft Mermaid diagrams within a chat interface not only streamlines the workflow but also encourages a more dynamic and interactive approach to visual thinking. So, dive into the world of AI-assisted diagram creation with ChatGPT and witness your ideas materialize in the form of beautifully crafted Mermaid diagrams. This is the first version of the Diagram generator. I will continue to enhance and refine the tool. Your feedback and suggestions are invaluable as we strive to create a more seamless and intuitive diagram creation experience with ChatGPT. Please try it out . Please Share your creations with us and let us know how you use this tool! We welcome all feedback and suggestions. here Also published . here

HueHive Diagram Generator: Easy Diagram Creation and Visualization with ChatGPT

Salespersons and copywriters know that the key to conversions is emotions. People make an and then rationally justify their decision. emotionally-based decision at first It is almost never the other way around. So, if you want to drive higher conversions like more email signups, more social media followers, or more sales, creating an emotional impact is key. And images are one of the most powerful ways to achieve this. When you use the right imagery in the right way, you can improve conversion rates and grow your faster. business In this post, I’ll cover some of the top ways you can leverage visuals to convert. Let’s go. Add Human Faces Think of the last time you downloaded a game or clicked on an ad because they included a person in the thumbnail. You’ve likely done it more times than you care to admit. Adding people’s faces to your home page, social media post, or some other area is certain to drive up engagement as well as conversions. Here’s what you should know about what makes faces and people so appealing to our psychology. (The following points are referenced from a post by .) Highbrow Smiles Eye Contact POV In general, images of people smiling have higher conversion rates than pictures with neutral expressions. Likewise, photos where the subject looks directly at the viewer will connect more. Finally, POV or Point of View has to do with the angle at which the viewer sees the image, i.e., an image of a person looking upwards at the viewer will create different impressions than one of an image where a person is looking away or downwards at the viewer. What you should know is that the type of expression, face, and image you choose should depend on your goal and audience. Do you want to convey professionalism? Then, a sterner expression and folded arms might be suitable. But if you want to invite people to visit your site, a smile would work better. As we’ll point out later, you need to test which images work best to drive the best results. Leverage Color There are many theories on the impact of color and while it is clear that color does make an impact on buying psychology - there’s no consistent information about what works in every scenario. Much depends on the purpose for which you use a color and where you apply it. In branding (which is related to conversions but also different), there are clear links between color and brand image. For example, browns and greens convey calmness and are often associated with greenery, energy, sustainability, and related concepts. Black is associated with professionalism and seriousness. in terms of driving leads. Red is said to have the best performance However, this doesn’t mean that if you use the color green in your content, it won’t convert. More than relying on a specific hue to get people to buy, you need to look at context and placement. For example, as long as your call to action button stands out and has a complementary color on a website, it will draw the eye and entice people to click on buy, sign up, or some other conversion metric. judge a business based on its web design - so you want to ensure that you’re leveraging how your site looks and feels to keep a steady stream of customers. 75% of people Here are some factors to consider when using color to ensure higher conversion rates: Contrast: Make sure that areas where you want the most attention have contrasting colors. Consistency: While colors are powerful, using more than 3-5 in any asset is a surefire way to lose customers. Stick a fixed number of specific colors and apply them consistently on all marketing assets. Cultural associations: Be mindful of how different cultures perceive colors. White may imply purity in some places but mourning in others. Do your research before you use a color in any geographical location. Complementarity: Never pick out colors randomly. Make sure that your palette of colors complements each other. Fortunately, there are free online tools where you can add colors you like, and the tool will automatically generate suitable colors that complement them. With these principles in mind, you’ll be better able to apply colors well in your assets to boost conversions. Think of Typography We’ve all played with changing fonts on documents as kids. We’ve used elaborate, unreadable, cursive fonts for stories. Or we played around with Comic Sans to convey fun and play. We have an intuitive understanding of the role that typography plays in conveying emotions and messages. Typography is the art and science of arranging letters to make them appealing and impactful. You should look at words and letters as visual ornaments and not just for the semantic meaning they convey. There are many ways typography can support conversions: Your choice of font will support your brand and the values consumers hold - leading to a higher likelihood of conversions Good typography creates a better user experience since it removes dissonance and ensures customers navigate an app or website easily. The choice of typography can attract a user’s attention to specific words and areas, which in turn can guide people to join an email list, buy, or take some other action. These are a few ways that typography can support higher conversions. They are visual mediums and must be leveraged to the fullest to create an impact on your audience. Use Icons and Symbols If you want to understand the power of icons and symbols, think of the emoji. It’s a standard part of modern communication where we rely heavily on text, and without emojis, we’d experience significant miscommunication and ruptured relationships. Today, icons and symbols play a big role in website and app design and they’re a powerful visual asset that can drive conversions. For example, research institute found that a ‘made-up’ symbol like a padlock icon or security badge created a greater sense of security. Baymard So, if you want to improve your payment checkout conversions, consider adding the little padlock symbol to your form in the right place. (Another interesting finding from Baymard is making the checkout process ‘robust’ by adding an outline or a line to contain the checkout form. This simple visual tactic contains the payment form and implies greater security during checkout.) In this way, make sure you use a carefully designed set of icons and symbols to make navigating your site easier and to convey ease and security on your products. Whitespace A user’s visual journey is not just influenced by the number of images on your site or app but also by the whitespace or the empty space around elements on your platform. Whitespace allows your content and features to breathe and keep users from getting overwhelmed. And when used correctly, it can draw attention to important parts of your site. So, don’t neglect to use whitespace as wisely as you do the other elements mentioned here. Carry out A/B Testing to Verify Your Design Choices No matter how experienced a UX/UI designer is, you must always test your design choices through user testing. This means presenting important visual content to your target audience base and asking for feedback. A good methodology to try is split testing or A/B testing. Give users a choice between two designs, A and B. And the one that wins the majority vote should be your design choice or improved and tested further. Only through testing can you figure out if your visual assets are impactful and create the right impression on your audience. Over to You There you have it: a breakdown of how to make your visual elements have a greater impact. Try to implement these aspects into your design, product development, and more. You’re certain to see a rise in conversions, which will lead to overall business success.

Visual Mastery: How to Create Impactful Marketing That Drives Engagement

These tools do more than just display data; they help in quickly reading, analyzing, and making informed decisions, which is critically important for both developers and businesses. A well-designed dashboard can become a key element in forecasting trends and anticipating outcomes, impacting the efficiency and motivation of the team. Hello! My name is Lisa, and I have worked as a product designer in large IT companies and small startups. Among my experience was the creation of internal products that help monitor metrics and the state of service operations. Thanks to this, I have accumulated significant experience in dashboard development, and today I want to share this experience with you. Today, I want to inspire you to create useful and effective dashboards by sharing my approach and emphasizing the importance of UI design in this process. The sense of dashboard I want to start with three fundamental principles that should guide the creation of dashboards. These are precisely what you, as a product manager or product designer, should advocate for: One of the less obvious but critically important tasks in dashboard creation is the ability . Visualization should not only display numbers but also convey context, show cause-and-effect relationships, and identify trends. This requires a deep understanding of how data correlates with real business processes and user behavior. Dashboard developers should aim not only to present data but also to explain it, creating an intuitive and engaging narrative structure. to tell a story with data Often in the dashboard development process, you may encounter the issue of “expectation overload” — when users want to see too many features and data. It’s important to be able to manage these expectations, explaining limitations and focusing on the most important aspects that truly add value. This might require communication and persuasion skills, as well as the ability to and the impact of various features on the final product. objectively assess priorities Technical and organizational obstacles often become a serious challenge. For instance, integrating data from various sources can be a complex task due to format incompatibilities or API limitations. In such cases, it’s crucial to to find solutions that ensure smooth integration and reliable system performance. It’s also important to consider organizational aspects, such as training the team to use the new dashboard and implementing it into work processes. closely collaborate with developers Goals Every successful dashboard begins with a clear understanding of its goals and audience. At my current job, before starting the development of a dashboard, we conduct . This could be, for example, monitoring key performance indicators for executives or providing technical data for the development team. an analysis of the objectives it needs to achieve and the audience it is intended for To illustrate, in one of our projects, the goal was to create a dashboard for monitoring server operations. The audience consisted of technical specialists who required detailed, real-time information about the system’s status. The goals and audience defined the structure and design of the dashboard, making it maximally informative and user-friendly for the end users. Moreover, an effective dashboard helps reduce risks for the company by providing For instance, thanks to the instant display of server downtime data, the team can quickly respond to issues, minimizing downtime and potential losses. quick access to critically important information. Equally important is the impact of the dashboard on the team’s motivation and awareness. When the team sees a dashboard tailored specifically for them with up-to-date metrics every day, it enhances their engagement and provides a clear understanding of the current state of the project. This creates a sense of control and confidence in the decisions being made, which in turn contributes to an overall increase in work efficiency. Users Before beginning the design of a dashboard, it’s critically important to understand . In my practice, this starts with a deep dive into the world of the end-users — developers, project managers, data analysts, and so on. I conduct interviews, analyze workflows, and gather feedback to understand their daily tasks and challenges. who the primary users will be and what tasks they will be addressing For example, might need real-time system performance monitoring, while may require an overview of task completion timelines and resources. By identifying these key usage scenarios, I can ensure that the dashboard will not only be functional but also maximally useful for specific users. developers project managers Next, I link the functionality of the dashboard to the overall It’s not just about presenting data; it’s about how these data can help achieve specific objectives. For instance, if a business goal is to increase efficiency, then the dashboard should highlight metrics that track progress and identify bottlenecks. business goals of the company. In one of the projects, the goal was to improve customer service quality. For this, we developed a dashboard that displayed key indicators in real-time related to the processing of customer inquiries, allowing the team to respond promptly to issues and improve service quality. Thus, understanding both user needs and business goals not only displays data but actively contributes to achieving the organization’s ultimate goals. Strategy When we start defining the key functions and priorities of a dashboard, it’s important to find a balance between what users want and what is truly needed to achieve business goals. In my experience, I begin by creating a list of features that could be useful and then prioritize them based on their impact on users and business objectives. For instance, for a dashboard designed for monitoring application performance, key features might include displaying system response time, code errors, and server load levels. This is not just about having “nice-to-have” features; it’s about creating a “must-have” list that is guided by strategic goals and the real needs of the user. In developing a dashboard, I always think about how it will fit into the broader context of the product. 👾How will it interact with other features? 📎 How will it help the user better understand and use the product as a whole? For example, if a dashboard is designed for a CRM system, it should not only provide data but also simplify interactions with customers and improve processes for working with them. In this way, we make the dashboard . a valuable addition, not just an isolated tool Design. Prototyping. Iterations. I start with basic sketches that allow for a quick assessment of ideas and structure. These sketches are more than just drawings; they help me and my team visualize the dashboard concept and initiate a dialogue about how it should function. Once the concept is approved, I move on to creating more detailed prototypes. I develop prototypes that not only resemble the final product but also . This is a critically important step as it allows for testing with real users and gathering feedback that will influence subsequent design iterations. give an insight into user interaction When designing the dashboard interface, my main goal is to create an intuitive and effective user experience. Here are a few key principles I always keep in mind: 🎧 Clarity and Noise Reduction It’s important that users can quickly understand what is displayed on the dashboard. I aim to avoid information overload, focusing on key metrics and data necessary for the specific audience. 🧭 Consistency and Predictability I use consistent design elements and layouts so that users can intuitively understand how to interact with the dashboard. This includes uniformity in colors, fonts, and layouts. 💠 Interactivity and Feedback The dashboard should be informative as well as interactive. I include elements such as filters and dropdown menus that allow users to customize data display according to their preferences. 🍟 Accessibility and User-Friendliness I believe that design should be accessible to all users. This includes considering people with different abilities and preferences, as well as ensuring that the dashboard is user-friendly on various devices. Data Visualization and Information Architecture One of the key aspects of creating effective dashboards is the proper selection of data . Each data type requires its own approach to presentation to ensure the information is understandable and easily digestible. visualization methods For example, line charts are ideal for time series as they clearly illustrate the dynamics of changes. Bar or pie charts work well for comparing values across categories. Heat maps can be useful in visualizing complex datasets, allowing for quick identification of patterns and anomalies. It’s important to remember that visualization should be not only informative but also . I use colors and shapes to make data more accessible and comprehensible, while avoiding overloading with visual information. appealing Additionally, I focus on and ensuring a consistent flow of information, which aids users in easily navigating and finding the data they need. For instance, in a dashboard designed for sales analysis, I might group data related to customer demographics, sales figures, and product performance in distinct but interconnected sections. This way, a sales manager can quickly locate specific insights, such as the best-selling products in a particular demographic segment. grouping related data Another example is a financial dashboard where I categorize data into revenue, expenses, and profit margins. By doing so, financial analysts can effortlessly switch between different financial aspects without losing track of the overall financial health of the company. These thoughtful groupings and layouts not only improve the usability of the dashboard but also enhance the decision-making process by presenting a coherent narrative of the data. Testing and Iteration To identify usability issues and understand how well the dashboard meets users’ needs and expectations, we showcase our developments to real users. Based on the feedback collected, the process of iterations begins. The key is to be the design in response to the data received. Iterations can affect both minor details of the interface and larger aspects of structure and functionality. open to changes and ready to adapt In one of our recent projects on creating a dashboard for server performance monitoring, user testing became a pivotal moment. After the initial development of the dashboard, we conducted a series of tests with our development team, who were the primary users of the product. During these sessions, I observed how they interacted with the dashboard, . A key issue was that the developers had trouble interpreting the performance time series. The charts were overloaded with data, making it difficult to quickly analyze the situation. noting any difficulties or misunderstandings Based on this initial testing, we began the process of iterative improvements. Our first step was to simplify the charts by highlighting the most critical metrics and reducing visual clutter. We also added the ability to filter data by time intervals, allowing developers to focus more easily on specific periods. After implementing these changes, we conducted , this time with a broader group of users, including project managers. The feedback was significantly more positive: the charts became clearer, and the data filtering feature was particularly appreciated for its usefulness. a second round of testing Product Integration The next key stage is the integration of the dashboard into the overall product. In my project of creating a dashboard for server monitoring, one of the main tasks was to ensure its . This required close collaboration with the development team to ensure that the dashboard accurately collects and displays data in real-time. seamless integration with the existing system We utilized APIs to connect the dashboard to various data sources, ensuring high performance and reliability. Work was also done to optimize data loading so that the dashboard could respond quickly to user queries, even when processing large volumes of information. It’s crucial that the dashboard not only meets current needs but can also . To this end, we developed a modular architecture that allows for the easy addition of new features and the integration of additional data sources. Ensuring continuous support and updates for the dashboard was also an important part of the process, guaranteeing its stability and the relevance of its data. adapt to future changes and expansions of the system Creating dashboards is an integral part of product design. They not only provide valuable information for decision-making but also significantly enhance user convenience and efficiency. My experience has shown that a well-designed dashboard can have a substantial impact on business, improving processes and aiding in the achievement of goals. Tips and Tricks for Product Designers Start by figuring out what your users and . It’s like being a detective, but instead of solving crimes, you’re solving design puzzles. business really need Regularly . Be ready to iterate based on the feedback test the dashboard with real users Aim for in data visualization. Avoid information overload and focus on the key metrics. simplicity Develop dashboards with and potential data or process changes in mind. future scaling Postscript Alternative Ways to Create Dashboards: No-Code and Low-Code Solutions In the modern world of product design, there is an increasing number of . These no-code and low-code platforms offer convenient means for quick and efficient dashboard development, making them accessible not just for professional developers but also for business analysts, marketers, and other specialists. tools that allow for dashboard creation without deep programming knowledge Platforms: is  a powerful platform for creating interactive dashboards, particularly valuable for monitoring and analyzing time-series data. Ideal for real-time system monitoring, network analysis, and IoT applications, Grafana supports multiple data sources, including Prometheus, MySQL, PostgreSQL, and many others. This tool is highly flexible in visualization customization, allowing for detailed and adjustable dashboards. However, it may require deeper technical knowledge for setup and use compared to other no-code/low-code solutions. Grafana is one of the most popular platforms for data visualization. It offers robust tools for creating a variety of dashboards with the ability to connect to different data sources. Tableau makes it easy to integrate data from various sources and create interactive dashboards. It is ideal for integration with other Microsoft products, such as Excel and Azure. Microsoft Power BI is a free solution from Google that allows for creating customizable dashboards. Particularly well-suited for working with data from Google Analytics, Google Ads, and other Google services. Google Data Studio : This tool provides flexible options for dashboard creation and business analytics. It enables not just data visualization but also in-depth analysis. Looker Using no-code and low-code platforms has its advantages, including . However, one should consider their limitations in terms of customization and integration with some complex systems. Therefore, it’s important to assess the needs of the project and choose a tool that best meets these requirements. development speed, ease of use, and flexibility in design alteration

Creating the Perfect Dashboard: Visualizing Your Metrics

নিখুঁত ড্যাশবোর্ড তৈরি করা: আপনার মেট্রিক্স ভিজ্যুয়ালাইজ করা

Erstellen des perfekten Dashboards: Visualisierung Ihrer Metriken

Creando el panel perfecto: visualizando tus métricas

Créer le tableau de bord parfait : visualiser vos métriques

परफेक्ट डैशबोर्ड बनाना: अपने मेट्रिक्स को विज़ुअलाइज़ करना

完璧なダッシュボードの作成: 指標の視覚化

완벽한 대시보드 만들기: 측정항목 시각화

Criando o painel perfeito: visualizando suas métricas

Создание идеальной информационной панели: визуализация показателей

Mükemmel Kontrol Panelini Oluşturma: Metriklerinizi Görselleştirme

Tạo Trang tổng quan hoàn hảo: Trực quan hóa các chỉ số của bạn

创建完美的仪表板：可视化您的指标

143 Stories To Learn About Data Visualization

As you hopefully know from reading some of my recent articles, I really enjoy writing Kubernetes operators! I've written and also just recently about how to build them at the inaugural in Portland, Oregon. So here goes another operator-related article, although this one is about one of the later stages of operator development: performance tuning. a bit about them on this blog presented a talk FOSSY conference Since I've been working on an operator that includes multiple controllers, each with four reconcilers running concurrently that make API calls to resources outside of the cluster, I wanted to start profiling my reconciliation loop performance to ensure that I could handle real-world throughput requirements. Prometheus Metrics offers as part of its default scaffolding. This provides a great way to profile and monitor your operator's performance under both testing and live conditions. Kubebuilder the ability to export operator-specific Prometheus metrics Some of these metrics (many on a per-controller basis) include: A histogram of reconcile times Number of active workers Workqueue depth Total reconcile time Total reconcile errors API server request method & response counts Process memory usage & GC performance I wanted a way to monitor these metrics for controllers that are under development on my local machine. This means that they are running as processes outside of any cluster context, which makes it difficult to scrape their exposed metrics using a standard Prometheus/grafana setup. operator-prom-metrics-viewer So I thought, why not craft a little GUI to display this information? Inspired by the absolutely incredible , I decided to make a terminal-driven GUI using the . k9s project tview library Since I'm not (yet) storing this information for further analysis, I decided to only display the latest scraped data point for each metric. But I also didn't want to implement my own Prometheus metric parser to do this, so I imported pieces of the Prometheus to handle the metric parsing. All I had to do was implement a few interfaces for storing and querying my metrics to interop with the scrape library. scrape library itself Prometheus in-memory, transient storage The Prometheus storage and query interfaces are relatively simple, and it helps that we actually don't need to implement all of their methods! Storage The underlying storage mechanism of my class is a simple map along with a mutex for locking it during multithreaded IO. In this map, we are only storing the latest value for each metric, so there's no problem overwriting a key's value if it already exists. And we also don't need to worry about out-of-order writes or any other time-series database problems. InMemoryMetricStorage type InMemoryAppender struct {
	data map[uint64]DataPoint
	mu   *sync.Mutex
} The struct maps directly to a Prometheus metric's structure. If you've worked with Prometheus metrics before, this should look pretty familiar to you. DataPoint type DataPoint struct {
	Labels    labels.Labels
	Timestamp int64
	Value     float64
} To populate each DataPoint's key in the map, we can simply use the Prometheus builtin function to generate a unique key for each DataPoint, without having to do any extra work on our end. uint64 labels.Hash() To demonstrate, here's an example of a Prometheus metric: # HELP http_requests_total Total number of http api requests
# TYPE http_requests_total counter
http_requests_total{api="add_product"} 4633433 And how it would be represented by the struct: DataPoint d := DataPoint{
    Labels: []Label{
        {Name: "api", Value: "add_product"},
    },
    Value: 4633433,
    Timestamp: time.Now(),
} Now that we have our data model, we need a way to store s for further retrieval. DataPoint Appender Here's the interface of the storage backend appender: type Appender interface {
	Append(ref SeriesRef, l labels.Labels, t int64, v float64) (SeriesRef, error)
	Commit() error
	Rollback() error

	ExemplarAppender
	HistogramAppender
	MetadataUpdater
} Because we're building a simple in-memory tool (with no persistence or availability guarantees), we can ignore the and methods (by turning them into no-ops). Furthermore, we can avoid implementing the bottom three interfaces since the metrics that are exposed by Kubebuilder are not exemplars, metadata, or histograms (the framework actually uses gauges to represent the histogram values; more on this below!). So this only leaves the function to implement, which just writes to the 's underlying map storage in a threadsafe manner. Commit() Rollback() Append() InMemoryAppender func (a *InMemoryAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64) (storage.SeriesRef, error) {
	a.mu.Lock()
	defer a.mu.Unlock()
	a.data[l.Hash()] = DataPoint{Labels: l, Timestamp: t, Value: v}
	return ref, nil
} Querier The querier implementation is also fairly straightforward. We just need to implement a single method against our datastore to extract metrics from our store. Query My solution is far from an optimized inner loop; it has awful exponential performance in the worst case. But for looping through a few metrics at a rate of at most once per second, I'm not overly concerned with the time complexity of this function. func (a *InMemoryAppender) Query(metric string, l labels.Labels) []DataPoint {
	a.mu.Lock()
	defer a.mu.Unlock()

	dataToReturn := []DataPoint{}

	for _, d := range a.data {
		if d.Labels.Get("__name__") != metric {
			continue
		}

		var isMatch bool = true
		for _, label := range l {
			if d.Labels.Get(label.Name) != label.Value {
				isMatch = false
			}
		}

		if isMatch {
			dataToReturn = append(dataToReturn, d)
		}

	}

	return dataToReturn
} Histogram implementation Since the controller reconcile time histogram data is stored in Prometheus gauges, I did need to write some additional code to transform these into a workable schema to actually generate a histogram. To aid in the construction of the histogram buckets, I created 2 structs, one to represent the histogram itself, and the other to represent each of its buckets. type HistogramData struct {
	buckets []Bucket
	curIdx  int
}

type Bucket struct {
	Label string
	Value int
} For each controller, we can run a query against our storage backend for the metric with the label. This will return all histogram buckets for a specific controller, each with a separate label ( ) that denotes the bucket's limit. We can iterate through these metrics to create objects, append them to the slice, and eventually sort them before rendering the histogram to keep the display consistent and in the correct order. workqueue_queue_duration_seconds_bucket name=<controller-name> le Bucket HistogramData.buckets The field on the struct is only used internally when rendering the histogram, to keep track of the current index of the slice that we're on. This way, we can consume buckets using a loop and exit when we return the final bucket. It's a bit clunky, but it works! curIdx HistogramData buckets for v1.0 After all of this hacking, I ended up with something that looks like this: It's far from perfect; since I don't manipulate the histogram values (yet) or have any display scrolling, it's very likely that the histogram will spill off the right of the screen. The UX can also be improved since you can only switch the controller that is being displayed by pressing the and buttons. Up Down But it's been a fantastic tool for me when debugging slow reconciles due to API rate limiting, and it has also highlighted errors for me when I miss them in the logs. Give it a whirl, and let me know what you think! Link to the GitHub: https://github.com/sklarsa/operator-prom-metrics-viewer Also published . here

Operator Performance Tuning: Building a GUI for Prometheus Metrics Visualization in Kubernetes

React UI Development: Real-Time Visualization with Codux

To achieve reliable visual testing, it’s crucial to prevent unreliable tests by effectively hiding dynamic parts of your application. When dealing with elements prone to change, like ad banners, moving text inputs, GIFs, and user cursors, it’s essential to use dynamic element masking. This means hiding these elements before taking screenshots during to avoid false results due to dynamic content. testing Let’s use an example and imagine we want to assess the layout of the Stories section through visual testing. Facebook The challenge here is that the images and titles in the stories tray element will differ whenever you reload the page. This isn’t ideal for visual testing. Modern testing frameworks provide methods for this. For instance, Playwright lets you hide specific page elements when taking screenshots by completely covering its bounding box with a #FF00FF color. Let’s try to hide all <img> elements before making a screenshot. let mask_locator = page.locator("//img")
await page.screenshot({path: 'masked.png', mask: [mask_locator]}) The problem with such an approach is that it completely covers your element bounding box, so since every element is a rectangle, you will see something like that. HTML Default Playwright masking is excellent for simple rectangle ad banners and buttons, but you want something better and more accurate for complex layouts. For instance, you can toggle the visibility of images in this section because they aren’t necessary for layout testing. To implement this, please review the script provided below. // Get all img elements on the page
var imgElements = document.getElementsByTagName('img');

// Loop through each img element and hide it
for (var i = 0; i < imgElements.length; i++) {
    imgElements[i].style.display = 'none';
}
// Get the element with aria-label="stories tray"
var storiesTray = document.querySelector('[aria-label="stories tray"]');
// Check if the stories tray element exists
if (storiesTray) {
    // Get all span elements inside the stories tray
    var spanElements = storiesTray.querySelectorAll('span');
    // Loop through each span element inside the stories tray and replace its text content with "test."
    spanElements.forEach(function(span) {
        span.textContent = 'test';
    });
} This script hides all <img> elements and changes the story titles into “test” because we don’t need to check the text value, just a layout. After executing such a script, the section will resemble a clean layout that you can capture in a screenshot and use for comparison in your visual tests. If you don’t want to hide such elements or want to highlight hidden areas, you can fill it with any color, i.e., #FF00FF, using the next script: // Get all img elements on the page
const imgElements = document.querySelectorAll('img');

// Loop through each img element and set its background color to red
imgElements.forEach((img) => {
  img.style.backgroundColor = '#FF00FF';
  img.src = ''; // Optional: Remove the image source to hide the original image
});

// Get the element with aria-label="stories tray"
var storiesTray = document.querySelector('[aria-label="stories tray"]');
// Check if the stories tray element exists
if (storiesTray) {
    // Get all span elements inside the stories tray
    var spanElements = storiesTray.querySelectorAll('span');
    // Loop through each span element inside the stories tray and replace its text content with "test"
    spanElements.forEach(function(span) {
        span.textContent = 'test';
    });
} Embracing this technique ensures stable and trustworthy visual tests, allowing you to detect real issues without distractions from transient visual elements. Also published here.

Stories, News & Mentions about VAISUAL

Vaisual’s Stories on HackerNoon