My guess is this would only enable a read-replica and not backups as Litestream currently does?

I would much prefer a cup of instant coffee to most coffee that is served at diners, brunch/lunch restaurants, etc. in the US. I prefer espresso still, but there's a lot of burnt tasting coffee in America.

I don't think it's fair to assume the author doesn't understand how transformers work. Their intention with this instruction appears to aggressively reduce output token cost.

i.e. I read this instruction as a hack to emulate the Qwen model series's /nothink token instruction

If you're goal is quality outputs, then it is likely too extreme, but there are otherwise useful instructions in this repo to (quantifiably) reduce verbosity.

In my opinion: there is a better argument for making new languages not have methods, or more accurately member functions (as what the author describes).

Consider the following situation: you are user of a library that declares a type called SomeType which has "methods" (member functions) in it. You want to add more "methods" to this type.

Now, there is a problem regarding consisteny w.r.t syntax, your new "methods" now have to be called via `foo(&bar)` instead of `bar.foo()`. You as a user of the library and language have to choice to make (regarding code style):

1. Accept this difference in syntax. Maybe you like this style difference, because now you can clearly see what procedures are declared in your codebase vs. the library's codebase, or:

2. Use freeform functions everywhere. Well actually, you can't do this without a refactor of the library (or with additional language features), i.e. you will need to fork the library and rewrite SomeType and the associated member functions in this freeform function/procedure style.

From a language designer's perspective, you can choose to solve the problem by either (a) forcing the declaration of procedures to be consistent or (b) introducing language features to make the calling code consistent. Odin obviously chose (a), but languages like Swift and C# chose (b) - whereas languages such as Nim chose both (a) & (b).

For (b), here's some possible features you could add:

* Extension methods (Swift, C#). This let's user declared "methods" feel like like "proper methods" of the class/struct, or

* UFCS (Nim, D). Declare everything as a freeform procedure/function but enable the syntax `arr.push(10)` when the procedure is declared as `proc push(arr: var Array, x: int)`

From this, you can see why languages such as Odin chose to go with option (a). It's simpler.

In addition, RAII has it's own complexities that need to be dealt with now, i.e. move semantics, which obviously C does not have nor will it likely ever.

These are really high quality and performant libraries.

Here is video demonstrating text rendered with Blend2D in real time (NO glyph cache used) - on the CPU!

https://vimeo.com/1152635716?fl=pl&fe=cm

Comments URL: https://news.ycombinator.com/item?id=46544770

Points: 2

# Comments: 1