skysight-inc/HackerNews huggingface dataset:
There are several problematic patterns at play here, and not all of them are store monopolies: App stores are a clear cut issue since they're a clear walled garden, but soft monopolies are even worse in my opinion. By soft monopolies I refer to those services whose utility is intrinsically tied to the number of users: youtube, social networks, messaging apps...

I'm pretty sure I can build a tinder clone with cool extra features pretty easily - barring maybe the infrastructure to support a giant number of users and the legal issues of operating internationally. But such an app would be completely useless, since the point of the app is that their userbase can easily be half the dating pool of your city. The same idea is true for many internet businesses - once established they're almost untouchable. they can't be challenged unless they screw up royally or someone's able to launch a giant enough marketing campaing that can bootstrap a large userbase in a matter of days.

Join to that the tendency towards monolithic ecosystems (google, apple, to a lesser extent microsoft, huawei...) and the result is pretty scary.
In a sense. You're right that once a container is built, it has few external dependencies. But you need to get those dependencies from somewhere at build-time, and if you're not careful it's easy to do that in a way that makes it extremely difficult to rebuild that container in the future.

To use a slightly more concrete example: let's say you're using a library in your container that has a severe bug. This bug results in incorrect computations, so you would like to upgrade to a fixed version.

Now let's say that when you built that container initially, you installed packages in the Dockerfile by running e.g. "pip install <package>". The problem is that once this image is built, it's nontrivial to rebuild this image and ensure you're using the same dependencies you were the first time. In a sense, you've lost that information (though you can probably start to figure it out with close inspection of the image).

Yes, there are usually ways around this with the language-specific package managers; Node has package-lock.json, Python has Pipfile.lock, etc. But it's not even close to being the default.
For all cli apps, the importance of cli itself can't be understated. While there are only a few cli programs available to ALL unix users (grep/ps/awk/sed/xargs/etc), the value of the pipe are one of the defining features of CLI that amplify any program made to work in CLI.

A command I often run: `ps aex | grep $common_denominator | awk '{print $1}' | xargs kill` to deal with multiprocess testing runs demonstrate this well. The pipe character is what uniquely enabled unix shells to be the great software it is that GUI have almost no real way to replicate.
Is this an American thing?

In Europe I never ever hear cars beep when locked/unlocked, just the mechanical sound of the central locking and flashing the hazard lights once when unlocked, double when locked successful and tripple when lock failed(door not closed properly).

Having your car make a loud sound for lock/unlock just creates more noise in the neighborhood.
Warren Escalates War with Zuckerberg and Facebook
People also aren’t adaptable to the ocean rising above their nation and swallowing their land below the oceans waves. The projected effects from each degree c of change are not linear. But the IPCC report assumed linear effects - 1% gdp per degree c change, according to a talk someone else posted. That’s highly unlikely. At one projection the earth may only be able to carry 1 billion people but be projected to have a gdp only 4-8% lower than today. Any economist worth their salt should be able to tell you that losing 6/7ths of humanity is going to shrink the global economy by something way, way higher. It probably doesn’t even make quite the same relevance to discuss global gdp in that world.
How does this implicit Copy trait interact with the Drop function? Doesn't that mean that the implicit copy would be dropped rather than the actual value for those types?
Interesting. Maybe my worry about new age stuff was unfounded.

I don’t really like the philosophical direction of the concept, though. It mostly seems about acknowledging that we are fundamentally coupled to our environment, and that our minds are not really designed to function in isolation as a brain in a vat.

That’s all true, but I think it dilutes both the definition of “self” and of “mind”. While we are not designed to function in isolation, the boundaries placed by the more traditional conception of both the self and the mind make them more useful, imo. If we consider the “self” to extend into our environment whenever there’s a dependency, at what point does “self” just become synonymous with everything? It’s going in a direction that makes the concept meaningless. And I don’t think it gives us any insight.

