Banana699

It shouldn't be hard to post examples then.

Do you ban similar comments from the other side ?

the correct approach would have been for Destiny to take legal action, instead of vigilantism.

So the correct response to percieved harrassment is indeed taking legal action, and not, say, mobilizing mobs to retaliate back ? Mmm, I wonder who needs to hear that.

Which wasn't what KF doing.

All of this is irrelevant and besides the point, 'hate speech' is not a magical word you say when mean people on the internet say things you don't like.

If you can't prove material damage in a court, it should be allowed.

Actually, yes it is. Just because you made up a new word to describe opinions you don't like doesn't mean those opinons aren't covered by free speech.

No, that is the entire point of exceptions

Which is why they're bad design. The comparison to function calls is misleading :

- Function calls are named, given a function name you can always go to a function definition and see for yourself how many functions it calls in all return paths. You don't have to, but you can, and this is crucial in many many situations, not the least of which is debugging (e.g "oh no! program ran into infinite loop, What was the last function called? I will go and see its definition")

- Function calls can be statically type-checked, given a function that returns X type, the compiler will ensure that every reference that holds its return result is X or one of its subtypes.

But in exceptions :

- Catches (the equivalent of calls) are unnamed, the set of places a catch can catch from is exponential in the number of function calls in its try{...} block. For an example, if you want to debug given a catch, you must recursively inspect every single function call in the try{...} block to know which function threw the exception. And no, the 50-line stack traces don't make things any better, if any thing they just rub in the fact of how many functions you need to inspect to know where the problem came from.

- Throws are not statically type-checked, given a function that throws E1, the compiler will not bother to ensure that it is called in contexts where E1 is caught, you're completely on your own. It is this which makes Exceptions free program-crashing coupons. Only Java tried to solve this as far as I know, and the solution is still full of holes.

I'm sure they would, just as they would be horrified by having multiple returns in the same function - never mind horrors like "break" and "continue".

You say this tongue-in-cheek, but as a matter of fact plenty of imperative languages ban "break" and "continue" for exactly this reasons, they are a huge source of loop bugs, and many style guide have problems with multiple returns and regulate them heavily if not banning them outright.

Regardless, the comparison is disingenuous, I just spent ~1000 words or so arguing why Exceptions are so utterly and fundamentally different from ordinary control flow. No return statement unwinds the stack arbitrarily, possibly to its very end, and with absolutely 0 static gaurantees.

If you think this is okay, we won't reach any useful consensus, and that's okay. But your original claim that Joel engages in faulty reasoning when he rejects exceptions as a form of goto is wrong, there is very good reasoning why exceptions are actually a much more dangerous goto than most modern goto, and plenty of much smarter people than you or me (or Joel) follow and accept this reasoning. Those people include those responsible for some of the most safety- and\or performance- critical software, like games and operating systems.

Dijkstras problem with goto was not that they jumped to a different place in the progam,

I read Dijkstra's paper, and I'm pretty sure when I say his problem was in fact exactly that. Unrestricted gotos make control flow an arbitrarily-complex graph, the fundamental reason for this is that the jump labels are public, and exceptions share that in a way that nothing else does, their catches are public to every single throw beneath them in the call stack. Throws are gotos that search for their labels at runtime, possibly failing and crashing the program or unwinding it beyond recognition.

When I'm done explaining how it's you, actually, who is the one who doesn't understand basic programming language theory and terms, and how you keep embarrassing yourself with hilariously false objections, you will probably need to apologize to me for this embarrassing and childish temper tantrum of yours.

First one call matches exactly one return. Then the same call matches a bunch of returns. Which is it?

There is usually a very basic distinction in Programming between 2 things : the runtime and the compile time. At compile time, the expression 5/0 is a perfectly valid integer expression, it returns an integer that can be used in all subsequent calculations. At runtime, it's a hardware trap, and the entire program will probably abort because of it. Integer or hardware trap? Which one is it? Both.

