skysight-inc/HackerNews huggingface dataset:
In rust, you are required to annotate at least the interface. In Haskell, if I remember it well, it is allowed but not required.

Even in Rust, I tend to specify types at variable bindings if the type gets overly complex, just to push errors closer to their cause.

A nice feature of Rust is you can specify partial types, wih underscores for the still-to-infer part. E.g. let x:Vec<_>=someexpression; is a vector of something, but you don't know what exactly.
In Haskell the culture is to always do it, more or less for this reason.
Hm. As far as I'm aware, we did not have the technology to destroy the world back in WW2 or the Great Depression.

Today, we have several avenues to destroy the entire world, including one that is merely incidental. And we continue to develop more.

So no, I don't believe it is a ridiculous take. I believe your denial is the ridiculous (and naive) perspective.
10 Years of Git: An Interview with Git Creator Linus Torvalds
Gavin Newsom needs to go down fast. Let's put cameras in his bedroom to keep him honest too. No need to criminalize every single citizen.
> Keep inference, it tells you when your annotations are inconsistent with tour code.

Isn't that plain type checking, rather than type inference?

Type checking detects inconsistencies, type inference assigns types in ways that avoid inconsistencies.
Eclipse attacks on Bitcoin's peer-to-peer network (2015) [pdf]
This makes no sense to me. In a generational GC gen-0 is more likely than not to be cached — and that’s where the ‘churn’ is. Outside of that, any longer lived allocations are by definition not easy to control cache-wise.

Locality is one of the big wins for GCs, the only issue I’m aware of is the ‘stop the world’ mark/sweep (yes, I know modern GCs have a background thread — but you still get stop-the-world events afaik)
> Just because you might be able to that (and maybe you prefer to do it personally) that doesn't mean it's enjoyable or a good idea for everyone.

The inverse of this that's always frustratingly missing from this point of view is going to an office. Just because you might be able to/enjoy to do that, doesn't mean it's enjoyable or a good idea for everyone.

People talking about wanting to stay remote for the most part have some line about RTO people being more than welcome to do so, if that's what they want. But RTO people want EVERYONE back to the office to fulfill their want for social interaction, and their inability to be effective remotely.

Both options need to be available. The stigma for working remote needs to die. The people who choose to work remote need to recognize the tradeoff and work harder to stay in the loop and on task. People in the office need to shut up about wanting EVERYONE back, and need to stop making claims that it's "better." No one size fits all, the world would be a better place if people just minded their own business and stopped looking at their neighbor, who might want to stay working remote. Managers need to hire people they trust so the temptation to micromanage isn't there.
The photo from the article shows a pilot with controls (or technician with a monitor?). How autonomous is the robot?
Academic writing 101: The abstract is NOT meant to be written as a cliff-hanger!
SF candidate Bilal Mahmood 'neuroscientist' credentials questioned
What do you think happens when a company is losing money?

It's not like the shareholders are just eating that loss out of the goodness of their hearts. Instead there are layoffs, cancelled projects, and pay cuts. All of those are workers bearing the cost of the losses.
'Where could it be used for?' They ask. Well their observing wildlife is nice, but the real market it observing your enemy in the Ukraine frontlines.
Never could get into foobar... team winamp here
I think the article's take on type inference is a bit heavy-handed and misses some of the nuances of modern software development.

First off, the complaint about reduced readability outside of IDEs feels like a niche problem. Sure, it's a valid point when you're reading code on paper or in a basic text editor, but let's be real: most of us live in IDEs with excellent type hinting capabilities. The argument kind of falls apart when you consider that good variable naming can often make the need for explicit types less critical. Plus, isn't the goal of any good codebase to be as self-documenting as possible?

Regarding OCaml's type inference being a "footgun," it seems like a bit of an exaggeration. Yes, OCaml's system is powerful and can lead to some head-scratching moments, but isn't that just part of the learning curve with any powerful tool? It sounds like the frustration comes more from not leveraging the type system correctly rather than an inherent flaw with type inference. And honestly, adding type annotations for debugging is a pretty standard practice across many languages—not just OCaml.

