skysight-inc/HackerNews huggingface dataset:
When it comes to the brain, I don't think causation (vs. correlation) matters that much. The brain is an association machine.
They just stop working properly when the 3/4/5G gets flakey?

That seems like a poor setup. If being online is that mission critical then it needs backup connectivity.
By building up design habits that lead to things passing the borrow checker on your first try.
When I worked at an online travel agency building our iOS app, dates were a giant pain in the ass. What is today? What is tomorrow? I covered it at https://thecodist.com/what_time_is_tomorrow_tales_from_the_t...
You had me after the first three words
Elsewhere in the thread, someone claims that oxygen has a similar narcotic effect. Does the NFL use a helium-oxygen mixture, or pure oxygen?
Before we crucify these guys do we know what articles they are deleting?

I’ve found deleting the worst quality ads to be good for everyone. Maybe they are deleting the worst.
Show HN: LLM Connected with REST APIs
Hey, folks here is a peek into Jujutsu. We at Poozle are working with hundreds of APIs and it has been always frustrating to

1. Search the API in the documentation or ask ChatGPT

2. Then copy it to the postman and understand/test the API

3. Generate code to integrate into the codebase

We thought how about having all of this at one place. We currently fine-tuned LLM on public REST APIs to reduce hallucination and then combined it with ChatGPT and Postman.

I look forward to feedback, feature requests and discussions!
How do people work without seeing the underlying prompts being sent to the LLM? I think I know what's going on (which probably isn't much?) but at least make it clear what's going on. The details all matter.

Not much here though, just rotating chat with the LLM taking on both sides. The prompts (https://python.langchain.com/docs/use_cases/agent_simulation...) are fine, but not great. No guidance on tension, on actions failing or succeeding, on plot advancement. Nothing to break out of anticipation loops, which are common (when the LLM promises something "is about to happen" but doesn't actually know what and keeps deferring the action).

It probably will work OK because the LLM plays both sides, and does so "fairly", i.e., always in character and never trying to "win". It'll run out of space for the history, but simple pagination might fix it (maybe that's even a LangChain feature?) – it'll drift, maybe dramatically. Or, given the system prompt, it might _not_ drift when appropriate; that is, it might not allow diverging from the original concept, and so not allow consequential action.
"On the developer's machine" isn't correct.

They are actually saved within a special file-system called "citc" (Clients-in-the-cloud). It saves literally every single revision of the file written during development. If you hit save, it is saved in perpetuity, which has saved me a bunch of times. Every single one. No need for any kind of commit or anything else.

Further, these saved revisions are all fully accessible to every engineer within the company, any time they want.
Boomers are in their 70s. They're not everyone who is older than you.
Experimentally one never observes waves. Light is detected based on its interaction with electrons and that is always by an electron absorbing a quanta of energy, not via some continuous process as would be the case with waves.

Classically one can imagine that as if electron was hit by a particle. But then we have light diffraction and interference, which classically is described as a wave. So from a classical point of view light travels as a wave but interact as a particle.

As of nature of the light, then consider that there is a reformulation of a classical electrodynamics that eliminates electromagnetic waves all together. There are only electrons that interacts with each other directly with no waves in between. Feynman spent quite some time trying to develop quantum electrodynamic based on that. He failed. Still the point stands that we never observe light directly but only through its effects on electrons and other charged particles. So it could be that what we call light is a theoretical artifact and there is no light in reality.
Great points here. Walkability is the main reason people enjoy their college experience so much. Imagine having to drive from your dorm, to class, then to hang out with friends, then back. It would be a nightmare. Unfortunately, this is the everyday experience for most Americans.
Try porter.run for full control over your infrastructure with Render style experience on AWS
apple's game-porting-toolkit is amazing, highly recommend checking out this article:

https://www.applegamingwiki.com/wiki/Game_Porting_Toolkit

and this thread (talking about installing 32 bit with wine64):

https://www.reddit.com/r/macgaming/comments/15l0onw/dark_and...

it's for a specific video game, but very similar (using wine)
My goal was to say that Haskell has a single namespace, not that it supports arity overloading, but your interpretation is valid as the text is currently phrased. I will address that (edit: now fixed). However, I don't believe it says Haskell has a special syntax for local calls.

The arity overloading is related (albeit not required!) because it adds to the expressive power of Lisp 1. As the examples show, you need a single function for defining the initial accumulator and the reduction operation, instead of passing two arguments or a composite type (see this example from Clojure [1]). By allowing a single function to encode more information via multiple arities, you also only need to override a single name (which must adhere to all arities). It is also an important characteristic of Elixir, so the article would be lacking if it was not included in the discussion.

[1]: https://clojure.org/reference/reducers#_using_reducers