At compile time, a call site has a finite (and obvious) set of returns it's associated with, usually a relatively small set. At runtime, however, a single return out of this set ends up returning control to the call site. So a call site is associated at compile time with a small set of very obvious returns, and at runtime with a single return drawn from this set. Anyone who doesn't understand this probably hasn't programmed enough time to have a worthwhile opinion.

Then, a catch catches innumerable throws?

Yes indeed. Every single type-compatible exception that can possibly be thrown on the call stack beneath a catch is catchable by it, this is, contrary to what you imagine, an exponential set, and I do really mean exponential, yes:

If 2 function are called in a try{} block, and each of those 2 function then calls 2 function, and each of those last 2 function then calls another 2 function, then the set of possible throws catchable by your original catch is all throws in the 8 functions. Catch candidate sets are exponential in the number of function calls in the try{} block they catch. Unlike an ordinary call site that can resume control from a very small set of known locations, a catch can resume control from an huge and intractable set of jumps.

it is only ever caught exactly once

Actually, it's at most once.

You don't get to count that as a flaw

I do and I did. Exceptions are not some family members of yours to be this defensive and upset because I criticized them. It's okay, people can hate things that you (unhealthily) love, learn to deal with it. It gets better.

Exceptions are not, in fact, dynamically typed.

This was a subtle point in my comment, so of course you didn't understand it and went on to angry ranting as usual. Here's a more detailed explanation of what I meant by that:

When you call a function foo() and assign the result it returns to an int, the compiler of any decent language will ensure that every single return in foo returns an int. Alternatively and equivalently, if you declare foo() as an int, every single variable that holds the result of foo is an int, else compiler complains.

This doesn't happen in exceptions.

In exceptions, you can throw a FileNotFoundException, in a function that only catches NetworkTimeoutException. The compiler won't complain. You can later call that function in a function that only catches DictKeyNotFoundException, and the compiler won't complain about the lack of catch for FileNotFoundException. You can keep doing this till the very end, forever in fact, always putting incompatible catches around the function that throws, and the compiler will never once complain.

It's in this sense that throwing exceptions is like a dynamically typed returns, it throws an object, i.e returns data, but the compiler never bothers to check for a matching reception of this object at the calling code, like it does for ordinary returns.

Java tried to solve this with its Checked Exceptions, but it also introduced Unchecked Exceptions that anybody can use and thus greatly reduced the benefit and use of Checked Exceptions.

Look up "exponentially"

Try thinking about something for 5 minutes before you hit the keyboard. It will payoff greatly.

Any catch block that doesn't lexically match that type is skipped over.

Look up "lexically". It does not mean what you seem to imagine.

A "lexical" thing, in programming language theory, is that which can be inferred from program text alone without running it. Catches don't work lexically because they respect subtyping (i.e inheritance). And with subtyping comes runtime polymorphism.

Specifically, if

- Cat and Dog are both subtypes of Animal, an abstract class\interface, and

- I'm catching a Cat,

Then if I throw an Animal exception, the question "Will my catch, catch that exception?" can't be resolved lexically, or from program text alone without running it. The catch will catch if the object pointed to by the Animal reference I threw is a Cat, it won't catch if the object pointed to by the Animal reference I threw is a Dog. Seriously, go run it and tell me if I'm wrong.

I understand how exceptions work, apparently much better than you, if your other comment is anything to judge by.

If you're insecure enough that my different opinions about what good code is and how it should be written leads you to claim that I don't understand things without evidence, remove yourself from the conversation right now. It's much better for you.

The funny thing about those sentiments is, aside from how exaggerated their proportions are (only a single judge in the Supreme Court remarked in passing about revisiting Obergefell, and the very hysterically-named Florida bill is literally just the tax payers telling you they don't want their children to hear about your sex life, straight or gay, in their tax-funded public schools. If you want your children to hear about sex lives, cool, do it on your own time and money. You can say gay as much as you want, just not to other people's kids.), is that they are largely self-inflicted.

The Florida bill they are so terrified of would have never been drafted if public school employees never put gay porn in the library, people would have never got tired of Obergefell if not for the month-long religious festivals that lgbt movements like to hold so much. Lgbt movements create the conditions of their own societal rejection.