The point about academic effort being wasted on type inference research also misses the mark. This research pushes the boundaries of what's possible with programming languages, leading to more expressive and safer languages. To frame this as a waste is to ignore the broader benefits of advancing programming language theory. Sure, it'd be nice if papers spent more time on practical applications, but that doesn't mean the theoretical aspects aren't valuable.

It feels like the article is conflating personal gripes with systemic issues. Type inference, when used correctly, can significantly reduce boilerplate and make code more concise and readable. Of course, it's not a silver bullet, and there are situations where explicit type annotations are beneficial for clarity, especially in public APIs. But to dismiss type inference outright seems like throwing the baby out with the bathwater.

In the end, it all boils down to using the right tool for the job and understanding the trade-offs. There's no one-size-fits-all answer in programming, and dismissing type inference entirely overlooks its benefits in many scenarios.
Terrible timing considering what day Monday is.
Hm. I don't see the poster claiming that MM cherry picked their data. Can you quote me the relevant section that makes that claim?
That isn't in the books, the way I read them (I don't recall the movies):

Sauron is obviously pretty clear (but I think even Sauron is a fallen angel of sorts?), but the rest of the story is about how everyone can be corrupted by power and defeated by despair. Even Gandalf, another 'angel' of sorts, could be corrupted. Sauruman, another being like Gandalf and the latter's superior, was corrupted.

In the end, the difference between the heroes and villians is whether they are wise enough to avoid exposing themselves to the corruption of power, and some cross that line. Finally, the ring is destroyed by someone who was thoroughly corrupted but, kept away from power and treated with love and mercy, was able to heal somewhat for a time.
I think that in academic work this is reasonable. People sometimes claim to have done something novel, when it is clearly a repetition of something older. Perhaps the citations of the works being criticized didn't make it clear that they were repeating an old idea. It allows the reader to see that there were relevant previous works that may have been subjected to criticism in the past and that those previous criticisms remain important for the more recent work. The question then is whether the recent work resolves those criticisms. The authors in this case seem not to think so.

A better paraphrase is the following: The new idea is not so new as some claim. It is 20 years old and was previously shown to be flawed in comparison to other approaches. Looking over 40 years of literature, one can see the flaws in the approach and how the flaws were subsequently resolved. Proponents of the "new idea" are either unaware of these advancements or are ignoring them.

I'd say that ignoring previous literature and work is a big problem is CS adjacent studies. My experience is being a theoretical linguist who interfaces with computational linguists. I have had colleagues receive criticism for citing work that is 10 years old or more, even if such a work represents the earliest example of a particular idea they are making use of. It is suggested that a more modern work should be cited. There is kind of an "anti-memory" culture that results from trying to make work seem cutting edge, even if a work is clearly an extension or reinvention of very old ideas.
okay but why not, just, use dogs or coyotes

not joking. Dogs can be trained. Coyotes… just set up some feeding pens full of carrion at either side of the airport, and set up some doors that open at intervals (there, scratched that robot itch).
these aren't login passwords like as part of a credential set. these are what AT&T does, in fact, refer to as "passcodes." and an account holder (or any agent of such) is required to furnish it to any AT&T representative in order to discuss and/or access sensitive account information.

kinda like MFA before MFA became ubiquitious. i have been required to provide all three—credentials, TOTP, and passcode—to access my account for as far back as i can recall.
If you're doing analytics that require full table scans, indices are pure overhead.

No database will beat just piping all the records through some process for full scans.
Type inference has usability problems (2019): https://austinhenley.com/blog/typeinference.html
It’s rather funny to me - that you cannot get security clearance unless you were born in the USA, against the backdrop of the level of contribution von Braun provided.
> Bragging about how simple their deployment is

