Visualizing Uncertainty for Non-Expert End Users: The Challenge of the Deterministic Construal Error
There is a growing body of evidence that numerical uncertainty expressions can be used by non-experts to improve decision quality. Moreover, there is some evidence that similar advantages extend to graphic expressions of uncertainty. However, visualizing uncertainty introduces challenges as well. Here, we discuss key misunderstandings that may arise from uncertainty visualizations, in particular the evidence that users sometimes fail to realize that the graphic depicts uncertainty. Instead they have a tendency to interpret the image as representing some deterministic quantity. We refer to this as the deterministic construal error. Although there is now growing evidence for the deterministic construal error, few studies are designed to detect it directly because they inform participants upfront that the visualization expresses uncertainty. In a natural setting such cues would be absent, perhaps making the deterministic assumption more likely. Here we discuss the psychological roots of this key but underappreciated misunderstanding as well as possible solutions. This is a critical question because it is now clear that members of the public understand that predictions involve uncertainty and have greater trust when uncertainty is included. Moreover, they can understand and use uncertainty predictions to tailor decisions to their own risk tolerance, as long as they are carefully expressed, taking into account the cognitive processes involved.
Kafka Monitoring with eBPF: It’s a Whole New Perspective
Find out why comprehensive monitoring of your Kafka performance is critical and why standard approaches like server-side monitoring can undercut visibility into Kafka performance – even if you don't realize it until it's too late. Get the tips you need to improve your Kafka monitoring strategy by leveraging tools like eBPF.
Event Modeling can be applied in designing systems that will store state in traditional databases. By providing a more thorough design, the solution can be implemented with a lot less waste that usually comes in the form of having to re-visit finished items as the solution is built up.
The Bespoke Supercomputing Architecture That Stood the Test of Time - The Next Platform
In the history of computing, there has been an endless push and pull between the need for general-purpose versus fine-tuned custom systems and software. While general purpose will, by nature, prevail on leadership-class HPC, the work done in meticulous world of ASIC design, system and software optimization filters into architectural thinking eventually. In the case
This series is all about infrastructure: the invisible layer of wires and guts and light that makes everything run. It’s not in the best shape, but what would it take to make it better?
This specification defines standard HTTP headers and a value format to propagate context information that enables distributed tracing scenarios. The specification standardizes how context information is sent and modified between services. Context information uniquely identifies individual requests in a distributed system and also defines a means to add and propagate provider-specific context information.
Simplifying Complexity: The Journey from WebSockets to HTTP Streams
This article explores the transition from a WebSocket-based implementation to a simpler, more direct stream over HTTP in the context of capturing touch screen inputs on Linux.
It begins by introducing the main theme, encapsulated in the statement Everything is a file is a stream of byte. The need to capture finger positions on a touchscreen by reading /dev/input/events in Linux is initially discussed, followed by a dilemma of transferring this data to a JavaScript client in a browser.
Initially, WebSockets are chosen, leading to a discussion on how frameworks often shape our technological choices and the challenges faced in debugging WebSocket connections. The article then introduces an alternative about sending a stream of bytes over HTTP, drawing a parallel to Linux’s approach to handling devices and files.
Serialization, the process of encoding messages for this stream, is discussed next, highlighting the implementation specifics in GoLang and its native advantages. The final section covers how to receive and decode this stream in JavaScript within a worker thread, and then send the decoded messages to the main thread using post requests.
The article concludes by reflecting on the benefits of simplicity in technology, urging readers to reevaluate default choices and consider more straightforward solutions to complex problems.