There is no distinction between "regular" and "error" control flow when it comes to reasoning and understanding, they are both control flow, they both need to be planned and synchronized in the programmer's head.

The arguments I give is for why Throw/Catch is a terrible control flow construct, a throw is an extremely dynamic goto that searches the call stack for its label, not guaranteed to be there by the way, and a catch is an extremely dynamic call that can resume control from any point underneath in the call stack. I don't know about you, but sounds to me like a disaster waiting to happen. Java tried to tame it by trying to incorporate exceptions into the type system, but it's half-baked and also comes with a big glaring hole called Unchecked Exceptions.

Errors or no errors, a bad control flow construct is a bad control flow construct. Error control flow deserve the same treatment as regular one.

I find code that's full of ifs and multiple return statements and global error state variables to handle truly exceptional conditions

Two wrongs don't make a right. Ad-hoc error handling is awful, but so is Ad-hoc exception handling as well. There is plenty of error handling mechanism (either built-in to languages or as an architecture over boring code) that is not both.

That's a very cliche and unnaunced point of view. If you like thinking about your code, you have assembly, I think x86 is a very nice flavor for you, will all its 40+ years galore of special cases. There are Turing Machines, for really testosterone-heavy programmers, there you don't even have registers, registers are for weaklings, am I right ? I think you will like them very much, just an FSM and an infinite tape, the sky is your limit, so much thinking.

If you want even more kickass bragging rights, you can program in a Lambda Calculus, where every single thing you try to do with the language will force you to think about it, more thinking ! yaaay ?.

Generally speaking, yes, the entirety of good design (in general, in all walks of life) and modern PL research comes down to "don't make me think about how I code", because good programmers don't think about the code, they think about the problem the code is trying to solve. As per Alfred Whitehead (a mathematician, so very much a fan of thinking) : "Civilization advances by extending the number of important operations which we can perform without thinking about them.", so is programming language research. It advances by allowing you to forget as much as possible that you're even programming a computer, a good language fades into the background, ideally you're not even programming a good language, you're simply stating the problem to be solved.

This is hampered by leaky and unreliable abstractions like Exceptions. They are a step backward in Error Handling, no static gaurantees, no static type checking, aweful synchronization between use sites.

I don't get that.

Call/Return Pairs are balanced at runtime, not lexically. From all possible returns in a function, only a single one runs, and terminates the whole function. Every call site is paired, at runtime, with a single return that will return control to it, and the entire set of candidate returns are known at compile time, and the compiler checks all of this to report dumb mistakes.

This is not how Exceptions work, you can throw more than you can catch, and you can catch more than what can ever be thrown (this is generally harmless, just garbage code that never runs). Neither the number nor the types of throw/catch sites are kept in sync statically.

a return can return to multiple different places depending on where the function was called from

Every single call site of a function is paired with all the returns of this function. The returns of a different function are paired with the call sites of that function, not the first. Unlike Exceptions, where every catch is a jump destination for every single throw of the same (dynamic) type across every single function beneath the catch on the call stack. That's literally an exponentially larger set than set of all the returns of a single function.

why that would even be a desirable property

It's desirable because it gives static gaurantees.

Given a throw, you can't even know how much of the stack it would unwind, it can potentially unwind the entire stack if no compatible catch is above it on the call stack*. Exceptions can break through their abstraction boundaries and unwind the stack of a calling component that doesn't know about them. Exceptions are fundamentally dynamically typed Returns that you can forget about. That's as big a footgun as you can get without being deliberately a troll.

Given a catch, you can't even know where is all the places that can go to that catch (unlike a call site). Oh, there is the trivial answer of course : Every single function called in the try{...}, and every single function that those functions call, etc etc etc. Again, an intractable thing to reason about. So people don't, but they have to, the throw/catch pair is a single logical feature, their uses must be reasoned about and kept in sync in assumptions and consequences.

