skysight-inc/HackerNews huggingface dataset:
I think it takes people who do not start out 'believing in types' (I was taught by pupils of dijkstra in NL so my belief in strict-as-possible has always been quite firm) a same kind of timespan / experience as the OP; experience (very) large weak/stringy typed projects, experience them for at least a few years full time and then, when the frustration sets in, try something which is the complete opposite like Haskell/Rust.

I think a certain frustration needs to be there to try something else anyway, when you come against the billionth cannot call hello() on undefined error in a critical (for the company), 100k+ LoC, multi-team project, you might wonder if there is something else.

You are probably not going to post your 'list' here but proper types prevent many trivial and non trivial bugs. Many of the points on your list will fit there, but you wouldn't know it yet.

> Talking about which tool can prevent the most bugs, integration tests win by a large margin.

Obviously there are ways of catching them without types, but proper type systems catch them at compile time and also; how are these mutually exclusive; we use both. We just need less integration tests.

> Like "Ooooooh shit! We have allowed people to tag items as duplicates of other items. And we have a function that traverses the list up to the original item. But now this new feature over there had a bug where it marks the last original as a duplicate of another duplicate and then when the traversal function in that other module is used, it ends up in an infinite loop".

In some of my favorite languages you can catch this in types at compile time.

Obviously; do what works best for you and your team; I just don't buy your overarching statements and 'proofs'. If it works it works, but it would probably work better with types.
It seemed like a good idea at the time.
Money is around the top of things people value in a job. It's very hard, to impossible, to make up for a crap salary.

At the very least pay market rate (i.e. an average salary) and then add benefits to turn average into good.
Ha! Best laugh I've had in a month!
yeah, you have to be very careful when doing this

people in many countries have died from this

it's very rare. However, you don't want to be the poster child for it
Appending just the question mark works here.
> I really don't see the point in having to write a Go snippet to describe the architecture: in the end you're providing only data as an input.

Writing a program to generate the diagram is similar to writing a program to generate your infrastructure which is exactly what you do in "infrastructure as code". If your infrastructure is simple then you may not need infrastructure as code. The same can be said for diagrams but at some point you might want the flexibility if the "diagram as code" approach.
You posted something like 20 times and ignored when people noted that was over the line . If you had only posted 3 times (like many others have), no one would have noticed or cared.
That's good info, thanks!
> Calling this a prosperous time is also flawed, for who? The middle class is nearly gone, freedoms are being eroded, racial tensions are still high, the world order is destabilizing as many governments lean into more dictator-like structures.

- It is a prosperous time for far more than ever before. Within the last thirty years, a new world power has risen and raised 400 million people out of poverty in an unprecedented act of economic engineering with no military conquest to enable it. Never before has this been done. Its neighbour during this time has simultaneously raised 180 million people out of poverty. During this time neither nation has fought its neighbour. Before this massive reduction of human unhappiness, the loss of the median American's third car pales.

- Absolute measures of human standards of living have continuously increased. They are not going down. The major world economies have all improved continuously. You will need to define the middle class and why that measurement is meaningful to you. If Bezos gets Mars and I get a piece of American land the size of San Francisco, our relative inequality will have increased, but I will take that trade every day.

- Racial tensions were way higher in the past. Black people were segregated! In South Africa, they had apartheid. And a little farther back and Japanese-Americans were in concentration camps. In California, the fourteen thousand Army National Guard troops suppressed race riots.

- The world order is being destabilized as America withdraws the shield that preserved Pax Americana. This is true. But that was a subsidy to (or perhaps an investment in) the world, a tide that raised all ships, and America's more than anyone else's. America prospered with world trade. By these actions, America weakens herself. But that's geopolitics. The sands shift with the wind. We shall see what happens. Other generations faced greater threats.
Does he use Redux by any chance :-)
If you mean in the red text, yes. Those are two different variants of the same character.
> Infections are rare in the US, with 34 reported between 2009 and 2018.