For example, it is incorrect to think of object instances as living in isolation during the runtime of a computer. They are a part of a more holistic state, and interact with are influenced by other parts of that state constantly.

But if you try to think of a program in terms of one giant state blob, reasoning becomes basically impossible. We need to break things down into differentiated modules in order to understand them. Keeping the concepts of “self” and “mind” as tools with which we can differentiate between something like “experiences per meatbag” and “thing doing the experiencing“, respectively, seems important, and the “embodied cognition” idea seems to be trying to get rid of those tools without replacing them.
Also, in physics at least, it seems like at some point in the 80s, the writing in academic papers became much worse than before.

When I had to (had the pleasure to) read some older papers, it was like they were from a different genre. They were clear and pleasant to read. Maybe it was before academics were measured by "hard numbers" (the academic version of PageRank - resulting in link farms) that some lazy fools made up.
name one except python
The author’s solution to help haskell take over the world seems to create a clone of it which lives in image-like environment, and breaks every single code management tool we have?

I thought Smalltalk showed everyone that this is not a good idea already?
Keep in mind that the printers are getting regular upgrade cycles. A 2019 i3 MK3S is nothing like a 2015 i3. Firmware upgrades are released every couple of months. So continuous testing is still valuable.
Dead, 5 others injured in shooting at Kansas City bar; manhunt underway
Earplugs and a white noise app!
Yeah, I posted a few comments here without actually watching their marketing video, and didn't realize it had those two things. Upgrading to get those features seems like a good idea, to compete with the cheaper models.

I don't think I would have engineered a new board and control stack just to get a web interface and a screen. Their last model (the i3 MK3S) has headers to accept a Pi Zero, and that seems like a good approach modulo the bugs, which would be worth fixing. (Apparently the bugs are, the Pi Zero isn't fast enough to emit gcode to the UART and record a video stream from a camera at the same time. I kind of doubt it, but that's what I'm told. The other problem is that the i3 has one power switch, so it can't keep the RPi on when the printer is powered off. This means a lot of people are corrupting their SD card, which is probably why they complain about the setup randomly breaking.)

I just want a USB serial port that accepts gcode. I have plenty of computers with much better screens (and SSL stacks) around for doing something more powerful ;)
I mean, one could complaint about many things in Django, but the documentation....??? Really?
unique_ptr disposes of the object its holding when it goes out of scope unless passed to another unique_ptr or ownership is explicitly released. Presumably klipt would std::move the unique_ptr, hence the universal reference (which seems unnecessary, just pass it by value).

Am I missing something? Does it not work with std::move?
You might be biased by the US West coast, which is an earthquake zone. Thick brick walls like that are common in the Midwestern US.
I expected it to -- graphically, it looks very similar to Penrose notation! -- but at first glance it seems to be quite different.

Penrose notation is very high level: edges correspond to tensor dimensions, joining corresponds roughly to tensor contraction. When you're working with multiple complicated multi-dimensional tensors, it can be a beautiful way to express things.

This notation seems to be expressing something a bit lower level: it seems that edges correspond to values and dots correspond to copy/add. So, roughly, they visually express linear functions. (I didn't read the full post, it's possible that they expand beyond this initial meaning.) Diagrams of a similar style are used in other contexts (eg. expressing the weights of neural networks), often as a pedagogical tool.
The site guidelines ask you not to post like this—would you mind reviewing them?

https://news.ycombinator.com/newsguidelines.html
I'm European, and pretty happy that the GDPR exists, but even I can't deny that a law is just as strong as the ruler's capacity to enforce it, and I'm a bit sceptical about the EU's ability to effectively govern the whole internet.
Oh, crap! DCOM! I'm have trauma just seeing those letters in that order.
For me, rust is still love & hate, even after 1 year of half-time (most of the free time I have) hacking.

It's a wonderful language but there are still some PITAs. For example you can't initialize some const x: SomeStruct with a function call. Also, zero-cost abstraction is likely the biggest bullshit I've ever heard, there is a lot of cost and there's also a lot of waiting for compiler if you're using cargo packages.

