When I first went from CT as an implementation detail of typed FP to studying CT on its own, I was very aggravated by this point: "where is there a functor that isn’t an endofunctor?"
Over time it has fallen away in two directions.
In one direction is that though you are always stuck in a category with types as objects and functions as arrows, that doesn't stop you from subdividing. This became more intuitive to me as I encountered more and more categories that are basically just Set with extra structure (just as the one we program in is basically Set with bottom). If you start putting extra structure on your arrows (that is something that carries around a function along with some extra proof-relevant structures, like say a way to show that some zero element in the domain under the function equals the zero element in the codomain and that multiplication is preserved under the function, now you have monoid-homomorphisms) then you end up in the general case with something that looks a lot like a binatural transformation of profunctors, which pretty cleanly encodes "exo"-functors between different sub-categories of the category with all types as objects and functions as arrows.
In the other direction is realizing that even imprecisely, there's quantifiable value in observing functors to and from the category of types and functions, say one between whiteboard diagrams and code, or between a specific problem domain and code, etc etc. If you have some other space with composable relationships that you want to preserve when you write code to correspond to it, or you have some other representation you want to produce based off some given codebase while preserving the structure of the code taken as input, you can gain a ton of conceptual leverage out of identifying a functor.
BondLink | Junior/Senior Software Engineer | Boston, MA, US | ONSITE | Full Time
We are a small team of Scala engineers who care about rigor and proving our code correct. We use advanced functional tools and techniques to ship reliable, rot-proof software. Presently that includes things like scalaz, generic type-level programming, free monad based programs, and monadic logging among others, and we eagerly embrace new approaches that help us to do our jobs better. If these things are familiar you will feel right at home, if they are interesting to you and you want to learn, you will find a safe and supportive environment to grow on the job (many of us have learned most of these things here at work.)
About the company:
BondLink provides a SaaS platform to bond issuers in the $4 trillion municipal bond industry. We have recently raised a large Series A, we have strong revenue growth, and we are already working with many of the largest issuers in the country.
The company was founded by a former Massachusetts Assistant State Treasurer who raised nearly 25 billion in funding for the state and set the gold standard in the industry for transparency and investor outreach, partnered with a multiple-time startup founder with several successful exits under his belt.
We have deep expertise and credibility in the industry we serve, great product-market fit, a strong footing with a ton of momentum, and a great handle on our software delivery.
If this sounds like something you'd want to be a part of, shoot an email to brian(at)bondlink(dot)com
Does unification of getter and setter have to be lost?
Assuming you are in a unityped context, hkts are gone, functor is not a thing. so
(a -> f a) -> (s -> f s)
is not meaningful. If we pretend that unityped means everything is parametrically polymorphic, for the purpose of this discussion, can't we leverage parametricity to choose a representation that provides this unification?
for example, if i provide laws that show for a given
lens :: (s -> a, s -> a -> s)
that
(snd lens) s (fst lens $ s) == id s
doesn't that provide the same assurance, even if less elegant and not typechecked (the latter of which is much broader than just applicability of lenses)
BondLink | Junior/Senior Software Engineer | Boston, MA, US | ONSITE | Full Time
We are a small team of Scala engineers using advanced functional techniques to ship reliable, rot-proof software. We use lots of shapeless and scalaz, a free monad based program/interpreter architecture, monadic logging, and more. If these things are familiar you will feel right at home, if they are interesting to you and you want to learn, you will find a safe and supportive environment to grow on the job.
About the company:
BondLink provides a SaaS platform to bond issuers in the $4 trillion municipal bond industry. We have recently raised a large Series A, we have strong revenue growth, and we are already working with many of the largest issuers in the country.
The company was founded by a former Massachusetts Assistant State Treasurer who raised nearly 25 billion in funding for the state and set the gold standard in the industry for transparency and investor outreach, partnered with a multiple-time startup founder with several successful exits under his belt.
We have deep expertise and credibility in the industry we serve, great product-market fit, a strong footing with a ton of momentum, and a great handle on our software delivery.
If this sounds like something you'd want to be a part of, shoot an email to brian(at)bondlink(dot)com
this one is incomplete but gave me a really good foundation that makes it easy to fill in gaps when I need, and most importantly gets you that "thinking in regex" result mentioned above- http://regex.learncodethehardway.org/book/
How many commenters in support of this perspective were in the area and part of all this? As someone who was a short distance from the explosions during the marathon, and the focused area of the manhunt during todays lockdown, I'd expect the answer would be none. And if I'm wrong, I'm shocked at the lack of empathy, or even lack of ability to emulate empathy through simple taste and common sense. This is a really disappointing thing for me to see on HN.
The time it takes to walk someone through all the use cases that need to be tested is not trivial. The reason for having a dedicated tester is so that knowledge of the system accumulates. I can't imagine how having to re-introduce your system to a new tester for every upcoming deployment could possibly be a realistic approach. In order for this to make sense I'd have to build a relationship with a freelance tester so that the same accumulation of knowledge could take place.
In some circumstances "accumulation of knowledge" in a tester is exactly what you're trying to avoid. Fresh eyes can be very valuable. Amongst other reasons, this is why we don't give developers sole responsibility for testing their own work.
That's an interesting point but I think it highlights that there are different types of testing - even above the obvious UX vs QA distinction.
I find that really good QA testing often needs someone quite technical and even someone who has some insight into the way the code works. You have to actively think about ways the system could break. It's probably closer to the mentality of a penetration test than it is to usability testing.
in my experience "not being okay" with something is rarely a sign of maturity, and certainly never when the something is the name of an open source app.
Over time it has fallen away in two directions.
In one direction is that though you are always stuck in a category with types as objects and functions as arrows, that doesn't stop you from subdividing. This became more intuitive to me as I encountered more and more categories that are basically just Set with extra structure (just as the one we program in is basically Set with bottom). If you start putting extra structure on your arrows (that is something that carries around a function along with some extra proof-relevant structures, like say a way to show that some zero element in the domain under the function equals the zero element in the codomain and that multiplication is preserved under the function, now you have monoid-homomorphisms) then you end up in the general case with something that looks a lot like a binatural transformation of profunctors, which pretty cleanly encodes "exo"-functors between different sub-categories of the category with all types as objects and functions as arrows.
In the other direction is realizing that even imprecisely, there's quantifiable value in observing functors to and from the category of types and functions, say one between whiteboard diagrams and code, or between a specific problem domain and code, etc etc. If you have some other space with composable relationships that you want to preserve when you write code to correspond to it, or you have some other representation you want to produce based off some given codebase while preserving the structure of the code taken as input, you can gain a ton of conceptual leverage out of identifying a functor.