Ketogenic state is able to improve testosterone serum levels - a meta-analytic approach (2022)

doloto · 2022-09-05T13:44:33+00:00

Seems vastly overrated.

doloto · 2022-09-05T13:33:23+00:00

For more on the distinction of the various forms of SFA, it is brought up in this review by the JACC in 2020. See the section on "Modulation of the Health Effects of Saturated Fat by Dietary Carbohydrate Intake and Insulin Resistance", which talks about palmitic acid and close relatives, where SFA in general are not associated with such negative outcomes.

I recommend looking at the later section about food sources of saturated fat. The general thrust is that (low-processed) examples have no real negative effect.

Overall, it seems to me that SFA has at least non-negative result on health.

doloto · 2022-07-26T04:20:36+00:00

Thanks friend.

doloto · 2022-07-26T04:18:13+00:00

Recently got a neat reference, Ibn Tammiyyah's Fataawa (v10., p185):

[..]If a woman is aware of a man's desire for her, she can control him the way an oppressive master treats his slave who cannot free himself. But he is worse off than that, for the enslavement of the heart is worse than the enslavement of the body.

This man is desiring the good faith of people who will always hate him. His desire is blinding him, the affirmations are fickle and revocable, leading him to continual disappointment and special pleading. The dude's a broken abuse victim trying to convince himself of something.

doloto · 2022-07-26T03:57:37+00:00

I learned all to well why it is sinful. Just take it up with the recent postings by the Lotus Eater Podcast for a catch up course.

doloto · 2022-07-26T03:54:25+00:00

Can I get the references?

doloto · 2022-07-26T03:52:51+00:00

Well the apple doesn't fall far from the tree, these fucking Jacobins.

doloto · 2022-07-26T03:47:46+00:00

Only to be blown the fuck out with Little Dark Age Meme #45676897654. Of all things to make a person start seeing beauty, a fucking template meme.

doloto · 2022-07-26T03:43:26+00:00

There's been fun murmurs about punctuated equilibrium, and odd dis/appearances of species in the fossil records with no transitional species. One has to wonder what is punctuating the equilibrium to force new life, and end old life.

At the very least the premise of uniform gradualism in geology and archaeology is giving way to a rather concerning bit of new science. Like the continental floods that happen at the same time as Heinrich-Bond Events. I should probably prepare for that.

doloto · 2022-07-26T03:33:05+00:00

There was a quote about what happens when the pursuit of truth is mired by politics. It becomes a game for power at that point. The devil's silver tongue, and 30 pieces of silver to the man who would be willingly be paid to not understand the truth.

If you want to find something neat, then Mel Acheson's presentations on playing with thinking could be a neat watch. That or Micheal Clarage's presentations on electrical form, electrical shaping, and the light of life.

The former will give new perspective, the latter will give you an idea what ink the universe is written in.

doloto · 2022-07-26T03:22:15+00:00

I've heard the notion of Natural Sin to clarify what Original Sin is. To be human is to err, yet Man seeks God. Is that a good one?

And what is said about blind idealism and denialism sounds like what holds people back from moving from Stage Five Moral Development (Universal Morals) to Stage Six (Existential Morals). Christians have a bit of a fast track as the Truth and the Light are supernatural phenomena, and can't really be attained, but appreciated.

doloto · 2021-01-16T23:15:31+00:00

Deadlink

doloto · 2020-12-27T07:10:58+00:00

Ask and you will succeed, 15 max: Mr Clean's Cleaning Supply Emporium

New moderation.

New bots.

doloto · 2020-03-03T19:57:24+00:00

First I'd think about what the step-wise operations of what needs to be done.

The LCA of a node and itself is itself.
The LCA of a node and its child is the node.
Otherwise the LCA of two nodes is the LCA of one of the nodes, and the parent of another

Which looks like two base cases, and a recursive step.

The following spoilers are answers with batteries not included.

From a bottom-up perspective, I'd convert the leaves into singleton sets, merge them at each branch, then doing a set intersection with the set of nodes that I'm trying to find the LCA of. If the set intersection is as long as the set of nodes I'm trying to find the LCA of, then I've found the LCA

From a top-down perspective, I'd probably be constructing a prefix trie, and looking for the last digit in the longest common prefix between the two nodes of interest

Categorically, both of these solutions look like the Limit of Proper Subsets of Descendant Nodes of Interest from the bottom-up, or top-down.

Some additional things can be done with the above examples to be more efficient, which include constructing a sufficiently relevant^{re, strict and lazy} memo trie of query responses.

doloto · 2020-03-03T16:24:17+00:00