That said, I wouldn't rather use C/C++/Go/Reason/Ocaml/? - that is probably the love part.

BTW: I've recently stopped worrying about unsafe and it got a bit better.

So my message is probably:
- keep your deps shallow, don't be afraid to implement something yourself
- if you get pissed off, try again later (sometimes try it the rust way, sometimes just do it in an entirely different way)
Tesla Cars Have a Memory Problem That May Cost You a Lot to Repair
Hangouts / Meet is terrible in all browsers but you're right, it's less terrible in Chromium. I keep Brave installed just for Meet.
NLL does not change those semantics; drop still runs at the end of the scope. It counts as a "use" for the purposes of NLL and thus keeps values with destructors alive.
Yeah, you can get some feedback from the controllers easily (and then omit physical endstops).

I am waiting for a 3D printer that uses servo motors, though. So many failed prints come from not knowing where the extruder is. But you can just measure exactly where it is, rather than guessing based on how much current the motor used.
That ultimatum is idealistic at best.

Not only that, the recourse of inspecting and modifying the code isn’t realistic to most people. Many open source projects die just because literally nobody with the skills required to maintain them are interested.

Then you get to certain types of programs where open source provides no benefit: specifically, games.

Games are largely just artistic content. Making games open source essentially means that all the content is going to be taken without compensating the artists. Open source works for other programs because they depend on interoperability. But games are just content, like a movie or book. The source is the product. For other programs, support and continual development are the product.
If journalism, as a profession, is to add more societal value than random blog posts, I think there needs to be a fundamental reworking of the medium. As it currently stands, the medium itself encourages sloppiness. A modest proposal:

1) Articles should, like legal briefs, support each non-trivial point with a footnote or citation. Primary sources, such as presses releases, documents, and transcripts, should be hyperlinked from the footnotes.

2) Long form articles—unless they appear in a literary magazine—should contain section headings ordered in a logical manner.

3) An adversarial aspect should be introduced into the medium. When a judge receives a legal brief, she doesn’t review the brief in isolation. Typically, there is an opening brief, a response, and a reply. It should be a matter of journalist practice to write response articles to other articles. Aggregators like Google News could then make it easy to see, for example, the Wall Street Journal’s response to a New York Times article.
“Seeing White” the podcast is maybe the best starting point to get to the heart of what race is.
https://www.sceneonradio.org/seeing-white/

The big takeaway: it’s invented recently (historically) and has no objective/natural basis. Otherwise and xenophobia, of course, are more fundamental to our nature, but not “race”. It was invented, and now we have to contend with it.
The compiler prevents you from implementing both Copy and Drop (i.e. a destructor). So dropping any copy type is a no-op.
You may be able to turn it off. I just went into my Vizio M’s settings menu for the first time in forever and low and behold a ToS for “Automated Content Recognition” shows up before I can access the settings. They make it sound so cool.

The setting can later be accessed buried away in “Reset and Admin”.

I wonder often if technology needs more legal guardrails for the 90% of people that don’t pay attention to telemetry and will gladly accept. Nutrition/medicine is another iffy one. It’s interesting to me how some countries require warnings on high sodium and high sugar food. Something like that probably wouldn’t fly in the US but I like that it exists.
https://web.archive.org/web/20191012190019/https://blog.prus...
I wouldn't say std::mem::drop acts like free at all, it's the equivalent of a destructor in C++. Mostly useful when you're dealing with manually allocated memory, FFI, implementing an RAII pattern, etc.