None of this is how a return works. If Structured Programming advocates saw Exceptions, they would be horrified. Even C's gotos don't allow you to jump out of a function.

* : (which, of course, is a dynamic property: in "if(...) then {Do_Something() catch(){...}} else{...}", only one branch will actually catch, one branch can crash the program, and none of this is visible to the compiler at write time)

Yes exactly, exceptions are much much nastier returns. Returns only go up exactly 1 frame, and the call/return pairs are balanced no matter what. Exceptions can unwind the entire stack, and the throw/catch pairs aren't balanced automatically. Returns of a single function own their call sites, nobody jumps to their call site except them, but a single catch accept every single throw from arbitrarily deep into the stack.

Exceptions are an entire call/return system hidden beneath the vanilla call/return system, with less thought in the design and more foot guns.

I don't follow your reasoning here

Okay forget it, it was a somewhat subjective point, my main point is as above, exceptions are extremely spicy returns, they interact dangerously with the regular call/return system and scoping. That's essentially all of what objections to exceptions boil down to, and it's a legitimate reason to hate and avoid them.

I'm not sure you're giving that argument all what it deserves.

Control structures and function calls are a very statically-well-behaved control flow: unlike gotos, when you see a jump you know exactly where its destination is (runtime polymorphism for functions\methods is... an exception, and that's why some people don't like it.), unlike a goto where that might be a dynamic address. The Return is the only modern goto with a dynamic destination, but even then the destination is not completely arbitary (stack discipline), and actually the destination is irrelevant if the function is a well-named non-leaky abstraction, the function simply returns to its "caller", wherever it may be.

Furthermore, traditional control flow is Structured, it "owns" its jump labels. Nobody can jump to an else clause of a conditional except that conditional, nobody can jump to a loop start except the code immediately before it or the loop end (breaks and continues are, again, limited exceptions to this, and that's why some people don't like them), only the Returns of a function can jump back to the callsite of that function. As utterly trivial and basic as that sounds, it's a marvel. Gotos are nothing like this, they jump to public labels, anybody can jump to the label, it's a communism of control flow.

Exceptions break all of that. You don't statically know what's the destination of a Throw is, and unlike a Return, the destination is not irrelevant, the program is disrupted, you really need to know where that Throw is going to end up. Throws don't own their catches as well, any Throw can jump to the same Catch.

In a very real sense, Exceptions are more dangerous gotos than ifs and whiles.

