skysight-inc/HackerNews huggingface dataset:
Still, coming from other languages, it is all too easy to write this and this silently fails without any warning.

This is consistent with the rest of the language, but I'd bet one rarely wants referential equality when comparing strings.

People commenting "yeah but that's because you are a newbie / you are comparing references and you should know better" miss the point I think. I can easily see myself making this mistake while fully understanding what's going on.
If you actually understand Java, you'll understand why this is wrong. Only newbies have confusion about this, most of which dissipates when you actually learn the language you're working with. Tired of this 20+ year old "flaw" being used as cannon fodder.
> greed or negligence

greed breeds negligence
KeePassX wasn't a fork of KeePass since one was developed in Qt, the other in .NET. It was just a compatible program.
> It takes way too many clicks to report spam in GMail. Considering this is such a frequent operation, it should have a one-button "ban" function, possibly with an "Oops" undo if you pressed it by mistake.

If keyboard shortcuts are enabled, '!' is mapped to "Report as spam". I don't recall whether the status popover that appears at the bottom of the UI has an "Undo" link, though...
It's rather easy to use, stable, has a really decent standard library, the tooling is excellent, it's performant, etc.

There are 3rd party libraries and integrations for _everything_ and it's comparatively easy to find skilled developers with years of experience.
It's not about moderating all language, it's about SELLING ADS in all languages. If they make money from those ads, then they should have people hired to review those ads. If they can't find the people, then just don't sell ads in that market.
Language with a fast runtime minus startup (although maybe they've fixed the startup since I last looked) that is incredibly tunable to fit your specific needs for good performance profile, while not needing to manage raw memory the way c or c++ would.

Personally I prefer c#, but a lot of places already were using Java in significant ways before c# became good (IMO 2.0ish) and saw no reason to change.
An interesting side effect of these types of companies popped up during the Navalny team's investigation of Putin's alleged yacht in Italy. They got the ship's crew manifest and then used a database like TrueCaller to check it out. The manifest had the crewmember's name and a phone number - so when you look up the number associated with 'Alexander Pechurkin', other people have him listed as "Sanya FSB" "Alexander FSO" and "Alexander Graceful Procurement". [FSB = Russian security services, FSO ~= secret service, 'Graceful' = Putin's previous yacht]. Pretty interesting work history and descriptions for a Boatswain's mate in Italy.

https://youtu.be/WyYp9xPLa8s?t=423

These lists must be a gold mine for intelligence agencies.
If you have an Android device, AnkiDroid 2.16 (currently in alpha) has basic drawing functionality [0].

Image Occlusion is available via a third-party app[1]:

The app is open to pull requests (raise an issue/pop into chat), and provides an API which allows external apps to create cards.

[0] https://github.com/ankidroid/Anki-Android/releases

[1] https://f-droid.org/en/packages/io.infinyte7.ankiimageocclus...
Aren’t yellow pages also adding everybody’s number without consent?

I didn’t grow up with them so I might be wrong.
Post a photo of a woman's nipple and you'll have your account removed...
I clarified that on our website, since that topic comes up again and again: https://keepassxc.org/docs/#faq-general-plugins
I guess it depends on what "decisions" we are talking about. I took it to mean design decisions, in which case Security and Simplicity are generally orthogonal.

Plain text passwords are a lot simpler and less secure than salted, hashed passwords. Using bcrypt to hash your passwords is a lot simpler and more secure than some home-grown, self-implemented hashing algorithm.

Also as it says he is talking about priorities, if something is simpler and less secure then choose security. If something is simpler and more secure then hey double win.
Great tooling. Good performance. The JVM is very tunable. Huge ecosystem of libraries. Language wise modern Java is fine, but if not, there are other languages on the JVM that interop.
I consider it a fair trade. I hand over my contacts and you tell me with high-confidence who the other person on the other end is.
The problem is that it's a different set of people who will die with self driving cars. Imagine the trolley problem but instead of 5 vs 1 it's 30,000 vs 29,000. The 30,000 people get hit by the trolley and die if you don't pull the lever, and a completely different set of 29,000 people die. People who did not do anything wrong. People who had no chance to fix the situation. Sure, it's 1,000 fewer people, but none of those 29,000 people did anything wrong. They were all killed by the self driving systems made by car manufacturers.

Regardless of whether or not you personally would pull the lever, you have to admit it's not the same as saving 1,000 lives.
CRT specifically attacks equal treatment under the law. The idea it attacks outcomes is a woefully simplistic understanding of its core criticism.
That's a reason not to use Oracle--GP's asking for a reason to use Oracle.
> Java developers are cheap and easy to find.

I wish.
Not sure, but 30% of crashes are alcohol-impaired. https://cdan.nhtsa.gov/tsftables/tsfar.htm# -> chapter 2 -> alcohol -> table 31
Me too. But it seems most people just believe everything they read, so I think it's important to be aware of it.
I agree with all points with respect to static EMRs including NLP efforts.

The cadence, uniformity and alignment of event stores to underlying pathways does pose an opportunity (but there's so little research and I suspect Brian didn't have access to this space). An EMR is a projection/point in time snapsot of these events (basically API calls). There's also inherent natural labels because inferences are evaluated against an actual pathway.

Specifically speaking about intra-episodic inferences -- longitudinal predictions (over several episodes -- or a patient life time) becomes wildly inaccurate. There's a lot of research to demonstrate this no matter which models are used.
who do you think should take the other portion of responsibility? Certainly not the person sleeping in th back seat with no control?
Doesn't seem equivalent, since at least treatment for immediate medical emergencies is given regardless of ability to pay.
you are in for a big surprise: there are quite a few people that do not build up any response to vaccination naturally, called either primary or acquired immunodeficiency, as well as immunosuppressed who cannot produce a response to a vaccine (those on CD20 inhibitors, or on daily equivalent of 1mg/kg of prednisone, etc, etc, etc).

There are millions of people with primary (1 in 1000), some more acquired, and hundreds of millions of immunosuppressed globally. "not a single person" just sounds laughable in this context.

500,000,000 vs 1.

Is that science? or is it hysteria?
That sounds like they are expecting a predictable relationship between literacy rates and once-in-a-lifetime geniuses being born…
> Plus, the author gives some good examples like pulse ox%, doctors and nurses are not at all concerned with or trained to record data in a way that makes sense to use programmatically. They're typically thinking only as if they're recording it for another human to read.

The unstructured doctor's notes may be where the best signal lies. Thet should be mostly uncorrupted by the billing/process related trash. Deep learning does not need data to be formatted to be read "programmatically", in fact it shines most on data that isn't.
Well I don't know, but I'd have a guess as to how they might easily do it. Pattern recognition and/or machine learning. Something like: here is what the pattern of a user moving through space when they are in a car. Here are a million other ones. Here is a pattern of a user walking through space, taking a bus, etc etc.
Now here is an unknown user. What pattern of movement does this user match closest to?

A pattern would be, for example: is he ever seen moving more than 5mph? Does he use driving directions? Is he only seen moving faster along bus routes? If he is only seen along bus routes does his pattern of moving and stopping align with the bus stops? Is there usually traffic jams at the same time of the week on different days, etc.

Just build up a database of patterns and check a 1 week old account with that to see what it fits best.

Perhaps in an area with no predictable traffic and no bus routes, that a wagon of phone matches the pattern of a traffic jam caused by a blockage on a road. It's less likely to be a bus, perhaps?
You can get a paid commercial support license for Oracle's JDK to get an extended maintenance window. But Oracle's publicly available builds don't require a paid license. However,they only provide public builds of the current Java version. If you want LTS, you have to pay them or use another vendors builds.
Yesterday, on one of my increasingly rare Facebook peeks, I kept getting this ad which was a link to a controversy with Mayim Bialik where she apparently got into a big spat with a producer over her touting new CBD gummies that supposedly cure dementia, and then it exploded into a huge thing, with even Tucker Carlson from Fox News weighing in, blah blah blah. It was perfectly-crafted clickbait because I clicked through just to read how insane it was.

The whole thing never happened! Complete and total hoax. A pump and dump scheme that Snopes got wise to more than a week ago. And it showed up in my feed 4 times in scrolling five minutes. I reported every single one of them as a scam.

I swear, no one is at the helm over there.
If I were the only person using it, yeah probably. As it is, with a household of other users, it’s staying for now but I still really enjoy thoroughly mocking HBO for it whenever the chance allows.

At least the emails are no more.
>> To train the system with a minimal amount of computing and memory, the researchers actually built two identical networks on top of each other. In the “clamped” network, they fed in the input voltages and fixed the output voltage to the value they wanted. In the “free” network, they fixed just the input voltage and then let all the other voltages float to whatever value they would, which generally gave the wrong voltage at the output.

>> The system then adjusted resistances in the two networks according to a simple rule that depended on whether the voltage difference across a resistor in the clamped network was bigger or smaller than the voltage difference across the corresponding resistor in the free network. After several iterations, those adjustments brought all voltages at all the nodes in the two networks into agreement and trained both networks to give the right output for a given input.

How is this not just a perceptron? I'm also curious about the rule for adjusting resistances in both networks.
To rephrase the famous quote attributed to G. Box,

`All languages are wrong, some are useful.`

And R is one of them.
The Lynch version deserved all the drubbing it received. Weirding modules, heart plugs, and rain on Arrakis: trampling all over the novel. The exposition by way of overdubbing was horrible too.
That’s short term look out over 50+ year periods and it moves in one direction.
Java values backwards compatibility very highly, so if something runs today, it's likely to keep running without modification on future JVMs. (Though the 8->9 transition was pretty rough for some.) Compiled Java artifacts are usually portable across OSes and CPU architectures, so your build pipeline can be pretty simple even if your infrastructure is not.

JVM performance is generally fine, and the language prevents you from introducing whole classes of memory safety bugs. You can still shoot yourself in the foot with native (JNI) extensions, but the decent performance of the JVM makes developers use JNI far less frequently than, say, Python or Ruby devs reach for compiled libraries.

JVM byte code decompilation is fairly trivial, so tools for the security scanning of artifacts are cheaper and more fully featured than similar tools for scanning machine code.
This structure (especially the optionality of the second pass) is how you end up with perfectly readable code iterating over List<T> when a hash map would suffice and be orders of magnitude more performant.

Nobody can do it perfectly, but I think trying to keep personal nitpicks out of reviews as much as possible - ideally by codifying team nitpicks in automated formatting/.prettierrc/whatever - lets people focus on things that matter: what the code does and how it does it.
Calculating your compensation – Hourly to Salary Calculator
Depends on the company a lot. I had my first return employee last year and it was a huge morale boost. I know from a friend this is super common at Stripe. In general it’s a good sign of a supportive company.
> It's clear some service team at Microsoft used Okta to SSO, or a contractor that did that's why they only got 37GB of code and Bing/Cortona not Windows OS or internal tools.

Did i miss some news or? I know Okta and Microsoft was compromised, but is there anything which shows it was related except for the hacker group and timing?
Because Java is engineered. You can imagine the amount of work going into it. You have multiple companies have whole teams working just on different garbage collection algorithms. No other dev stack has this kind of focus. The JVM is a small wonder. And Java is evolving quite nicely too.
And Curtiss is that Curtiss. Always fascinating to me how two rivals ended up with their companies merged together: https://en.wikipedia.org/wiki/Glenn_Curtiss
I do not know but apart from just vendor lock in, oracle might provide guarantees (maintenance?) that the other providers cannot.
It is true that C# improved this. Separating primitives and references in Java was definitely an error and it cannot be fixed at this point.

The good news is that a linter trivially detects this bug.
Congratulations on the launch. What is a good email to reach you at?
That's the OP's point, if you blame it simply because it's driving, you're incentivizing the systems to only work when it thinks it's 100% safe to drive. It's how you get "you can only engage on pre-defined major highways and only during daylight".
both. you absolutely benefit from being free to improvise and follow the creative muse when pen on paper

you also need a well-thought out outline for any larger work like a novel, or, it will be a disaster, or at least not be anywhere as good as it could have been

credentials: creative writing for decades and experienced 1sthand tradeoffs of each. my verdict? seek the Hegelian dialectic. ;-)
Implementation guides built on HL7 FHIR are well structured open protocols for interoperability. Several of the largest EHR vendors actively participate in defining those standards, and have built them into products.

Of course that doesn't solve the garbage in / garbage out problem. If users configure the software incorrectly or don't enter the right data then then you don't have much to work with.

In some cases NLP technology can be used to convert unstructured chart notes into coded clinical concepts. That can work well enough for research and analytics, but isn't accurate enough to use for direct patient care without human review.
Still waiting for JNullType to be deleted or made illegal to inhabit all reference types.

"I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language (ALGOL W). My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn't resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years. In recent years, a number of program analysers like PREfix and PREfast in Microsoft have been used to check references, and give warnings if there is a risk they may be non-null. More recent programming languages like Spec# have introduced declarations for non-null references. This is the solution, which I rejected in 1965." -- Tony Hoare

Let's give credit to C# and Dart for fixing this, and bring shame to Java and Go for not doing so.
Copyright infringement requires sharing the copy without a license to do so, not making the copy
> Aucun organe de coupure externe

My understanding of this is possibly that "externe" here means external as in external to the building.

Presumably, there was a breaker - it was just in the same room as the fire.
+1, I also focus first on readability while reviewing code.

Software engineering is a collaborative process. I don't write code for the machine; I write it for my colleagues and my future self to read. Code we write 6 months ago looks like someone else code. Readability is important unless you're convinced that it's prototype/throwaway code.

After readability then I'd look for tests. It's a theme: good tests are also meant to be read as documentation. Beside ensuring correctness, it's also the example my colleagues or future self can refer for the module usage.
And Javelins don't get stuck in dirt, wallowed in ditches or stymied by curbs.
I remember checking out Common Sense once, and it quickly became apparent that it was a conservative reactionary paranoia engine and not a platform for intelligent discussion.

If you want a conservative anti-"woke" angle on things, The Weekly Dish and Matt Taibbi are much better reading. Even if you disagree with a lot of what they write, at least they mostly try to argue in good faith.
there is a lawyering up way to go forward

And there is a political way to go forward, start a political movement of people who sympathize with you, and don't want anything like that ever to happen, declare a goal to provide legal council to every case like that and sue the fuck out of every company that does anything like that again.

The perfect start is to start a fundraising campaign(with first step to fund your fight, and all other steps to create a nonprofit).

P.S. also it would strengthen you negotiating position in current settlement, but i hope that if you have the strength to start fighting you will not walk away.
Great error handling? What does that mean? Checked exceptions seem cool at first, but are really just nonsense… as your only real way of dealing with this is:

1. Catch, log and rethrow, or

2. Wrap as a runtime exception (so you don’t have to change every method signature up to main())

Sure, there’s option 3: catch and handle… but this is used 1/50 times, and the ergonomics of (2) overwhelm the utility of this.

BTW, vavr is nice. Just, “run it all” and optimize for the golden path. If there’s an error account for it locally.
There’s a lot of different kinds of deadlines. Some can be extended. Some can not.

“I love deadlines. I love the whooshing noise they make as they go by.” - Douglas Adams, a man who was very familiar with the many varieties of deadlines.
Sure, but in the novel, Arrakis really is hot. In the Appendix, it's stated that the sand surface reached 76.85 Celsius (170.33 F).
Mainly if you want long term support from Oracle. Many enterprise systems are very slow to update. So they can't manage to upgrade before the LTS version goes out of support. So instead of paying to developers to continuously update the code base they pay Oracle to keep supporting the "out-of-free-support" versions of the JVM.
I've always taken part of my job as a data scientist is to articulate when data is not sufficient to meet a particular a goal (and to outline what data would be necessary). For some goals doing special data sampling and building a model on small (complete) data is better than using the fragmented overall database.

I work mostly on claims data now, and building models to identify problematic claims I assure folks is feasible.
If you need to run Oracle apps like EBS. They only work on their release, not openjdk.

Side note: Avoid EBS at all costs if you can, unless you like spending money on consultants and like crappy obfuscated processes.
I think you're missing the point: it's incredibly hard to determine functional correctness of unreadable code.

So the first priority is getting the change to a readable state. I'm not talking about nits, I'm talking about minimizing the cognitive overhead to truly understand what the code is doing.

That being said, it is also easy to identify nits during this phase. In codebases that have collections of best practices, this often helps to ensure that the change is expressed in terms of a common vocabulary. Once this pass is done, the reviewer can usually better understand the intent of the changes.
true caller's dumping of one's contact list is no different what facebook did

I don't see anyone in this discussion saying that what Facebook did was OK.

Or is that the point that you're making? Because one person stole a car, it's OK for everyone else to steal cars, too?
Cromemco Cyclops
Using backend technology:

- Java has great ecosystem support

- JVM is very performant

- Java has well understood quirks

- Reasonably mature build system

- Good deploy story

I wouldn’t use Java for a web server but I like it very much for many other things.

I think Scala + Play does a good job for JVM web frameworks but I’d use a Typescript thing (or just Rails)

There are downsides to Java. Bit and byte manipulation are annoying, for instance. But I’m still happy with it.
Another aspect, the pyramid makes code review look like the only thing around the actual value outcome. There’s a lot of other aspects like pair-programming that eliminates most things in the pyramid, taking it out of scope from a review process
It is a perceptron, just implemented in actual hardware. The Veritasium YT channel recently did a piece on analogue computers [0]. I didn't find his explanation too compelling, but it is still a good video.

[0] - https://www.veritasium.com/videos/2021/12/21/the-most-powerf...
I think the Swift compiler does less magic for SwiftUI. They added a new literal syntax for the UI view tree literals, but other than that I believe the behavior is in the runtime. SwiftUI expects you to use Combine, Apple’s (F)RP system, to a greater extent than Compose expects you to use RxJava/Kotlin Flow. My impression is that Compose is more React-y and is actually an escape from RxJava FRP-land; I can translate most hooks to Compose after reading the Compose docs a few times but find it much harder to do the same with SwiftUI/Combine.

Personally I prefer Compose because it’s open-source (so you can figure out how it works if you need to), has much better docs, and seems less welded to FRP stuff which I don’t enjoy. I don’t really have enough experience to really review either though.
Was referring more to structured stack traces. You're able to shoot yourself in the foot in any language's error handling system - quite trivially at that.
> It sounds like a good idea, but I can imagine lots of downstream breakage, some of it not immediately obvious, with apps that make bad assumptions.

You're not wrong, which is probably why they did it in this release.

JDK 17 was an LTS release, and 18 isn't. The next LTS will be JDK 21 in September 2023:

* https://www.oracle.com/java/technologies/java-se-support-roa...

This presumably gives folks times to adjust before jumping between LTSes in production.
Actually, i like it for basic desktop apps, because it just works, and i stay clear of the last 12 years of front-end dumpster fires, where nothing that is over 18 months old, can build, compile or get support anymore. In my day job, I inherit "fun" tasks as 'get this thing someone glued together with webpack4 and frontend-du-jour to work with webpack5 in 2022. Java thank you, any day of the week.