To the contrary, I wish more people do this: The more people know that their overly complex infra is sub-optimal the better!
Part of the challenge of a reference implementation is that HTMX works with every backend. The Hypermedia Systems book [1] has a reference implementation in Flask (Python), but that’s less helpful if you’re in a very different ecosystem.

I think what’s needed is a sort of, repository of patterns. The main criticism of HTMX is it turns into spaghetti if not well structured. But that is also true of React and needing backend API endpoints well organized, and avoiding React hook-hell. And React has established those robust patterns of usage.

[1] https://hypermedia.systems/
Veloren, an open source game, release 0.16
It made more sense to go through the effort to install IrfanView when there was no image previewer built into windows, in the days of Windows 95/98/ME/2000. Those only had MS Paint, and I think some versions only supported bmp files (no jpeg or gif). Windows XP had an ok image previewer.
This is not good. One of the author's arguments is that type inference in an IDE is bad because sometimes I read code in a book where I don't have type inference...

I don't know about other folks, but the vast majority of code I read is in my editor, where the type inference saves me a ton of time and pain.
Given that the no-GC-by-default market is ~10% of the global software market [1] with no signs of shift in either direction over the past couple of decades, which sounds about right to me (considering the percentage of programs that need to run in memory-constrained environment or must have precise control over memory), it seems that the number of those who may benefit significantly from a different choice is small and so it doesn't look like anyone wants or needs to be convinced of anything. "GC languages" already command ~90% of the market and have little to gain from such a small market of potential converts, and the others aren't trying or succeeding in increasing their market share, so who cares given the small stakes?

[1]: https://www.devjobsscanner.com/blog/top-8-most-demanded-prog...
Your writing is riveting. I enjoyed this comment very much.
That's actually how I use IntelliJ, I'll type something like

x = foo();

And then accept the correction it offers to

vector<Bar> x = foo();

Which is nice enough since you can invoke all this with just the keyboard.
I'm amazed we have gotten this far without something like that happening. Critical infastructure is built ontop of this pile of software that is all being maintained by. If every major piece of infastructure (power plant, water treatment plant, etc) would dedicate 1 full time engineer to 1 open source dependency that they use, there would be more than enough man power to solve it.
I think a TCP proxy would also work with http challenges.
How about 2 or 3 passes, where are you shuffle the pieces around and take another scan or two, to resolve ambiguity.
Timing Analysis for Inferring the Topology of the Bitcoin P2P Network (2016) [pdf]
Maybe a parking lot with cars driving around isn't the best place to demo this product.
The parts of your comment that have any truth in them could have been said of PyTorch when it came out. People wasting time on shiny things is how we get better tools.
An unusual 7400-series chip implemented with a gate array
OCaml's type system allows for expressing complex data structures and behaviors in a concise and readable manner. These types can significantly improve code clarity by providing explicit declarations of intent and structure. Here are some examples:

type 'a binary_tree =
| Leaf
| Node of 'a binary_tree * 'a * 'a binary_tree