> If we think a special syntax is needed to use local variables of function type, why not use the same syntax for local variables of all types? E.g. $localvar, $localfunc() vs globalvar, globalfunc().

Elixir doesn't have global variables, so trying to unify from that angle would not necessarily help (it would only make local variables of all types more verbose).
Are there any real-world studies on SPF DKIM and DMARC impact on deliverability?
This would seem to be a simple thing to find but all searches turn up are vague blog posts (symptom of general internet decline but... whatev).

Anyone have something with numbers on this topic bookmarked somewhere? Or that they can share from internal studies at larger email providers?
Inclined to disagree - gpt2 is far more likely to produce gibberish. So if you can force specific outputs on that then it is a good demo that higher quality models will be even better
Montana loses fight against youth climate activists in landmark ruling
>Enabling the same production with fewer workers (or, equivalently, greater production with the same number of workers) is the definition of a productivity increase, not something that constitutes a difference in kind from a normal productivity increase.

Of course. But "greater production with the same number of workers" vs "the same production with fewer workers" is already a difference in quantity (of both production, and, the thing pertinent to the discussion, of workers).

And there's also "greater production with fewer workers" - where you get to have your employer pie (fewer workers) and eat it too (still get greater production).
Yeah, this was my first thought reading through this. It literally makes no sense to close a department that, after operational and administrative costs, is net positive while you are facing a budget crisis.

Later on, the writer mentions an ideological split/decision on the chairperson's part. I wish they would delve into that more. Do the administrative heads feel that using outsourced labor will be more profitable?
This isn’t shocking. It’s the nature of layoffs. The folks making the cuts aren’t telling the the folks in the communications office, “hey, we are firing that person you’re doing a front page story on.”

Also, the department won’t be dissolved until the end of the academic year.
I love this post for this exact reason:

https://overreacted.io/things-i-dont-know-as-of-2018/

It's written by Dan Abramov who has been instrumental in React's development
Haha thank you for the reply. How would you improve the website and/or business strategy of this product? I need to sell 700 more to meet MOQ.
All well and good when u have an active dev team who knows the code. Have fun walking into a code base that has just been running for the last 5 years and all the consultants that created it have left.
Sometimes I despair for humanity [see advertising/social media/politics], but then I see something like this and think, we're doing pretty well for self-taught primates.
This is an interesting point. The link (nor the GP) doesn't claim it's "residential" though, just "retail". Perhaps commercial rates significantly lower it? If you have better data, I'd love to see if it affects the substance of the GPs post.
I have not really figured out whether it's worse to turn programmers into API designers, or to force programmers to talk to each other and agree on a schedule for a feature that only benefits one half of the people talking to each other. Both are tricky.

To me, I think backend teams largely want to be left alone, while frontend teams want to make Their Thing today. So the backend teams say "sure we'll make an API" and then the frontend teams in theory never schedule PM-driven meetings with them, but can still experiment with new interaction patterns cheaply.

How this all works out in practice, I'm unsure, but highly suspicious. My personal opinion is that frontend and backend developers working on the same codebase, going to the same meetings, reviewing each other's code is probably faster and more efficient in the long run. But at some point you need 100 teams, and the "just have one team" method can't scale, so at that point, you have to accept that you can't be perfect and come up with something. GraphQL is that something.

(I would have just used SQL. Many good libraries around for parsing them into query plans that are easy to execute.)
This is a sick path to be on. Keep the money, plug kids into some other university's classes remotely. To what end? A school full of nothing but overpaid administrators, and kids all taking remote classes at disparate cheapest possible offerings?
Absolute shame.

The repo: https://github.com/openfarmcc/OpenFarm seems like it has all the info, and honestly, this doesn't need to be a bloody website, a bunch of MD files with links between each other and hosted on GitHub would be far easier to maintain and extend. If you want to get posh, have it use Jekyll.

Neat weekend hackathon for a group of students or similar, mind you.
Check further pages - some are up. They're not flagged - that would show up differently then just dead. They're just likely to be downvoted, because they're mostly low quality.
i love the stories of companies announcing layoffs and then immediately announce bonuses for management. there's tone deaf, and then there's whatever this is
lots of java shops have loads of internal libraries that solve organizational goals or interface with other internal systems. they will continue to build new projects in java because the cost of tossing all that out is high.
> Boomers are in their 70s.

59-77, this year, by the usual definition.
Based on my personal experience, I have seen some raw SQL codes about 200 to 1000 lines in some production source codes,

not readable at all, not easy to change, which is a terrible development experience.

I guess if it is simple CRUD, it does not give too much problem, but it will definitely work in a complex case.
> It's more that how a lambda can only contain a single expression

