PurplePanda

"Tech Ingredients" youtube channel built (https://www.youtube.com/watch?v=YWUhwmmZa7A) and then tested (https://www.youtube.com/watch?v=cw8ipUYodkE) such a thing.

Maybe they've been there before and happen to remember "page 10".

Maybe someone else has been there before and told them "Go to page ten".

Maybe you know that there are 20 pages, and are looking to find the median, or are just informally playing around, looking at the distribution.

Same as you'd do with an interesting page of a book. I don't think I'd stop using page numbers in dead tree books if they somehow came with filters.

The first sermon is said to be recorded by the dhammacakkappavattana sutta.

Ṭhānissaro Bhikkhu's translations of the pāli Canon are usually sensible: https://www.dhammatalks.org/suttas/SN/SN56_11.html

or Bhikkhu Bodhi: https://www.budsas.org/ebud/ebsut001.htm

There are also translations around that come via the Chinese cannon instead.

The suttas are probably very hard to understand without background knowledge or commentary (or, really, actual practice), but of course I don't know which of the commentaries GP refers to. The dhammacakkappavattana sutta, being one of the important/famous ones, has truly voluminous commentary from truly voluminous sources.

GP refers to "continuous effort to face the uncomfortable". I'm not sure that I'd use that sentence to summarise the Buddhas teaching to be honest. But I suppose that it could be a reference to the 6th limb of the noble eightfold path (right-effort), or the 7th (right-mindfulness), or to the 1st noble truth (the truth of unsatisfactoriness/ suffering).

https://en.wikipedia.org/wiki/Noble_Eightfold_Path

First sermon aside, his last words also, as given in the maha-parinibbana sutta, were to be "heedful" or to "strive diligently".

that, and others, are mentioned on this projects comparison page https://pyoxidizer.readthedocs.io/en/latest/comparisons.html

something like `pip install --user DataShape`, maybe.

what's the point of that?

it takes a while to learn how to use your text editor well, and everyone is probably good at a different one. but they all pretty well have the ability to produce the same result, so why bother forcing one?

it's better to (have a tool that can) specify what the end result should look like and let people work the way that they are good at.

If I had some persistent problem or concern I would just bring it up, I wouldn't wait for some scheduled meeting. I guess some managers might not be so easily available.

The OpenBSD license template is slightly different, eliding the "/or". http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/shar...

I believe the same is true of other paradigms. Of course complexity is difficult. Do concatenative languages exaggerate the effect?

nvi that comes with FreeBSD. sometimes i miss features but it feels more friendly than vim.

Thanks, I haven't seen that syntax before.

It confuses me that it doesn't work for functions. like

    int main() return 0;

I have had good luck with https://www.arpnetworks.com/

I have had good luck with arpnetworks. So far only noticed one outage in three years of use. Have had good network and CPU performance. They don't do tech support for things inside your operating system, but they are always helpful when I ask them to do things on their end.

I've seen this notation quite commonly.

I haven't looked at the link but based on your quote your comment about page 14 doesn't look right. The different notation doesn't change the number of times you need to write the operator.

Your new equation is just writing the same thing on each side, but using a different notation. It's like a=a. Whereas their equation is apparently giving an identity.

My knife isn't perfect, but I'll keep just it and no other life long if I have to. I don't need a new one for each batch of carrots.

But when collaborating on a curry, I don't want to use the same knife as the guy who cut the tomatoes wants to use. That knife looks blunt and rusty to me.

I'm not sure about that.

I think that it was merged into FreeBSD a while back though: http://svnweb.freebsd.org/base?view=revision&revision=224638

Thank you, I'll look into it. I haven't studied Rust.

Experimenting with ways of having automatic memory management without either traditional garbage collection or reference counting, but rather by finding proofs of nonliveness at compile time. Trying to find under what language restrictions such a thing might be possible.

I had to change it to start at i=1 to avoid clicking on the link to github and leaving the page

I would never describe either finding new problems or people telling me what I could do better as frustrating! They are both some of my favourite things to experience!

I understand that other being hard to scale in a machine efficiency sense, the old techniques were also rather limited in applicable domain. They were often based on unjustified models of whatever the author decided was a good model of thought/reasoning, whether "frames", predicate calculus, constraint propagation or whatever. It seems to me that although you say statistical methods have little motivation, the motivation of the alternative - heuristics - is very questionable. Can anyone correct me on this?

I don't think that anyone can answer that categorically. It's a question for philosophy or metaphysics. Almost merely a matter of opinion. It's hard to criticize software for not working towards a "fundamental understanding of what the concepts mean" if we admit that we don't really even agree on whether that is a valid sentence or what it might mean.

Can anyone say if the difference between recursion and corecursion is the same as the difference between recursive process and iterative process as described in SICP? They seem the same to me. It also seems to be related to the bottom up solving method of dynamic programming.

This would seem to be true as long as mathematics is discovered rather than invented. Otherwise I beleive that one may be able to invent generalisations that result in a simplification of mathematics.

Some lisp systems implemented pairs this way. A global array of CARs and a global array of CDRs

Some reduction in lines of code may have come if they had rewritten it in Java too, due to better understanding the problem space after having written the first version. Java has a fair amount of boilerplate type code other than getters and setters. For example forcing you to use "classes" for everything, even when you really want a procedural or functional API. Some people try to write semi functional style programs anyway using object oriented "patterns", which can sometimes lead to really just a lof more lines of code too. Also explicit type annotations take up space. And the Java style of using exceptions can be quite verbose. There may also be better designed libraries to do a lot of things for you automatically in clojure. Macros are very helpful too. But I'm just making all of this up, haven't actually seen the codebases to compare them.

start learning?

that's an empty set. it'll happen anyway, though.

The article was about intrusive advertisements not who is or isn't monitoring which email providers. Switching to fast mail solves the problem the article was complaining about!