Yes exactly, any language with zero\low cost type definitions and natural use of custom types (they don't look second class in e.g operators) would automate what Joel calls Apps Hungarian (the original Hungarian notation). In fact, good custom types would make Apps Hungarian, the useful Hungarian notation, as useless as the Systems Hungarian.

This is a natural direction is programming language research, to make as much of program constraints and custom logic automatically checkable and enforced.

Where the Howler here?

You can make a religion out of this.

It's doubly hilarious how worrying about "anti-trans and anti-gay panics" is itself a moral panic and a faulty virtue signalling mechanism.

Yeah GP just casually described a Utopian ideal.

I wasn't engaging in personal attacks, it's what I sincerely think of religions and their followers. What good is niceness when it's not sincere? Would you prefer if I pretended to like or respect you or your ideology while secretly despising you like the plague?

Your religion involves far more than "treating people with respect", this is such a pathetically false and cowardly phrase that all religions try to hide behind under various formulations. Your religion involves revering a certain class of people and elevating them above the rest of us and agreeing to every bullshit they make up or risk the consequences for dissent, made abundantly clear by repeated examples. I.e, just a standard old delusion, but with new words.

I don't despise any religion for faith, I despise ideologies for authoritarianism. Your religion, just as the 1400 year old disease I was raised on before I knew any better, is the authoritarian ploy currently in fashion to destroy lives and bend free wills. You support it, you kneel to it, you are happy your kids are absorbing your delusions before they know any better, and that makes you an authoritarian. You and the rest of your religion deserves nothing but contempt and sneering.

Having said that, I have to admit I don't actually know what do you actually hope to accomplish by replying to me? Knowing why I despise your kind of believers? I made that very clear. What else?

Not necessarily, there are plenty of non-normalized things that are not political. Like I said, being political is first and foremost an attitude, a very specific attitude that nothing matters except your very own pet issue, and the willingness to let everything and everyone burn in order to push your view or just flaunt it.

would it be political to bring your non-heterosexual spouse to a company function where other employees may bring their spouses?

Depends on you and your coworker attitudes, but generally no. A function like this would probably be very laid back and casual, it's not even "work" by a strict definition, so I can't think of a way your non hetero spouse would be a problem. Company asked for people to bring spouses, company got people who brought spouses. If they wanted Man/w/Woman only, they should have asked for it, subtly or explicitly.

Of course, the kind of people I have in mind can still ruin this, just like they ruin everything. They can always come dressed in a pride flag and act insufferable. And that's exactly my point, being political is, as I think of it, a personality. You can be the most boring normative person in existence and still be political, you can be the most radical and norms-challenging person in existence and still shut up and fix the damn bug because nobody got the time and patience to fight your moral crusades.

Even a few "slips" here and there could be forgiven, we all get political if somebody pushes our buttons enough after all. But repeated, deliberate attempts to be pushy and transgressive and an oppressed victim? That's just something else. It can always be recognized.

I use a gender neutral restroom, but our office has none. ... Political?

Yes, don't use the bathroom at office.

I use they/them pronouns, and I ask politely for others to use them... Political?

Absolutely, it is the very visible agenda of a very loud political machine. It's nothing but political. It can be an example of "political, n." in a dictionary.

That said, you don't need to be fired over everything political you do, just like discussing a little politics with your office colleagues once in a while is not necessarily an offence. Just as long as you stay respectful and polite when someone says no, they won't use your nonsense pronouns, very fine.

Cause I've been told that being a queer person is political.

I doubt someone actually said that unironically, you're very likely deleting tons of context.

But the long and short of it is that no identity is political unless you make it, given the stereotypical "queer" person, I absolutely empathize with whoever said that statement to you, but "queerness", whatever that may be, itself is not necessarily making you political at work, it's just the kinds of people attracted to it. In theory, every ideology of every shape and color and identity can coexist under temporary and concrete banners like "make money".

Eh, I respectfully disagree to your disrespectful disagreement. Things are just different, there is no way around that.

Citing past experience is cheating, if you had already encountered X before to the point that learning it in detail is a negligible cost to you, then you're not truly unfamiliar with X, you amortized (part of) the cost of its learning over the past encounters.

There is no way, and I mean no way, a e.g Java programmer is going to be productive in a Haskell without a 3/6/9-month (depending on how much learning is "productive") learning phase where they are, most of the time, a "read only contributer". Java and Haskell are just too different computing machines entirely. Bad practices here are good practices there, good practices here are bad practices there, how I can describe it? It's literally programming a different abstract machine, they both eventually compile down to electrons but the journeys they take are vastly different.

I think the post title must contain an implied "And be prepared to mentor them while they are being unproductive". In the jumpy 3-years-at-most-per-job world of most tech jobs, that's unacceptable for employers unless they're really desperate.

Nobody is the manager of the Internet, that's the whole fucking point of the Internet.

Your right to censor and regulate traffic ends exactly where your machines do not reach. Cloudflare own the machines in question, so they decide what stays on and what doesn't. They are the managers of the part of the Internet where their machines reach (Duh), but none else.

It's funny that I have to explain this because it's usually the other way around, some tech giant will usually ban someone for something incredibly arbitrary and nakedly unfair, and the folks crying about Cloudflare's decisions here are usually the first to start cheering and explaining to the rest of us how they're a private company and have the right to do anything they want. Well, Cloudflare is a private company too, folks, and they decided that free speech is awesome and worth it, and you gotta respect their decisions and stop raging impotently about things you can't control.

It took a hit because a bunch of random nobodies are raging about them on HN?

It's utterly hilarious how you think the person who cites research and asks specific concrete questions (which, as a reminder, you hadn't answered yet) is the one who talks in circles and strokes his ego.

