DonbunEf7

The central question in philosophy of science is a meta-scientific question, as would be expected, and it's the Demarcation Problem. You know this, but I'm restating it for observers: What is the difference between science and pseudoscience, and how can it be realized as a repeatable procedure?

Science should be left to scientists, but the interpretation of science is still an individual responsibility.

I do like the joke that career philosophers know no maths aside from arithmetic and about half of Bayes' Theorem.

"Deconstructionists, having discovered that such faith acts are necessary, then refuse to engage with any particular choice made by people who want to discuss pragmatic meaning." I'm perfectly happy to have such discussions, as long as it's understood that, regardless of the beliefs brought to the table, the idea of "good enough" is not set in stone and itself is a perspective that is also brought to the table. I'm also not a Deconstructionist, whatever that is.

I find that most arguments that I have had with people usually end with them implying that their epistemology is rooted in something that is "good" or "reasonable" or "close enough" without any explanation of why it is that their chosen way of looking at the world must necessarily be beneficial. Indeed, you have pointed out that maths is a source of "important and valuable things", which I could agree with, but only with the understanding that our agreement is bound to the reality defined by our joint observations, and not a universal truth.

My point was not about choosing axioms, but about incompleteness, undefinability, uncomputability, etc., which cut short any attempts to bless a particular set of axioms as uniquely correct. You are only seeing the surface level so far; I assure you that it all deconstructs. (Be careful when looking directly at The Void.)

Finally: Where does meaning come from when having dialogues? Hofstadter explains it well: We constantly exchange deeply-coded messages with recursive layers of meaning, trying to reflect the symbols in our mind into words which we think will reconstruct those symbols in the minds we talk to. The "mooring of their meaning" is a fascinating illusion based on the inherent difficulty of stepping outside ourselves to examine where our own sense of meaning comes from.

Deconstruction is a way of viewing reality which comes naturally equipped with a process for disassembling ideas (the "deconstructive process") as well as a process for viewing ideas as the synthesis of other ideas (the "constructive process"). The core is this: all semantics are relative, all observations surface-level, and all truths buried in the raw materials. But since the materials are themselves relative, all truths are ultimately undefinable, recursively unknowable. To see a house is to know that it was built on a foundation, that its walls are made of gypsum, and that the number of children living there are proportional to the number of toys left on the lawn. Conversely, to see a corporate email thread is to know the shape of the corporate power structure, the bickering between departments, the products under development, and the CEO's ability to curse. Everything is connected and related. This is the entailment of postmodernism, where we first glimpsed that narrative truths could be relative; now, we know that reality itself is relative, whether it is the reality of a book or the reality of our current "real-world" narrative.

Deconstruction isn't bullshit, but we've been swimming in deconstructive and reconstructive narrative media for nearly half a century, and it has altered how we critique media so heavily that people don't see it as a distinct feature of their worldview. (Great example: Folks seem to love Rick & Morty, a deconstructive soft sci-fi serial, and also Steven Universe, a reconstructive soft sci-fi serial, both of which are running on a network which markets to youth, not literature postdocs.)

Kay, like Derrida, hasn't been unable to explain to people for lack of words, but because the enormity of the paradigm shift means that no number of words will necessarily suffice.

(Aside: If you are rubbed wrong by the first paragraph, in particular because you believe that reality is absolute or that truth is definable, then do not fear. You are merely having trouble overcoming instincts. Trust in mathematics; postmodernism arrived in mathematics in 1874, was completed in 1930, and is widely accepted by the mathematical community as meta-truth. Dissenters exist but necessarily must accept the meta-truth ("There is no one true foundation for mathematics.") to avoid being laughed out of the room.)

I will believe as soon as you justify the correct answer to the demarcation problem. If you don't have an answer, then I'm free to interpret scientific results in my own way, including disbelief.

C'mon, use logic and reason.

"Guix...uses the Nix daemon" and "to extend the reach of Scheme to the daemon" are incompatible and I hope you see why. Patches aren't flowing from Guix to Nix, or if they are, nobody's talking about it and the patches aren't showing up on anybody's radar.

The wimpiness of the Nix language is a virtue. There is no call/cc. There's no ports, and indeed networking is tamed. The language is just barely powerful enough to do its job, and community members have found it somewhere between intractable and impossible to build compilers, text processors, etc. in Nix itself.

String interpolation is a fitting punishment for our decision to continue to use Unix-styled systems; our systems think in bytes and communicate in bytes, and I see no reason why we should walk away from our highly-developed long-standing relationship with bytestrings as long as we are still on Unix. (You will say something beautiful about Scheme. I am busy looking ahead to capability-aware languages; Nix is a scaffold and nothing else.)

In the Nix language, which Guix takes heavy inspiration from (to say the least), there are a small handful of primitive types, but no mechanism for building up bigger, more complex types. One of the primitive types is the derivation, which is not a set, not a list, not a number, etc. but a wholly new type which describes a package in the Nix store.

I agree that Guix overcomplicates it, but they didn't have to. It's a natural consequence of using an incredibly powerful host language to embed their build language.

