railway | Functional helpers including Async and Result | Functional Programming library

A simple way of handling the exceptions on the "side track" is by using the peekleft method Vavr provides, which consumes the Either.Left() side. We can plug our exception processing logic in there, and leave our Either.right() stuff nicely on the main track without any ugliness.

I am pretty sure this can be improved, and would love ideas on improving this.

One of the main advantages of using euclidean distance is that is simple to compute. However, the RGB space is not a good color space in which to compare color differences. Its grayscale projection is even less adapt.

Based on these premises, several color spaces have been proposed in history in order to measure human-perceived color differences with the euclidean distance.

The complexity of the human perception, however, collides with the attempt to use simple formulas for mapping coordinates relative to different color-spaces. This led to the proliferation of a number of solutions that balance the objective to approximate the human perception with the simplicity of the formulas.

The CIELAB is one of the most broadly used color-spaces for evaluating color differences. According to Wikipedia

CIELAB was intended as a perceptually uniform space, where a given numerical change corresponds to similar perceived change in color.

The original definition that uses just the euclidean distance dates back to 1976. Another Wikipedia page explains that various refinements have been published in history in order to correct the non-uniformities that were discovered later.

To summarize, for evaluating the human-perceived difference between two colors, I suggest you to proceed in the following way:

1. Convert the colors from RGB color space to CIELAB color space by using the formulas you can find online (you may want to convert RGB to CIEXYZ and then CIEXYZ to CIELAB);
2. Compute the euclidean difference between the two mapped colors. You can of course use one of the other metrics according to the accuracy you need.

Should a resource design like this be avoided or is such a design common practice?

It's fine.

Imagine the "resource" as a web page. GET /journeys/15 returns a document that is an HTML representation of the journey. As the driver reports events, the document updates to match. The "end of journey" event removes the information about the driver that is enclosed within the document.

That's all perfectly normal.

Human beings are decent at dealing with that ambiguity, but for machines we probably want to have a more explicit schema. For this design, that would include a description of how to interpret the document to extract various bits of information, and which elements of information are optional.

Would it be better in this example to have two seperate resources, such as /live/journeys and /analytics/journeys to avoid confusion and to seperate live application state and business-view state?

Let's start with "is it reasonable?" Yes. Resource models might have many resources with common information. As an analogy, you might consider two different reports produced by queries on the same data set. Having different resources for each report is a perfectly normal design.

Is it better? "It depends". The potential problem with having multiple resources describing the same information is that cached copies of the two resources may not be synchronized. General purpose components (like web caches) won't necessarily know that the resources are related, and in particular won't know all of the resources that need to be invalidated when the driver updates /journeys/15

For a domain where nobody is likely to look at the analytics resource until the journey is done, synchronization probably isn't a big concern, so multiple resources should be fine.

Get a list of all paragraphs

You can turn this off by creating a custom ScalarFormatter object and turning scientific notation off. For more details, see the matplotlib documentation pages on tick formatters and on ScalarFormatter.

If I understand your Question correctly then you need to use onPanelSlide: callback to report the sliding percentage of your panel.

so in your SlidingUpPannel will be

I THINK YOU JUST MISSED TO INCLUDE BOOTSTRAP PLUGINS

<@link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/normalize/8.0.1/normalize.min.css">
<@link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css">

<@script src="https://code.jquery.com/jquery-1.12.4.min.js"> <@script src="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/js/bootstrap.min.js">

The problem is that your read_json(....).text line returns a series, not a dataframe.

Adding a .to_frame() and referencing the column in the following line should fix it:

Python's CSV module might help you. Using the CSV module makes it easy. The only thing you need to do is to append the items to a list and then output them all at once, see my_list in the code below.