That's exactly how lambdas (and all functions) work in actually functional languages like Haskell. And it's a good thing,lambdas shouldn't allow statements.

> how you can't pipe/chain things

Ironically after switching from Elixir to a language where I can have any operator I wish, I found myself using the equivalent of Elixir's |> only on a very rare occasion. IMO they're vastly overrated.
Personal attention costs money.
I've been in ML/vision since the HOG features + SVM and Viola-Jones face detection days, and have seen the methods run on non-cherry picked actual data. I remember when I first got reasonable image segmentation results on my own random photos, or when I first got good captions generated for my own holiday photos, not the test set of the same dataset. You see, back in the day datasets were extremely narrowly defined, small, with a particular style of lighting, the objects at a particular angle etc. The difference is so night-and-day that it doesn't need statistics or meticulous measurement to see it.

A big component of it all is certainly what Rich Sutton called the "bitter lesson", i.e. that throwing ever bigger compute and data at scalable models has been the major catalyst of the field.

But I'll offer up another one. There's some kind of shadow scholarship lurking in the background that doesn't have much of a footprint in the literature necessarily. This is of people trying each other's code, poking at stuff and gaining intuition and converging on practices that actually work, regardless of what the papers say. As an academic you develop a sixth sense for what numbers to ignore and what ideas to try perhaps. This is all vague and adhoc and not the clean story of what The Scientific Method is as described in the serious textbooks. But it does lead to the progress we see. It's just not elegant enough to put into papers. So the main story of the paper is often around a minor aspect of the work, because you can't easily make a story around "I sat down and really combed through everything and made sure not to have bugs and paid attention to all the small details others are careless about." But the net result is that the community will go forward with your codebase and your well-working setup. Even if they think that the part that makes it really good is that weird trick that the paper is selling, when that only contributed like 1%.

And it's not like those long tail papers are totally bogus. Their methods surely work and would beat the state-of-the-art from ~2 years ago even under the highest standards of scrutiny. But it's doubtful it's really better than all the other ones that came out around the same time or a few months before.

Overall, despite the shoddy practices required to publish, which introduces a lot of noise into the system, the trendline goes up, because there is genuine effort put into the work. Maybe all we are doing is some kind of unsexy distributed hyperparameter tuning and architecture search. Hinton humorously called it (at the single-person level) graduate student descent (i.e. that the phd student fiddles with the settings until it works well). And we may be doing this on a distributed level. But still, it does not seem to be overfitting, there have been studies on this that appear high quality.

So well, maybe it's not a "science", but whatever else it is, it is working and does deliver results, so nobody feels a need to mess with a running system. Again, I don't insist on the label of science. Call it engineering, fiddling, or whatever, but the planes do land.
The worst part is how they deceptively hide the nitrites/nitrates. They extract it from celery powder or sea salt and then claim "no nitrites except those naturally occurring in the ingredients". That makes it sound like there is an ingredient that has a trace amount of preservatives, when in reality they have one ingredient that is the source of all of the preservatives, and which was only included for that reason. Even if you're being conscientious, and you're aware that preservatives can occur in natural things and be distilled from those sources, you still have to read the label like a lawyer to avoid getting dosed.
Maybe... but then if I want to use something better, I have to figure out how by myself. I said "at least one example", not "please change all the examples to llama2." I agree with your general point. It would be nice if there were an example of how to use a better model.

Models often have different shapes and requirements, so is it really as simple as changing the string "gpt2" to "llama2-13B-Chat" and it will magically work? If so, that's great, and I wish that was made clear. Unfortunately, that hasn't always been my experience with other libraries.
neuroscientists are just mad that "gut feeling" is actually the truth, and we're generally being manipulated by the billions of microbes in our guts. Simple example: why do people crave cake when they're on a diet that doesn't allow cake? There are microbes that convert stuff in grasses (corn, etc) into opioids. Opioids are great, make us feel great, and if we are used to having opioids and suddenly stop, we go into opioid withdrawal.

I haven't really put a fine point on the grand theory of gut-mind-body interaction, but i'm fairly certain that nearly every disorder or disease that isn't external (like radiation or malaria) will eventually be traced back to gut flora, from auto-immune disorders to depression.
No one is willing to admit here that they too hate Agile for fear of reprisal from current and/or future employers.
I’ve read something like: there are bunch of observations of extremely dense masses in various suroundings. Talented people can find explanations other than black holes in each case.
But that feels adhoc, and black hole fits quite nicely for whole class of observations. Current consensus is that b holes exist.
Remember when you learned how recursion works?

