skysight-inc/HackerNews huggingface dataset:
You can get light out of anything.

All you need to do is shoot it with a photon bean, and the when material can no longer absorb the photons you send at it, it will begin releasing them as reflection. But the one you are shooting in aren't the same ones that are coming out.
There is more to dependency risk than 'getting hacked' - correctness, maintainability, IP due diligence all play a role.
BS. Ruby isn't slow. The same apps can be written in pretty much any language nowadays.

The problem is in developers. They are slow and dumb and lazy and most often also biased. Blaming language is easy. Bad developer will always write spaghetti no matter which language he uses.
what do you mean by product velocity? is it development team velocity?
This "news" article exemplifies the specious yellow journalism that surrounds COVID-19. For example, it repeats a rumor, based on unconfirmed data from China, that people with type A blood have a significantly higher risk for acquiring COVID-19 compared with non-A blood groups. The article was apparently intended to frighten people with type A blood. Otherwise, they might have investigated the data being compiled in the U.S.

COVID-19 tests may be new, but routine blood typing has been around for a very long time. With 20,000 COVID-19 deaths currently being reported in the U.S., we would suspect that the blood group data would be available anonymously for thousands of them without delaying for publication in a peer-reviewed journal.
How the A&W Third Pounder failed to compete with McDonald’s
WTF horizontal gene transfer = platypus!?!?

Show me some paper on this. I mean an actual scientific paper, not a paper used to roll a yard-long spliff.
By making a new handle every day, apparently.
Citrulline Mallate, Argenine also increases nitrogen in the body and so do green leafy vegetables
I'm probably a lot lower than you but I feel I hit a similar wall. I naturally end up writing a function soup which feels super dirty.. as much as I dislike the term (uml-overload) there's a need for architecture that I don't know how to address in FP.
Not just a SCSI interface, it turns the Raspberry Pi into a SCSI device so you can hook it up and use it as a hard disk for computers like the X68000.

Old Macintosh and Amiga enthusiasts should get a kick out of this as well.
Once I saw that I could tell it was news from an alternate timeline and ducked out.
It's not really hell though, is it? Hell is infinite pain and agony. This is more like an occasional bother.

Yes, we get comically large numbers when we look through node_modules. But, real "dependency hell" is when you have situations that take unbounded manual effort to resolve.

How often do we end up with impossible circular dependencies? Or conflicting versions clobbering each other? Or non-deterministic builds introducing random behavior?

That all is commonplace even today with other platforms like python, and rarely an issue with node. I'd much rather occasionally sneer at the size of node_modules than any of that actual hell.
I think that by the time they become stable enough to use as a daily driver, no one will be using 2003-compatible software or hardware. If they're even using the hardware now, that is. I mean we're talking ten years and older.

I don't question why they're "bothering", but I do wonder why they haven't adjusted their compatibility goals to something more useful such as Vista or Windows 7.
It's less true now because some of the patterns associated with code that's difficult to understand have been deprecated or flagged by the community to avoid.

For example, implicit conversions are now disabled by default. It's possible in Scala to pass a Foo to a function requiring a Bar due to a chain of automatic conversions from Foo -> Baz -> BazMutable -> Bar. This is fun and magical but difficult to understand and debug. The community and language itself now suggests against this pattern.

Another example is that it's now (more or less) recognized within the community that it's not preferable to dogmatically adhere to a particular style of programming, such as pure functional or reactive/actors. It's better to use the right tool for the right problem.

Whole classes of confusing code are now prevented or mitigated by language changes in Scala 3. For example, Scala 2's implicits are famously hard to learn and follow within a codebase. One reason for this is that in Scala 2 the keyword "implicit" was overloaded into a few common patterns, including the aforementioned implicit conversions, typeclass instances, and dependency injection. Scala 3 introduces new constructs and keywords to split out these patterns into separate language features, making them easier to learn and more understandable within a codebase.
Not a downvoter, but I did have a blog that I didn't promote, which I used mostly to get practice with my writing. I enjoyed it being public but with zero traffic, because writing that is 100% private can easily turn into a private rant. If there is the chance it will be seen, I hold myself to a higher standard, and hopefully that practice comes across when I engage in written communications with others, whether on HN, other sites, or at work.

