HNHacker News
TopNewBestAskShowJobs

Banana699

845 karma · joined October 2, 2020

Hates Trannies, Hates Faggots.
submissionscomments
Banana699··on The Merge
Any person who thinks that a computer is going through symbolic formulas and selecting which one to substitute in to find a hash function nonce doesn't know a whole lot about what a blockchain fundamentally is and how computers make it possible. That's either the fault of the explanation they read\are reading (if it was falsely advertised) or the fault of the person (if they're biting on explanations beyond their level) or nobody's fault really because somewhat-hard concepts are somewhat-hard.

Any explanation of PoW worth its salt no matter how basic should - and does in my experience - repeatedly drive home the idea that PoW is inefficient, it's literally right there in the name, Proof of Work, jumping through hoops as an algorithm. If somebody doesn't understand that PoW is extraordinarily inefficient, they don't understand blockchains and why they are cryptographically secure modulo implementations and social engineering.

Nothing new is added or said by emphasising how inefficient PoW is, that's the entire point, that's why it's secure. The comment that started this chain basically said that in very simple terms, and the comment I replied to expressed disapproval about a very minor issue with the terms then re-said what its parent already said in more words that don't add any clarity.

Will people see 'mathematical' and assume the computer is integrating dy/dx by parts to get the next nonce ? You can assume that the average HN reader knows that when we say a computer is 'solving math' it's meant that it's crunching an aweful lot of binary strings. That's why we call classic AI "classic" or "symbolic". Everything a computer do is crunching numbers brute-force style except when said otherwise.

Banana699··on The Merge
This is a lot of words to say that PoW involves an inverse-hash problem being solved. Inverse-hash is a mathematical problem. Finding the nonce is solving it.
Banana699··on Unconscious bias in media interviews with female top managers
>This is not my position. My position is "Some Women Affected".

Ok. I think you're honest, but the people you're defending are not. If 'some' women are affected, then women deserve only 'some' of the collective attention of society. Therefore 'Unconcious Bias Against Men' should be a recurring headline in media as the other headline for women is. Therefore 'Male Genital Mutilation' should be an important and widespread topic of discussion and not an obscure piece of arcane trivia that google doesn't bother to index in the first 10 pages. Etc, etc, etc.

>I don't think assertions about what is or isn't inherent to feminism are possible.

Oh I think they are. Feminism is at its core a cluster of interlocking beliefs that women are fundamentally and deeply oppressed by men, that women are locked in an eternal conflict with men, and that this war can only be fought on the gender-wide level, with no room for compromise or exceptions unless those made by men. Show me a piece of feminist media\publication (time limit : 20 min), and I will show you those implicit claims in its (sub)text.

It's very easy to see if you know what to look for.

>It's a term that identifies different sets of (often contradictory or opposite) beliefs depending on who you talk to.

Which is exactly why it should be derided and avoided by all honest people, it's a vacuous identity. Vacuous identites are a tool for the dishonest to use the stupid.

>it's just moral cover for a person's own beliefs

I like this framing, specifically the term 'Moral Cover'. It encapsulates the cowardice inherent in Feminism: instead of coming right out and stating their values in reasonable (but debatable) definitions, moral cowards prefer to cover their beliefs inside vague rituals, cloudy language, and metaphysical confabulations about "Patriarchy", the invisible force that men supposedly have the power to deploy to harm and persecute women anywhere anytime.

>fairness, dignity, and respect

But wouldn't this be trivial ? Do you need an ideology to tell people you want to be treated with fairness, dignity and respect ? Do you need anything else besides the Golden Rule ? Do you need think tanks and Affirmative Action and UN committees ?

This is called a motte-and-bailey maneuver[1]. I'm not accusing you of engaging in it, just that you have fell for it.

Feminists have plenty of other claims and demands besides "fairness, dignity and respect", namely the cluster of beliefs that I summarized above. This is the "Bailey", a pleasant but indefensible territory\claim. As long as feminists are not pressed or forced to argue their case, they can occupy the Bailey. When under attack, however, feminists can retreat to the much more trivially trite "fairness, dignity and respect", this is the "Motte", a very well-defended fort but a useless place to live. They can hide behind those trivially defensible claims till the attack subsides, then they can return to their Bailey again. It's a useful pattern to be aware of.

[1]https://en.wikipedia.org/wiki/Motte-and-bailey_fallacy

Banana699··on Unconscious bias in media interviews with female top managers
>An enormous amount of women have faced unfair (or worse) situations with negative (or worse) personal outcomes for just the fact of being women.

You can replace 'women' in this statment by any number of other group tags and still preserve the truth of the statment :

--------

An enormous amount of men have faced unfair (or worse) situations with negative (or worse) personal outcomes for just the fact of being men, like

- forced military service,

- genital mutilation (amusing fact : searching this term in google only turns up results about female genital mutilation in all pages),

- and child labor.

I leave it as an exercise to you how you can correctly apply the template to a random group label of your choosing.

--------

So 'Women Most Affected' sentiments like yours serve only to illustrate the curious asymmetry with which injustice against men and injustice against women are treated. An asymmetry that, while not created by feminism and allied ideologies, is certainly much exploited and streamlined and stroked by them.

>The promoters of the disputed language

Oh, but it isn't a problem of language. The inherent delusion of feminism is that women are especially oppressed, in ways that fundamentally differ quantitatively and qualitatively from men. Expressing this delusion in any language will output biased and dumb nonsense, lobbyism dressed up as 'fighting for justice'.

In other words, you can't say 'Women Most Affected' in more intelligent or naunced language. Every way of expressing a delusion will turn out to be ridicoulous and unfair and easily-detected.

Banana699··on Unconscious bias in media interviews with female top managers
Because it's one-sided and unscientific.

The kind of feminist-infected soft fields that make up those terms and agendas (HR, "Communication Studies",...) only really care about women, and by 'caring' about women I really mean they care very much about how easy it's for women to be corporate drones while thinking it's "Empowering". Have you ever heard about "Unconscious Bias Against Men"? Of course not, nobody gives a shit about men.

It's unscientific because the conclusion is already formed before the data is gathered. Women get more questions about family than men? That must mean that the interviewers think women are baby factories unfit for work, SEXISM. Women get less questions about family than men? That must mean that the interviewers think career-driven women are barren and childless and without prospect for having a family of their own, SEXISM. No matter what happens, they have already made up their mind, women are oppressed. The "experiments" and the "data" is just a dress up game to make it look as if they're doing serious science.

Banana699··on The James Webb Space Telescope Runs JavaScript, Apparently
No, actually. JS wasn't designed to be generally and minimally embeddable, it was a hack designed to be a embedded in a proprietary program with lots of bells and whistles. You can say that a thing doesn't have to be designed for something to do it good if the users are crafty enough, but then what's the point? Python or Ruby would have equally served the role, none of the 3 languages were designed to be lightweight embeddable. The point about JS runtimes having more eyeballs and corporate support than most other language is fair, but the actual facts in OP make it moot : JS is used because of, what else?, legacy reasons. The decision was made in 2003-2004. That's, I think, barely after or during the first standard of JS, and when all the runtimes available were very buggy and divergent in behaviour.

In reality, there are plenty of interpreters you can embed and be very sure you're not making a mistake. Lisp and Forth are the top of that list, forth far ahead of lisp (literally designed to be used in embedded systems, and much simpler and lower-lever than most lisps). After that, there is Lua and Tcl, both explicitly designed to be embedded and extended, and lua specifically pushing words like "portable" and "lightweight" to the extremities. After that, you have Java (which runs on 3 billion devices!) and even Python, which has micro-variants running on higher end embedded Linux devices. JS is at around this tier.

Banana699··on Programming breakthroughs we need
Indeed, Abstract Interpretation is powerful and beautiful as heck. Type Systems can be seen as just a special case of general Abstract Interpretation, where the types are the abstract values computed from each expression. The problem is that it requires ingenuity to devise abstract value systems that don't degrade into useless generality as unknown branches in the code 'execute'. Even types only succeed as much as they do because they require extensive and invasive (language-design-changing as well as program-changing) cooperation from both the language designer(s)\implementer(s), as well as the language developer(s), without this cooperation you will leave open very wide gaps. Symbolic Execution is another much much more powerful technique but, predictably, also very inefficient in general.

My way of looking at this is just frustration at the misallocation of resources. Dynamic programs already have tons of typing information available, just not in the right time and place. Your brain spends an aweful lot of time "executing" the code of a dynamic language while it's writing the code, just like the language runtime only far more slowly and with a sky high probability of error. So all what I'm saying is, why this immense suffering, when the information that your brain is in dire need of is already right there in the interpreter's data structures, just in opaque and execution-temporary forms ? It strikes me as incredibly obvious to try to bring in those typing information from the runtime into persistent transparent records available at dev-time.

Abstract Interpretation or Symbolic Executation are (fancy) tools in programming language theory's toolbox that can help us, but the simplest possible thing to try first is to make use of the already-available information that are just lying around elsewhere. To make a somewhat forced analogy : if we have a food crisis at hand, we could try fancy solutions like genetic engineering of super crops or hydroponic farming, but the dumbest possible solution to try first would be to simply bring in food from other places where its plentiful. Typing info in dynamic languages is very plentiful, it's just not there when we need it.

Banana699··on Programming breakthroughs we need
>This is only feasible if the program takes no input, or a very limited set.

One of the insights that people making tools for dynamic languages discover over and over again is that most uses of dynamic features is highly static and constrained. In general, yes, a python program can just do eval(input("enter some python code to execute :) \n>>")), but people mostly don't do this. People use extremly dynamic and extremly flexible constructs and features in very constrained ways. This is like the observation that most utterances of human languages are highly constrained and highly specific, even within syntactically-valid and semantically-meaningful sentences, not all utterances are equally probable, and some are so improbable as to be essentially irrelevant. People who try to memorize the dictionary never learn the language, because the vast majority of the dictionary is useless and mostly unused, and even the words that are used are only used in a subset of their possible meanings.

>Once you open it up to arbitrary input, no single run (or even a large set of runs) can capture everything the program might be expected to handle.

Anything is better than nothing, right ? if your program keeps executing with some set of types over and over again (and it will, because no program is infinitely-generic, the human brains that wrote the code can't reason over infinity in general), wouldn't it be better to record this and make it avilable at static write-time ?

Human brains are finite, how do we reason over the "infinite" types that every Python program theoretically deals with ? We don't! like I said, most dynamic features are an illusion, there is a very finite set of uses that we have in mind for them. Here is an experiment you might try, the next time you write in a dynamic language, try to observe yourself thinking about the code. In the vast majority of cases, you will find that your brain already has a very specific type in mind for each variable (or else how can you do anything ? even printing the thing requires assuming it has a __repr__ method that doesn't fail.).

>How does the type profiler know that the variable that only contained values like "123" or "456" was handling identifiers, not numbers?

It doesn't. I think you misunderstood the idea a little, the type profiler makes no attempt whatsoever at discerning the "meaning" of the data pointed to by variables, it will only record that your variable held strings during runtime. If the number of string values the variable held was small enough, it might attempt to list them like this "Str WHERE Str in ["123","456"]". If the number of values the variable held was larger than some threshold but some predicate held for it consistently it can also use that, i.e. "Str WHERE is_numeric(Str)". If a string variable was always tested against a regex before every use, it will notice that and include the regex into the type. No additional "smart pants" than this is attempted, just the info your VM or interpreter already knows, just recorded instead of thrown away after each execution.

The profiler will not and can not attempt to understand any "meaning" behind the data nor it needs to in order to be useful, it's just a (dynamic) type system. No current type system, static or otherwise, attempts to say "'123' is a numeric, would you like to make it an int ?", that would be painful, absurd in most cases I can think of and misguided in general.

Banana699··on You can’t buy one square foot of land in Scotland and become a Scottish lord
Why is becoming a Scottish Lord desirable in the first place ? explained for someone who doesn't live in Scotland or any of the neighbouring Isles ?
Banana699··on Programming breakthroughs we need
I think dynamic analysis is incredibly powerful and criminally underused in IDEs and other dev tools.

I have thought of an idea about 6 months ago that has been fermenting in my mind since then : what if (e.g.) a Python VM had a mode where it records all type info of all identifiers as it executed the code and persisted this info into a standard format, later when you open a .py file in an IDE, all type info of the objects defined or named in the file are pulled from the persistent record and crunched by the IDE and used to present a top-notch dev experience?

The traditional achilles's heel of static analysis and type systems is Turing Completeness, traditional answers range from trying and giving up (Java's Object or Kotlin's Any?), not bothering to try in the first place (Ruby, Python, etc...), very cleverly restricting what you can say so that you never or rarely run into the embarrassing problems (Haskell, Rust,...), and whatever the fuck C++'s type system is. The type-profiling approach suggests another answer entirely : what if we just execute the damn thing without regard for types, like we already do now for Python and the like, but record everything that happens so that later static analysis can do a whole ton of things it can't do from program text alone. You can have Turing-Complete types that way, you just can't have them immediately (as soon as you write the code) or completely (as there are always execution paths that aren't visited, which can change types of things you think you know, e.g. x = 1 ; if VERY_SPECIFIC_RARE_CONDITION : x = "Hello" ).

You can have incredibly specific and fine-grained types, like "Dict[String->int] WHERE 'foo' in Dict and Dict['bar'] == 42", which is peculiar subset of all string-int dictionaries that satisfy the WHERE clause. All of this would be "profiled" automatically from the runtime, you're already executing the code for free anyway. Essentially, type- checking and inference becomes a never-halting computation amortized over all executions of a program, producing incremental results along the way.

I have ahead of me some opportunity to at least have a go at this idea, but I'm not completely free to pursue it (others can veto the whole thing) and I'm not sure I have all the angles or the prerequisite knowledge necessary to dive in and make something that matters. If anyone of the good folks at JetBrains or VisualStudio or similar orgs are reading this : please steal this idea and make it far better than I can, or at least pass it to others if you don't have the time.

Banana699··on Instagram, TikTok, and the Three Trends
But "people" isn't just a single thing, it's a distributed system of many interdependent but ultimately independent agents. If you only grind your own axe, yes many people will be indeed swept in, but a lot of other people will spend their parallel hours seeing others grind their own axe, which would include the axes of your opponents. There is an equilibrium where you reach all the people you would ever reach but your opponents still carves out their own niche out of other people's attention.

Whereas, if you pursue both pushing your agenda and suppressing your opponent's agenda, you will more truly make it zero-sum. Now even the parallel people who would never see/care about your own propaganda would also never see your opponent's propaganda, because you suppressed it at its source.

Banana699··on Instagram, TikTok, and the Three Trends
None of those are AI-generated (therefore don't have the potential massive automated scale) or auto-play.
Banana699··on The impact of removing jQuery on our web performance
GP was talking about loading JS, adding JS to a webpage doesn't affect its rendering (unless the loaded JS is DOM-manipulating) does it ?
Banana699··on A Review of the Art of the Metaobject Protocol (2010) [pdf]
As with all arguments about "not really innovation", the problem seems to be in drawing boundaries around ideas. If people in the 1980s and the 1990s were all really reinventing Kay and Mccarthy, then why weren't Kay and Mccarthy reinventing Turing and Church? Why weren't Turing and Church reinventing Russell and Frege? Are we going, like 1 philosopher called the entirety of philosophy and its history as a "series of footnotes to Plato", to call the entirety of CS and its history as a series of footnotes to Leibnitz ?

In some sense of the words, all of this is true. The human brain is just a finite configuration of 100 billion object after all, and as you zoom out to more meaningful levels of abstractions the set of distinguishable states only get smaller. Shoulders Of Giants, etc etc etc. So, off course whatever you have thought of is not original if you zoom out far enough. My only question : why stop zooming out at the arbitrary cutoff of the early 1980s? Lisp dates back from 1958, Algol from 1960, Simula from 1962, APL from 1964; those 4 together are essentially all of programming language design summarized into 4 specimen in the same way that [bird, fish, ape, virus] are essentially all of life summarized into 4 specimen, don't you agree? so 'essentially' all programing languages were invented before 1965, even more essentially before 1970. What makes this 'essentially' more false than your essentially, which just moves the cutoff 20 years later? Types are just fancy sets right? Sets are ancient, all of type theory is 'essentially' reinventing Russell and Whitehead.

In essence, Computer Science was invented before it was born, and that's literally true in a very peculiar sense : CS is an outgrowth of a delightfully bizarre intersection between Math, Logic, Physics, Information Theory, etc... that was always there as long as those fields existed by any name or the other, it was just recognized as special in the 1940s-1960s and given a name.

So, before I push back on your particular claims, I will grant you that there is indeed a very particular sense in which you're completely correct, but I don't find that sense convincing enough. You can always find the very special and peculiar way\interpretation\precondition in which any statement can be true if you're patient enough, there is a glimmer of truth in every statement no matter how bizarre. I don't mean to say your claim is bizarre or obviously false, it's not, but it's not obviously plausible or even a useful way to view things either in my view.

--------

>> 1980 is the debut of Smalltalk.

>1972, actually!

I should have clarified that by 'debut' I mean the general release of the Smalltalk VM to non-XeroxParc audience. This is an important milestone because what followed was a 2 decades (smalltalk fans would say 4 decades and counting :)) of research and enhancement of all ideas surrounding the language and the paradigm. One particularly beautiful direction is Self, which invented prototypical OO, and was the first to articulate and implement the idea of "Extremely Smart Runtime-Adaptive Compiler" publicly as far as I know. Isn't this another hole in your claim?

>Finished in the mid 90s. But Lisp was around well before the 80s, and CL was in a lot of ways a standardisation of the practices developed in the 70s & 80s.

What I'm saying is, why bother stopping at 1970s? When you can just as easily say that Lisp was largely finished by 1965 ? You wouldn't be qualitatively more wrong, only very incrementally.

>Python is just an unacceptable Lisp (1958), and Ruby is by analogy an unacceptable Smalltalk (1972).

Lisp is just an unacceptable Lambda Calculus (1935).

>The JVM is just refinement of ideas dating back to UCSD Pascal (1977), and the CLR is just an embraced and extended JVM.

I will just play my same old unimaginative game and ask you : why stop at UCSD Pascal? Search for "Virtual Machines" on the ACM repository, you will find hits from the early 1960s. Bytecode is an idea that falls extremely naturally out of the idea of pseudo code, which assembly programmers were using extensively since the early 1950s, indeed the first proto-languages (Pre-Fortran!) were just bytecode interpreters (except the bytecode was written directly by the programmers, and that was a improvement over hardware assembly). Fortran compilers for the IBM 1401, to give a specific and far-from-the-only example, consisted of about 60 or so passes that began with human readable text and ended with machine executable bytes, every IR in between is just begging you to discover the idea of a formalized bytecode format and, from there, the Entire Thing of VMs. The Apollo project (1969 launch, software developed from 1965 to 1969) software engineers explicitly embedded a VM for vector math inside the code, and wrote a big part of the vector-heavy navigation code in its bytecode. An honest-to-God VM, that interpreted its bytecode at runtime. People Knew The Stuff.

What did Pascal VMs do? they were the first to, publicly and popularly and with extensible implementations, evangelize and elaborate on the ideas known for 20+ years. In other words, Not Really Progress (^TM).

>partial evaluation in Lisp in their 1980 paper On compiling embedded languages in LISP

And the entire idea dates back to Futamora projections from the 1970s,that's not the point, the point is the vast amount of learning and research and development that happened since then. Like I said above, if you're only concerned with the raw beginnings of the idea, then types are just a trivial footnote to Sets and (more generally) Category Theory, both extensively elaborated on from the 1900s to 1950s. Sets, in particular, are "just" a kinky way of denoting natural numbers, sooo... Do you see where this one is going?

>Haskell was strongly influenced by Miranda

I think you're familiar enough with my "But Why Stop There?" game that you can play it yourself here, but I will just note that Haskell's incorporation of Lazy Eval into the entirety of the language was something unprecedented as far as I know, so there's that, 1 ground-shaking idea and all of its myriad consequences on the language and its design.

>F# is another member of the ML (1973) family. ‘Something old, but this time on a new VM!’ isn’t really progress, is it?

>Scala is OO (60s) plus functional programming (50s)

><other languages>

All of those have a ton of new things to offer. As examples, F# is far from a generic ML clone, just look at active patterns and type providers. Scala gives people who venture too deep inside it ptsd, although I haven't experienced it myself. Julia and Mathematica have macros without being as braindead as Lisp on syntax, which is a massive improvement and refutes a point that Lisp fans love repeating till today. They aren't the only ones, Elixir (which wouldn't have been possible without Erlang) is another, among many others. Perl and Mathematica's legacy is Extreme Syntactic Flexibility, Mathematics goes as far as making diagrams and images first-class-syntax, all the while representing Syntax as nested lists underneath. Raku is the first general purpose language to give BNF grammars full first class's citizen status.

Like I said, it really seems to me you're doing "All of life is just birds, viruses, fishes and mammals, what's new here? Biology is done".

Banana699··on A Review of the Art of the Metaobject Protocol (2010) [pdf]
>there is a very real sense in which programming languages haven’t really progressed since the early 80s.

Can this be made any more precise to somebody who doesn't share the feeling?

As a programming language aficionado, my attitude is the exact opposite of this. 1980 is the debut of Smalltalk. Standardisation of CommonLisp happened sometimes in the mid 1980s. The 1990s is the "Interpreters Renaissance", when Python and Ruby (and other less elegant siblings) came out, as well as the JVM and the proto-beginnings of the CLR. The 1980s and 1990s was an era of massive interest in Partial Evaluation, the revolutionary idea with consequences such as deriving a compiler out of an interpreter automatically. Those ideas were later revived\paid off in projects like PyPy and GraalVM+Truffle, late 2000s and early 2010s stuff. Haskell? 1990, and only popular beginning in the late 2000s\early 2010s. LLVM? early 2000s. SML? OCaml? F#? Scala? Erlang? Rust? Clojure? Perl and its legacy in Raku? Julia? Mathematica? I can go on and on.

Highly skeptical of that "very real sense" that views all of this cambrian explosion of ideas and explorations as not really progress.

Banana699··on Objective-S: architecture-oriented language based on Smalltalk and Objective-C
The only thing lisp seems to have not figured out yet is this small thing we call "Syntax", which the PL community mostly figured out 50 years ago : you write terse notations and the compiler builds up the tree for you, you don't layout the syntax tree yourself.

Lisp also seems to have a shortage of knowledgeable advocates who understands other programming languages enough to know that not everything is or needs to be a lisp.

Banana699··on I hacked my car
The 'S' in iot stands for security.
Banana699··on Local simulation feature to be removed from all Autodesk Fusion 360 versions
This is one of the areas where piracy is good and moral, as a low-cost vigilante solution to harass corporations who have grown safe and fat. Piracy is a fresh slap on the backside to wake those kind of people up.

And this is why all this "muh cloud" bullshit is a nightmare world where you, the client, have 0 leverage or rights or any kind of weight. Aside from the astonishingly dumb UX choice of "You always need a reliable network to do anything" off course.

Banana699··on The Unreasonable Effectiveness of Makefiles
Configuration doesn't have to be declarative, for example see https://lukeplant.me.uk/blog/posts/less-powerful-languages/, in particular the section about python configuration, where an imperative configuration language is discussed. How imperative? Very. It's a line-oriented language, where the program reads a line and changes something in an internal data structure accordingly then continue reading the file. This is imperative, the person writing the configuration file has to think about state and time while writing the file, not just abstract goal states and facts.

Declarative vs. Imperative is a spectrum. For instance, there is a declarative language hiding inside most imperative languages : Infix Math. 1+2*3/71**7 is declarative because it under-specifies the order of operation, only the data flow dependencies implied by operator precedence needs to be respected. In the precedence hierarchy I had in mind when I wrote it, You can do 2*3 first or 71**7 first, it's unspecified and irrelevant. I only ask that you do both before you perform the division of their results, and that the addition is the last operation. Meanwhile, in Forth, math is imperative, you have to unroll the expression tree into an exact sequence.

Declarative is any language that under-specifies the task being described. Therefore, every language worth using is declarative to some degree or the other. After all, that is the very purpose of a high level language : to under-specify a task by describing only the most essential of details, all the abstracted details are taken care of by either inference (compiler figures it out, possibly according to rules that you need to be aware of) or exhaustive checking (compiler generates all possible cases and code to select among them at runtime, or very generic code that can handle all cases uniformly). If, like Alan Perlis says, "A low level language is that which requires attention to the irrelevant", then every good language is already declarative in some sense, you omit things and they get taken care of automatically, that's what Decorative means.

You can say you hate buzzwords, I empathize. You can just say that make is bad software (trivially true, or we wouldn't have needed software to generate makefiles, effectively making them a machine code that isn't meant to be written by humans) and that being declarative doesn't make it any less bad. Declarative vs. Imperative are just names for design decisions, they guide a language designer but don't have the power to make a language good single-handedly.

Banana699··on The hacking of Starlink terminals has begun
There is an argument to be made that if a word has a very widely-known meaning, and a very niche meaning, then the niche usage requires clarification even among the niche group that invented the niche meaning.

For example, when there is a certain word that you and your peer group use as an in-joke, you usually have to wink or smirk to invoke the joke meaning, that acts as a signal to the group to resolve the word to its group-specific meaning.

Banana699··on Non-Believers
>the probability of change in each system might not be high, but overall probability of general change is much higher - because it's multiplication of individual probabilities.

I get what the author is trying to say, but they had this one backward. Probabilities get smaller by multiplication. What he probably had in mind is :

- The probabilities of change events C1,...,Cn is P1,...,Pn

- The probability of no change at all is therefore (1-P1)(1-P2)...(1-Pn), which does indeed become smaller as more (independent) events C1,..., Cn are accounted for. And therfore the probability of change increases, but not because its a multiplication of probabilities, the exact opposite in fact, its because 1 - <multiplication of multiple probabilities>.

- Another way of phrasing the above is that, although each Pi might be small, their sum represents a sizable chunk of 1,therefore a significant probability. This only holds if events intersects minimally or not at all. This is a different assumption than that of independence.

Banana699··on Phrases in computing that might need retiring
PS: This is hilariously dumb and brain-dead. I can't stop re-reading it back and laughing like a maniac.

My followup question would be : what is your IQ, and that of the woman you asked?

Banana699··on Excel is pretty dang cool
By that metric, all programming languages including assembly have exactly 0 consumers, since nothing human-readable actually runs on computers.

Look at that, I have saved programming from language popularity contests, no need to thank me. I will humbly accept your bitcoins though.

---

The most reasonable definition of a language consumer is as follows: If a program text P is written by a human-level intelligence in source language L, then every user of any automatically-produced-artifact from P is a consumer of L.

Suppose a programmer use typescript to write a web app:

- The programmer, who must compile the typescript to javascript, is a consumer of whatever language the typescript compiler happens to be written in.

- The user, who must run the resultant javascript files, is a consumer of

     (1) typescript, because the JS files is an artifact produced automatically 
         from the typescript text the programmer, who is a human-level 
         intelligence, wrote.

     (2) The languages the browser/JS engine is source-written in, typically C++, 
         Rust, or Zig. 

     (3) Possibly javascript, because typescript is a strict superset of 
         javascript, and thus there is a probability that at least part of the 
         original text of the webapp is valid javascript, and thus qualify in the 
         definition. Take note that this has nothing to do with the typescript 
         program text compiling to javascript, this is solely due to the fact 
         that typescript is a strict superset of javascript, any language that is 
         not would not have this property.
From (3) we see that languages are not completely mutually exclusive : There is a language called Arithmetic ('+','*','-','/' and numbers) that has a vast userbase unparalled by any single programming language, since it's a subset of a lot of programming languages. Other consequences of this definition is that :

- Languages with no human-level-intelligence writers have 0 consumers

- Every producer is a consumer, since the only human-level intelligences currently writing code are humans, and human producers are always consumers as well since they run the artifacts produced from their own program texts.

- Auto-Generated code add to the consumers of the generating language, not the generated language. If part of a C++ app came from the output of a python script, every consumer of the app is a consumer of python, since some of the artifacts they consume ultimately came from python source. If the script generates (say) Rust or Fortran code that is then compiled and linked into the final executable, the only languages the users consume are C++ and Python. Auto-generated code is an automatically produced artifact.

Banana699··on TruffleC: A C implementation on top of JVM (2014)
I think you're (perhaps intentionally) overestimating the hate the JVM gets to paint Java critics as unreasonable, but the fact of the matter is that the JVM and Java the language are light years apart in quality and (subsequently) the attitude they get from their users. One is a decent VM with man-centuries of work and inspiration from academia (Self, whose VM heavily influenced hotspot), the other is an ugly mess of a language whose syntax and semantics is pure unfiltered paperwork and bureaucracy.

I have elaborated plenty of times on why Java is a 1980s language that were obsolete as soon as it was released, the latest is my comment on https://news.ycombinator.com/item?id=32128271, which I reproduce in full at the very bottom of this comment to save you a ctrl-f.

>loom, valhalla, graalVM

Every single one of those has nothing to do with Java and everything to do with the JVM as a high-tech psedo-OS that challenges the classic preconceptions about performance-productivity tradeoffs. I don't want to attribute dishonesty to you, but again, I see absolutely no reason to confuse a VM with a (incredibly inferior and badly designed) human-level programming language just because it happens to be the first language to run on the VM.

>frankly believe the only other commercially viable language that has similar philosophy to JVM development, is Rust.

Come again? How is Rust similar or even comparable to the JVM ?

----------

Reproduced Comment

----------

>>>>I'm a Java hater. Here are the reason I hate it for

- Baking the difference between primitives and objects into the language itself : an ugly mistake with far reaching consequences, made by a language designed in 1995 while another designed in 1980 (smalltalk), in 1991 (Python) and 1995 (Ruby) all didn't fall for it.

The difference is an irrelevant VM-level optimization detail, there is no reason to uglify the human-level language with it. Once the initial mistake has been made, the correct response was NOT to make the even uglier hack of wrapper classes, but to make the primitives objects in the newer releases of the language, this won't break old code, as valid uses of objects are a superset of valid uses of primitives, except perhaps that objects need to be allocated explictely with "new", but this can be a special case for primtives (i.e. "int is a special kind of object that you don't need to allocate explicitly"). The compiler can figure out whether it needs to be represented as objects or as primitives, you can leave hooks and knobs for people to tell the compiler they need to the primitives to be represented as primitves, but it shouldn't be mandatory.

- Baking in choices about object representations : Like the fact that objects are always passed by reference, or that they are always allocated on the heap. Why the "always" part ? why not give developers the choice between pass-by-value and pass-by-reference like C# does ? why not give developers the choice to allocate on the stack (and complain as loud as you want when they want to do something unsafe with it, like escaping from methods), which, unfortunately, even C# doesn't ?

Everytime you see something like "foo deepCopy()" that's a failure of the language, forcing you to explicitely pay attention to the fact that foo objects need to be copied deeply everytime they are copied, instead of just once when you define the object by marking it as a "struct" or whatever word to signify that object has value semantics, and then deep copy is just assignment or passing as a parameter. Why make it the default to be inefficient with the heap when it's very easy to give developers the choice to be efficient in situations where it's always safe ?

- No operator overloading : I get the hate, it's a powerful tool. But it's misguided to ban it, operators should not be special, languages like Haskell and Raku go even further and allow you to define new operators entirely and control their predence and other things. You don't need to go that far, why can't objects use the already built-in symbols the language support ? because it might be confusing ? anything can be confusing, you can write assembly in any programming language, and it will be even worse than assembly because of the more powerful and obscure abstractions.

- Generics : The overall theme of forcing you to do things its way seems to a staple with java. Why do I need to use type-erased generics ? why shouldn't I get the choice to specify whether I need a new class generated for runtime efficiency or use the type-erased catch-all for size efficiency? there is no need to bake VM-level support for this, it can all be done at compile time (possibly with help of additional metadata files or special fields in the .class of the generic type).

- Overall verbosity : Why "extends" and "implements" ? do you really need to know whether you're inheriting a class or an interface ? and can't those be lighter symbols like "<" and ":" perhaps ? why is "private/public/protected" a must in front of every method and field ? most people align fields and methods by their visibility, C++'s way is that you declare "public:" and then everything declared below that is public. In the worst case you can always recover Java's way by "public : <method> ; private : <method> ; public : <method>" and so on, but it's nice to at least have the choice of not repeating yourself.

Why aren't any constructors generated ? there are at least 2 very obvious ones : the empty one, and the one that assigns all the non-defaulted fields (and can take optional arguments to override the default fields). Why aren't generated getters and setters available with a small and light request, like C#'s "get ; set ;" ? Java's design is just full of things like this. It feels like a weird sort of disrespect for your time, "yeah you must write those routine 25 lines of code all by yourself, you have anything better to do?", how about actually writing my application instead of pleasing your language with weird and unnecessary incantations ? It's like a modern COBOL.

- Horrible OOP excesses : Not really the language's fault (except that it encourages verbosity and loves it) and already mentioned, but worth mentioning again.

Overall, I treat java as assembly. I write kotlin in my spare time, and whenever I'm confused about the semantics of some construct I make intellij show the bytecode then hit "decompile" to see a Java rendition of the code, the exact semantics will be obvious but verbose. A language that took this literally is Xtend, a high-level augmented java which transpiles to java and is a strict superset of it, but with option that the Xtend compiler figures out all the verbosity for you. Groovy also takes the "Superset and Augment" approach but doesn't transpile. And off course Kotlin is very good with it's interoperability, every JVM language is but Kotlin's mixture of being close to Java semantics (unlike say, Scala or Clojure) and Intellij excellent support for mixed projects makes it at least somewhat special.

I like the JVM and it's cutting edge research and performance, and these days the Java standard writers seem to show signs of finally waking up to reality after years of being behind every mainstream language, and they regularly augment and modernize the language. But you can't undo 20 years or so of bad design, not easily and not painlessly.

>Indeed, tooling is the new syntax.

Very much agreed, long long gone are the days when a compiler or an interpeter is the only thing expected out of a language. But it's not a panacea to treat any bad design, at best it's just a band-aid for bad designs that makes them barely berable. The language has to be designed from the start with the knowledge of "this is going to run in an IDE" baked in to make full use of the full range of fantastic things an IDE can do.

---------------------

Banana699··on Phrases in computing that might need retiring
So men are the only people who comment without revealing their gender? What about trans individuals? Does that mean I can reliably mask my gender by deciding whether or not I mention it in my comments and posts?

And this still doesn't answer what rules you or the men's talk expert you asked use. Anybody can claim they have "a lifetime of experience" in anything they want, but without either an empirical success rate or a set of explicit testable rules, it's all bullshit out of their ass.

>We have a lifetime of experience listening to a man's point of view.

I and a lot of other men have a lifetime of experience listening to women's point of view too, and yet I can find no sane man who claims they can identify gender from text, unless in very special cases.

Banana699··on Reddit’s database has two tables (2012)
>For the same result

You're assuming that the "result" data structure is only a single boolean, is_task_done. That's not how most things work, GP's bubble sort will pretty damn well show up in locked-up UIs and injured-dog-slow bottlenecks, that's as observable as the Sun at 9 AM. That would happen pretty fast too - don't delude yourself with "Move Fast And Fix Later" with quadratic algorithms - 1000 squared is a million, and at 10000 it is a hundred millions.

>carrying it yourself, using a wheelbarrow, and using an F-150 Lightning all have exactly the same result and none is inferior

Off course not, the method used would show up in your health and exertion data, your fuel costs, the amount of noise and heat you emit while doing the work, etc... Every single way of observing a boolean is_bag_moved result can also be used to observe a metric measuring those things, and thus determine the method you used.

You're trying to defend an extremly strong claim : If algorithms A and B gives the same output in memory, NOTHING else matters. Here's an concrete example, consider the following sequence of algorithms:

Algorithm 0 : Print("Hello")

Algorithm 1 : do {Nothing} then Print("Hello")

Algorithm 2 : 2.times do {Nothing} then Print("Hello")

...

Algorithm N : N.times do {Nothing} then Print("Hello")

This is an infinite sequence of algorithms that all have exactly the same behaviour in a time-space agnostic manner. Would you say every algorithm in this sequence solves the proplem of printing "Hello" exactly as well as every other algorithm ? If yes... interesting. If no, then your original claim is false as-is, it needs qualifying with what observable behaviour means, as this example shows, it's a difficult notion to exactly define, a naive definition of "Everything that can be observed in computer memory or on screen" would leave you open to ridicilous conclusions.

Banana699··on Faster Ruby: Thoughts from the outside
I generally agree with you that compiling to machine code is not a magic wand, code that does more is always slower than code that does less in a fair fight. But interpretation adds additional overhead to make slow code even slower, the more complex\unoptimized the interpreter the more it adds overhead. It's good for a language to have a baseline expectations of "Don't make things worse", shit code will always be slow, but at least it's not made slower by things outside of the developer's responsibilities.
Banana699··on Don’t call it a comeback: Java is still champ
> DSLs don't.

DSL is a general name to any embedded language inside a host language. C++'s templates can be used to write DSLs, they are compile-time checked. Kotlin's lambda syntax can also create very convincing DSLs[1] to describe hierarchical structures\processes, and they are fully typed, compile-time checked constructs.

There are far more to DSLs than hacky strings (regex) or chaining method calls at runtime (fluent APIs). It's a very general pattern.

[1] Example from https://kotlinlang.org/docs/type-safe-builders.html

html {

        head {

            title {+"XML encoding with Kotlin"}

        }

        body {

            h1 {+"XML encoding with Kotlin"}

            p  {+"this format can be used as an alternative markup to XML"}

        }

}
Banana699··on Don’t call it a comeback: Java is still champ
>package com.seriouscompany.business.java.fizzbuzz.packagenamingpackage

>Issue #597 : It's written in java but doesn't support my blu-ray player

Banana699··on A History of Lua (2001)
Same as Scheme.
← PreviousPage 4 of 19Next →