fdb

Key quote:

“When we started the log analysis, we first used frontier models behind commercial APIs. This did not work: the analysis requires submitting large volumes of real attack commands, exploit payloads, and C2 artifacts, and these requests were blocked by the providers' safety guardrails, which cannot distinguish an incident responder from an attacker.“

I keep being surprised of what you can use/abuse the terminal for...

Hey, cool, that's using my library: https://opentype.js.org/

It's nice to see it pop up in so many places!

This came from a piece by Margaret-Anne Storey on "cognitive debt", picked up by @simonw, and which I personally also encountered. While building a synth engine from scratch, I kinda lost the plot. Then I let Claude document each "phase", and from that I generated Remotion videos. It worked quite well, and I learned a lot, much more than I would have from just reading the source code!

Code for synth and Remotion setup is open source: https://github.com/fdb/vamos

It's on Lovable so you can just fork it and take a look (the prompt is in supabase/functions/transform-render/index.ts):

Transform this idealized architectural rendering into the most brutally realistic, depressing photograph possible. This is the WORST CASE scenario - what the building will actually look like in reality:

- Set on a dreary, grey, overcast late November day with flat, lifeless lighting - The sky is a uniform dirty grey, threatening rain - All trees are completely bare - just skeletal branches against the grey sky - The landscaping is dead, muddy, or non-existent. No lush gardens, just patchy brown grass and bare dirt - Remove ALL people, the scene should feel empty and abandoned - Any water features should look stagnant and grey - Add realistic weathering, dirt streaks, and construction residue on the building - The building materials should look how they actually appear, not the idealized clean version - Include visible utility boxes, drainage grates, and other mundane infrastructure usually hidden in renders - The overall mood should be bleak but realistic - this is what buyers will actually see on a random Tuesday in late autumn - Maintain the exact building, angle, and composition, just strip away all the marketing polish

The goal is honest truth, not beauty. Show what the architect's client will actually see when they visit the site.

A great podcast about this is “If Books Could Kill”, where they critique these type of self-help books.

Hmm, it seems Claude Research is only available for the Max plan:

Research is now available in early beta for Max, Team, and Enterprise plans in the United States, Japan, and Brazil. Simply toggle on the Research setting in chat.

Janelle Shane’s work has been really inspiring. Her talk at Strange Loop from a couple of years ago — right before DALL-E, before ChatGPT — was a turning point, and very funny:

https://youtu.be/yneJIxOdMX4?feature=shared

Which treadmill do you have?

As a HyperCard fan I was struck by this quote from Bill Atkinson:

“I have realized over time that I missed the mark with HyperCard,” he said from his studio in Menlo Park, California. “I grew up in a box-centric culture at Apple. If I’d grown up in a network-centric culture, like Sun, HyperCard might have been the first Web browser. My blind spot at Apple prevented me from making HyperCard the first Web browser.”

Same here. I observed it making up functions in d3 (`d3.geoProjectionRaw` and `d3.geoVisible`), in addition to ignoring functions it could have used.

It failed my simple "fox, goose, corn" benchmark. Here's the prompt:

"Farmer to cross a river with fox, goose and corn in a boat that takes at most two. Fox eats goose and goose eats corn if left alone. Farmer can row the boat himself and doesn't need a boatman to ferry them across. How can he cross the river with all the three unharmed in least number of trips?"

It starts promising but fails in step 5:

Let's think through the problem step by step:

1. The farmer needs to transport three items across the river: a fox, a goose, and some corn.

2. He can only take one item with him on each trip because if he leaves the fox and the goose together, the fox will eat the goose, and if he leaves the goose and the corn together, the goose will eat the corn.

3. Therefore, the first trip should be with the goose since it is harmless and won't cause any damage to the other items.

4. After dropping off the goose at the other side of the river, the farmer returns to pick up the fox for the second trip.

5. Once the fox is dropped off at the other side, the farmer returns again to pick up the corn for the third and final trip.