Ultimately, though, all the sharing of our blog URLs and this related discussion made me realize that I didn't really want an audience, so I killed off my domain.
I think "good enough" is not a perfect mentality for what we want from our services. Ruby 3x3 is great (3 times faster is insane!), and we are looking at many things to optimise Ruby. TruffleRuby does aim to get more than 3x faster (already does on optcarrot) and could also provide some insight to be applied elsewhere. Other reasons include TruffleRuby features such as Chrome dev tools debugging (I'm not endorsing it as superior or inferior to any existing Ruby debugging tools) and polyglot programming. All in all, the goal is most accurately described as "research".
1527 tabs in this session with about half of them loaded in fully and half just "suspended" with tab history and favicon. My browser is using just under 3.5 GB of ram. I don't use 'web apps' block all JS and run a single process browser that isn't chrome.
While it's still very slow, modern Javascript VMs are fast enough for many usages. Ruby is slow, but it could be a lot faster with a lot of time and money.
Here's a note for everyone:

> I do have backup archives of many of the videos and they will be back online again as soon as possible. Unfortunately, I was not diligent enough in keeping backups — especially early on. I am missing the following 21 videos ...

Another reminder, yet again, not to trust "Cloud Services" and always to have a copy of data you care about.

I hope the problem gets resolved and the channel is restored, I hope we get to hear what happens.
>'TruffleRuby has high potential in speed, as it is nine times faster than CRuby on optcarrot, a NES emulator benchmark developed by the Ruby Core Team.'

Really? But now the latest results are in apparently and judging by these benchmarks[0], I don't know what to make of this claim given how slow TruffleRuby is when compared to other similar languages or even Ruby. But its clear that its LLVM-based cousin Crystal still blows it out of the ocean in every benchmark if you're really talking about 'high performance'...

[0] https://github.com/kostya/benchmarks
Okay I’m safe then.
Two systems, one for Tax/Assessment which was provided by the state is SQL and ASPX and the other which is used for historical inquiry and document generation which is in-house code in SQL and Coldfusion.

The ASPX taxing/assessment system is the slow one in comparison when it comes to calculating. The ColdFusion system is not as hindered but its used for making letters and reports, exporting layers to GIS, and generally replacing COBOL-screens for information retrieval.

Is/are there better solutions, yes, but I was giving an example rather than critiquing the County’s choice of software that happened well before I came along.
I would second this.

My experience is that people get scarred of so much new terms which get introduced in Haskell and that could feel overwhelming.

When beginning with Haskell, I would advice to just write code and try to intuitively understand bits, but not get down into unwrapping things or theory much. Stay high level and figure out how things interact as you would do in black box model. Don't open the box, but poke it and see what result you will get (in other words; just write code and do trial and error).

When you get comfortable with black-box learning then open the box and look for the details.
Chamath Palihapitiya: Pay every American more, let billionaires ‘get wiped out’
Really like OneTab for this same functionality.
https://www.one-tab.com
- For Firefox and Chrome.

Differences, clicking OneTab's "Share as web page" will give you a link with the date-time you merged your tabs into the OneTabs list as well as a QR Code.

Saving tabs and also saving memory, when it auto merges them into a single space.
Before Firefox switched to WebExtensions there were addons that made that possible, but I don't think they work anymore. So I have about:profiles page bookmarked which has the restart button and use that when needed. Not the most elegant solution, but it works.
The first time I saw Connections it was broadcast by the local PBS station. No commercials.
I wish I could see what this looks like, I'm having trouble imagining how it all works.
And avoid using mouthwash: https://www.ncbi.nlm.nih.gov/pubmed/31709856
Agreed. Title is quite far from the truth
I had success by replacing the get_mask function with:

from keras.models import load_model

model = load_model('models/transpose_seg/deconv_bnoptimized_munet.h5', compile=False)

def get_mask(frame):
# Preprocess
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

simg = cv2.resize(frame, (128, 128), interpolation=cv2.INTER_AREA)
simg = simg.reshape((1, 128, 128, 3)) / 255.0

# Predict
out = model.predict(simg)

# Postprocess
msk = out.reshape((128, 128, 1))
mask = cv2.resize(msk, (frame.shape[1], frame.shape[0]))

return mask

The model file I got from:
https://github.com/anilsathyan7/Portrait-Segmentation
Boy book 0.50 only enjoy
1: https://payhip.com/b/4rY2
2: httpjos://payhip.com/b/H7CJ
3: https://payhip.com/b/Tedc
4: https://payhip.com/b/qYlM
5: https://payhip.com/b/SD9k
6: https://payhip.com/b/EWLz
7: https://payhip.com/b/fnc1
8: https://payhip.com/b/hsTE
9: https://payhip.com/b/5pua
10: https://payhip.com/b/D71r
11: https://payhip.com/b/Hp6r
12: https://payhip.com/b/9mHw
13: https://payhip.com/b/YW6K
14: https://payhip.com/b/Dbt1
15: https://payhip.com/b/C0ma
16: https://payhip.com/b/HCqQ
17: https://payhip.com/b/wK8F
18: https://payhip.com/b/BUtj
19: https://payhip.com/b/0mPr
20: https://payhip.com/b/bs48
21: https://payhip.com/b/zkTE
22: https://payhip.com/b/cZIz
23: https://payhip.com/b/O728
24: https://payhip.com/b/oEHi
25: https://payhip.com/b/DFpU
26: https://payhip.com/b/l9hC
27: https://payhip.com/b/udvD
28: https://payhip.com/b/RmAj
29: https://payhip.com/b/qU26
30: https://payhip.com/b/mCEe
31: https://payhip.com/b/kV2W
32: https://payhip.com/b/d306
33: https://payhip.com/b/v0bd
34: https://payhip.com/b/N6G0
35: https://payhip.com/b/7SRY
36: https://payhip.com/b/5kvp
37: https://payhip.com/b/7uvt
38: https://payhip.com/b/yuw6
Golang does a lot better than other languages (but probably the language that allowed me to use the most unmaintained/oldest projects is Clojure, I can't remember/find out when the oldest breaking change to the language was), but the situation in Golang was piss poor not too long ago, when Golang libraries were all fetched from GitHub/Git sources without any way of specifying specific versions, you basically lived on the edge all the time. There was third party tools to work around this (and the ever present vendoring technique) but seems weird they didn't realize this until gomod started being a thought.
Because we can't even agree on whether React or Vue or Angular is best.

In fact this is the root of the issue. It's important to realize that `node_modules` for any project in Popular Framework X will be almost identical. Most of the packages are related to compiling, bundling, and the development environment and a small minority are actual client-side dependencies. Even the frameworks themselves are pretty light -- React has a grand total of 2 dependencies. It's packaging the entire toolchain that causes most of the bloat.
This is an example of one of those rare posts made by an expert that is generally understandable by anyone, but still gives glimpses into the mastery of the work by the author. Great read, love old posts like these. I have never even thought about how it's a challenge to get patterns to line up correctly on clothing.
I wish, there was an english version, because this looks very interesting.
One curious thing I gleaned from the schema is that the scsi-bus can also be used to tunnel ethernet and remote file-systems, and not only block devices.
I found a picture of the meters for those that are curious - http://static.righto.com/images/ibm-360/epo-30.jpg
Funny, I'm the opposite. I used to switch between the two for about 15 years or so but these days I'm tired of dealing with issues around Linux hardware drivers each release; so I've settled into just using windows.

When I want the nix experience, I'll get it on VirtualBox (I don't count WSL, personally; though I do use it)
Python dependency management is a disaster. But I find myself using far fewer dependencies with Python projects so I suffer the pain less.
Crystal is not Ruby.
“ We make the Facebook, as people using it.”
This is false. Facebook has hundreds, if not thousands, of product people working to alter, maximize, and monetize user behavior.
that's life 95% of the time. many people have an opinion, but most of them don't have the depth needed. the important thing is that you 1) are curious 2) you keep learning.
1406 points, 216 comments, 3 days ago: https://news.ycombinator.com/item?id=22815453
As a general comment about production applications, memory is less important than speed since computers are cheap compared to having poorer user experience. Also, with JITs, consuming less memory isn't that realistic. You can find "complaints" about Pypy and Java and consuming a lot of memory.
Boy book 0.50 only enjoy
In my experience is the people who complain most audibly about npm are the same folks who think nothing of spending a few days debugging classpath issues.
Reportedly, there are definitely more interesting challenges. We are seeing this in academia quite frequently where the older professors have some hard worked program in BASIC from whenever and they try really hard to get someone to maintain it's existence since otherwise their efforts really do disappear. For the person taking this on it's tedious, thankless and of dubious tangible merit to the participant who should be focused on their own contemporary work.