Yeah, 15 years in industry and academia, and you don't know how statistics and probability theory are different.

May you have a nice happy day\night my guy.

Great analogy, too bad it's hyperbolic and doesn't actually say anything about the situations it's supposed to help us think about.

People need to get it through their head that speech is not violence, words are not weapons. Your Exquisite Analogy about how speech laws should Akshually reflect gun laws or martial laws doesn't work, never worked, and never will.

Every single argument against free speech is a general argument against living in any kind of large networked society. Your problem is not the tools the harrasser uses, your problem is the harrasser themself, the tools they use is the same tools used by dissidents and freedom fighters to "harrass" the oppressive governments they are rebelling against.

We went through this entire tiresome arguments before with the debates around cryptography and anonymity, people just keep Missing The Point. Yes, building backdoors into encryption standards and harvesting data without users' permission will allow you to catch The Big Bad Pedos, but it will also allow Putin and Ibn Salman unprecedented power to catch their own type of enemies. "Oh, we just want to do bad things to the bad guys only" no, you can't, believe me, you can't and you won't, every single thing you advocate for can and will be used against you.

So something that is used to develop something that later generates billions of dollar of profits isn't, in itself, responsible in part for those billions of dollars ?

So by this reasoning, something like Linux has exactly $0 value in monetary terms. Linux is never an application, it never does something that actual users pay for (the "users" who pay for Linux support are just developers and corporations who use it to develop something else).

I also don't think you understand what profit is and the difference between profit and revenue.

Yes, I don't understand an elementary distinction between terms that anybody with a dictionary understands. This is quite a fair and productive point for you to make.

this exchange has become pretty pointless.

Probably the one thing you're right about in this, I'm indeed not interested in debating incredibly insecure people fond of accusing others of ignorance (quite often a projection technique) instead of engaging with their arguments or citing specific examples or research.

I wouldn't be so quick. #1 is usually implemented by Deep Reinforcement Learning systems, RL is an AI paradigm descended from Control Theory and is used extensively elsewhere in Optimization and Operations Research. Here[0] for example is a Nvidia blog post detailing how they used it to obtain circuits with 25% less area at the same performance metrics. (I didn't search for this post except just to get the link, it's very typical of the kind of research I follow and I read it as soon as it was posted several weeks ago.) In another[1] example, Deepmind researchers used DRL to control a fusion reactor with results that exceed the current state of the art.

I used games as examples just because they are the easiest to understand and most popular applications of RL, and also very general, but that would be like saying that CNNs are useless because recognizing cats is not a bussiness, recognizing cats is just 1 example of the vast array of things CNNs can do. For every optimization algorithm pioneered by RL research in order to play a useless $0-return game, you can bet that it's later implemented and used in other areas to save and generate millions or billions of dollars. Games are just the test playground for new research.

I don't understand how #3 can't be credited with the billions of dollars the products and services based on it generate. According to [2], the global market of offering a speech-to-text API is valued at 1.3 billion dollars in 2019, if you assume that just 20% of that is actual customer value (to account for hype, errors in valuation, etc...), that's about 260 million dollar per year. Even an extremly conservative value estimate tells you the technology generates a billion dollar every 4 year (if it stays constant, the forecast projects the market will reach >3 billions by 2027). Keep in mind that this does not include any value generated from any other component or product, this is just the profits from the APIs alone, the generous 20% discount is to account for hype, analysis errors and bad data.

But you know what ? the broader point is, these are just 3 examples that I pulled off the top of my head while I was making a 5 minute comment without consulting google. And considering the person I'm replying to never provided a single example or any kind of specific clarification till now, or anwered any of my questions or otherwise offered any kind of rebuttal, I think it's pretty fair to say they hold up nicely.

[0] https://developer.nvidia.com/blog/designing-arithmetic-circu...

[1] https://www.nature.com/articles/s41586-021-04301-9

[2] https://www.fortunebusinessinsights.com/speech-to-text-api-m...