As an "unlucky" person, I can't help but wonder: what about an alternative version of the experiment where the newspaper contained the big "This newspaper has 43 photographs" text - followed by 44 photographs?

(This "unlucky" - or perhaps "paranoid" - mindset has, frankly, made me a damn good programmer and debugger.)

Especially since commonly followed wisdom seems to be "trust, but verify."

Tbh If I noticed the text(s), I'd still have counted the photos and still looked at every page in case there were other prizes.

See other top-level comment - direction was to keep counting, and you would indeed have won another prize (although it's unclear whether they actually paid out).

Hmmm, "Rama is programmed entirely with a Java API – no custom languages or DSLs" according to the landing page, but this sure looks like an embedded DSL for dataflow graphs to me - Expr and Ops everywhere. Odd angle to take.

I consider "DSL" as something that's its own language with it's own lexer and parser, like SQL. The Rama API is just Java – classes, interfaces, methods, etc. Everything you do in Rama, from defining indexes, performing queries, or writing dataflow ETLs, is done in Java.

This is usually referred to as an "embedded DSL" - you have a DSL embedded in a normal programming language using its first class constructs.

Yep the original term DSL was for custom languages, the eventual introduction of using it for these kinds of literate APIs was done later. Using it in the original way unqualified is fine imo.

Meh. By this definition all libraries expose an "embedded DSL" — their API. I'm honestly not sure this is a useful definition.

Whether you like it or not; internal DSLs became a thing with Ruby back in the day. And these days things like Kotlin also lend themselves pretty well to creating internal DSLs. Java is not ideal for this. Kotlin and Ruby have a few syntax features that make it very easy.

What's the distinguishing difference between a regular library and an embedded DSL?

The difference is making an effort to expose the features of the library via a syntactically friendly way. Most Kotlin libraries indeed have nice APIs that are effectively mini DSLs.

If you need an example, Kotlin uses a nice internal DSL for HTML where you write things like

  Div {
     P { 
        +"Hello world"
     }
  }

This is valid Kotlin that happens to construct a dom tree. There is no magic going on here; just usage of a few syntax features of the language. Div and p here are normal functions that take a receiver block as the last parameter that receive an instance of the element they are creating. The + in front of the string is function with a header like this in the implementation of that element.

   operator fun String.unaryPlus()

The same code in Java would be a lot messier because of the lack of syntactical support for this. You basically end up with a lot of method chaining, semicolumns and their convoluted lamda syntax. The article has a few examples that would look a lot cleaner if you'd rewrite them in Kotlin.

Odd thing to split hairs over.

When someone makes a distinction that you don't immediately appreciate, maybe don't just dismiss it as splitting hairs, as if the world was a simple place.

It’s not a small detail. It’s one of the headline claims!

It is, though, by the same argument also collectively dumber than the dumbest person who ever lived. No single human moron's brain could accommodate so much misinformation, useless fluff, spurious reasoning, etc. etc. etc.

So I think time will tell. My money is on a sort of regression to the mean: these models will capture the style and "creativity" of the average 2020s Reddit, StackOverflow, etc. user. I can't say I'm terribly excited.

> It is, though, by the same argument also collectively dumber than the dumbest person who ever lived.

Not at all, it's not symmetrical. You're ignoring the training data and all the additional RLHF fine tuning. The model is being actively penalized for being dumb which is why it isn't that dumb in a lot of cases.

but the popular models plastered across HN are in fact, dumb in a lot of cases.

Everyone is impressed when the model does something they don't understand deeply. But it's very rare when someone is impressed when the model is generating text based in something they do understand deeply.

I do think it's slightly better than the mean across all topics. But I also strongly suspect it'll soon serve as a great example for regressing to the mean.

> But it's very rare when someone is impressed when the model is generating text based in something they do understand deeply.

This statement sounds out of date. And you can see this sentiment a lot on HN. I don’t know if the people who say this haven’t tried GPT-4 or they have and are just stubbornly refusing to change their mind about something when presented with new evidence.

> s haven’t tried GPT-4 or they have and are just stubbornly refusing to change their mind about something when presented with new evidence.

Have you considered that the evidence just isn't convincing yet?

If you view popular llms as text prediction machines, they are in fact much better than spell check or auto correct from a few years ago. But if you actually ask it to solve the problem with nuance it will not use nuance. That's the part that would impress me.

As a recent example if you ask chat GPT how to use ffmpeg to slice out a video. and you tell it that you only want 3 seconds of video. somebody who deeply understands how ffmpeg works, (or even someone who deeply read the documentation) would point out that you have to be aware that it can only cut to keyframes. so if the keyframe is not aligned to the time you ask for you will not get the video that you expect.

another example ask it to play 20 questions with you, it will cheat at the end. even if you give it very specific instructions it still is unable to follow them to the fair conclusion of the game. (or it will make a mistake and understanding about some of the semantics of the question, but I don't fault it for a difference in context)

I'd caution you that just because you're impressed for the subjects that you understand deeply does not mean that chat gpt is good at all subjects. and therefore I assert that it is disrespectful to be so dismissive of people who have different opinions than yours. I believe the default should be to assume good faith rather than dismissiveness "they just don't understand"

I had it extract some general rules from this page and pasted them below:

https://video.stackexchange.com/questions/26302/ffmpeg-cutti...

USER given the following general rules:

1. The issue described in the text occurs when cutting a video between keyframes, resulting in blank video with original sound. 2. Potential solutions include overlaying the copied part with a few seconds of the re-encoded original, seeking to an earlier frame, finding the previous keyframe and clipping from that, or re-encoding the whole clip. 3. FFmpeg does not have a built-in feature to automatically resolve this issue.

Are any of these rules applicable to the question below?

"how do I use ffmpeg to slice out a video. and I only want 3 seconds of video." ASSISTANT Enter an assistant message here.

ASSISTANT Yes, rule 1 and rule 3 are applicable to the question. The issue of cutting a video between keyframes may apply when slicing out a 3-second video using FFmpeg, and FFmpeg does not have a built-in feature to automatically resolve this issue.

USER Given that what is the answer to the question

ASSISTANT To use FFmpeg to slice out a 3-second video, you can use the following command:

```bash ffmpeg -i input.mp4 -ss START_TIME -t 3 -c:v libx264 -c:a copy output.mp4 ```

Replace `START_TIME` with the timestamp (in the format `hh:mm:ss`) from which you want to start the 3-second clip. For example, if you want to start at 1 minute and 30 seconds, the command would be:

```bash ffmpeg -i input.mp4 -ss 00:01:30 -t 3 -c:v libx264 -c:a copy output.mp4 ```

However, if you encounter an issue with blank video caused by keyframe cutting, you may need to seek to an earlier frame, find the previous keyframe, or re-encode the whole clip as mentioned in the provided rules.

It seems to be able to find the applicable rules and apply them.

I'm not sure what you thought I meant. Or what this is supposed to show. If you tell your text prediction engine to make sure to account for keyframes. It's not impressive that it responds with how to account for them. I know it can use ffmpeg, I haven't seen it attempt to account for well known edge cases, or caveats they way a real expert trying to be helpful would.

ChatGPT with GPT-4 with just "how to use ffmpeg to slice out a video" pasted directly from your comment without any additional prompting or clarification brought up your point about the keyframes.

So whatever you think you're criticising isn't the same thing that I'm using. Kind of demonstrates my point that you're either using an older version or choosing to ignore evidence for some reason.

It doesn't impress me that once corrected (which it has been multiple times), that it stops giving wrong answers. If it was able to detect and supply nuance to something novel. Then I might be impressed.

BTW: when I posed this question

> how do I use ffmpeg to slice out a video, I only want 3 seconds of video from the middle

to chatgpt4, it did not mention anything about accounting for keyframes. So I'm not sure what version you're using, but it's not the one I have access to :/ Another reason to assume good faith, because you seem to have access to something that I don't.

And, this is now (well before this specific conversation) an expired example because openai's model has been specifically training on this nuance, and thus even if it never made a mistake around it, it still wouldn't be impressive to me; simply because this nuance was directly added to it's model. Remember, we're talking about if the abilities of available models are impressive, what would be impressive to me is if they're able to generalize well enough to know things they haven't been directly taught.

I watched some flat earthers in debates, and they seemed to revel in their freedom to not be impressed by their opponents arguments. It seemed like a kind of rush for them, like a kind of power trip, that was more intense the stronger their opponents arguments. Like a kind of 'no matter how strong your argument is you can't make me agree with you' power trip.

I don't mean to imply that I'm attempting to not be impressed. Before writing the comment you replied to, I asked a friend who is enamored by the new abilities how I would know my mental model for how it works, and what it's able to do is wrong. If I'm wrong, missing something, or making a mistake. I'd like to know about it. Outside of that, the context for the whole discussion is

> Why do so many assume we’re on the cusp of super-intelligent AI?

And how "smart" text to text engines can become.

My argument is actually pretty close to yours. People that are impressed, want to be. They're looking for ways to be impressed. Just like you think I'm looking for ways not to be impressed. Which, even if I am, it still should be easy to convince me (or others) that super-intelligent AI is coming soon to an API near you!

Right now, the LLMs that are the new hotness, aren't super intelligent. They're not domain experts, they can't play a simple game that children love without cheating. They're easily distracted if you know how to word a question correctly. While it's cool they can generate language that seems to be true, and useful. It's not as useful as what already exists. (For the context that I care about) And, all of these examples are markers of below average intelligence. What's the argument that would convince me that very soon, we'll take something stupid and make it hyper-intelligent? Because that's no something I've seen happen before.

Still, all of that said. Your comment that seems clearly meant to be insulting, doesn't actually make any other point. Did you mean to imply something else? Or was it just an attempt to throw insults by pretending to make an observation? Because the conversation is about if people should be impressed. Which when it comes down to it an opinion, are opinions bad?

I guess what I'm supposed to do in 2023 in USA if I have a prediction, like a prediction that increasing params+flops+dataset LLM training will keep unlocking new cognitive capabilities, is to make money from it by doing some kind of investment. I don't know how to do it though. The obvious suggestions are like TSMC, NVIDIA, an AI-specific portfolio, etc. but I'm not confident that those would be good investments for unrelated reasons even though I am confident in my prediction.

I think the issue is just that people are using different words to mean the same thing.

If we get precise, take for example what you said earlier:

> it's slightly better than the mean across all topics.

Most people who can do "better than average across all topics" usually aren't considered "dumb" at all. They might even be considered impressive, albeit being a jack of all trades might be a career disadvantage.

In these discussions I see (generally) a strong sentiment among the naysayers along the lines of "because ChatGPT is so overhyped, I've decided to play it cool and downplay it as a reaction to the hype". And hence the other comment suggesting that you're intentionally not allowing yourself to be impressed by the state of the art achievements.

IMHO there's too much arguing over how we should subjectively "feel" about the new tech. Everyone should be free to "feel" whatever they want to feel about the state of things, whether being impressed or not.

It’s amazing how easily people are fooled into thinking something is intelligent. I met Stephen Hawking once and asked him how to slice video with ffmpeg. He didn’t have a clue! Obviously he isn’t an intelligent person. Yet so many people think he is smart.

Your strawman argument isn't impressive either, even chatGPT knows how to avoid them! But I'll play along! Didn't happen to try something different, like playing 20 questions? Or something else? Because I've already given those as other examples for simple tasks that I don't think a banal text prediction algorithm could do.

Find something on the map that you know you like. Now look around it to see similar (i.e. if you like this, you're likely to like that) books.

I think most new parents have semi-wished for, like, a life-size cutout of themselves attached to a Roomba that could roll into their nursery at 3am when the baby randomly wakes and make vaguely reassuring noises to soothe them back to sleep. I know I have. But I'm not sure it's wise to enable or encourage this level of parental disengagement.

Anyway, what I really wanted to share is "The Robot and the Baby", by John McCarthy (yeah, the same one): http://jmc.stanford.edu/articles/robotandbaby/robotandbaby.p...

I think lenses/optics have stolen some of zippers' (very localized) thunder in recent years, but I still enjoy finding excuses to use them every once in a while. (OK, so really just a couple Advent of Code problems.)

I have never actually had the wherewithal to go through the whole automatic-derivation-of-zippers thing, but this (https://stackoverflow.com/questions/25554062/zipper-comonads...) StackOverflow Q&A (along with all of Conor McBride's SO answers - compiled at https://personal.cis.strath.ac.uk/conor.mcbride/so-pigworker...) might be of interest in conjunction with the linked paper.

I had a whole rant queued up on "Pandas and its consequences have been a disaster for the human race" (well, at least for newbie programmers), but I think instead I want to focus on the damn dictionary splats. I just don't get it - it's pure "clever" code in the pejorative Dijkstra sense. It's hard to edit, it's hard to typecheck. Why not pay the very low whitespace tax to give each key/value pair its own longhand line:

  .astype({
    'central_air': bool,
    'ms_subclass': 'uint8',
    ...
  })

Now if, say, ms_subclass and overall_qual need different types, that's an easy diff to read. Ah, but I suppose that wouldn't be as Twitter-friendly.

I’m on the same page with formatting, it’s not a pandas thing. (Doesn’t actually look like you’re saying it’s only a pandas thing) The same formatting patterns happen in all languages I’ve seen, sql quite often.

It’s just a bad programming habit thing.

I find the legal and ethical implications more interesting than the technology as it stands. Maybe I just don't do the kind of work it's suited to, but I didn't find it terribly useful when I gave it a go. I had an experience that went "oh wow, that turned out a lot of code fast and it looks pretty good" followed by "oh, it made the exact subtle mistakes everyone makes when they write this kind of thing". No surprise given the nature of ML.

On the other hand, I find myself torn between "information wants to be free and this is one more nail in the coffin of our odd and ahistorical concepts of 'intellectual property' and 'plagiarism'" and "oh great, another way for giant corporations to reap all the benefits from work done by individuals and smaller businesses".

I don't think I'll ever use the thing, and I have ~0 power over the societal implications, so overall - yeah, can't get that exercised over it either.

That's R (and S/S+ before it), for better or worse.

What, you’re not persuaded that the concept of immutability popped into existence in the late 2000s with the appearance of Clojure?