Have the reports of high pay been confirmed, AFAIK the push now is for volunteers.
System/360 was supposed to be ASCII from the get go, the architecture supports it (the RCA Spectra 70 series which was a System/360 architecture system was ASCII).

All System/360 descendants support ASCII, the issue they ran into early in the System/360 program was accessories, IBM had lots of EBCDIC I/O devices, and developing a line of ASCII I/O devices would have delayed introduction of the line by a period of time.
I have eight Chrome windows open across six workspaces.

Seven windows have between 5 and 20 tabs open.

And I'm ashamed to report the eighth window has so many tabs I can't see them all when maximized on a 32-inch monitor, just have to ctrl-tab through the invisible ones that scroll off the right side.
I’ve tried learning Haskell once or twice and it didn’t really click. However, I’m know knee deep in learning Lean, which is a dependently typed functional language that is also a theorem prover and it’s been a much easier ride. It’s not any less complex than Haskell but learning FP by essentially doing mathematics has made it a lot easier for some reason.
You don't think that there are any issues going forward with the survivors who realized that government opted to liquidate them to save money? No issues from all the people expected to go to work and possibly die and ultimately infect and kill their relatives? In your perspective these people just keep going to work and creating shareholder value?
Businesses should Reduce social contact by serving one client cohort per day
I'm also a JS developer myself, so I guess the dig includes myself too (99% of my time is spent with ClojureScript). JavaScript was just a example out of many. Same with Java or basically most languages, where you can't change the core language from the outside without forking it. I don't think anyone will deny that some languages add features just to satisfy a smaller part of it's users, because there is no other way for those people to get their features.

