• 0 Posts
  • 6 Comments
Joined 1 year ago
cake
Cake day: August 4th, 2023

help-circle
  • This is true for only red and green loght detecting proteins (opsins) - the blue opsin gene is on chromosome 7.

    The red and green detecting proteins have an interesting history in humans.

    Fish, amphibians, lizards and birds have 4 different opsins: for red, green, yellow and blue colours. And the blue opsin sees up into the ultra-violet. Most animals can see waaaay more colours in the world than we (or any mammal) can. So what happened that makes mammal vision so poor?

    It’s thought that all mammals descend from one or a few species of nocturnal mammal that survived the catastrophe that wiped out the dinosaurs at the end of the Cretaceous. The colour detecting cells (the cones) need a lot of light compared to ones that see in black-and-white (the rods) and therefore nocturnal animals frequently lose cones in favour of the more sensitive rods for better night vision. The mammals that survived the Cretaceous extinction had also lost the green and yellow opsins while keeping red and blue - basically the two different ends of the light spectrum.

    Consequently today most mammals still have only 2 opsins so your cat or dog is red-green colourblind.

    Why do humans see green? Probably because our monkey forebears, who lived in trees and ate leaves, needed to distinguish red leaves and red fruit (visible to birds) from the green background.

    But how did we bring back the green opsin? A whole section of the X chromosome (where the red opsin is coded) got duplicated in a dna copying mistake and then there were two genes for red opsins. As there are different alleles (versions), they could be selected for independently and so one red opsin drifted up the spectrum to be specific for green. So our green opsin is a completely different gene to the green opsin in fish, birds, etc. This kind of evolution happens a lot which is why, for example, there are many families of similar hormones like testosterone and estrogen. And steroids too.


  • It is terribly sad - they must live in a world of hurt.

    However so many of these people actively try to hurt LGBTQ+ and trans people by inciting hate and changing laws to harm the non-straight. In particular they have been preaching that being gay/trans equates to being a child molester. This is horrific and needs to stop. Exposing the hypocrisy is essential to reducing the harm they are inflicting to real people right now



  • I don’t think that the anti-oop collective is attacking polymorphism or overloading - both are important in functional programming. And let’s add encapsulation and implementation hiding to this list.

    The argument is that OOP makes the wrong abstractions. Inheritance (as OOP models it) is quite rare on business entities. The other major example cited is that an algorithm written in the OOP style ends up distributing its code across the different classes, and therefore

    1. It is difficult to understand: the developer has to open two, three or more different classes to view the whole algorithm
    2. It is inefficient: because the algorithm is distributed over many classes and instances, as the algorithm runs, there are a lot of unnecessary calls (eg one method on one instance has to iterate over many instances of its children, and each child has to iterate over its children) and data has to pass through these function calls.

    Instead of this, the functional programmer says, you should write the algorithm as a function (or several functions) in one place, so it’s the function that walks the object structure. The navigation is done using tools like apply or map rather than a loop in a method on the parent instance.

    A key insight in this approach is that the way an algorithm walks the data structure is the responsibility of the algorithm rather than a responsibility that is shared across many classes and subclasses.

    In general, I think this is a valid point - when you are writing algorithms over the whole dataset. OOP does have some counterpoints encapsulating behaviour on just that object for example validating the object’s private members, or data processing for that object and its immediate children or peers.