One cool thing about Drop (and some other cool stuff, like MaybeUninit) is that it makes doing things like allocating/freeing in place just like any other Rust code. There may be some unsafe involved, but the syntax is consistent. Whereas in C++ seeing placement new and manually called destructors can raise eyebrows.
Hopefully in this case, they will switch to Firefox.
Yes, you're missing that the type `T&&` is a reference, not a value, and so does not run the object's destructor when it goes out of scope.
agree all is gameable - this is why I argue social media should provide tools for users to filter their own content rather than being everyones nanny
how is that a trick? you still can't access without quotes? the real trick is a Dict class that in the __init__ sets self.__dict__. but why would you do that just to save trying quotes
Given FaceBooks recent troubles, yeah, this seems a little tone deaf
There's no doubt that facebook done a lot of harm by leaking private information, but it's disingenous to call facebook 'disinformation machine' when people actively chase and consume disinformation to satisfy their own bias.

If they won't be able to find disinformation on facebook, they'll move to other echo chambers like reddit and continue to consume the same crap. To expect a substantial portion of population to suddenly gain the ability to think critically against their own bias is not realistic. Facebook is just a scapegoat in this regard.
Yeah, that's probably it. I was counting from completion date.
The Camp Fire, which is the one that looks likely to bankrupt them, probably wasn't even caused by inadequate tree trimming. Apparently one of their power lines had a weak, defective fixing which failed due to the same high winds that caused the fire to spread so rapidly and uncontrollably.
> Also, zero-cost abstraction is likely the biggest bullshit I've ever heard, there is a lot of cost and there's also a lot of waiting for compiler if you're using cargo packages.

Zero cost refers to runtime cost, not compilation cost. Zero cost abstraction is not bullshit.
The usual suspects for things missing from go are the following: Generics, sum types, match statements, tuple types, compile-time data-race detection, type-safe concurrent-maps, hygienic macros, immutable types/references, functional constructs such as 'map', 'filter', or monads, marker interfaces, better error handling, type-inference for consts that isn't garbage, etc.

Less common complaints are that it's missing: object oriented features like inheritance, a configurable gc (as java has), the ability to work with OS threads, c-compatible stacks for fast c-interop, ownership semantics, type-inference for arguments (e.g. as haskell does), operator overloading, dependent types, etc.

The list of things in the first set can mostly be summed up as "go has a worse type-system than C++/rust/etc, something much closer to java 1 before generics, or c". Basically, the language is intentionally crippled because it intentionally ignores advances in type-theory that have been shown to allow expressing many things more safely.

For example, sum types and match statements make modifying code much safer. People will write switch/if-else-ladder code to do exactly the same sort of thing even without them, the code will just fail at runtime rather than compile-time when a new variant is added or one is not handled by accident.
Many people either cannot hear very low frequency sound, and they cannot understand what it’s like for those of us who can.

The sounds don’t necessarily get louder at night - there are just fewer competing sounds to mask them.

Earplugs and other sound barriers make it worse by filtering out higher frequency sounds, making the remaining VLF sounds seem louder.

VLFs also penetrate earth, stone, concrete, etc. And because of their long periods, especially when accidentally synced with parallel walls, some locations in your house can behave like an amplifier.

There’s no real solution other than moving, and there’s no guarantee that human progress will not catch up with you in your next location.
It may be an unnecessary dig, but the author may indeed be familiar with Go and still think it's unacceptably crippled for all their use cases. The whole post is just their opinion.
This is incorrect. Values still go out of scope and have their destructors run at the same time.

NLL only affects values without destructors.
In a corner of Brazil, the state is achieving “media capture”
NLL didn't affect when objects get dropped. That would be a breaking change. Things still get dropped at end of block (well, approximately... the exact rule is actual quite complex).
Work for a remote first company, make your desire for leadership opportunities known during the interview process, and follow up on that goal in 1 on 1s.
Show HN: BuzMap – Global Unified Transit Map
Go code feels very low-level to me, and very boilerplatey. In Rust I can write code that in almost the same way I write JavaScript (but with added type annotations), but Go makes me deal with all the little details, and makes it hard to abstract things neatly.