Because of it's dynamic nature, there is no plateau in Clojure (lisps in general), the responsibility just shifted to outside the core language that Rich Hickey et al maintains.
Forecasting with uncertainty
I have https://clusterwm.com/ set up to open once I hit Cmd+Shift+L.

It opens a new tab with a list of open tabs and a (focused) search field you can use to filter that list. Really useful when you have a ton of open tabs and looking for one in particular.
https://blog.jldc.me/

Most of my articles aren't opinion pieces or tutorials - they're explorations of topics and events I found interesting. I'll work through my logic and steps to discovering something new, or reverse engineer something that someone smarter than I did.

Some of my favorite posts:

https://blog.jldc.me/posts/illegal-streams?ref=about - Illegal streams, decrypting m3u8’s, and building a better stream experience - An article on exploring illegal sports streams online, building a client to watch them, and seeing how the streamers are piggybacking real services.

https://blog.jldc.me/posts/deobfuscating-amex-scammer?ref=ab... - Obfuscated javascript, scam emails, and American Express - An article on reversing and decompiling obfuscated javascript, tracking spam emails, and finding the root command and control server for a scam campaign.

https://blog.jldc.me/posts/ryan-air?ref=about - Ryanair, Hamiltonian Cycles, and using graph theory to find cheap flights - An article on how I routed my European vacation, writing an NP hard problem solver, and releasing a tool to help you do the same.
I guess this is very subjective but personally I wouldn't ask this question, especially in a technical interview. First, it may embarrass the interviewer. They may not be willing to answer this question. Second, after you know the answer, you won't be able to fix anything. You don't want to start arguing that lacking a degree is not a big deal.

It's akin to asking someone in a date "any reason why you wouldn't like me?". It feels like lacking confidence and anticipating rejection.