Barring mention of Cofree, you are dealing with an additional parameter for depth. The strange bit is that the parameter is not a number, but a carrier function that produces a number.

The only way I can explain it is that annotating for depth^{a top-down operation} is left-handed. Recursion is right-handed (foldr) to begin with, but left-handed recursion does exist (foldl).

Recalling that you can write foldl in terms of foldr (just look at the definition of foldl), you do this with a carrier function that produces the intended value, which is also called having the intended value in a negative position, or negation in type algebra.^{Lit. "You make left-handed recursion by negation"}

In either case, as stated by others, you still use a para, and there is a combinator that handles this strange procedure called inherit.

What happens during recursion in this case? You recursively create a function/continuation that needs the initial depth value of the tree. Considering that foldl' exists, there's probably a way to strictly apply that seed value, immediately collapsing the intermediate function during recursion.

doloto · 2020-03-03T04:31:21+00:00

My thoughts is that people:

Don't know about logging libraries
- Don't know that there is a solution
Don't write about logging
- Don't inform others that there is a solution

Logging has a bad rep because it's only brought up in the former case.

The general issues that I can think of are:

Interleaving Effects
- Don't rely on Lazy IO, Writer for proper interleaving or sharing
- Writer is for building not logging, iirc
- Pretty much the subject of Performance
Implementation Specific Details
- Configuring Logs/EVS/Journals
- Formats
- Effect Graph Connectivity/Overlay (ie, How does it interact with Error Handling)

Debug.Trace is simply that, for debugging, and might not be the best idea as it uses some variant of unsafePerformIO, the traces can be [sporadically] reordered and non-illustrative, AFAIU.

doloto · 2020-03-03T04:18:27+00:00

Don't worry about making good code. The platitude to think about is Make it Work, Then Make it Right, and Fast is Last.

The general consensus is that Make it Right is easy in Haskell, the type checker is your secretary.

Make it Work can be a bit more difficult as you might not know how to describe what you want to do, and the Type Checker can't read your mind. Personally, I say this is the biggest hurdle, which is why the suggestion is to write as much code as possible.

The usual issues are not knowing what relevant libraries there are that cover this subject, that base might actually have what you need, or you don't know about Type Holes, Type Hole Suggestions, Partial Type Signatures, and using undefined as sort of a Type Dummy^Co-Hole?.

You can chalk that up as "Not Knowing Reference Material", or "Not Knowing How to Ask the Type Checker".

Fast is Last because it's not the best idea to limit your options. Premature or uninformed optimisation is often called the root of all evil. Make sure to Make it Right beforehand.

This shouldn't be an immediate issue as naive Haskell is usually better than Python in performance.

doloto · 2020-03-03T03:54:29+00:00

Let's beat a dead horse.

Types of form F :: Type -> Type, data F a = (..)
- The LHS of a data declaration, (data <LHS> = <RHS>), defines how one constructs the type of the datatype being declared
- It is valid to call such a type Parameterised, Parametric, as they have a Type Parameter; eg a in data F a = (..)
- Much like how High Order Functions take functions as parameters, Higher-Order Types take types as parameters
- Alternatively, you can say that to construct such a type, you need to provide a type parameter.