Lack of generics is a big part of the issue. But more generally the focus on "simple" code means that more sophisticated abstractions are actively eschewed, and personally I find this makes writing Go code quite frustrating.
If given a good spec, a clearly written formula, I don't think it's too unreasonable to expect a seasoned programmer to implement it despite not understanding the science that prompted the math. Maybe I'm wrong for some kinds of exotic math, but I've certainly implemented a few mathematical formulas that looked like Greek to me, at least when I started.

Moreover what I propose is that every researcher have a programmer available to consult with, who would perhaps write small amounts of code (perhaps make sure the code builds before it's published?) I don't suggest that researchers not write code, I think they should write code. But I think an expert in writing code should be available to help keep the standard of code high.
that one is legit. sometimes I do something like map(int, [x,y,z]) and I always trip over that it's a generator
> bells from catholic churches

The huge bronze bells in Germany are another thing entirely. They sound wonderful (dare I say heavenly?).

But the cheap electric klaxons used in American churches are horrible.
So... Don't be a one-trick pony?

Duh, quite obvious, diversification is what all companies desire, but most just try and milk the golden goose for as long as possible. Until it is too late.

It does astonish me though when every year I walk through the booths at AWS Summit (poor man's Re:Invent) and see all these companies that are a feature-announcement-in-one-tiny-paragraph-in-an-AWS-blog-post away from going out of business. But I guess it pays the mortgage bills for a lot of people until those blog posts.
I will try to present to GeoMob sometime next year. I have stumbled across an interesting/powerful way to render planetary sized vector tile sets, leveraging Agafonkin's amazing geojson2vector of course.

I am not having much progress selling the idea that people like to look at a map and discover stuff. I like to devise "excursions", daft train trips that last weeks, that kind of thing. The layout of any region's transit infrastructure., from metropolis, country to entire continental level is at the very least highly intriguing.

You obviously have to do this with vector tiles, but even then you need to rapidly simplify the network if you want it to be interactive obviously, the lines have to be merged and unique else you wont be able to interact with them. It's timetable driven we only paint where we know there's a service, not everywhere we can see railway track and not by crudely styling out road classifications, It's not a journey planner. it's a route finder though. You get to see every route in any context just by looking at it. it's a map. I am using graphhopper extensively behind the scenes obviously but a much closer integration with a multi-modal journy planner is required. Once you actually get down to asking what time the bus actually comes we are better off in a journey planner proper. Existing journey planners to my knowledge dont allow you to wave the cursor outside your hotel and instantly see where all the nearest buses go to.

They dont allow you to look at a country and instantly see there's an interesting wiggly line on some extremity of the network that will invariably turn out to be some kind of tourism target. They don't allow you to look at an entire continent and visualize all international ferries, arterial bus routes and essentially the entire rail network, in one blink.

I need to put back the whole of TfI buses and ferries as we have essentially comprehensive data set for ROI. And I have some bugs and thresholds to fix. I will update this thread if there's a significant step forward, Collaboration or just vocal support is sought.
Maybe. But it’s also slightly more nuanced. Honda for example works like this. One press of the remote, locks all the doors. The second press will beep the horn if all the doors are successfully locked. If you left one of the doors open, the horn won’t beep on the second press. So it’s a away of getting confirmation that all doors are closed and locked. It seems useful, but when my neighbor comes home in the middle of the night and locks her car and the horn wakes up my kid who starts crying, it seems a lot less useful.
It's not out of date, source on that claim? It's 1.22.4 just as it is in the Chrome store. https://i.imgur.com/c2voeqg.png
I used to work for a firewall company in the 90's. Their product's original name was "Janus" until they discovered Europeans pronounce it without the J sound -- like Anus. They renamed the firewall to literally avoid sounding like ass (a startup story that unsurprisingly does not appear on their corporate ABOUT page).

Now, about "Perennium": Taint the kind of name I would use for that very same reason.

This isn't meant as an insult and hope it doesn't come across that way. I love the project idea.