Is this in the US as a whole or only in the local area in question?
No, see CTAN.
> Linux, especially Linux Desktop, is wonderfully flourishing right now [...] because we’ve built what we’ve wanted

I agree, but it has to be said that this has also happened because desktop features across the board have stagnated.

There has been little evolution of desktop features in the last 15 years on Windows and Mac; MS and Apple are focused on other things, namely services integration to increase revenue and convergence with mobile OSes to reduce costs. This has allowed the Linux desktop to catch on and solidify, by not having to constantly chase feature-matching. Same for hardware support: new devices and ports for the desktop and laptop market have been few and far between; if anything things are getting simpler (USB-C for everyone, no cd, no modem, etc).

I have no doubt that both Apple and MS could destroy the attractiveness of Linux desktops very quickly if they focused a bit more resources on evolving their desktops.
Upgrading to 27 made no difference for me.
Shouldn't the salt kill the microbes? All you have to do is leave your salted water for a while.
> Why do they hang on to Python2.7?

https://doc.pypy.org/en/latest/faq.html#how-long-will-pypy-s...

PyPy is written in RPython, which is a subset of Python 2 without most of the dynamic features, so it can be compiled. Moving it to a subset of Python 3 would be a major effort, as they would have to rewrite both the PyPy code and the RPython compiler.

And RPython, being a subset of Python, can also be interpreted, so they probably want to keep the Python 2 interpreter so they can interpret it.
What are you working on though? What algorithmic structure?
> Yet somehow this story make it to the front page of an international computer news web site.

what's news-worthy isn't the same as what's high impact.

Car crashes kill so many people every day, yet you barely hear about it. The most you'd hear about is a high speed chase or a high way pile up. Because it's rare and interesting.

So definitely examine what you read, but also learn about recency bias and such to prevent being "tricked" into thinking the wrong thing about the true state of the world.
The amoeba isn't very good at getting to people's brains, but once it's there the fatality rate is 95%. So it's rare, but it's still dangerous to have a lot of people exposed.
The fact that you have to do any of that in the first place, is reason enough to not use windows at all.
> Climate change and the collapse of global ecosystems can absolutely manage that and according to every serious scientist we are pretty much on the worst case scenario path according to any peer reviewed model.

Except that most models are piss-poor at predicting anything and that they only cherry pick the ones that happen to make it with new data.

On top of that, climate change is a slow moving disaster, and we are typically good at mitigating long term changes (at least way better than urgent crises). Scientists calling for the end of the world at every opportunity will look ridiculous 100 years from now.
You mean a filter to transform the query from A (say, with syntactic sugar syntax) to B (with final syntax)?

I'm actually doing something similar in GraphQL by PoP, on a couple of levels: queries are decoupled into requested and executable, where they can differ in syntax, directives attached to them, and others. I wrote a bit about this strategy here:

https://blog.logrocket.com/adding-directives-schema-code-fir...

In addition, GraphQL by PoP does not understand the GraphQL syntax. It understands another syntax, that I've called PQL:

https://graphql-by-pop.com/docs/extended/pql.html.

PQL is a superset of the GraphQL query, so GraphQL by PoP transforms from GraphQL to PQL syntax and then executes it. For instance, this GraphQL query:

```

query {

posts {

excerpt

titleES: title @translate(from:"en",to:"en")

}

}

```

is converted to this:

```

posts.excerpt|title@titleES<translate(from:en,to:es)>

```

Check it out here:

https://newapi.getpop.org/api/graphql/?query=posts.excerpt|t...

This works great. Only issue is when there's some error when retrieving the data, and I need to return an error message with the path to the problem in the query. In that case, the path corresponds to the transformed PQL query, not the original GraphQL query. (It would be possible to have a mapping for them, token by token, but I haven't coded it)

---

Btw, connected to PQL, GraphQL by PoP can support the embeddable fields feature because the PQL supports composable fields, which can be considered its superset:

https://graphql-by-pop.com/docs/extended/pql-language-featur...

I've also proposed composable fields for the GraphQL spec (https://github.com/graphql/graphql-spec/issues/682) but it hasn't got any support (that's why I'm now asking if embeddable fields could have some backing)
> increasing the ease of exploration and understanding of a codebase

Very true and a good thing to remember when discussing static typing.
Anyone overlooking the ancient Indian philosophical (or spiritual depending on the way you look at it) literature, a.k.a The Upanishads, is being ignorant about consciousness studies.

The term "Chit" (https://en.wikipedia.org/wiki/Cit_(consciousness)) was introduced by The Upanishads for referring to consciousness/awareness long before any of the modern philosophers did so.

For more info: https://www.youtube.com/watch?v=yfUXXKB_G_Q
I did a bit with instances of an Open Source deep learning server of mine, for three years+ now. Made up to 1.5k/month, lower now but it's on my plate to revive it. It's provided side money to our service/ software business.

Keep in mind there's a 30% cut from AWS, plus if you're in the EU, you need a tier like payoneer to channel your revenues back into the EU.
Yeah I agree most of the pain of types comes from the ways they're implemented (especially in early C++/Java etc)

Hence my beef with them. PyLint (as an example) can deduce and type check your program for you. Why do I need to annotate the types for every single thing? Python is not exactly a weakly typed language if you go down the details.

So if the compiler knows (or even worse in the case of Java: the IDE knows), why do I need to tell it that? Then you end up with the cases of several prototypes for the same function for things that are essentially the same.

I can understand type annotations for documenting interfaces. Those make sense.
Run into a strange behavior though. When I pause the video with the mouse (and consequently, leave the pointer above the play button), and later try to continue the play with space, it will double-press the play button and pause the video again.
503 - it’s dead, Jim.
But ultimately the main purpose of such stat is to make policy decisions to reduce amount of greenhouse emissions, and so it should show effects of the both making cargo ships more emmision efficient and reducing amount of things people buy. So it's better to let it overlap.
What is the best library to use these days for developing in Visual C++? I had to write some VCpp code a few days ago using the Winhttp api and it was a nightmare. I'm not sure if its because I've been spoiled rotten by python where you can do a get/post request with a few lines of code, and that this is just how CPP is, but most of the complications are to do with calling and using the (not very well) documented API itself. Is there usually a easier way to do this? I'm just doing simple post and get requests, and I couldn't even do a file upload post properly by passing the binary data in, had to convert to base64 text in the end for it to work.
For me it is somewhat different: I always used typed languages and occasionally have to read and improve untyped code. I must admit, I feel half blind in the latter. When debugging a python web service, trying to figure out the control or data flow, I very often scratch my head and wonder "what is this thing"? This applies both to library functions and code from colleagues. Sometimes it feels like untyped languages are write-only languages.
The peak of what aspect of human civilization? And why 2015?

[Edit: I find it highly unlikely the peak of human civilization, whatever it means, should happen during my lifetime. Surely the Romans in 100BC might have thought the same as you do? Why do you think there won't be people in 2222 who think the same?]
Nothing good comes easy. The dozens of hours I'd spend staring at 26 lines in R just trying different ideas to shorten/optimize/improve clarity, and that wasn't something I needed to sell that someone else would depend on for business or personal use.

But I can relate to the pressure to deliver quick results. I found myself burnt out when working on a forecast model around three years ago. The constant "how's it goin'?" tore my attention away from the work, and I'm still convinced I could have delivered a better result.

So, in a way, I agree. In another, I understand the other side of the issue, and I think there are so many less time-intensive tasks going on around engineering that there's often little awareness that something like refactoring a class for better efficiency pays in smaller but compounding ways long-term, with most of the time cost and perceived opportunity cost being immediate and short-term. It's still worth it if you really do the math on the long-term benefit.
I was never a fan of meeting these monstrous F-150s in an urban setting as a pedestrian. However, linking "Rural" to the right to drive a pickup is still a bit cringeworthy IMO.

Most NYC urbanites I know e.g. wouldn't describe Staten Island or most/all of New Jersey as densley populated. Yet, the workers/contractors that can't afford to live in the center or dumbo have to get their tools into the city somehow, if they are to fix my 150k+/year income earning friends condos.

So now I found your stats intriguing and looking into it: That alledged 72% urban area inhabitants include non-dense areas like staten island and NJ, so I guess the stats are a bit misleading?
For http? Embed libcurl.
Static Linking Considered Harmful (2004)
Types are useful, but they are currently trending, so now, they might often be forced into situations where they might not be needed.

Programming languages and their type systems are tools, at the end of the day.

Occasionally, an overwrought system of types will slow you down, or quite possibly make simple changes impossible.

On another day, some other type declaration could save you hours of debugging, or speed up your program by orders of magnitude...

Simply put, I feel that many Java programs probably could happily be replaced by Python or Node JS.

On the other hand, some safety critical UI projects (or at least, some key portions of them) absolutely would benefit from Typescript or Elm.

I wish there was more discussion about when each is a better fit, rather than talking about how much worse A is than B.
I was wrong about types too. I used to think after I had mastered half a dozen languages, I should start spending time on typed languages, maybe eventually learning type theory, Haskell and what not.

Now I focus on things that matter: deep learning, AI, and robotics.
>Friendly reminder that IRS enforcement is one of the most cost-effective activities that the federal government can engage in, and that Congress has consistently cut funding for the IRS for years and years

It hardly matters whether it makes money. Two things come to mind:

* Civil asset forfeiture is one of the most profitable acts for police departments. California outlawed this for money below some large sum.

* Traffic tickets are one of the most profitable acts for some city departments. I would far prefer that they reduce that.

I don't care that the Federal Government makes money. It is not a good thing that it makes money. It is just a thing.

When North Carolina came after me for taxes they thought I owed, only for them to reduce the judgment from the many thousands to a few hundred dollars when I sent them a "yo, I think you're mistaken" letter, I didn't feel pleasure. The fact that they insisted any further appeal could only occur in person, knowing full well that a flight to that state cost more than paying the bill, I did not feel like the government was made better through the experience. If they had decided that they should collect the whole amount I would not feel like they would be doing a better job.
For those saying this is only possible with a good passport and a full bank account: I see people doing similar with crappy passports and nearly no money. Sure, they don't have a computer program telling them what to do, but I've heard standard dice are more random than PRNGs anyway.

As far as expenses go, most people do Couchsurfing or something similar. With housing taken care of, you can feed yourself on a couple bucks a day, and hitchhiking is free.

Sure, with a crappy passport you can't go absolutely everywhere, but with a South American or African passport you can travel your entire home continent visa free, with a Russian passport you can travel the CIS countries, etc.

If anyone here (rich or poor, good passport or bad) would like to try their hand at this kind of random, see-where-life-takes-you kind of living, feel free to come stay at my boat home (currently sailing from the Netherlands to France.) I take tons of Couchsurfers of all kinds, many of which live the low budget version of this guy's life :) My email's in my profile.
For my use cases, the vast majority of errors with dynamic languages boil down to being able to run scripts that have undefined variables; I'm prone to (mental) typos, so if I had a dialect of Python that failed before runtime when undeclared references exist, I could probably cut the number of iterations I need to arrive at a working script by at least half.

I've never found a valid use case for allowing undefined references, though I suppose it does make the language implementation significantly easier.

Writing tests is not really a solution either. Tests are also code and suffer from the same problem.
To play against the current wave, and give a contrarian pov:

I'm grown up with statically typed languages from C/C++/C#/Java and later and didn't know about dynamic languages till recently.

1. Which types are we talking about?

- In earlier static-typed language, the processor-based types `uint64` looked very strict, optimized the code for hardware architecture.

- Having mathematically and ontological correct types is one approach `integer`/`float`/`string`/`datetime`.

- Each type being well defined and each object-class being used as type is another strict approach.

Look at the types of Rust and Kotlin and see the cacophony of decisions made:

- Rust https://doc.rust-lang.org/reference/types.html

- Kotlin https://kotlinlang.org/docs/reference/basic-types.html

2. When you want to implement a method which applies to multiple libraries, you end up writing `fooString`, `fooInteger`, `fooDatetime` etc (or foo(String), foo(Integer)) etc. DRYing is too hard. So you end up writing 10x more methods

3. No you don't avoid `null` checks at all.

4. Generalizations are harder to implement.

5. Interfaces are uglier compared to dynamic languages.

6. The code becomes less readable, not concise and verbose

7. Every new and old typed language is less elegant compared to the dynamic. Look at typescript vs javascript, typescript code is ugly, verbose, non-readable at all.
I hope they can put dev.to articles to higher priority.
At worst, the Lake Jackson authorities are being excessively cautious. When drinking, there's a slight chance of some liquid not being swallowed, after all.

Given the recent fatality, erring on the side of caution seems quite understandable.

If I were living in the region served by Brazosport Water Authority, I'd be more interested in the criteria used to proclaim the safety of the rest of the service area, especially after perusing this:

https://cen.acs.org/articles/93/web/2015/09/Brain-Eating-AmoebaScoffs-Chlorine-Water.html
"pulcher" is a fairly elementary piece of Latin vocab. It's in Book I of the Cambridge Latin Course, for example. This is much the same in other courses. So anyone, Indian or not, who has done basic Latin in school is likely to have encountered it and hence be aware of "pulchritude".

* https://www.dl.cambridgescp.com/dl_course/book-i

A random other example: https://www.ocr.org.uk/Images/221512-gcse-latin-j282-defined...
I don't necessarily see it as a "win" for Linux, but I do see it as an admission of defeat for windows.

If windows (and it's related tooling) is so garbage that you have to literally bundle an entire OS and tools in it just so that a developer can get real work done, then that speaks volumes.

And also why would I want all of the pain of using windows, (with linux bundled in it) if I can just use linux?
Remote Dental Check UPS
This concerns me very much. Information control can basically be equated with population control. I have no doubt that your average Chinese citizen is a good person and it pisses me off that much more knowing the CCP is manipulating thier own people, often at the expense of thier own people. I recently saw a video that you might appreciate on the rise of open source softwate in China as a means of circumventing censorship and oppression.10 minute video, worth the watch.

Heres the link:
https://m.youtube.com/watch?v=RFjIBM0TR7U

Or you can go to YouTube and search china rise of open source it's by a channel called honeypot. To be honest i fear that the US is also starting to head down that path. Very alarming.
Yogis in India traditionally did it with their own urine.

It sounds discussing, but urine is usually quite pure (although not sterile as is the common myth) and it has the right temperature and salinity.
For error correcting codes (Hamming), you make 1+1=0 as a starting point.

Setting 1+1=2 creates patterns that often useful in real life (e.g. counting discrete objects). But it's by no means some universal law.

In this case setting 1+1=0 creates other patterns useful for error correcting codes.
Aaah, now I see it, thanks!
Richard Feynman on Computer Science
Do we want 100 year old buildings? I don't think we can predict the needs of building even 20 years into the future. City layout could change drastically. Monumental buildings should last a long time, but not every structure.

The alternative is to build from wood whenever possible, and capture extra cabon in building material. This increases market need for wood and therefore forestation.
But what is going to build your iOS/macOS application, the application of %99.9 of swift code? It's only going to build on macOS unless you are willing to illegally virtualize macOS on non-apple hardware.
Looking at 90%ile total income tax in UK it’s about the same as 90%ile in a typical US state, but you get comprehensive health care in UK
Caramel: an Erlang back end for OCaml