This is a similar case. You'll learn how to understand how a Lisp interpreter works. You'll get an extremely simple one, which is written in itself. The same primitive language which is interpreted is used to write the interpreter. That's basically the local maximum of simplicity. You'll reuse much of Lisp, including the data structures, I/O, memory management, etc. But you can concentrate on the core of the interpreter: how does it process lists of code to compute a result. Thus you'll see a minimal language applied to itself. The minimal language can be written in very primitive list processing operations in a few lines of code.

I've taken one of McCarthy's example interpreters and made the language Common Lisp compatible. One can then load the interpreter into Common Lisp and run example programs. Which example programs could we run? We can run the interpreter itself. Then we have an interpreter of the small Lisp, which runs itself and which itself is running in a larger, but compatible, Lisp.

https://gist.github.com/lispm/d752d5761f7078de4041d4e453e70c...

When you run this Lisp in Lisp, you can debug itself, while it is running in itself... which you can then debug, too.

Once you understand how this simple interpreter works, you can then start thinking of changing it: tweaking the implemented language, making it faster, implement a larger language, ...
"The market can stay irrational for longer than you can stay solvent"
If someone has access to your account I assume they can read all your messages and possibly impersonate you.
On their Github's Readme there is an @farmbot.io address, maybe this project was at least initially maintained by FarmBot employees. Maybe it still is? It seems that someone is still doing the bare minimum to keep the lights on, such as merging Dependabot PRs.

It is a valuable resource and I hope through the exposure here on HN maybe someone will step forward and maintain it.
It's silly to demean the people who did that. You were the one that defined the existence of a "last minute we will accept applications," not those people. If you had wanted everyone to submit applications an hour before that time, you should have defined that to be the last minute (and then not demeaned people who submitted in that last minute). There's either a last minute you will accept applications, or there isn't!
"Data scientist" properly ought to be something like "statistician" or "predictive modeler" in most orgs.

I think the need for a broader umbrella term is still present and I think that explains the wide adoption of the word "data science" in the first place. But the current meaning has been stretched way too far.

> Maybe a we’re seeing unsatisfied need for, like, office workers with some technical proficiency?

Specifically, data analysts who also know Python.
I feel strongly that the stock market is due for a massive crash but I'm also aware of the possibility that some highly connected individuals may find a way to cheat, cover up and censor their way to extend the 'growth' period by some arbitrarily long amount of time by which point my put options will have expired many times over.

There is no way that the stock market would experience a massive crash without some serious massive-scale cheating. If this is an extinction-type event, some banks would go rogue and come up with new (possibly illegal) ways to start printing money to prop up the stock market... Given the complexity of the monetary system and correspondent banking, they could keep this going for a while. I mean there are thousands of institutions involved and countless ways to corrupt the system.

Our modern system is all made up of centralized databases with thousands of participants trusting each other; trusting the data that all those thousands of distinct centralized systems are reporting and treating them as if they were a cohesive whole... That's our monetary system; thousands of databases managed by different people who trust each other based on what each others' systems are reporting with no way to verify any of those systems.
The thing is processes get killed before the IO event appears.
Transitioning prompt classification models using TorchServe
I'm building a webapp backend in Python right now and the ecosystem compared to Java is just horrendous.

* Maven (or at the very least transitive dependency management) is a defacto standard. While some solutions exist such as Poetry, there is no such as thing as a centralized repository with POMs that tell you all the related dependencies easily. And managing virtual environments feels like a huge step backward.

* I ended up using FastAPI + Dependency Injector for the Python project, and while great, it is less robust, less well documented than things like Spring + JAX-RS

* Because Python sucks at multithreading and is slow, everyone has a bunch of C in their libraries, so when there is a bug (which there will always be), it's very hard to debug. In Java land I can easily step through any code, including the JVM.

* Lack of typing metadata - even relatively new libraries like the OpenAI client lack typing information, leaving you guessing about what data is available to work with.

* SQL Alchemy is vastly inferior to Java ORM solutions IMO (no, I don't want to discuss ORMs...)

* IDE support is still relatively primitive for pytest. Until a couple weeks ago, you couldn't see the output of all your tests in the VS Code console log until it was done executing. Or when you get an error, you can't just click on the stack trace to go to the failing line.

* Lack of autogenerated API documentation, e.g. equivalent of Javadoc

Love the Python syntax, but I still feel like I was more productive in Java for writing webapps. YMMV
Writing on Well-Trodden Topics
Thanks for the recommendation, I'll give them a try :).
Boomers born 20 years after WWII? I feel this is Gen X erasure. I barely count as Gen X and I'm almost 50.
Official Android language is Kotlin though.
Which ad blocker was it?
I hate it. No regrets. It is good for newbies only. Even seniors new to project can benefit from it for like 2 days at most.
Updated again. Does this revision make more sense?