6. Upon reaching the other side, the farmer reunites with his unharmed fox, goose, and corn.

Final answer: It takes 3 trips to cross the river with all three unharmed.

Statement from the photographer: https://www.eldagsen.com/sony-world-photography-awards-2023/

The author just made an update that makes the generation much better, even with the 7B model:

https://twitter.com/ggerganov/status/1634310199170179075

I tried it out myself (git pull && make) and the difference in results are day and night! It's amazing to play with, although you should prompt it differently than ChatGPT (more like the GPT-3 API).

You can, using Google Takeout:

https://9to5google.com/2021/02/02/how-to-export-download-gam...

However you can’t import it back in, so this is a one-way feature at the moment.

I believe the engine is multi-platform but the editor is Windows-only at the moment.

Handmade Hero implements a live coding workflow in C++: https://www.youtube.com/watch?v=WMSBRk5WG58

You're right. It still works in Chrome though...

SDL is not a GUI library: it doesn't have any buttons, sliders or text controls. That's what this library provides.

To get on something on screen, it provides a number of backends, including SDL. However there is also one that talks to X11 directly, providing the minimum dependencies needed on Linux (as far as I'm aware).

Basically the library generates a list of drawing commands. It is up to the underlying backend (SDL, GLFW, X11, your own embedded one,....) to draw these on-screen.

I've got it running on OS X with some modifications:

- In the Makefile, use

  LIBS = -lglfw3 -framework OpenGL -lm -lGLEW

- In the shader code, change "#version 300 es" to "#version 400" for both the vertex and fragment shader.

I'll try to make a PR with conditionals if I can find the time today.

The Badfish page at https://filippo.io/Badfish/ seems to be down. Any other place where I can direct people to check for invalid security certificates?

Silly question perhaps, but does this apply to Macs as well?

Maybe this came up already, but how does the tracking protection work? Does it use a blacklist like uBlock, or a whitelist like Privacy Badger?

South Park had an excellent episode explaining freemium games: http://southpark.cc.com/full-episodes/s18e06-freemium-isnt-f...

Plumin is a light wrapper around paper.js [1] and my opentype.js library[2], which can parse and write OpenType fonts in pure JavaScript.

Plumin is nice to build fonts from scratch. If you're interested in taking an existing font and manipulating its shape or metrics, consider using opentype.js directly.

[1] http://paperjs.org/

[2] https://github.com/nodebox/opentype.js

The "Wat Hifi?" Tumblr features more of these products: http://wathifi.tumblr.com/

So, how does this compare to Pattern (http://www.clips.ua.ac.be/pages/pattern) -- a (in my opinion) very high-quality, BSD-licensed data mining and NLP library coming from the academic world?

I've made a similar project about two years ago in Python, called Choice Words [1]. I've had some really interesting results by encoding the grammar of SVG, which generates procedural drawings (the GitHub project shows an example).

My project was based on the Kant Generator, an example project from Dive Into Python[2].

[1] https://github.com/fdb/choicewords

[2] http://www.diveintopython.net/

I have an interest in helping out. I've created opentype.js, an OpenType parser and generator (https://github.com/nodebox/opentype.js).

I understand your concern for keeping the format declarative, but I'm not entirely sure you can handle TTF files that way, as you'll run into walls very quickly.

For example, to know the number of entries in the `loca` table, you have to parse the `numGlyphs` field from the `maxp` table. The `maxp` table doesn't have to come first...

Looks really cool! I'd love to see an open grammar definition format for all kinds of tools, both command-line and GUI.

I've worked on parsing TrueType files, and they have some really "interesting" grammars. For example, they have lookup tables that define offsets at the beginning of the file. Also, a format flag at the beginning of a table might define the structure of the rest of the table.

It seems that once you decide you want to be able to parse all of this, you're grammar will turn into a Turing-complete language. Have you considered this? Where do you stop?