Correctness – A paradigm for sustainable software development - <AUTHOR> http://nonullpointers.com/posts/2019-03-27-correctness-the-paradigm-for-sustainable-software-development.html <comment><USER2> _> The thing you need to look at if you're using say, a dynamic language, or object oriented design, is that in the long term, what is the language and mindset of "objects" with dynamic dispatch providing you apart from an endless stream of bugs that seem to keep reoccurring everytime you try an evolve the software to introduce a new requirement?_

I am sick and tired of the arrogant, willfully ignorant developers touting their FP horn and bashing OOP without any qualifiers. This is getting as annoying as Java people posting their design pattern nonsense as if it was something good.

If you know what a monad is, you should also know the founding ideas behind OOP.

[http://userpage.fu- berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay...](http://userpage.fu- berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_en)

The ideas make sense. Moreover, Kay has an amazing track record of saying unpopular things and being proven right in the long run. If you spend some time looking into it, you should see that his high-level intuitions about software architecture are proving to be correct, despite many of his critics. A lot of hyped-up modern technologies are implicit, ad-hoc, overly complex implementations of OOP ideas done without realizing they are such. The whole IT industry would be far better off if people took time to look into _and understand_ the original ideas behind OOP.

1\. OOP is a higher-level paradigm than FP, so people comparing them directly usually are missing the point to begin with. OOP systems can be implemented in functional languages or use functional-flavored components.

2\. It is beneficial to model _algorithms_ without using state. FP is very good that that. (Boring but practical example: LINQ vs loops and variables in C#. Functional LINQ pretty much always "wins", just like Streams always win in Java.) However, large-scale systems almost always have state. If you do not have some wise approach for handling it, your designs will have issues at system level. OOP is one such approach and _at that level_ its ideas have a lot of value.

I'll edit this post later to add a few more points.

<comment> thraway-burnout This is a bit like the "Islam is a religion of peace" discourse. I'm sure it is, but:

OOP as actually implemented and found in the wild isn't about Smalltalk or message passing. It's about transforming functions into methods by unnecessarily wrapping behaviour in classes, as an example of cargo-cult programming.

OOP the idea is great. How do you actually find it in the world?

<comment><USER3> If functional programming were implemented as widely and abused as much as OOP is, would it really fare any better?

<comment><USER4> You can already see examples of this.

Take callback hell. Opaque callbacks are the functional equivalent of goto statements.

Also, many functional programmers, particularly Haskell programmers, seem not to care about readability and maintainability. They're focused on maximizing their own productivity as an individual coder, and writing cool concise and abstracted code that might not actually be easy for another engineer to understand and modify.

The difference though is that good functional programming is still quite common whereas good object oriented programming seems to be rare (the one exception being microservices).

<comment><USER5> > Opaque callbacks are the functional equivalent of goto statements

in some sense they are worse because you can't just grep for the call site of an anonymous closure, like you can for a goto, it could be almost anywhere in the code base

</comment></comment></comment></comment></comment><comment><USER6> I had a thread on twitter about this problem of "musicians nerding over gear." In our metaphor it was about mountain climbers. The programming language and its paradigms chosen may have some effect on how you scale the mountain but the real problem is the mountain. Whether you use functional programming or dynamic typing it only affects small, local problems in the practice of climbing mountains.

The problem of efficiently scaling mountains requires a broader scope. This is why I think formal methods are starting to break into the mainstream: they give us tools to use to simulate and verify designs (model checking, system design validation), validate implementations (verification, proof), and generate provably correct code from high level specifications (synthesis).

Grumpy programmers who think maths is for academics are going to miss out I think. It's an exciting field and the cost for something that used to be only used for extreme circumstances has been coming down so rapidly that it can be effectively used in small businesses as well.

It all comes down to clarity: in communication, in thought, and in practice.

<comment><USER7> Interesting point. I think I've been feeling this lately as a desire to have, basically, smarter compilers. It's actually incredible to me when I think about how many minutes of human thought are wasted among myself and my peers to informally verify facts about our programs.

Obviously, types and tests help. But it's astonishing how much incidental complexity creeps into one's everyday work with our current tools. Under most circumstances telling a computer to do something shouldn't be that much harder than telling a human to do it (assuming a concrete grammar and shared vocabulary).

<comment><USER8> I've programmed professionally in Haskell, Scala and Python in large projects across several jobs.

In my experience, the compiler is rarely helpful at catching bugs. Most bugs, whether in a dynamic typing language or otherwise, are behavioral bugs that occur at runtime without generating explicit runtime errors, just incorrect but uninterrupted behavior.

I always heard people make grandiose claims about Haskell, like if you get your program to compile, it's very likely to be correct and run without error. I've emphatically never found that to be true.

The types of bugs that compilers can help with are very simplistic most of the time. Requesting a method or attribute that doesn't exist, typos, confusion about arguments passed to a function.

In dynamic typing, you also solve these same things in a super cheap and low effort way with unit tests.

Additional behavioral unit tests are where real effort becomes required, and these are needed in any paradigm.

Compilers are also not free. My experience with the Scala compiler for example was awful. It is so incredibly slow to compile that I absolutely would rather give up type checking and just use some cheap unit tests to have a much faster development cycle. When you make 1 or 2 small changes and even a smart incremental compiler setup like zinc needs to recompile 30 code units and it takes ~ 3 minutes before you can run tests, this is maddening, and the cycle repeats the whole time you're working, so it's this constant extremely disruptive expense.

I've had similar thinga happen in legacy code bases with Haskell too.

<comment><USER9> > In dynamic typing, you also solve these same things in a super cheap and low > effort way with unit tests.

I wouldn't call it "super cheap and low effort", given that tests for stuff like "what if it's not an integer?" tend to be a large part of the overall unit test suite in dynamic languages. Just on the amount of code alone, I would say that it's far less effort to express that kind of stuff in types than in tests.

<comment><USER8> If you're writing tests like "what if the input is not an integer" in Python, you're probably doing a lot more stuff wrong. Dynamic typing is useful typically because you rarely need to check these types of issues. Instead you'd have some sort of input sanitizer that is responsible for all such inputs into a large system, and would include what type of failover logic should happen upon receiving a wrong input.

If you're testing all kinds of different functions for argument checks or defensive programming conditions, it suggests a refactor to a central sanitizer pattern, and just one small set of sanitization tests. Other functions can take it for granted that the sanitizer works correctly.

You often need the same thing in statically typed systems anyway for cases when calculating whether an input is valid involves conditions not encoded by the type system (possibly even runtime configurable by the user). So except for all but the most trivial kinds of type validation, this does not actually constitute a difference in effort between the two paradigms anyway.

</comment></comment></comment></comment></comment><comment><USER10> As someone who practices and encourages others to employ formal methods in software development, I'm disappointed to read a post that claims FP has some significant effect on correctness. This has not been established, and does not at all appear to be the case. There are many aspects, including techniques and tools, that can positively affect program correctness. The choice of a programming language or even a paradigm is not high on the list if it is on it at all. Not only does the little data we have not substantiate the hypothesis that FP has a significant positive effect on correctness, there are even significantly fewer anecdotal reports supporting that hypothesis than other, apparently more effective techniques. In short, any connection between FP and correctness is, at this point in time, nothing more than wishful thinking, and the efforts of those who really care about correctness are better spent elsewhere (i.e. _not_ on picking a new language).

<comment><USER11> There are certainly a lot of people who _feel_ that way, though. Especially when the language has an expressive type system. Would you say these languages merely swap one kind of error for another?

<comment><USER10> There are certainly quite a lot of people who feel homeopathy is effective. In both cases, that feeling is a result of a complex process [1]. Explaining why it is _unlikely_ (from a theory perspective) that languages like Haskell have a significant effect on correctness is easier [2], but it, too, requires much more space. What _is_ simple to show is that organizations that develop in, say, Haskell do not produce more correct software more cheaply (or some combination of the two) than those that use other languages.

[1]: For example, in this case, what you call "a lot" may just be the effect of some sort of enthusiasm that results in publications rather than an actual great number of people. Also, the feeling can be the result of programmers facing an unfamiliar language that is challenging them, hence they are required to focus and think more, and that gives them a feeling that they're writing something that's more correct. That the languages catches early some errors may also strengthen this feeling. They're also likely writing smaller programs. I've programmed in many languages, and one of the languages where I get it right most quickly is assembly, probably because I write smaller things, and because I need to focus much more.

[2]: It's relatively easy to classify which program properties can be assisted by the language and which cannot. Those that can (e.g. memory safety and type safety) are called _inductive_ (or compositional). They can be helpful, but the vast majority of correctness properties aren't inductive. Inductive/compositional means that the property is preserved by all primitive operations in the language.

<comment><USER11> Interesting! Thanks for a detailed reply. Since you bring up the cost of software, do you believe that using formal methods helps reduce costs?

<comment><USER10> Formal methods encompass a very wide range of techniques that vary wildly in cost. When the appropriate technique is applied to the appropriate problem, then it can certainly reduce costs, even significantly. But like I wrote in another comment, most of the cost of building software is determined by _what_ we build, not _how_. Tools and techniques, even those that are effective, can only help so much.

</comment></comment></comment></comment></comment><comment><USER12> This is a very backend/algorithm-centric view of correctness.

What about user interfaces? What is a "correct" user interface? If a bug is "unexpected" behavior, and my user interface has several thousand users, how do I manage to not produce unexpected behavior to anybody?

Many software supports workflows and processes in some enterprise, and those workflows shift subtly over time. How does Haskell help me write "correct" software in such a context, whatever that means?

How do I deal with low quality of input data, when I can't ask my product owner to create a matrix of each case of missing data and behavior, because that would be exponential in size?

Phrased another way, the problems with correctness that seem to trouble the author are not the problems with correctness that I tend to encounter often in my work.

The case where there is a clear-cut bug in an algorithm tend to be easier to debug and fix than a bug that stems from several department having subtly different ideas of what certain pieces of data and action mean.

<comment><USER13> A workflow can be modeled using something like a state machine or statecharts. That can be encoded into the type system in a language like Haskell. For front end stuff, you could model your system using something like [0] which uses statecharts. An example of unexpected behavior: Is it possible for a user of your application or site to end up in a state where the only next step is to close it and restart? Or can they properly navigate from nearly any display to any other? While the linked tool doesn't directly answer those questions, it will help you construct your models in a way that you can manually evaluate them more easily or convert to a TLA+ or similar specification and have the computer check that.

Could you, or should you, use formal methods for _everything_? No. But it can be applied pretty broadly if you're open to it, and in fairly lightweight ways (especially these days since there's been a ton of interest over the last few years).

Once you start recording your formal (or more formal) specs, you can also share them more easily. A major problem in coordinating with so many different groups is that they all have their own model for what's going on based on their interaction with the systems. By creating more formalized models that allow for clearer communication (a few statecharts versus pages and pages of prose; flow charts versus pseudocode) you can reduce the communication error between teams/departments. And with all the recent work going into it, and using more capable languages (or tools with less capable languages) you can encode much of this into your program and make correct system construction more feasible.

[0] [https://sketch.systems/](https://sketch.systems/)

</comment></comment><comment><USER14> I've been thinking about this subject for a while and been on the verge of writing about it.

The thing is, I've come to the opposite conclusion.

My conclusion is that programmers have been trained to think about correctness. What they should be trained on and design is to account for inevitable failures. My main paradigm is the floating point design. It incorporates a built-in invalid value, which neatly propagates itself. Objective-C also has this concept of propagating a chain of failures accross function calls.

Your programs will be buggy, your data will be wrong. Design to support propagating it with null actions and detect it at the top of your action loop.

(One of the unfortunate heritage of computin ghistory is the missed opportunity of the binary system imbalance around zero. Both 1-complement and 2-complement have abnormal values. In 1-comp, it's negative zero. In 2-comp, it's the fact that the most negative number has no positive value and is its own negation (- INT_MIn == INT_MIN). It was an opportunity to reserve such value for invalid integers. Then you design your null pointer to be that value too, and NAN to be that bit pattern. Than all your fundamental invalid values map to the same bit pattern that can easily be propagated. Oh well.)

<comment><USER15> "What they should be trained on and design is to account for inevitable failures."

That is pretty much the design philosophy of Erlang. You should check it out if you haven't.

</comment></comment><comment><USER16> Correctness is not an engineering problem. It's an economics problem. As long as IT Industry is able to extract money from their clients while delivering crappy software, they will keep delivering crappy software.

<comment><USER17> If you think of it as an economics problem, it raises a question, one which I'm not completely convinced I know the answer to.

Namely, is crappy software actually more efficient? Does it deliver more value for less cost? Or is it, instead, that crappy software is a bad value, but markets are not transparent enough, and it is too hard for clients to assess whether the software they have received is crappy and too hard for businesses to convince people to pay them for quality?

If you hire a maid who always manages to miss a spot or two cleaning your bathroom, does it really matter? Your bathroom is a lot cleaner than it would've been otherwise, so mission accomplished in the grand scheme of things.

On the other hand, if you hire a mechanic to overhaul your car engine, you might not be able to tell the difference when you drive it home from the repair shop, but if they did a poor quality job, it is going to come back to bite you. Quality is important even if you need to pay more to get it.

Which one of these two things is software more like? I could see it going either way. Maybe it depends. Maybe there are ways you can cut corners that are a win (more value / less cost) and other ways that are a loss.

<comment><USER18> >> If you hire a maid who always manages to miss a spot or two cleaning your bathroom, does it really matter?

It depends on the spot missed: is it contaminated with fecal matter? There you get into the realm of risk management. The problem is that, with software, one bad mistake can leave the user with complete loss of data. Look at Microsoft's recent update debacle; some people lost a great deal of data.

>> Namely, is crappy software actually more efficient?

Never. As the Chinese expression goes: Pay a lot, cry once.

The problem is that the people who pay for the creation of software (i.e. corporate directors) are usually ignorant about all things except for money and the vague desires of their customers. The folks that can specify and implement the systems rarely have the clout to allocate the resources necessary to get the job done well.

>> Which one of these two things is software more like?

Information systems (software that must run over and over again against the same data, often concurrently) are actually engines in that they must withstand stopping and starting; of course, the information engines that run continuously are even more difficult to keep functioning as their uptime stretches on. Therefore, the answer to your question is that software is most certainly more like an engine because information systems _are_ engines, just that their fuel is data (including user input) and their output is information (data made meaningful to human beings) and changes to its information base.

We can all see how the poorly designed information engines of the world accrue ugly cruft that eventually leads to their needing to be "re-built", which, for example for Windows, means re-installing from scratch.

<comment><USER17> Thanks for the thoughtful reply. I feel like our industry is in two camps right now, one that firmly believes quality always pays off and one which believes it is more of a luxury.

Unfortunately, I don't see either side backing it up with anything that looks like real evidence. It's so complicated to evaluate that I don't think anyone really can prove either way. But you can't not have an opinion since it's an important question, so it seems like people join one camp or the other mostly because it suits their personality or working style.

If they take pride in their work and feel disappointment at the prospect of producing code they can't be proud of, they tend to believe quality is worth it in the end. If they are impatient and like to wrap up one thing quickly so they can move on to the next thing, they tend to be in the other camp.

I myself am in the quality and correctness camp, and I really would love to know that it always pays off because that would mean the way I prefer to develop software is also the most practical and reasonable way. But I can't really prove that it's the right view when you consider the economics.

</comment></comment></comment></comment><comment><USER19> > Developers — focusing on correctness. This is the paradigm shift that we are > starting to see.

I haven't seen this yet, but I sure hope to. I'm stuck in the "everyone does devops now" paradigm :(

</comment><comment><USER20> Unfortunately, there are increasingly important areas where correctness isn't even well-defined, including social networks, machine learning, performance, and UI design. Things can go very wrong without violating a traditional algorithmic correctness constraint.

But it helps to eliminate large classes of bugs where you can, so you can concentrate on other things.

<comment><USER21> I agree. Reasoning about correctness can be a very powerful tool for some of the algorithmic parts of a system. But large parts of a system are not really amenable to formal reasoning about correctness.

As an example, if you try to write our own web search engine, the linear algebra or neural network operations you may be using are certainly amenable to mathematical reasoning, but the relevancy of the returned results is not something you can prove mathematically.

And in my opinion, this fact often leads "correctness" fanatics to retreat to safe areas where their methods work, and snipe at all the rest of the world. Characteristically, the article quotes E.W.Dijkstra, whose much beloved notes are full of explorations of mathematical toy problems, and catty dismissals of anybody trying to make real world use of computers.

When Knuth was dissatisfied with the results of early computer typesetting, he spent years of his life developing TeX. Meanwhile, Dijkstra kept hand writing his papers and having staff turn them into printed form. That, to me, is the epitome of the "correctness über alles" mindset.

<comment><USER13> That seems to be an unfair assessment of Dijkstra's interests and activities. He made major contributions in algorithms, language design, concurrent computing, and distributed contributing, among other fields. He is basically the face of the Structured Programming movement (and coined the term) which led to the common design elements of many languages used today (both the presence of certain elements, and the absence of others).

I think it'd do you some good to read a bit more of his work and the history of computing.

<comment><USER21> There's a good chance I have read more of his work than you have.

Yes, Dijkstra made major contributions to algorithms—exactly the "safe corner" where correctness thinking applies. Ironically, one of his contributions was to the concept of semaphores. I sure don't hear any of Dijkstra's fans claim today that if distributed programs just used semaphores, all our concurrency problems would be solved.

Another important contribution: The Banker's algorithm, of which Andrew Tanenbaum observed (Modern Operating Systems, 2nd ed):

> The banker's algorithm was first published by Dijkstra in 1965. Since that > time, nearly every book on operating systems has described it in detail. > Innumerable papers have been written about various aspects of it. > Unfortunately, few authors have had the audacity to point out that although > in theory the algorithm is wonderful, in practice it is essentially useless > because processes rarely know in advance what their maximum resource needs > will be. In addition, the number of processes is not fixed, but dynamically > varying as new users log in and out. Furthermore, resources that were > thought to be available can suddenly vanish (tape drives can break). Thus in > practice, few, if any, existing systems use the banker's algorithm for > avoiding deadlocks.

... which is pretty much my argument: Dijkstra picked himself the neat little corner that WAS amenable to mathematical reasoning, at the expense of real world applicability.

One of Dijkstra's contributions to language design was resigning from the Algol 68 committee. It might do proponents of formal methods good to reflect on why that language was less than a stellar success, given how strongly it relied on advanced formal descriptions.

But the question is not whether Dijkstra contributed to algorithms, language design, or concurrent+distributed computing (he certainly did). The thesis that the Article presents (and supports by quoting Dijkstra, who did agree with that thesis) is that formal methods apply universally in system design, and that today's software woes are largely the result of insufficient application of formal methods.

It is there that I disagree, and that Dijkstra kept pontificating about despite having abolished programming and using computers around the time he started focusing on formal methods. And that detachment from and disdain of the actual practice of computer use is what renders his later opinions suspect to me.

</comment></comment></comment></comment><comment><USER22> The biggest problem is communication and setting expectations. I constantly hear/see people saying "oh that will be quick!" without any real evaluation of the work. Simply saying "this is hard, it will take some time" makes focusing on correctness a hell of a lot easier. In no uncertain terms: don't be a pushover. If it can't be done well in the amount of time you suggest, don't say that it can be. You're just digging a hole for yourself (both present and future) and any one you work with.

<comment><USER23> This is easy to say and not unheard of, but in organizations it is common (in my experience at least) that if you say too often "this is hard and might take some time", people will just start to bypass you (and/or your input/judgement) in order to get stuff done quickly but less correctly.

<comment><USER22> If you explain why they're less likely to. And if they push back, just say "okay, then I need your okay to rush on this so we can get it done—keep in mind that it may have flaws and I'd need you to take responsibility for those."

</comment></comment></comment><comment><USER24> I hope this article strikes a chord.

Two quibbles: Haskell is prone to something that might be considered a class of bug that Rust avoid: the space and time performance of idiomatic Haskell code can be very surprising.

I also wonder at the possible answers you give to " "When" would you say that the software had a bug?" \- the most obvious answer to me is when the commit is made to the codebase that introduces possibly observable incorrect behaviour.

<comment><USER25> I think it's experimental right now, but Idris (which I consider the "Child of Haskell"), has basic support for linear types [1], which could at least help the space-prediction problems. Doesn't hurt that Idris isn't lazy-by-default either.

My point is that I actually think that Idris could end up being successful in an industrial sense, due to the fact that it gives you all the correctness guarantees of Haskell (and more), but has managed to (thus far) avoid a lot of the cruft that has built up in the ~30 years Haskell has been around. Fingers crossed.

[1] [http://docs.idris-lang.org/en/latest/reference/uniqueness- ty...](http://docs.idris-lang.org/en/latest/reference/uniqueness-types.html)

<comment><USER26> This stuff feels like a proof of concept that isn't really integrated to the rest of the language (Kinda like OCaml's OO). For example, it's unfortunate that Type, UniqueType and BorrowedType are different kinds (in Rust, they are the same kind; stuff that isn't "unique" just implement Copy)

Rust's advantage is that its borrow system, with reborrowing rules and such, feels much more ergonomic.

<comment><USER25> You're not wrong, but the fact that some work is being done on this is at least a good sign I think. A proof-of-concept is necessary before you can integrate these things organically into the language, and I that as a result it could be pretty interesting.

If I knew anything about elaborate type systems, I would try and address your complaints. Sadly, my knowledge of linear logic and whatnot is very ad hoc.

</comment></comment></comment></comment><comment><USER27> There are several strongly typed (and functional) languages being built for the web that compile to JavaScript:

       ReasonML - OCaml - https://reasonml.github.io
       PureScript - Haskell - http://www.purescript.org
       TypeScript - https://www.typescriptlang.org
       Scala.js - http://scala-js.org
       Elm - https://elm-lang.org
       ghcjs - Haskell (https://github.com/ghcjs/ghcjs)

This podcast covers many of them:

[http://bikeshed.fm/192](http://bikeshed.fm/192)

<comment><USER28> Don't forget Fable - F# - [https://fable.io](https://fable.io)

</comment></comment><comment><USER29> I just got off a job where my boss was under the impression that bugs are because of incompetence or laziness. He literally expected the code I produced to be of perfect quality, or else, using his words "you don't know what you're doing". I told him about how most major companies have QA teams and engineers spend a lot of time fixing bugs and reviewing others' work.

My (now former) boss was non-technical. Wondering if anyone else has encountered such a person? Coming from other industries, is it common that people view software engineers as somehow sloppy or lazy in their work? Is it really true? Is it unreasonable to expect a competent engineer produce working, correct & bugfree performant code on the first try? I've definitely had my moments of brilliance where it all "just worked" but that usually isn't the case and I'm wondering if it could be something wrong with me?

<comment><USER18> Software is still very much a craft, as opposed to an engineering discipline. As such, we each have to learn, over time, how to produce defect-free code. For the capable, concerned and intelligent developer, this means that each new bug leads to new ways to ensure that such bugs will not happen again in the future.

So, no, like life itself, we all make mistakes in our systems. The important thing is that we don't make the same ones over and over again. In software development, that means adjusting our development methology to make such bugs less likely in the future. That is why software development is both the most challenging and most rewarding of careers. Of course, I _may_ be a bit biased ;-)

As far as encountering crappy managers, I'll just say that I can count the good managers I've had on one hand and still have a couple of fingers left over. As to your former manager's particular flavor of belligerence, I haven't had that one specifically, but there are very much uglier variants, my friend. My understanding is that one cannot be made a manager unless the person is willing to prioritize money over human beings and it doesn't take a biblical scholar to see how that is causing so many problems in the small and large across the world. In the small, that attitude manifests itself in many ugly personality traits, while being the foundation of the entire structure and intention of the for-profit corporation where the vast majority of us are forced to find our work.

</comment></comment><comment><USER30> I'm honestly having a hard time figuring out what the take-away from this article is. It claims to to lay out a paradigm but it doesn't really seem to lay it out all that clearly.

</comment><comment><USER31> Software engineering is still mostly a craft, not a type of engineering. We should not start another FP versus OOP war. I think it misses the point. We should start thinking about languages where it is possible to precisely define implementation, like: X implements Y using representation R under conditions C. For example, a CPU instruction for adding two numbers works with modular arithmitics presuming a certain representation of numbers, nowadays, usually 2-complement with a certain power of 2. If you want it to represent the addition of two numbers then that is only possible if the sum of the two numbers does not cause an 'overflow'. There are algorithms to implement additions of much larger numbers using other representations and combinations of machine instructions. Writing an implementation for a certain problem, like summing a sequence of numbers, should begin with specifying the characteristics of the kind of sums one want to calculate. If one would have a library of implementation, one could engineer a 'correct' solution, without having to write an implementation by yourself.

</comment><comment><USER32> I started learning to write Haskell a while ago. My current reflection is while it's easy to start learning to write simple code and correct code it a much larger step to actually be able to write performant code that is generic. Performant idiomatic Haskell requires a good enough understanding of the functional paradigm.

<comment><USER33> I experienced the same thing. Once you get over the practical application of monads hump it becomes a lot more like the progress experience in other languages. You don't need to achieve your "monads are a burrito" moment to successfully write complex Haskell, you just need to be able to cargo cult while recognizing that you are doing so and the understanding will slowly accrete. That said, Haskell is the first language I've worked in where there are periodic learning cliffs (lenses stand out here) where when you scoot into a slightly foreign domain you need a few days of study. I still think the juice is worth the squeeze though since once you learn how to do the thing then doing the thing correctly tends to be easier in more forgiving languages.

</comment></comment><comment><USER34> "Make it work, Make it right, Make it fast." \- Kent Beck

My take on correctness is this: for ethical reasons, a developer should __never __be the final say on whether their solution is correct.

The users, whose voices are concentrated in the one and only Product Owner, should always have the final say on the correctness of our production code.

The tricky bit is proving to the Product Owner and ourselves that we have met the users' expectations.

I believe this is where testing and refactoring comes in. Language and programming paradigm choices are window dressing if the actual code is a slapdash mess with no formal proofs of correctness.

Until some genius comes up with something better, those proofs must take the form of fully passing, comprehensive test suites.

</comment><comment><USER35> > what is the language and mindset of "objects" with dynamic dispatch > providing you apart from an endless stream of bugs that seem to keep > reoccurring everytime you try an evolve the software to introduce a new > requirement?

The only mindset required to avoid long-term bugs and maintenance problems is a _personal_ conscientiousness, a _personal_ approach to defensive programming based on (ideally, extensive) _personal_ experience, which will inevitably include a very-hard-earned skillset of _decoupling_.

Everything else is trivial (borderline bike-shedding) in comparison.

Static types, OO, functional programming, agile, TDD, etc, etc -- these will not save you from your own _personal_ deficiencies. Only long, hard _practice_ will.

A skilled practitioner can build a large, complex system in Visual Basic or PHP using entirely OO idioms. Now he or she may do a somewhat quicker (and happier) job if he or she is able to employ some convenient tools of the trade (eg syntactic niceties, functional-orientation, immutable libs, testing libs, etc etc etc). But the quality and manageability of the system is entirely a function of experience-based skillsets that far transcend the particulars of the programming paradigms that we currently have available to us.

I've seen many a strong static typer, who thinks they have found God, make an absolute mess of everything _including_ its leverage of the type system over time.

I've seen many a developer write OO code within a functional language and vice versa and the success or failure in these cases is irregardless of even the slight misapplication of the tool in hand.

Can you articulate a real world problem into a sound domain model? Can you decouple the behaviors of your system into composable parts? Are you conscientious enough to informally "prove" the transformations (ie git commits) you make to your software system?

If you can do these things, you avoid a mess of a system _regardless_ of your PL and programming paradigms.

If you cannot do these things then no matter what kind of process you bring to the table, you will not be saved.

<comment><USER36> This makes a whole lot of sense to me. However, one of the elements of truly productive learning is _focused_ practice; that is, practice with mindfulness and intentionality directed at a specific element. One won't necessarily get any better at decoupling unless it is specifically practiced. To that end, _how_ would one truly practice the skill of decoupling? Or maybe, what resources or heuristics or strategies would you suggest to help draw the lines between behaviours or modules?

The first thing that comes to mind is Gary Bernhardt's talk on Boundaries, or "functional core, imperative shell", but I'm not sure that this is entirely what you're discussing here.

<comment><USER35> I think you're hitting the nail on the head. It is specific and _focused_ practice. I've been thinking about working on a book or set of blog posts or something to try to flesh out what a regimen would look like.

Most writing on software of course is technical (on PLs, algorithms, processes) but there seems to be very little to guide the software practitioner who really wants to seek mastery.

> what resources or heuristics or strategies would you suggest to help draw > the lines between behaviours or modules?

The best I can come up with for teaching this would be to create some concrete "problems"/scenarios that would exercise the skill set, and then reveal various ways the problem could be decomposed and quantify the degree of decoupling and even reveal the practical consequence of the coupling by introducing new "requirements"/dimensions to the scenario.

</comment></comment></comment><comment><USER37> I fix software all day, but very few of the defects are really about "correctness" in the strict sense of code implementing the specification incorrectly. Most often it is simply that the "specification" was bad/wrong/incomplete in the first place.

I appreciate that in some cases the specification is straightforward and the challenge is to implement it correctly. But I think in most software development it is really the other way around: Designing/specifying the expected behavior is the hard part. It is pretty straightforward to implement this behavior correctly.

</comment><comment><USER38> Without a specification the correctness of a program is necessarily undefined. This means that most buggy software isn't incorrect. In fact most buggy software isn't even unpleasant, at least insofar as users prefer using it to not and continue to pay.

It follows that as commonly used the term bug refers to a pleasantness defect rather than a correctness defect. And this stands up to our day to day experience. In the overwhelming majority of cases users report bugs because they are displeased by a behavior, not because they studied the specification and discovered a correctness error.

</comment><comment><USER39> I know this is a nit, but the incorrect use of commas is making this a really tough read for me...pet peeve of mine, I suppose. Anyway, salient points: use the right tools for the right jobs and all that jazz. Depends on the required level of correctness for the application. Are we coding for an airplane control system, or a slack bot that lets us know when the build biffs?

</comment><comment><USER40> If you notice bugs, you should do more maths and get tweaking. Wait... something's not quite right there.

On a more serious note: the biggest barrier to correctness I've encountered is doing things I don't understand. I also care less and less for being paid to understand particular things, it's so much worse than just being paid to do work.

</comment><comment><USER41> Yet another generic and sophomoric "the paradigms and type systems I prefer are so much better guise!" Piece.

This one is particularly obnoxious because he's aware of the tribalism and thinks that by mentioning it then his post is magically no longer merely more fuel to the decades-old flamewars.

</comment><comment><USER42> Haskell has existential types, which are specifically used to implement dynamic dispatch. The problem here is weak type systems & excessive statefulness, not dynamic dispatch per se.

</comment><comment><USER43> I disagree, based on this articles logic everyone should strive for a perfect codebase which is impossible.

You will always run into issues because code just like matter decays to entropy.

</comment><comment><USER44> Pretty good piece that brings to my mind software craftsmanship principles.</comment>


Show HN: Dead simple, Live updating, Facebook API monitors - <AUTHOR> https://graphmon.com/

<comment><AUTHOR> My first SaaS application. I have heard so much complaining about this on the Facebook Developer Forums that I built a service around it.

Release post: <http://blog.knoopgroup.com/graph-mon-launches>

Technology Stack: Linode, PHP/MySql, Stripe (Payments -- you guys rock!)</comment>


Bot for Slack that sends state-of-the-art papers - <AUTHOR> https://sotabot.com <comment><AUTHOR> SOTAbot for Slack which allows you to easily query arXiv.org for the latest state-of-the-art papers and subscribe to updates</comment>


Show HN: Effects of House and Senate Bill on California Residents - <AUTHOR> http://flu.io/2018-tax-bills/ <comment><USER2> Nice tool, but a lot of the market is being altered in a way that blows out these savings. For example, I run my business and my overall tax rate last year was 28%. However, when I account for healthcare premiums and hitting my out of pocket max, I was over 40%. According to the calculator, my tax burden is reduced slightly under the plan. That said, my health costs for next year went up 37% and I'm receiving worse coverage. As such, I will be at a net loss for 2018 and it looks like it will become worse in 2019 if the individual mandate is eliminated.

So, no, I don't expect a calculator to be perfect, but I can't help but stress how important the changes in healthcare costs for self-employed are under this plan.

<comment><USER3> My view is that if the individual mandate is eliminated then other insurers will come into the market with cheaper plans that don't include everything (Eg mental health) so health costs for healthy self-employed folks will go down. The thing I've always hated about Obamacare was how healthy self employed folks are subsiding the unhealthy people, this happens because most people in their 20's or 30s are covered by work plans which have a better risk pool.

<comment><USER2> I'm sure it will for some people. That said when I was 21, I was diagnosed and treated for stage 3 melanoma and I can assure you the drugs that I took during that year were not cheap. At this point, it's been more than a decade and I'm wonderfully healthy, but I'm considered a high-risk because of my past with cancer.

Now, there's a very valid moral question as to whether or not I'm entitled to have my healthcare subsidized by others in a pool and I'm fine having that conversation. From an economic point of view, I'm just shy of my mid-thirties with an advanced degree, been in the black with a self-funded business for the last 4-5 years, and have the potential to release products in the near future that could return millions in tax dollars. However, I may be robbed of that opportunity if I'm unable to purchase health insurance that covers cancer. Certainly, that's a frustrating proposition given that the only major misstep that I had was being unfortunate enough to become afflicted with a disease not under my control.

And, just in case someone is curious about high-risk pools, I actually currently carry insurance from one because the ACA marketplace in my state does not offer PPOs and I have one regular appointment out of state. Anyway, the coverage and cost of high-risk pools varied wildly from state to state. As an example, since I'm familiar with TX, prior to disbanding the pool, the law allowed high-risk individuals to purchase insurance at twice the prevailing rate from the pool. If I recall correctly, its pool used a PPO, which is no longer found on the exchange, so we'll use a gold plan EPO to approximate. In Harris county, the current premium for that rate is $429/month with an out of pocket max of $6350. If we went back to the old model of twice the prevailing rate, I'd have to budget $16,646/year, which isn't all that far off from what it used to be. Now, that's just TX and different states had different rules. In the state I'm currently in, the 2018 premium will be $514/month with a $5000 out of pocket max. And, to be clear, there is cheaper health insurance available, but my perspective of coverage and costs changed dramatically after my illness. Health insurance doesn't mean much if it doesn't cover the doctors you trust for a price you can afford.

Anyway, my point is that just because someone is in their 30's and healthy doesn't mean that their coverage will become cheaper or even attainable. Further, this has broad economic implications because it will quite simply force many of us out of the self-employed market because it's not responsible to carry an insurance plan that does not provide comprehensive coverage. This tax plan has been touted as helping small businesses, but it may end mine depending on what happens to the market in 2019.

<comment><USER4> My situation was crazy. I was denied insurance right before the ACA took effect because of a "preexisting condition" that I never thought about. I have what for all intents and purposes is very mild cerebral palsy. As an adult, I've never had any complications, I was in excellent shape - I had been a part time fitness instructor for years and ran two half marathons the year before. The only noticeable effect of my CP is one of my hands.

</comment></comment></comment></comment><comment><USER5> I guess this sort of misses the main point, IMO.

Sure, my taxes will go down, but I have grad student friends that may have to drop out because they now have to treat waived tuition as income, and pay ~10k tax on it somehow with their 20k-30k stipend they get. And I've got friends with kids that are going to see their tax burden go up by thousands.

Meanwhile with all of this 'simplification' and 'getting rid of subsidies', we're not doing the same for corporate or high income 'subsidies'.

<comment><USER6> _I have grad student friends that may have to drop out because they now have to treat waived tuition as income_

If this happens, this will be a huge failure on their institution part. The only reason their tax bill might be affected is due to creative accounting practices of universities, who use the tuition waiver as a way to skim more money from the grants. Universities will just start offering education for free instead of waiving the tuition, and will find a new accounting trick to take money from federal science grants in "overhead".

<comment><USER7> 1) Why does the tax bill assume that treating waived tuition as income will raise revenue, then, if all universities will just switch to different accounting methods? Or is this one of the many parts of the tax bill that will actually increase the deficit but needs some kind of plausible cover until the buck can be passed?

2) "creative accounting" and "skim more money" are pretty ridiculous ways to describe how research grants work. It's a system like any other. Disrupting it for no particular reason is anything but conservative.

<comment><USER8> Because that's how the game is played. When scoring the effect of a tax bill, you were not allowed to take into consideration changes in behavior

<comment><USER9> Didn't they get $500 billion worth of new revenue credit in the JCT score exactly by taking into account changes in behavior (aka dynamic scoring)?

</comment></comment></comment></comment></comment><comment><USER10> I'm guessing this covers just 2018/19 and not the lead up to 2027. A lot of these individual income tax cuts not permanent, and are set to expire in stages towards 2027. The bill is going through reconciliation with senate rules restricting deficits increases after 10 years (the bill is deficit financed to the tune of $1.5 trillion - which is insanity).

Pretty much the only permanent features of the bill are the corporate rate, the pass through shenanigans, removal of estate tax, and removal of a number of deductions such as SALT, etc... also sabotaging the ACA marketplaces by repealing the individual mandate.

<comment><USER11> This is a prominent criticism, but it strikes me as fundamentally weird to say, yeah, you're right that these are tax cuts, but the cuts expire in 10 years. This is government. Who knows what the world will look like in 10 years? Would, say, 20 years be better? Sure, I guess. But 10 years is a pretty long time. It's pretty difficult to plan most personal finances out that far, anyway. Who knows what your own life will be like in 10 years?

Isn't the complaint that the cuts don't last longer tacit approval of the cuts?

<comment><USER10> As another commentator said, its not really tacit approval of the cuts. The point I and others are making is that these cuts are clearly designed to be a political smokescreen for midterm elections. These cuts are deficit financed giveaways that in most cases will disappear, and in many cases income tax payers will see tax increases on income in later years to finance the permanent cuts elsewhere.

The actual goal of the bill are the changes the congress choose to be permanent, which are the cuts on corporate rates, pass-through rates, and estate tax, which benefit a very small group of tax payers.

<comment><USER11> I think I'd want to argue that in tax policy, anything nominally permanent isn't and anything set to expire in 10 years likely won't.

I'd be worried if this were the last ever tax bill, but since it isn't, and since 10 years is a pretty long time, I don't think it's so bad (even if I agree with you about some portions (e.g. the elimination of the estate tax)).

</comment></comment></comment></comment><comment><USER12> You should consider showing how they change over time, since a lot of the personal deductions will be phased out.

<comment><USER13> Definitely important. A lot of people will get slight benefit that will phase out over years. Corporation tax cuts never expire though.

</comment></comment><comment><USER14> I love calculators. What I haven't seen yet is a calculator that shows you where the money originated from. How much of my tax deduction is new debt, vs money stripped from Medicare, Social Security, College Graduate deductions, etc. It's not enough to know how much more _I am getting_ , but where the money originated from.

<comment><USER15> money is fungible. You can't trace it to a specific origin.

<comment><USER14> That's pure pessimism. You can compare the previous-year government budget and next-year government budget and work out the gaps. Sure, the money might have all sloshed together in the general fund, but the _average_ values are all matter for analysis on an individual level.

</comment></comment></comment><comment><AUTHOR> Hey, I built this in my spare time over the past few days to calculate some of the basic implications of the new House and Senate Tax Bills on personal income taxes.

This is open source and available on GitHub here: [https://github.com/brockwhittaker/House-Senate-Tax- Bills/](https://github.com/brockwhittaker/House-Senate-Tax-Bills/)

If you have any questions or issues, you can open them on GitHub or contact me at: email@example.com

<comment><USER16> I just filed this issue: [https://github.com/brockwhittaker/House-Senate-Tax- Bills/iss...](https://github.com/brockwhittaker/House-Senate-Tax- Bills/issues/2)

You are not properly changing the deduction for married people. You have a single static value that gets used and is the "single" setting..

That ore I read the code completely wrong (which is always a possibility) =)

</comment></comment><comment><USER17> This doesn't count AMT, everyone in the state who itemizes and makes more than $200k has to pay the amt essentially making deductions completely useless. A NYT article showed how elites in Cali and NY will lose money but I calculated various incomes and the only people who would lose money are the ones making $1M plus. The article completely excluded that fact. Steph curry for instance will lose over a million in this new bill because he doesn't pay AMT currently and deducts $2M stats taxes. Not being able to deduct that plus only a minor drop in income tax brackets screws him.

This is not a bad bill. Very few people wil have to pay more and those that do are making $1M + and they'd slightly see a decrease while people with $5M+ will see a more significant decrease, so I'm not concerned. That being said, I think there should be even a bigger tax cut on the middle class and greater deductions for disabled seniors. Family making $50k with 2 kids barely saves more than a family $35k with 2 kids especially if they have Medicaid while the other family has insane premiums and deductibles.

<comment><USER18> If everyone pays less, where is the money coming from then?

<comment><USER19> They claim it will come from a huge economic boom which will be unleashed by cutting corporate tax rates.

However, a proposal to automatically undo some of the changes if the "guaranteed to pay for itself" plan fails was scrapped. I'd rather have challenged those claiming the cuts would pay for themselves to put up or shut up: force retirement if the growth didn't appear.

<comment><USER17> That was political grandstanding. Imagine if some war broke out or something like the financial crisis happened in 3 years. Already poor economic growth, 401k crashing, job cutting, businesses losing money and all of a sudden taxes go up 15%? It would sink the economy and force govt to pay trillions. It was a comically absurd idea that becomes easily refuted with 5 seconds of thought. Unfortunately, 99% of politics is grandstanding, just hope that things that pass into actual law are rational.

</comment></comment></comment></comment><comment><USER20> I would love this even more if you could input your itemization total. This tool is so much better than the ones I've seen previously, and actually it's kind of ridiculous that congress can't create this tool. Being educated about the personal effects of this bill is just good governance.

</comment><comment><USER21> Great calculator! Just what i was looking for. I like the simple UI.

But, you should add the state tax as well as the FICO and social security tax/ medicare tax, to show a more complete picture.

</comment><comment><USER22> Thanks for doing this.

What about mortgage interest and property tax?

EDIT: I'm skeptical this is right. I'm in a high tax state, with high property and mortgage interest. Yet this shows me between 1% and 12% better off despite every report I've read and www.republicantaxcalculator.com showing me much, much worse off.

<comment><USER23> Not taking property and mortgage interest into account, this tool is misleading at best! I just did my projections. This calculator shows our family will benefit slightly, when in fact our taxes will increase approx. 25K or 40% per year.

<comment><USER22> That's what I was expecting too. How did you do those calculations, if you don't mind sharing? With an accountant, the hard way with a spreadsheet, or (please!) some magical accurate online calculator with 5 fields and a big button?

Thanks!

<comment><USER23> I apologize for missing your question.

Well, first I used the new brackets to calculate the tax and found us slightly in the black. Then I dug out my last year tax return, added four numbers -- income tax, property tax, mortgage and donations -- subtracted proposed 24K standard deduction and applied our new bracket (35%) to the difference. Subtracted the first number. Felt robbed.

That said, I'm waiting for my CPA to get back to me with the projections for 2017 along with the tax reform impact estimate.

</comment></comment></comment></comment><comment><USER24> This is not accurate at all because it does not include things like the per- child tax credit which has a dramatic effect on the taxes you pay.

<comment><USER25> Indeed, the source code only considers tax brackets, the personal exemption, and the standard deduction. I've read of an increase of $650 in the per-child tax credit combined with the loss of the per-dependent personal exemption and an increase in the standard deduction. If your last $4333 of annual income is going to be taxed at rate of 15%, then a $650 credit is just as valuable as a $4333 deduction or exemption and thus slightly more valuable than the current $4050 personal exemption. Thus, contrary to this calculator, middle-class families with lots of kids will not get big tax increases.

</comment></comment><comment><USER26> Can someone help me out here? Last year I paid 5-figure state income taxes (CA) which, as far as I understand, is no longer deductible from my federal income. So if my federal income taxes are ~30% then I'd expect to have a $3000+ tax increase from the loss of that deduction.

Yet this tool implies I will get a tax cut.

What elements of the new bills will result in a tax cut large enough to offset the loss of the SALT deduction? I am single, living in CA, no dependents. I do not own a business.

<comment><USER27> As a sibling noted, your standard deduction will double. That likely isn't enough, so I would guess that juggling the income limits in the different brackets is what made up for the difference.

My state income tax paid is more than even the new standard deduction amount, and it showed a tax cut for me as well, so I can only assume the bracket reorg is what did that.

In the end, my income & tax situation is more complicated than the simple single slider this calculator gives, so it doesn't really tell me much that is useful.

</comment></comment><comment><USER28> Would love to see this over time. The tax breaks fall off pretty significantly after a few years for the average person.

</comment><comment><USER29> This is interesting, but it needs more data input for a more accurate picture for those who own a house, or hope to own one soon. Particularly those in the Bay Area, where the 10k SALT cap wouldn't be too difficult to run into.

<comment><USER30> It's not a 10K SALT cap, its a 10k property tax deduction cap, the itemized deduction for state and local income taxes are eliminated in both House and Senate versions as far as I understand.

<comment><USER31> Correct although they're now considering adding it back... (who knows how they would pay for it)

<comment><USER32> Lets squeeze the college students more...

</comment></comment></comment></comment><comment><USER33> Looks like it got hugged to death.

<comment><AUTHOR> It should be fixed now! Didn't work too well on a DigitalOcean server w/ 512mb RAM and 100 requests a minute. :)

<comment><USER34> Have you scaled the size of the server or added more servers? Would be interesting to know some stats as I'm thinking between DO vs Vultr

</comment></comment></comment><comment><USER35> Would be nice to include a field for long-term capital gains. Removal of the state income-tax deduction changes the effective tax rate for those gains, which would help someone decide whether to realize those gains in the remaining weeks of 2017 or else to keep holding.

</comment><comment><USER36> I will be itemizing this year, it would be nice if I could add some of those writroffs in with this calculator. In my case, it's the difference between my taxes going down or up

</comment><comment><USER37> his github project if you want to run it locally: [https://github.com/brockwhittaker/House-Senate-Tax- Bills/](https://github.com/brockwhittaker/House-Senate-Tax-Bills/)

<comment><USER38> I was about to ask this since his site is taking a pounding ATM.

EDIT ==== How in the heck do you run it?

<comment><USER39> npm install && npm start

</comment></comment></comment><comment><USER32> This seems to imply that families with 2 kids and a median household income of $60k will owe a extra $5k in taxes?

Edit: misread it. Not $5k more but 15-20% more.

<comment><USER40> More kids results in less "tax benefit"... is that correct/intentional?

<comment><USER32> I think it is because the exemptions are eliminated. Of course I don't know how accurate this calculator is but if you enter my assumptions above for a typical middle class family of 2 kids and $60k income, nearly every state has higher taxes.

<comment><USER41> There's no way this calculator is accurate.

Take A married couple with 2 kids with $60k AGI, all W2.

Filing in 2017, standard deduction:

60k - 12.7k deduction - 16.2k exemption = 31.1 taxable income, with ladder rates that's $3,733 - $2,000 in child tax credits for $1,733.

Filing in 2017 with a 24,000 (!! out of 60k!) itemized deduction to match the new standard deduction:

60k - 24k deduction - 16.2k exemption = 19.8k taxable income, ladder rates make it $2,038 - $2,000 in tax credits for a grand total of $38 in taxes owed.

Current Senate proposal:

60k - 24k standard deduction = 36k taxable income, with proposed ladder rates that's $3,939 - $4,000 child tax credits, you owe $0.

Hard to see a scenario where: a) a 60k family is itemizing that much, and b) the child tax credit doesn't significantly increase.

</comment></comment></comment></comment><comment><USER42> This site completely hoses the back button, and doesn't give any kind of future look, rendering it largely pointless and annoying.

</comment><comment><USER43> Nice UI, not very useful / actionable in terms of actual insights.

We've had a couple of threads about Excel lately and the power/beauty of Excel is that it'll be butt ugly but someone with zero programming knowledge but extensive tax knowledge can build a model for you that'll give you great actionable insights with decently quick turnaround.

<comment><USER44> ditto, it would be nice to show the intermediate calculations in MathML or something. Let us see the flow of money, that is more interesting than anything else.

</comment></comment><comment><USER21> The calculator shows people who make a lot of money 1million+ and very little money < 50K will have a bigger federal tax bill.

they'll only be able to deduct 10k of the prop taxes too

<comment><USER45> But let's be clear, US median household income is $59,039, so the $50K you cite is not actually "very little money" but rather a normal income _for a household_. Agreed that in reality, it is very little money when we take into account CoL, household debt, etc. This bill, combined with the ongoing burden of health care expenses, will continue to cripple the typical US household.

Source: [https://www.nytimes.com/2017/09/12/business/economy/income-r...](https://www.nytimes.com/2017/09/12/business/economy/income- rebound-recession.html)

</comment></comment><comment><USER46> Holy history, Batman!

I dragged the sliders around for a minute, and my browser history was completely decimated by identically-named entries.

Maybe replace the existing state rather than pushing the new one?

</comment><comment><USER47> These tax bills are hilarious. For the majority of us, it is like moving money from your left pocket to the right pocket. There is no savings whatsoever besides bad healthcare for all. This bill should really be called "Corporations are people too, my friends" bill as it really gives away money for rich companies who honestly do not need more money given Apple, Amazon, Facebook and Google are becoming trillion dollar companies.

</comment><comment><USER48> huh. so i'm going to benefit from these tax changes.

interesting.

<comment><USER49> Most people will. What most people are getting mad about is that a lot of the personal deductions will expire in the future, and that the ultra-wealthy are getting a tax discount as well as the average person.

<comment><USER50> It looks like filing single with even one dependent drastically increases the tax burden in both plans.

Additionally, the House plan raises the tax burden in those making less than 30k.

<comment><USER51> Adding three dependents to mine raised my tax bill 20%.

Thanks Obama!

</comment></comment></comment></comment><comment><USER52> Is the site broken for anyone else? I see {{ STATE }} when I get into the page and a bunch of template variables in the page. None of the controls work and I have disabled my adblock, https everywhere, etc.

EDIT: Never mind, false alarm

<comment><USER53> It looks like that until all the javascript loads. The site is currently being hugged to death so it takes a minute.

</comment></comment><comment><USER54> The result is very different from this one[1], for a family with 2 kids.

Which one is more close to the fact?

[1] [http://taxplancalculator.com/calc](http://taxplancalculator.com/calc)

</comment><comment><USER55> And it's down. This is why we can't have nice things.

</comment><comment><USER56> Nice work. You should consider making the state field optional. There is a large expat community who still need to file US taxes (but not state taxes).

<comment><USER57> Just pick a state without income tax, such as Florida.

</comment></comment><comment><USER58> The media has been portraying this tax bill as a major break for billionaires, but these charts don't seem to show that.

<comment><USER10> Two reasons for that:

1) These are the first year income tax cuts, but most of these income tax cuts are getting phased out over time after the first year. By 2027 some of these income groups may see tax increases, and most won't see much benefit at all.

2) The temporary income tax cuts are peanuts compared to what is happening with the corporate rate, pass-throughs, capital gains, and estate tax (all permanent), which benefit people that own companies and/or inherit wealth - which is predominately the richest people. The richest people in the country don't get their wealth from their income, but rather from returns on capital.

<comment><USER59> I thought capital gains rates weren't changing?

</comment></comment></comment><comment><USER60> Great tool

If I can feature request, would love to see city/local taxes accounted for, especially with the SALT deduction removed.

Good work!!

</comment><comment><USER61> Template is {{var}} on iOS Safari

<comment><AUTHOR> Fixed now. Was getting hugged to death. :)

<comment><USER62> Site appears to be hugged to death again.

</comment></comment></comment><comment><USER63> link is dead. Please check if your server is dead. any alternate links?

</comment><comment><USER64> Would be great if this supported my situation, single member LLC (pass- through). Though probably not popular here on HN, the bill's goal is to reduce the burden of taxes on small business and corporations to promote repatriotization of capital back to the US.

<comment><USER65> >reduce the burden of taxes on small business and corporations to promote repatriotization of capital back to the US.

The horror of giving a fair share to the country that supports your corporation.

I think we should fine companies like Apple who bilk the US and refuse to bring back hundreds of billions until they get a sweetheart deal.

<comment><USER64> It's not a sweetheart deal. US corporate tax rates are some of the highest in the entire world. It is just smart by Apple to ship capital off until it makes business sense. I suspect we are not going to agree about this though.

<comment><USER66> This is nonsense. The effective tax rate lands right in the middle of most OECD countries.

[https://www.npr.org/2017/08/07/541797699/fact-check-does- the...](https://www.npr.org/2017/08/07/541797699/fact-check-does-the-u-s-have- the-highest-corporate-tax-rate-in-the-world)

[https://www.cbpp.org/research/federal-tax/actual-us- corporat...](https://www.cbpp.org/research/federal-tax/actual-us-corporate- tax-rates-are-in-line-with-comparable-countries)

<comment><USER64> Did you even read the article you linked? There is a reason all the bay area tech companies have offices in Dublin Ireland... 12.5% corporate rate.

> The long answer: The U.S. has the highest top corporate tax rate at least > among advanced economies. Compared with nations in the OECD — the > Organization for Economic Cooperation and Development, a group of highly > developed countries — the U.S. has the highest top corporate tax rate in the > world.

<comment><USER67> From the rest of the article:

> Factor In Deductions And Other Expenditures, And The U.S. Corporate Tax Rate > Isn't So High

</comment></comment></comment></comment></comment></comment><comment><USER68> Marriage deduction is not yet fully implemented.

</comment><comment><USER69> maybe it works on ie 11, not working on chrome.

</comment><comment><USER70> Make sure you use incognito mode! I hate looking at sites like these. I'm sure this one is probably OK but most aren't to be trusted.

Not only are you giving away personal financial info to an unknown site, you're pairing that with your browser so making yourself a target to every advertiser and scammer in the future.

<comment><USER71> I guess just drag the bar around a lot and look at a few different states.

</comment></comment><comment> javascript-this could you NOT wreck my browser's back-button please?

</comment><comment><USER72> Who decided the color scale for the US map was a good idea? Holy shit it is hard to tell the difference

</comment><comment><USER73> Very interesting. Unsure how reliable the source is, but when you play with salary indicator.. at $250k everything slowly starts turning gray and then red. So this bill truly hits into top % of these that make more than 25k or 125k per spouse.

Only question remains what will the rich do with these savings. Administration says people will hire more and buy more goods that will obviously turn into more jobs and better economy. Let's hope for that!

</comment><comment><USER74> Say what you want about the tax bill on net, the elimination of the SALT deduction is very good for the country.

There is zero reason for the Feds to subsidize and distort incentivize to encourage states to increase their tax burdens. SALT has always been one of the most corrupt tax breaks (mortgage interest being another).

<comment><USER75> > Say what you want about the tax bill on net, the elimination of the SALT > deduction is very good for the country.

No, it's very _bad_.

> There is zero reason for the Feds to subsidize and distort incentivize to > encourage states to increase their tax burdens.

That seems like a reasonable position, but SALT doesn't do that; quite the opposite, it keeps federal taxation neutral in terms of incentives for state and local taxes. _Not_ deducting state and local taxes distorts incentives by creating a federal tax disincentive to state/local tax-funded programs that produce a net economic gain. I've written up a simplified scenario illustrating this in a recent prior discussion on HN:

[https://news.ycombinator.com/item?id=15855955](https://news.ycombinator.com/item?id=15855955)

</comment></comment><comment><USER76> This website literally just loads another page, IP address, over raw HTTP. There's no way in hell I would trust it in any way, shape, or form. You really should build your website better before showing it off.

Edit: It looks like the page does _not_ just load an iframe to an IP address any more. I'll take back what I said.

<comment><AUTHOR> Sorry, I'm doing this while the new DNS info propagates to point it to a new server. My old server was too small and got crushed immediately. :(

<comment><USER46> I'm curious as to why you even used a server at all. From the looks of it, you could have shipped the server code with the frontend and saved some bandwidth.</comment></comment></comment>


This USB Drive Is Just Thicker than a Penny and Holds 2TB - <AUTHOR> http://www.netbooknews.com/33811/2tb-usb-the-size-of-your-finger-nail/

<comment><USER2> And is almost certainly vaporware, at least as far as a 2TB version available any time soon is concerned.

</comment><comment><USER3> SDXC cards can also go up to 2TB, you can only buy a 128GB now. These headlines don't count.</comment>


ProjectXpresso pairs students for 15 minute chats with industry professionals - <AUTHOR> http://projectxpresso.com/

<comment><AUTHOR> Hard to find on the site, but looks to be run by the folks at TradeUp: [http://www.tradeup.io/](http://www.tradeup.io/)

Interesting model, if the industry professionals end up referring students they chat with to their organization it seems like a very worthwhile 15 minutes from their perspective.</comment>


Ask HN: Electronic Tool Booth - <AUTHOR> Every time I pass an electronic tool booth with RFID tag on the car always amazes me how fast it reads, verify if active and other stuff and opens for the car on moving. How this actually work and how's the latency is so small? <comment><USER2> The word you want is "toll" not "tool".</comment>


Summer of Startups: 10 Startups to Graduate from Finland's 1st Startup School - <AUTHOR> http://aaltoes.com/2010/08/summer-of-startups-10-startups-to-graduate-from-finland%E2%80%99s-first-ever-incubator-internship/

<comment><AUTHOR> Disclaimer: I'm the main coach of the program</comment>


Breaking Up With Amazon - <AUTHOR> http://ce.ntup.org/?u=http://danielverastiqui.com/2014/04/breaking-up-with-amazon/&t=Breaking%20Up%20With%20Amazon&p=Daniel%20Verastiqui

<comment><USER2> No small amount of irony posting this on Hacker News.</comment>


Metal shards from Boeing 787 taking off over Rome rain down on people below - <AUTHOR> https://www.independent.co.uk/news/world/europe/plane-debris-falls-from-sky-boeing-787-rome-norwegian-isola-sacra-a9054216.html <comment><USER3> [https://www.forbes.com/sites/davidnikel/2019/08/12/norwegian...](https://www.forbes.com/sites/davidnikel/2019/08/12/norwegian- boeing-787-engine-parts-fall-from-sky-onto-italian-town/)

 _The plane in question was a 5.5-year-old Boeing 787-8 with the registration LN-LND. The parts are believed to have come from the left engine, a Rolls- Royce Trent 1000, a model that has been plagued with problems._

Link about the problems: [https://www.theengineer.co.uk/rolls-royce-problems- trent-100...](https://www.theengineer.co.uk/rolls-royce-problems-trent-1000/)

 _Cracking problems in the intermediate pressure (IPT) section of the turbine have plagued the engine since early 2016, five years after its launch. Unscheduled groundings of Trent 1000-powered aircraft cost Rolls-Royce some £450m last year, and Horwood said that addressing the problem was "the single most important issue" currently facing the company.

One of Rolls-Royce's most important potential customers for Trent 1000, Air New Zealand, recently announced that it has opted for General Electric power- plants for a new batch of 787-10 airliners, although its 787-9 fleets still fly with Trent engines._

I'm reminded of all the jokes Jeremy Clarkson makes at Rolls Royce's expense...

<comment><USER4> > I'm reminded of all the jokes Jeremy Clarkson makes at Rolls Royce's > expense...

Rolls-Royce Holdings only makes aero engines, the cars are made by BMW.

<comment><USER5> >the cars are made by BMW.

as of 1998.

Most of Clarksons' jokes are in reference to the 70s and 80s era of Rolls Royce -- which is known among auto enthusiasts as one of the least reliable group of cars to have ever existed.

<comment><USER6> Driving a 1977 Rolls established your wealth without question. Not only could you afford _a_ Rools, you could afford three:

One you're driving.

One in the shop.

One in the garage in case the one you're driving goes to the shop before the other one is repaired.

<comment><USER7> I guess owners graduate from Range Rovers, which drive either to a service shop or just out of one.

</comment></comment></comment></comment></comment><comment><USER8> Small shards (in great numbers) that according to a witness on the ground were burning or very hot sounds a lot like (pieces of) blades from the turbine or stator/guide vanes. In both cases it's a very significant engine failure.

<comment><USER9> Given that the aircraft itself seems otherwise undamaged, and people on the ground reported it 'rained' metal shards, I'd say these parts melted off the turbine and fell out. Significant but not catastrophic.

<comment><USER10> This ended well, fortunately. But that must have been pretty scary.

A 787 that is out one engine will put extra load on the remaining engine, if that one has gone through a similar life as the one that just dropped bits all over the place I'd not wager on the remaining one being as safe as when it was last inspected. That's a lot of eggs in one basket.

And they don't glide particularly well either, though there are some interesting stories around passenger aircraft and glide landings:

[https://en.wikipedia.org/wiki/Gimli_Glider](https://en.wikipedia.org/wiki/Gimli_Glider)

But that one had a good 9000 meters more height to work with and it wasn't over densely populated area either.

<comment><USER11> > And they don't glide particularly well either

Nonsense! Modern airlines glide exceptionally well. For example a 787 has a glide ratio of over 20:1 !

[http://www.lissys.demon.co.uk/samp1/](http://www.lissys.demon.co.uk/samp1/)

[https://seekingalpha.com/article/2494925-boeing-the- airbus-a...](https://seekingalpha.com/article/2494925-boeing-the- airbus-a330neo-a-real-competitor-for-the-boeing-787-part-3)

<comment><USER10> 20:1 from 3000 meters gives you 60 km to line up and land, that's not as bad as a shuttle but not nearly as good as an actual glider. Personally I'd love to be on the ground in that situation.

You can't just land a 787 on a bit of farmland. BTW if you _have_ to deadstick a commercial plane then the 787 is probably the best, it has the best glide ratio of all commercial planes in service today. But I'd hate for that to be put to the test.

<comment><USER11> That is a nonsensical comparison. Shuttle's glide ratio was 4.5:1 - <USER2> better than a brick

<comment><USER12> > Shuttle's glide ratio was 4.5:1 - barely better than a brick

A brick has a glide ratio somewhere worse than 1:10; the shuttle (at subsonic speeds) is closer to a sailplane (~40:1, or ~9× better than the shuttle) than a brick (more than 50× worse).

<comment><USER13> I'd like to see the footage of the brick tests.

<comment><USER14> [https://www.youtube.com/watch?v=C-9fEoeNc3I](https://www.youtube.com/watch?v=C-9fEoeNc3I)

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER15> One of the pieces in her hand has the unique shape of a fan blade. There's a series on YouTube documenting the factories where the engines are created: [https://youtu.be/UazsDDFsS7Q](https://youtu.be/UazsDDFsS7Q)

<comment><USER16> The show _How It 's Made_ did a cool segment on turbine blades, which really gave me a deep appreciation of the process.

[https://www.youtube.com/watch?v=KnrCjVf9xuY](https://www.youtube.com/watch?v=KnrCjVf9xuY)

</comment></comment><comment><USER17> Curious if this was before or after Rolls-Royce thought they'd fixed it.

</comment><comment><USER18> More info and photos. [http://avherald.com/h?article=4cb6a09d&opt=0](http://avherald.com/h?article=4cb6a09d&opt=0)

<comment><USER19> Those metal bits look big enough to kill a person. I mean, anything havier than a marble falling from high enough will do a lot of damage, right?

<comment><USER20> Anything with enough power to smash a hole right through a car windscreen (as in the second picture) can kill you, definitely.

<comment><USER21> I'm being pedantic here, but there are exceptions to that rule.

In SF, it's common for car thieves to break windows using a small chip (size of a pencil eraser) of ceramic from a spark plug. The ceramic is super hard but light weight and can shatter a window easily.[1] being hit by it would barely register.

[1] [https://youtu.be/llu-ckEe5cQ](https://youtu.be/llu-ckEe5cQ)

</comment></comment></comment></comment><comment> valiant-comma A British Airways 787 with the Trent 1000 engines had to make an emergency landing in Istanbul on June 15 while en route to London:

[http://avherald.com/h?article=4c9549b4](http://avherald.com/h?article=4c9549b4)

</comment><comment><USER22> 2019 has been a true _annus horribilis_ for Boeing.

<comment><USER23> Well, engin failures are not exactly the rarest of occurrences. It's just that given the context, every stories about Boeing will gain quite a bit of traction. It's probably deserved given how bad the company have messed-up, but let not overreact.

<comment><USER22> Engine failures are not rare, true, but engine failures pelting populated areas with hot shrapnel are not that common.

</comment></comment></comment><comment><USER24> Is this the same issue that has plagued the Trent 1000 since the beginning or is it something different? It says the plane is 5.5 years but I guess that doesn't say whether the engine had been modernized.

On the bright side, Rolls seem to have sorted out most issues from the 1000 in their newer engine the XWB.

[https://en.m.wikipedia.org/wiki/Rolls- Royce_Trent_1000](https://en.m.wikipedia.org/wiki/Rolls-Royce_Trent_1000)

<comment><USER25> > Boeing dispatched 737 MAX head VP Keith Leverkuhn to help Rolls-Royce > overcome the problems

Well that really inspires confidence.

The new engines are still suffering these same problems, very good chance Norwegian has the newer variant as the older ones are mostly grounded and I'm quite sure Boeing agreed to replace them all years ago.

[https://simpleflying.com/singapore-airlines-787-10-engine- is...](https://simpleflying.com/singapore-airlines-787-10-engine-issues/)

<comment><USER26> >Well that really inspires confidence.

For better or worse it appears Boeing is practicing [https://codeascraft.com/2012/05/22/blameless- postmortems/](https://codeascraft.com/2012/05/22/blameless-postmortems/)

It appears to work in software, so unless demonstrated otherwise I assume it's effective in other engineering disciplines. We can learn from the equivalents of the FAA in other countries where blame automatically gets assigned based on who is in charge, it leads to finger-pointing and worse safety records/poorer investigations: watch a few seasons of Mayday: Air Crash Investigations to see the pattern. You see it especially in more autocratic countries where hierarchy is rigid. One especially good example is Malaysia Airlines Flight 370, there's a good chance we would've found the plane if everyone in the government wasn't practicing CYA which led to significant delays and made the search exponentially harder. Compare that to Air France Flight 447 where the right information was shared with the world immediately (and it _still_ took us two years to find the black boxes).

</comment></comment></comment><comment><USER27> Despite an update and partial retraction in this article. It seems that there are known issues. [https://thepointsguy.com/2018/01/norwegian-787-engine- replac...](https://thepointsguy.com/2018/01/norwegian-787-engine-replacement/)

</comment><comment><USER28> Videos on the site does not work, I assume because of adblocking. Related video for those who also are too lazy to read [https://www.youtube.com/watch?v=RvxucqNRPRg](https://www.youtube.com/watch?v=RvxucqNRPRg)

</comment><comment><USER29> Who is responsible from a liability perspective: Boeing, Rolls Royce, or Norwegian?

<comment><USER30> Chain. Norwegian to the people hurt and property damaged, they will in turn sue Boeing who in turn will sue Rolls Royce.

<comment><USER31> So the big winners are the lawyers I guess...

</comment></comment></comment><comment><USER32> This really doesn't make me feel very confident about getting on a 787 for a 14 hour flight next week.

<comment><USER33> If it has GEnx engines you have little to worry about. The easiest way to tell the difference is the GE has metal leading edges on the fan. The Trent fans are all cfrp.

<comment><USER34> Can you tell this when booking your tickets? It isn't a detail I've seen using most travel websites or even an airline's own app.

<comment><USER35> You probably can figure it out with some sleuthing. For one example, SeatGuru records every airline fleet's different plane types. Once you have airline + plane type for each of that airline's routes, I bet you can dig up the engine type from that info.

<comment><USER36> There's often also press about it - eg [https://www.geaviation.com/press- release/genx-engine-family/...](https://www.geaviation.com/press-release/genx- engine-family/qantas-selects-genx-engines-power-its-new- boeing-787-9-dreamliners)

</comment></comment></comment></comment></comment><comment><USER37> Sounds like someone forgot to take the FOD out of the aircraft

</comment><comment><USER38> Oh, and it's raining again

Light on your car light, bullets on tin.

<comment><USER39> For years I'd thought it was "like bullets on tin".

Most lyrics sites seem to have the lyrics you said, but there's still some with the version I thought. I can't find any official source of lyrics either.

I've now listened to the video clip[1] a dozen times trying to figure out which it is, and honestly I'm no closer.

[1] [https://youtu.be/NdZHZZtJacg?t=25](https://youtu.be/NdZHZZtJacg?t=25)

<comment><USER38> Hold me closer, Tony Danza!

</comment></comment></comment><comment><USER40> Oh man Boeing just can't catch a break lately

</comment><comment><USER41> So Rome has a science police?

<comment><USER42> Reminds me how excited I was when I found out there was a religion based around science.

</comment></comment><comment><USER43> And this is what a culture of management bonuses causes. I don't want to ever fly Boeing again at this rate...

<comment><USER44> It was a problem with the engine, not the airframe. The 787 ships with Rolls- Royce and GE engines - the GE equipped ones are fine. Boeing manufactures the planes, and then works with engine manufacturers to offer various options for powering them. The airlines choose which engines they'd like to install on their aircraft.

GE, for all of its faults as a corporation (the stock price is what, $9-something now?), makes very good jet engines.

<comment><USER45> it's just plug and play hey?</comment></comment></comment>


Pushnote - Comments for the web - <AUTHOR> http://www.pushnote.com/

<comment><USER2> What _is_ it?

Why should I wait for some Flash thing to load?

</comment><comment><USER3> What is it?

Why does it need gender and the DoB?

</comment><comment><USER4> nice video</comment>


Mobile Ad Brokers as DDoS Distribution Vectors: A Case Study - <AUTHOR> https://blog.cloudflare.com/mobile-ad-networks-as-ddos-vectors/?? <comment><USER2> 1187 words, 3 graphics, 6 subheadings, 8 highlighted content sections, a bulletpoint list... and all to say "An ad with a malicious script was used to ddos a website. We don't know how it happened, but please use our service!".

Welcome to the wonderful world of content marketing.

</comment><comment><USER3> In case anyone wonders about the `!+[1,]` bit:

In modern browsers, `[1,]` is the same as `[1]`. If you coerce it to number, you get 1. (You get "1" if you toString it.)

In IE8, `[1,]` is the same as creating an array with a length of 2 whose first slot contains 1 and whose second slot was left empty. It's kinda like `[1, undefined]`, but there is no "1" key. If you coerce it to number, you get NaN. (You get "1," if you toString it.)

If you coerce 1 to boolean and negate it, you get false.

If you coerce NaN to boolean and negate it, you get true.

So, basically, it just checks if trailing commas in array literals are handled incorrectly.

<comment><AUTHOR> Interesting explanation. When I last checked that the "!+[1,]" expression alone was coherent across all the browser but "if(!+[1,])" statement was not.

I think there is something weird about the parsing of the comma in "if" statement in old IE.

<comment><AUTHOR> Correction. There is nothing special in "if". IE9 is just different, as you explained.

</comment></comment></comment><comment><USER4> Anyone else read it as "Mobile Ad Blockers"? I came here curious to see how ad blockers could be used as DDOS vectors. Well, I guess theoretically, it might be possible to overwhelm a device with a page which has too many elements to block, causing the ad blocker to consume a lot of resources.

<comment><USER5> I did :)

</comment></comment><comment><USER6> Another thing to consider, it might not have been an ad network but rather something like xcodeghost. Some of the most popular Chinese apps were compromised.

</comment><comment><USER7> I dont understand how is it possible that browser would allow crossdomain request from attacker website to victim website? Unless victim has some CORS headers allowing all sites to query it?

<comment> slipstream- Wouldn't the browser still make the request even with the CORS headers, because the server needs to send such headers?</comment></comment>


Your Vape Could Soon Have a Tracking Chip in It - <AUTHOR> https://www.vice.com/en_us/article/3a8pxn/your-vape-could-soon-have-a-tracking-chip-in-it <comment><USER2> > "I did have some privacy concerns about this in the beginning," Morris said. > "But the people who would be using this information would be law-enforcement > officials [...]

Wait, is he saying that there is no privacy concern because the only people this would be useful for is cops? I don't see how that reduces the privacy concerns much.

In any case, I wouldn't touch products that have this with a ten-foot pole.</comment>


Linus Torvalds think the Linux desktop is in trouble - <AUTHOR> https://www.zdnet.com/article/the-linux-desktop-is-in-trouble/ <comment><USER2> > the traditional Linux desktop, in all its variations, will remain a niche > operating system for power users.

Is it not the case that, well, _computers_ are a niche system for power users?

Most of the developers I know use OSX or Linux.

The students I know are all on OSX and effectively use Office and the browser.

People with bog-standard office jobs are on Windows because their employer controls their machine.

Everyone else doesn't really use traditional "computers", it's all phone stuff.

<comment><USER3> You are forgetting pc gamers :)

</comment></comment><comment><USER4> The two sides that I've hopped back and forth from in this argument are competition leads to innovation, and fragmentation is the problem.

Getting started with Linux 8 years ago, I used to think the endless array of distros was a beautiful and unique characteristic that reflected on the openness of FOSS. As I gained experience, I realized that the differences were too close to really care. That there's an awfully large amount of effort being put into divided communities too maintain working "operating systems" that are hardly unique.

I find Linux best suited in its inherent case, Unix for the x86 PC. Unix as a programmers workbench. Unfortunately and fortunately the "Windows killer" nameplace is responsible for its early success and what it will probably continue to live by for desktop usage.

It's always great to hear someone put life into their grandma's Windows 7 laptop by reimaging with an Ubuntu USB. But I feel like that doesn't last long as non corporate supported desktop Linux doesn't hold up well without some annual sys admin love.

I definitely went on a rant, but what I can conclude is that competing technologies isn't really to blame as the freedom of choice goes with the nature of FOSS. The bigger problem is that we are fighting to turn a Unix like OS into a Windows replacement by relying on voluntary man power and overlapping attempts at essentially the same goal. Leave it to Apple and Google to bring Unix to the masses, if that even matters.

</comment><comment><USER5> I've shared the same exact frustration for over a decade now. One of Linux's greatest strengths gives rise to it's biggest weakness- fragmentation.

"I disagree with x design decision, I'll make my own distro"

It's like there is so much rope that the community can't help but hang itself. The talent is spread across dozens of distros each with their own ethos and design direction. Every new distro hurts Linux as a whole at this point.

<comment><USER6> I wonder how many people would Patreon/sponsor developers to do a Linux OS properly?

I am happy to throw money towards it - I think it would have to be built on ostree, flatpack, Gnome 3 and Systemd to get anywhere close to a modern development desktop.

Anyone else interested in putting money where their mouth is?

<comment><USER7> The problem of Linux package management has been solved, and the solution is not flatpak (nor snap). It is Nix/Guix.

About the user experience, I'm right there with Linus that Chrome OS is the way to go forward. And this opinion is not new btw., he already voiced it way back when he got his first Chromebooks.

</comment></comment></comment><comment><USER8> I don't think a Foundation would help in this regard, who's going to fund it and why would they?

The article kind of glosses over the fact that there's really no business case for a traditional linux desktop.

Chromebooks are tied to a hardware sale where the hardware is certified to avoid having to support multiple hardware configurations and ensure users never see Linux at all.

Specialty shops like System76 and Dell's Sputnik specifically are tied to hardware and a specific market (pros and sysadmdins), this is where I fall in but most normal PC users would generate absolutely zero revenue for anyone trying to build a sustainable linux desktop experience.

</comment><comment><USER9> Flatpak, Snap are not significant contributors to desktop fragmentation, unlike Gnome 3, Wayland, dropping Unity, all forcing people to try different distros. I switched to Lubuntu myself after Unity and probably going to switch again to Xfce-based Xubuntu, because they want to break Lubuntu too.

</comment><comment><USER10> and here I was thinking that 2019 must surely be the year of Linux on the desktop

<comment><USER11> We'll win eventually, once Microsoft gives up. We've got far more staying power, since it costs us virtually nothing to stay the course. It may take another 20 years, but we'll get there. :)

<comment><USER12> Why would Microsoft ever give up? They make billions off of Windows.

<comment><USER13> For the time being, talent is limited. Their costly engineers' time might be spent more productively on other products. Windows is already no longer their primary cash cow (nor even their secondary -- IIRC, it comes third in revenue after Azure and Office). I don't think they will kill windows any time soon, but I do think that the probably is non-zero, even in the not too distant future.</comment></comment></comment></comment>