laurentlb

Thanks for providing the query and a link to execute it (I didn't know about that one). Now I can play with it and find the most popular words...

"to", "the", "of". I don't know what I expected.

Note that it's also possible to review changes afterwards. Many (human) teams have been working like this.

I agree that many vibe-coders are likely to skip reviews completely, but it doesn't have to be like this.

Note that there are no mp3 files at all. It's a player for module files (e.g. .mod, .xm, etc.)

If you'd like to download module files, https://modarchive.org is a good reference.

You'll find it here: https://chiptune.app/?play=FwwaT5Rc

As mentioned in other comments, chiptune.app seems to be a better project and has been maintained for years (https://github.com/mmontag/chip-player-js).

Also available here: https://modarchive.org/index.php?request=view_by_moduleid&qu...

I've worked 12 years at Google. When I was tech lead, I periodically checked Memegen and searched for my project name. I found it useful to get this feedback. Sometimes I converted the meme into a proper bug report; sometimes I responded to the meme with an explanation.

Not everyone will use Memegen in the same way. But quite often a high voted meme can be treated like a high voted bug report. It provides signal to the team.

Note that I worked on internal tooling. External facing teams have lots of other feedback channels, and they know that Googler's feedback is biased. So how the team responds to the feedback can be vary a lot.

Is there a way to set the default unit? I'd prefer to see the information per 100g by default (instead using random units).

For security reasons, the VSCode marketplace is not accessible, but many (in the 3-digit range) external extensions have been imported. One technical limitation is that some extensions are not designed for the web (e.g. try to run local things).

It's VSCode, so it's 90% similar to https://vscode.dev There are internal extensions, but they don't dramatically change the look and feel.

I think many VSCode users are not familiar with the Comments UI, but it's used in e.g. the "GitHub Pull Requests" extension. Apart from that, some changes in the list of directories/files (for performance reasons) and a redesigned SCM integration.

As far as I remember, this "IDE in cr/" explanation was found afterwards.

I'm not sure about the dates. At some point (2014?), the use of IntelliJ was discouraged in favor of Eclipse. One year later or so, the decision was reversed and the effort focused on IntelliJ (and Eclipse were considered deprecated).

I can't check when Cider got started. I was probably wrong (it wasn't much used in my circles at that time), I'll update the post.

Although the tool is internal, a lot of information about it is not confidential.

As the team had to collaborate with the VSCode team, we got clearance for sharing information about it. The screenshots in the article were posted publicly on GitHub (in vscode issues). You can also find screenshots in https://research.google/blog/smart-paste-for-context-aware-a...

More generally, a lot has been communicated on developer infrastructure at Google.

I like the approach in Lingua Latina per se Illustrata (sometimes called the "natural method"). I've noticed that it was adapted for other languages too, but most of the adaptations seemed old and outdated.

Recently I was wondering if I should work on a modernization of the concept (using audio and a more interactive medium). If anyone has thoughts on this topic, I'd be happy to discuss more.

There have been lots of discussions around AI in the demoscene. Revision limits how you can use AI (https://2026.revision-party.net/competitions/general-rules/), even if it's not always enforceable.

There's a lot of push back against AI-generated graphics and music. For code, it's more difficult to know. AI is used by some people to automate the boring tasks, so that they can focus more on the artistic side.

My personal website + blog: https://laurent.le-brun.eu

Multiple of my blog posts have been shared here before

There's no specific filter. The main effect is blending the previous frame with the current frame. When blending, I modify the coordinates and add some noise. This makes the graphics look less basic and it creates this noisy trail when things move.

The source code is here: https://github.com/laurentlb/shmup8/blob/main/src/shaders/sc...

Blending is on lines 241, 242.

I didn't try to get a specific 80s look, I just played with formulas.

Interesting topic. I appreciate the effort that went into this, there are some good animations.

But I find this kind of presentation much harder to read than a classic blog post. It's difficult to skim through the text to see how far it goes (and the article structure is not apparent); instead, I was kind of forced to read the text sentence by sentence (since I was familiar with the topic, I wanted to skip over the basics).

Very nice project! Thanks for making it open-source and very easy to use. I hope you'll find contributors and be able to get a nice collection of animations!

I'm starting a new project, I may have to use this tool in the next few months.

What's the downside of open sourcing it?

Each time I read this kind of feedback, I wonder if there should be a free, community driven, alternative to Duolingo.

- Content may be provided by contributors (like Duolingo did for many years)

- It could be supported by donations (I believe the costs can be kept low)

My feeling is that lots of problems with Duolingo are caused by monetization (and many things were better in Duolingo a few years ago).

I'm still not sure of how it should be designed and what we need exactly. One of the problems is also to get enough contributors. I'd be interested in hearing more thoughts on this.

As a hobby, I started building an alternative to the Duolingo Stories feature (https://lingostories.org), but it's still fairly limited.

I'd rather have the choice to control the camera (the "smart" camera could be used only if I don't control it), because it didn't work well for me.

Nice game otherwise.

Building old code and getting the same result is not always trivial to do.

Potential issues:

- If you have content in a database, can you able to restore the database at any point in time?

- If you code has dependencies, were all the dependencies checked in the repository? If not, can you still find the same version you were using.

- What about your tools, compilers, etc.? Sure some of them like Go are pretty good with backward compatibility, but not all of them. Maybe you used a beta version of a tool? You might need to find the same version of the tools you were using. By the way, did you keep track of the versions of your tools, or do you need to guess?

Even with static websites, you can get into trouble if you referenced e.g. a JS file stored somewhere else. But the point is: going back in time is often much easier with static websites.

(Related topic: reproducible builds.)

It's defined in the standard library and can be redefined by anyone.

It's usually called operator because it uses an infix notation.

Interesting project!

When I looked into CYOA, I opted for Ink. It's using a nice text-based language, a bit like markdown. It worked well for me, and I think it's a good option if you want to use a text editor.

I wrote about my experiments here: https://laurent.le-brun.eu/blog/my-adventures-with-narrative...

Nice project!

As it was not clear from the description, there's a one-time payment (4.29€) to get more than 7 puzzles in a day.

Lichess also offers a good alternative to this, although their offline support is limited.

Thanks! To be fair, there have been a few years without a single commit: https://github.com/laurentlb/shader-minifier/graphs/contribu... (before 2013, the code was in a private svn repo).

I also enjoy alternating work between multiple of my hobby projects, and I find it refreshing to come back to this F# codebase once in a while. :)

Most transformations don't change the code that's executed.

  const float x = sin(2);
  const float y = 2;

Renaming uniforms is optional (there's a flag). If you use C++, you can generate a .h header file that contains both the minified shader and macros that tell you how they've been renamed.

So Shader Minifier will generate macros like:

  # define VAR_time "f"

I wrote this article mainly for the people in the demoscene. If anything is unclear or missing for the Hackernews audience, I'm happy to answer questions here.

If anyone wants to try it, I've made a web build: https://ctrl-alt-test.fr/minifier/

I might write a more general article later on writing code minifiers, e.g. how it compares to writing a code formatter, how to implement the transformations, etc.

On the tech side, the code is written in F#. The web build uses Bolero (Blazor for F#). So maybe I'll write later about my experience writing an open source project with F# and evolving it.

That's how I wrote my website a long time ago.

  #include "header.htm"
  <h1>Title</h1>
  ...
  #include "footer.htm"

There are many ways to use LLMs.

The issue, IMO, is that some people throw in a one-shot, short prompt, and get a generic, boring output. "Garbage in, generic out."

Here's how I actually use LLMs:

- To dump my thoughts and get help organizing them.

- To get feedback on phrasing and transitions (I'm not a native speaker).

- To improve tone, style (while trying to keep it personal!), or just to simplify messy sentences.

- To identify issues, missing information, etc. in my text.

It’s usually an iterative process, and the combined prompt length ends up longer than the final result. And I incorporate the feedback manually.

So sure, if someone types "write a blog post about X" and hits go, the prompt is more interesting than the output. But when there are five rounds of edits and context, would you really rather read all the prompts and drafts instead of the final version?

(if you do: https://chatgpt.com/share/6817dd19-4604-800b-95ee-f2dd05add4...)