This question could make sense if you don't get an offer. If you get a chance to talk to the recruiter, you can ask them if there are particular things you could try to improve if you were to interview again at their company.
Google is free and your aggro stance doesn't encourage me to satisfy your petulant demand.
One thing I haven’t seen listed yet that is important to personal happiness:

“What does your change process look like?”

Do they have boards and paperwork? Pull requests and code? Engineer just executes? Do they make technical decisions at the team level or require further meetings / boards, etc.

Tells you a lot about the company both in terms of maturity but also in terms of culture.
Show HN: Is this how to post a post to show HN please ignore this
I thought I told you to ignore this huh?
you people are so ......... give a vote plz
Sounds like every other believer of the JVM. I’ve been reading about how Java outperforms C for 20+ years now. When it doesn’t even come close, someone faithful of the JVM insists that I try some new garbage collector or wait for the next release.
There is something that has always bugged me about the space curving analogy and how it relates to relativity.

Gravity in a multi body system or in special cases of a two body system, has counteracting forces. If you found the Lagrange point between a binary black hole system, you could stay there. Or if you hollowed out the core of the Earth, you would float because you are being pulled in all directions at once (essentially the 2 body problem doesn’t “behave” for concave objects or distance less than diameter).

Is time slower or faster at the Earth’s core? Is it slower or faster at the Lagrange point of a three body system?
I’m surprised you had such a bad experience with scala. Or do you think these are problems with how scala is perceived versus how it actually is to use?

Personally I liked it. I spent a while doing java web dev with the play framework, and also spent a while doing scala web dev with the play framework, which allowed me to compare directly. I have to say scala is a far nicer OOP language than java. The collection classes are better designed, the way futures and options work is so much more elegant than the java counterparts, and the overall syntax is much more efficient. IMHO if you just use scala as a nicer java, it absolutely trounces it. I couldn’t really say what OOP feature it lacks compared to java. I never tried kotlin, so I cannot tell how that compares.

I also spent a while doing FP style programming with scala in
spark and akka. I cannot compare it against other FP languages because I never used them but I can say it was similarly very enjoyable and it was easy to write elegant and understandable code.

I would agree mixing both approaches in a single codebase is a path fraught with peril. If scala has a flaw then it is having too many features. Like C++ you need to be careful which features you use in which combination, or you can end up writing an intractable codebase.
Not technically but it can run a lot of Ruby code with no changes.
I dont know enough about SRTP negotiation to know if a downgrade attack is possible, but I can see ways in a new system to deal with that though.
Indeed and probably there is no perfect measure for this. One way to look at it is Maven download data (https://i.imgur.com/66yEO9C.png) where it continues to increase. Another is to look at Google Trends data (https://trends.google.com/trends/explore?date=all&q=%2Fm%2F0...) where it seems like it's decreasing in searches.
To be sure. And I don't think that modern Fortran is overly obscure that you couldn't basically pick it up over a weekend from the language specification.

Every modern Linux distribution has a current gfortran bundled.
Right? I thought it's one of the most popular Lisps.
I very much agree with your point on academics pursuing programming language theory for the sake of theory, and not for language design. I don't want to disparage FP research as a whole, but it seems to be the area of language design that cares the least about practicality and I don't really know why.

Being an undergrad doing my dissertation into programming language design, it seems that FP evolved from an area of research that was very much tied to the theory of computation and never really danced with the practical side of software engineering. Of course there are a few languages that have tried to marry the two (OCaml, Rust to an extent) it seems to very much a mathematicians game. Of course I love the math but it gets annoying to explain that no programmer should have to have a working understanding of category theory to use a language effectively.
Scala and the Play Framework became my tool belt for whatever web application I need.
It has all the batteries included, it’s stable and rock-solid.
It never felt so good to use a “boring” stack.
We had a teacher in the 8th grade that basically forced us to watch the whole thing. I liked it then. Love it now.
Maximum number of participants on a meeting on meet.jit.si server
The other day I had over 800. I went on a closing spree and whittled them down to ~150 that I'm _sure_ I'll get around to reading any day now.