You're not wrong, but you're not sufficiently right yet. You are saying that folks see only the forest, but you want to point out that there are lots of trees. Open your eyes: There are trees and forests.

A corporation has a power structure which necessarily is independent from any one person. It follows that there is something about corporations which is distinct from its employees. Look at a business as both having employees, who are people, and being a corporation, which is like a golem.

Sure, but there's a simpler and already-well-accepted convention for doing this. Say "interpreter" if it takes a program and causes its effects to happen, or "compiler" if it takes a program and emits an equivalent program. If somebody says "transpiler", just mentally replace it with "compiler". Done!

Composition of compilers still works as normal. You can use tombstone diagrams to reason about complex chains of compilers and interpreters. And it demystifies the act of building compilers, which is important because otherwise you'll be shaming junior engineers for attempting what is not just the pinnacle of computer science but also our bread and butter.

Seriously! Of all the definitions of "transpiler" that I've heard of so far, "compiler but shitty" is the worst yet.

You didn't watch the video, or you watched but didn't listen, or you watched and listened but didn't think. I can't tell which. I'm letting you know your mistake so that you can avoid being downvoted next time.

Normally it's hard to tell when somebody hasn't read before commenting, but given that a non-trivial portion of this talk is explicitly laying out the different facets of type systems and doing compare-and-contrast analysis, it's really obvious that your reply was written without watching.

Hi! Lemme help you out here.

"Detest" and "despise" are not synonyms. To detest is to speak out against; to despise is to look down upon. Their roots come directly from Latin/French. If you detest something, you are issuing speech which indicates that you dislike it. If you despise something, you have observed it and disliked your observation (or, more usually, something about the detail of the observation!)

When people use these words in idioms like, "I despise and detest their actions," they are saying that they have seen the actions, they do not like what they have seen, and they are now speaking out to denounce those actions.

Um. Here's the first part of Clojure's docs [0]. Compare and contrast: "A pitch is a frequency. 440Hz is an A pitch. There are twelve pitches. Each pitch differs from the previous pitch by the multiplicative constant twelfth-root-of-two. Twelve pitches in a row doubles the frequency, creating an octave." It only takes four or five paragraphs to mathematically describe the basis for chromatic notation.

If Clojure fully contained all its abstractions, then it would not have the option of calling into the JVM.

Clojure does not have the property that cutting any fragment of a valid program yields a valid program. There are languages in the concatenative style which have this property, but even there, the ability to compose does not guarantee the ability to split.

If you think that types produce reliability, then you do not understand types.

You seem dedicated to Clojure, which is great, but music is thousands of years older and has figured out a lot of stuff. I think that you also missed my bigger point, which is that programming is roughly at the same point in its art that cave painting was at hundreds of thousands of years ago. If you think that Lisps are beautiful and Clojure is the pinnacle, then I think that you don't know beauty. But it's not your fault; you've never seen anything beautiful. None of us have. And none of us ever will, at the current rate of progress.

Here, have a video to provoke some thoughts: [1]

[0] https://clojure.org/reference/reader [1] https://vimeo.com/74354480

Well, actually, let's explore the metaphor. Here's how I compose music.

First, I use a highly-flexible prototyping instrument to quickly iterate on melodic ideas. Normally this is either humming or whistling. "Our first instrument," as an instructor used to call it. I do this until the melody is catchy enough to start sticking in my mind. Then I'll look at alternate parts, like countermelodies, B/C sections, harmonies, or basslines. Each part gets repeated until it gets stuck in my head.

Then, I repeatedly hum/whistle each part like a disturbed rambler until I get home or to some other place where I can scribble the parts down onto paper. I used to be faster just typing out the Lilypond, but I'm out of practice with that whereas all musicians generally never stop having a short shitty hard-to-read staff-based shorthand.

Now, finally, I actually start playing the different parts on actual instruments, figuring out stuff like fingering for guitar or piano, rhythm and phrasing, filling out transition chords, etc. During this process, I play less and less of the song, drilling down to tiny fragments and setting up tiny local contexts for testing ornaments, phrasings, hits, etc.

If I'm gonna try to make the metaphor rigorous, there would be only one language, because the musical process happens entirely in one language. This language is small enough to write on a single piece of paper, fully contains all of its abstractions, has focused notation for specific instruments, and permits debugging any part of a program by cutting any contiguous subprogram out and turning that fragment into its own live environment.

I'd write a program first on a prototyping platform which is so lightweight that nearly any prototype program will run, and I'd use that to write out the entire first draft of my program. Then, I'd incrementally move pieces of my program transparently onto a more rigorously-precise framework which is more restrictive about types but makes it easier to compose modules and let them stay composed.

There is a point in time when composition is more about managing multiple parts at once and you won't actually want to listen to more than about 15s of your song at once, and you'll want your runtime to support your quest towards stability as a basis for tweaking the fine details of your song.

Oh, of course, people dislike JS because they're unhappy inside. It can't be that JS is a lame language.

I bet you love pugs, bulldogs, and dalmatians too.

Oh noes! But wait, people already hold multiple jobs.