type http_response = [
| `Ok of string
| `Error of int
| `Redirect of string
]

module type QUEUE = sig
type 'a t
exception Empty
val empty: unit -> 'a t
val enqueue: 'a -> 'a t -> 'a t
val dequeue: 'a t -> 'a option * 'a t
end

type _ expr =
| Int : int -> int expr
| Bool : bool -> bool expr
| If : bool expr * 'a expr * 'a expr -> 'a expr

type person = {
name: string;
age: int;
address: string;
}
I would much rather drive an anemic Tesla - skinny cheaper tires, lighter so easier to change myself.
Hard disagree. One of the reasons I fell in love with F# was the succint code one can write, specifically due to the compilers ability to infer types.
That will make them persistent liars. And hurt security practices in general

That is why I am all for remediation solutions and compensation.
But also when printing code in a book I would annotate with types, inference or not.
I wonder how much these things weigh. Sadly the first thing that my mind wondered is if someone could attach it to the bottom of a drone. Like the ones the Ukranians are using to hit Russian oil refineries. A lot of those are being shot down by regular soldiers with rifles looking up into the sky.

My guess is the invisibility effect only works at very specific distances and it weighs far too much.
I meant rent on GCP. You’re right.
> but consciousness itself, at least as it is usually conceived of, does not.

What are "you" saying here, and how do you know this to be true?
Apologies, I should've been more clear. The absolute length of SQL wasn't what I was alluding to: it was the ratio of Datalog to SQL I was curious about based on this statement in the website:

> Among database theoreticians Datalog and SQL are known to be equivalent. And indeed the conversion from Datalog to SQL and back is often straightforward.

I was skeptical, and indeed the sample I linked to shows 8 lines of Datalog turning into 265 lines of SQL. In defense of SQL, I note WITH RECURSIVE wasn't used.
SSPL that is now adopted by Redis >7.4.2 is a fork of AGPL and adds one more extra clause that makes it more difficult to run any competing product.
Right. I guess I meant annotate most of the things. (Top level things, complicated inner functions …) A few temporary values (next = current + 1) might go un-explicitly-typed. Anonymous functions will go untyped.
I should have said “ensure your intentions with regards to types are clear”.
If you're using a type like that repeatedly then it probably deserves an alias.
I first read this when I was an English Lit undergraduate. Theory was my favourite topic -- Derrida, Foucault, Althusser, etc -- but this book, in particular, always stood out to me. It's the writing style. The words and sentences are simple, especially compared to other theory books, and it was captivating to read as a result. (It doesn't hurt that the topic itself is highly interesting and relatable.) IMO, an example of excellent writing.
Also not very useful for tomorrow, transgender day of visibility
As a kid, the Lewes ferry was always a treat getting to my grandparents, who lived in Elizabeth across from NYC.

Another treat was driving up the NJ Turnpike past exit 9, because I always wanted to see the old ferry Mary Murray that was beached on the Raritan River. I'm rather sad it's gone.
The core systems of Linux should be secured, regardless of who is using it. We don't need every single open source project to be secured. It's not okay to me that SSH is potentially vulnerable, just because it's my personal machine. As for allies spying on each other, that certainly happens, but is a lot harder to do without significant consequences. It will be even harder if we make sure that every commit is tied to a real person that can face real consequences.
The hydrogen bomb is a quack idea though. The whole purpose is just to destroy cities. It has no legitimate military value. Just because it can be

That is why he was controversial in the post war.
I admit, I like to use `auto` more than I like to read it
The built-in viewer in windows is fine. I can't really think of a feature that it doesn't have that I need. Could you say why irfanview gets your vote?
(1) the pivot from rcu to general purpose tracing gcs is bait-and-switch.

(2) Manual memory management is more than just malloc/free calls -- it's about layout (e.g. struct-of-arrays, inlining, implicit offsets, packing, etc)
Around those times I was mostly a .NET kid and most of the .NET projects I remember looking at were on CodePlex, so maybe my perspective is a little distorted.
Agreed - I'm still using it everyday to view and do some minor editing (trimming and resizing pics). It, along with browsers, VLC, Putty, and SublimeText (and now also ObsidianMD) are the first things I will download to a new Windows PC.
Only if you expand all the discussion they've hidden! Ignorance is bliss, right?

> We are targeting to land support for IPv6 towards the beginning of next year. We will communicate updates on this issue.

Was from 2023-10-01, I guess it's early until June 30.
> languages that use it too much are harder to write. It’s a false economy whereby you save unobservable milliseconds of typing today and make everything else worse.

I enjoyed this reference to a false dichotomy while making one itself. Languages don't make programmers leave out annotations where it aids readability.
Bullocks. I wrote thousands if not hundred thousandths lines of untyped Python code in over 15 years, for critical systems and thousands of users.
It works for me. I'm not confused about the code, I can code and debug quicker than many of my typed-language colleagues and even now that python supports type hints I often only use them in bigger projects or in places where they're actually convenient.
It's simply the way of working that a developer is used to.
> When the Third Millennium Stasis kick off, basilisks on leashes, those are the intelligence treasure troves they will stripmine your optionality with.

I don't know what all this means, but generally I think it's probably not too hard to deduce an org's schedule for certificate rotation by just looking at the expiration dates on those same certificates.
That's certainly true-- at the very least it "seems" like Asian, but it could very well be from any nation. If they were patient enough to work up to this point they would likely not be dumb enough to leak such information.
I also find myself reading code in a browser, for example in GitHub or any other system for source control, issue management, code review etc.
Surprised she didn't "retire" into VC. That seems to be the natural order of things, when you hit jackpot in tech.
the classic article "if only gay sex caused global warming" goes into the psychology behind perceived harm and threats https://www.latimes.com/archives/la-xpm-2006-jul-02-op-gilbe...
> Type inference is bad. It makes code harder to read, and languages that use it too much are harder to write.

If inference is bad, maybe the second sentence shouldn't leave it up to the reader to infer what "it" means. Surely it would be much easier to read as "Type inference [...] type inference [...] type inference".
Vercel's VP of product has been asking for requirements for IPv6 there. This should be a good one.

https://github.com/orgs/vercel/discussions/47#discussioncomm...

It painful to see tech providers go down this road, which is pretty similar to what's happening at Boeing. (Business taking over Engineering)
When trying to figure out something's type is the same as trying to fully comprehend a regex pattern, you know things have gone too far.
> And the company gets to wash their hands of liability (most of the time).

Certification theater.

It's completely performative.
Hey. I'm sorry for bothering you in this thread. I found your old comment about your business processes built around literate programming and I can't reply there: https://news.ycombinator.com/item?id=35988792

Is this approach documented anywhere? Honestly, this would be a cool blog post. I'd love to know more. I use org-mode for literate programming, but jupiter would do as well I guess.

So, my question is more about the business side of it.
The fact that people can get used to something and be productive with it doesn't mean that its not objectively worse than the alternative.
The not-so-cynical view would be that perhaps she enjoys building companies and leading product teams.
I wish I had corporate credit card... I could get myself copy for work...
I feel like this would be very useful in architecture, hiding things like heat pumps without disguising the structure behind by erecting barriers and that sort of thing. Or at events disguising rigging for lighting and whatnot. In my day to day life I rarely need to hide, but I can see lots of applications where hiding fixed objects without disrupting the scenery is a benefit.
If you can think of "no situation" where a server may incur a page fault, forced preemption, or need to perform any I/O to a service/database, then I hope you at least recognise that your world in no way represents the state of server software at large because none of these things is true for the vast majority of server software.

In a former life I worked on some safety-critical onboard avionics software for an ultrasonic platform, and 2us was around the upper-limit worst-case latency (i.e. you'll kill someone if you miss that deadline); still, it's not the kind of requirements the vast majority of software finds itself under.

When working over the internet, some of the very best services are at >10ms ping latency anyway, where a 500us hiccup is imperceptible.
For me it makes sense to distinguish between type inference at the call site or the definition site. As a caller of a function, I don't want to have to spell out type parameters for that function if they can be inferred (but forcing inference is also not great because it's helpful to have type parameters that have nothing to do with the inputs and merely depend on the outputs).

At the definition site, I agree with the author that type inference is more of a burden for the most part, at least if the function is more than a hidden implementation detail of the class/module/file.
I get their argument on reading code in less than an IDE environment (ie. book), but in general, I think _limited_ type inference is good (on classes/structs and functions). Not having local variable types is a net positive in general, but I agree with the author that full type inference (on functions) removes too much documentation. In OCaml one should therefore use interface files always IMO.