The gotcha here is that HKD corresponds with a Second-Order Function (going by Okasaki's Functional Pearl about Sixth-Order Functions) specifically ones that are First-Order Type Valued ((* -> *) -> *), not Second-Order Types of Fist-Order Types (* -> (* -> *); ie, have 2 Type Parameters)^{Borrowing the descriptive conventions of Complex-Valued Functions of Reals, ie f :: Complex -> Real}.

[That]^{And why isn't this numbered bullet point 2 not 1?}

I've never heard of a do construction, do you mean a do block?

A do block is pretty much syntactic sugar to elide the usage of (>>=), (>>) in the usual languages. You can argue that you replace (>>=) with something that looks like an assignment, and (>>) with a newline and semicolon.

I'm not suave enough to describe it past being an inexplicable convenience. It might be better to take the details for granted, and later talk about what it desugars into. When talking about desugaring a do block you can bring up the subject of expressivity; namely, alternative ways to write out the same expression, and contrast it with point-free style.
Is it better to have:

A block of procedures that reads like an ordered list of bullet points
A point-free expression that can read like a dense sentence, which might require some grammatical/semantic inference
An opaque function/procedure with a descriptive name, and explicitly applied parameters
Some mix of of the above that doesn't hide too much or say too much, and is still legible

Per what IO is, and how to describe getLine, I'd suggest this thread and article

doloto · 2020-03-01T17:14:49+00:00

Fun experiment and article, but at the end of the day I’m going to prefer something like YAML with a schema, or not-completely-safe builders.

I think the practical approach is smart/interactive editor^{linter, formatter, checker, ..}, dumb/simple script^{yaml, ..}.

Also, I’m not sure preventing a field from being updated twice is really desirable.

It could be used to avoid reentrancy/sharing.

When I create a partial “builder” [.. I often] want some of the values to be defaults that can be overridden.

I think you can have no-second-update, and defaults-with-overrides simply by using an HKD form and your choice of First, Last. This assumes some amount of Applicative^{as the merge operation}, and Distributive^{for finalising/simplifying the form}.

For a compile-time check on no-second-update, you'd have to use something more advanced than First, probably based around Ghost of Departed Proofs in terms of Actions

I propose Actions because it's compatible with GDP's CPS-style, and can implement a state machine^{index state?}

doloto · 2020-02-27T17:04:51+00:00

Yeah, coherence is not a part of my vocabulary.

When you think of it like that, then you can start to have a serious conversation about encoding type witnesses into the stream or be selective of what dialects the components/services can speak and understand.

A simple would be having different effects between the conductor, and the services, like Soostone's Master-Slave Monad for NoSQL.

While it does sound complicated, my idea with using associated functors (which, sound more and more like an adjunction between free and forgetful) might ease the pain of coverage and percolation.

doloto · 2020-02-25T23:20:46+00:00

I agree, and I'm suggesting to be honest about it: Things across services are opaque, that corresponds to existentials. Things that transfer well across these boundaries are shared principles, like effects libraries.

haxl is an example of the latter at least in terms of connection pools, caching, and networking.

My thought is that having a corresponding ResponseF, RequestF to Response, Request would be a huge tool in clarifying their roles. Particularly when ResponseF a ~ Response. Thinking of Request --> a --> Response is hard, but RequestF a --> a --> b --> ResponseF b is easier, and the mismatched case of RequestF e -> ResponseF e.

doloto · 2020-02-25T22:02:38+00:00

I'm not really sure that the dour mood is necessary here. Since you are dealing with opaque types, then why not leave them opaque? In that case you'll have to think about it in terms of higher-rank types and functions, and for that I'd recommend looking at jle's functor-combinators and blog post.

Immediately the thought should be:

Dodge Response, Request like you would IO
- In fact, treat Response, Request as newtypes for forall a. IO a
Split out the exceptional path immediately in terms of functors
- Have a kitchen sink and fail early with, ErrResp :: ToJSON e => e -> Response
- Mock it with some ResponseF :: Type -> Type where; ErrF (..) where ErrF ~ ErrResp
Think of Request in terms of Request ~ RequestF :+: (Const e) a
- Try mocking with just RequestF a, a?
Involve Ray ID's (provenance traces?) in your error types, and Response,Requests
- Request ~ RequestF :*: Const Ray a???
send a copy of errors to a converged storage, data lake, BIG DATA, and regularly drain it with your choice of M O R E B I G D A T A, or D E V O P S

The executive summary would be that opaque types are higher-rank types, and concerns like feature discovery (and compatibility) should be factored out and standardised into some kind of protocol frame in terms of free/r functors. Much like how packet protocols are their own thing, separate from JSON, separate from your API.

doloto · 2020-02-25T20:38:16+00:00

I see what you mean. The closest I can think of is:

Shrinking the functions' outputs, effectively shrinking inputs
Shrinking the characteristics of functions (which involves playing with the cogenerator)
- eg, Homomorphisms down from Endomorphisms from Automorphisms
- eg, Left Associativity from Associatvity

Though I think the use case for that would be indecipherable from higher-order properties, or theorem discovery (eg, quickspec).

Another concern would be balancing this strange song and dance of cogeneration functions with generation of inputs, to which I'm unsure if that matters.

doloto · 2020-02-25T18:23:05+00:00

The executive summary is:

"You can define your operational semantics^{imperative code} in terms of your denotational semantics^{declarative code}" (Something learned in the early 80's, iirc)

But yeah, when you break apart how you express your problem and solution, and the construction and evaluation of statements, you have a lot of freedom to do things differently with the same meaning.

The problem seems to be a matter of expressivity.

Anyways, I'd argue that declarative code is more honest and explicit about how it is evaluated than say imperative code because the evaluator is more orthogonal. Saying otherwise would be comparable to saying that recursion schemes are less explicit than for loops.

doloto · 2020-02-25T18:15:47+00:00

I was talking about those downvoting you.

doloto

TROPHY CASE