Wouldn't it be nice if holding two full-time jobs meant 40hrs/wk? Then, that irritating feeling instilled by a typical work week, that our salary is ultimately meaningless beyond a certain point and surely isn't worth the slight but never-ceasing pain and suffering inflicted in a banal-yet-reliable way by the entire corporate hegemony (not with malicious ends but merely out of a desire to ensure the 2% year-over-year train never derails), not to mention the expression that one's spouse wears to cope with the reality that, by working your drone-bee life through its paces and building your career, you've stopped being the sexy intelligent beautiful person that they fell in love with and become an inhuman ghost whose presence at home is welcomed and tolerated only in exchange for ensuring that your childrens' college fund will be well-stocked when they turn 19 and decide to go live a five-year decadence party on your hard-earned pennies, an expression which is no longer full of love but only imitating it shallowly, could be sorrow-drowned not in intoxicants and prostitutes but in the knowledge that you are bringing home sufficient double-income bacon to ensure spousal endearment and the best Greek houses for your kids.

I dunno. I think it might be nice.

If you haven't, check out LyX, as it dramatically improves the LaTeX experience.

Since no other comment explicitly spelled it out fully: Why don't people work nine hours in the USA?

The answer is very simple: Benefits, overtime, breaks, and other bits of labor law are written around an eight-hour day. This coerces employers and employees alike into preferring eight hours over seven or nine, simply as a matter of optimizing the business's need to pay out overtime with the employee's need to secure FTE benefits.

If there were such a thing as a 20hr work week in law, not defined as part-time with no benefits, but defined as part-time with partial or full benefits, then I imagine that everybody's tune would change quite quickly and we would end up multimodal, with one peak at four hrs/day and another at eight hrs/day.

Graal and Truffle are cool. It's unfortunate that it's in Java, mostly because I don't trust Oracle to do the right thing with the community and I expect them to change licenses to make business opportunities for Substrate VM licensing.

"Not that the Futamura projections can be used with erlscp yet, but, you know, just in case that day ever comes. A man can dream."

I feel like this is the lament of every compiler author.

AGPL is too toxic to use. Fortunately, there's not much compelling software using it, so it's easy to avoid.

Businesses should shun AGPL, period.

Go is a uniquely rude language which both has over a dozen numeric types (seventeen from my reading of [0]) and also zero code reusability. I can't think of a better way to ruin any chances I might have of avoiding numeric bugs.

[0] https://golang.org/ref/spec

Anonymity, global connectivity, and the grant of arbitrary powers to fresh accounts with no prior reputation. You need this third piece, but websites are often too happy to gloss over it in favor of getting more accounts, more eyeballs, more community, etc.

(As usual, posting from an anonymous account.)

Indeed, I would say that capability-safety is the next plateau after memory-safety, but most languages are only barely glimpsing the capability horizon.

The NSA is our spy organization.

I used to think this, too, but Aaronson changed my mind with the observation in [0] that, if P != NP is independent, then it would necessarily imply a lot of what we would demand from a constructive P = NP proof. In particular, we could get some pretty hilarious improvements on those exponents in NP-complete algorithms, to the point where they become tractable for day-to-day computing.

There is a sense in which any complexity class which is self-low is "physical", or analogous to machines which we might build by hand with modular designs. A self-low class doesn't gain any additional power when relativized with itself as an oracle, and this directly corresponds to building a physical machine out of smaller machine modules.

We know that P is self-low. It seems that the universe insists that either we are able to build machines which tractably solve NP-complete problems, or not, but there is no in-between position.

[0] http://www.scottaaronson.com/papers/pnp.pdf p28

The paper is really two papers. The first paper is a thoughtful and careful explanation of how we should consider judging pseudorandomness, and how to measure various criteria, along with a survey of many popular ten-lines-or-less PRNGs which PCG competes with. I found it interesting.

Switched from CPython+Numpy to PyPy years and years ago, got a 60x speedup on a core numerical kernel and 20x speedup on real-world benchmarks. The codebase was a multiplayer game server. Less memory usage overall, leading to a big improvement in the number of players that could be connected.

You have to not have problematic libraries in your system, but honestly they're all either shitty on CPython too (literally every GUI toolkit that is not Tkinter!) or they're stuff like lxml, where the author/maintainer just has an anti-PyPy bias that they won't drop.

To follow up on this, in computational linguistics, there is a sharp divide between facts which take cubic time, like recognizing whether a string belongs to a context-free language, and facts which are halting-problem-hard, like recognizing whether two context-free grammars describe the same language. There doesn't appear to be much of a middle ground.

In another realm of computational mathematics, matrix mjultiplication is cubic, with optimizations that can approach quadratic time with lots of effort. It's conjectured that matrix multiplication can actually be brought arbitrarily close to quadratic time, but at the expense of ever-more-complex algorithms.

It could very well be that the biggest interesting exponent in P is 3 or 4.

On your second point, a construction which transforms NP-complete problems into P problems in polynomial time necessarily implies P = NP, by construction. If the algorithm isn't correct, then it's a heuristic, not an algorithm, and we have piles of heuristics for working with NP-complete problems already.

So use LyX. It's a LaTeX word processor. I've used it for years to avoid having to directly write LaTeX.