Completely agree on limiting yourself reducing the nesting of code.
There is more difficulty working with code such as
if x {
//...
} else {
//...
}
Than code like
if x {
// returns from this block
}
// execution continues
In some legacy code I sometimes encounter very long chains of checks which nest 4-8 layers, which becomes very difficult to maintain a mental model of where you are in execution at any point. I try to refactor into the second pattern from above when possible.
The intent is clearly to prevent entities from publishing clearly fake/ill-gotten reviews. The first amendment does not protect your speech when that speech is used to assist in committing another crime. The second amendment exists, but that does not give you carte blanche to shoot people (extreme example).
For a speech related example, see the Freeman v Giuliani case[^1], where the defense stated that they "have a first amendment right to lie," which was ruled to not be the case in defamation.
Also remember that there needs to be some measurable level of harm inflicted. A silly comment in this thread is unlikely to have any measurable level of harm, but cheating reviews may result in tens to hundreds of thousands of dollars in sales.
The issue isn't the "hunt for the bottom line" but the fact that simultaneously multiple parties are offered different price points for an unknown reason (to the workers).
You say it's not discrimination, but you cannot definitively make that claim. That's the issue. Red lining isn't immediately discrimination against a protected class, but silently is it. This is not to say that Uber/Lyft are discriminating against a protected class - it's just that because of the lack of transparency we don't know that they are not.
This is a hard thing for people to accept, but we need to take a deep look at how we implement ML to classify things tied to individuals. It's very easy to de-humanize the humans affected by the systems we build, because "it's just an algorithm."
There was a (now deleted comment) about how there is no proof of wage discrimination for Uber/Lyft drivers, which was posted with no evidence.
This video (https://www.youtube.com/watch?v=OEXJmNj6SPk) was recently published which shows drivers being offered the same gigs, but different payment amounts. Note that I could not find a published version of the data they collected in this video.
That is not explicitly proof of wrongdoing, but clearly algorithmic price setting can be demonstrated as not always offering the same payment to the same drivers for the same work. There may be a valid reason to why this is the case, but as the calculation method is closed source, the individuals being offered the wage are unaware of why they would be paid less than their peers.
This is work that is often considered "low skill" - which should actually make it extremely cut and dry as to why an individual would be paid more or less. Are they making their pickups faster? Are their customers more satisfied? If that's the case, why would they sometimes be offered more money than their peers and sometimes less money?
Almost all workers here are price takers, and suffer greatly from the information asymmetry present. Companies hiding behind "oh but the algorithm says..." is a poor excuse for inequality.
Edit: Because discrimination is in the title of the OP, I feel the need to clarify: in no way is the above saying that the video posted is proof of discrimination. Inequality need not be discrimination. When there is inequality without any measurable source, we need to be skeptical of the reason. Maybe one driver has better customer feedback, therefore they get offered a higher wage. There are many logical explanations for the result, but Uber/Lyft do not seem to engage with the discussion. This should raise red flags. That does not conclude that they are discriminating against anyone, and that would be a poor conclusion to draw without a true investigation.
There is more difficulty working with code such as
if x { //... } else { //... }
Than code like
if x { // returns from this block } // execution continues
In some legacy code I sometimes encounter very long chains of checks which nest 4-8 layers, which becomes very difficult to maintain a mental model of where you are in execution at any point. I try to refactor into the second pattern from above when possible.