bvrmn

The funny thing LLM's are amazingly good with writing in Zig. They could inspect stdlib source code to fix compatibility issues with newer compilers and quite prolific with idioms.

For example I got a working application with minimal prompt like "I need an X11 tray icon app showing battery charge level". BTW result: https://github.com/baverman/battray/

Now I'm trying to implement a full taskbar to replace bmpanel2. Results are very positive. I've got feature parity app in 1h with solid zig code.

Oh boy. The major difference is coordinate transformations, global/local/face. OpenScad basically leaves you alone with math you should figure out on your own. Also it's math heavy for all other stuff, for example tangents, smooth connections, intersection coordinates, etc.

For me NF>3 seems like an implicit encoding of underlying data logic. They impose additional restrictions (usually contrived and artificial, break really fast in real life) on data not directly expressed as data tuples. Because of that they are hard to explain, natural reaction: "why you just don't store data?".

Shameless plug: https://github.com/baverman/build123d_draft

Experimental extension to make code-cadding as terse as possible.

> Who is forced to use it? Just use X11, as you said (many times) you do already.

Recent versions of gnome session are compiled only with wayland support in archlinux. To change DE or distribution or use custom package is quite a stretch to call it's not forced.

I bet Fabrice could write JSAndroid which would provide no lag emulation experience.

Repairability score page[1] looks like a Lenovo advert.

[1]: https://www.ifixit.com/repairability/laptop-repairability-sc...

Actually in Python you could recast (zerocopy) bytearray as other primitive C type or even any other structure using ctypes module.

Naming is atrocious indeed.

It's kinda hard to deliver value in fewer lines.

Thank you for posting it. It's the launcher I didn't know I need! My usage pattern is literally: use first desktop for often used apps and search for everything else. Samsung launcher search is quite shitty and slow and takes considerable amount of gestures to reach.

Installed and toyed with KISS for 30min and yes. It's perfect for me!

> 2.6 One vs. Many Check-outs per Repository

For practical cases `git worktree` allows to have multiple checkouts. Document marks this section as "partly disputed" with an external link. IMHO git worktrees has the same ergonomics as in fossil. This section kinda discredits the rest of the article.

> there's no central King whose greed for wealth can be satisfied once.

King and court and lords are the same amount of greedy bastards. The issue with kings is on another plain, what to do with power transfer to a new king. Democracy try to solve exactly this problem. What to do with individuals bending laws to be new kings is another issue to solve.

I could live with 1-indexing but a closed range array unpack (slices) is quite big toll and breaks nice intuitive invariant.

1 case: 14w * 1h -> 0.014kWh * 40p of total cost. There is nothing complex.

2 case: It's an issue with mAh markings. Battery rated in Wh has same simple math.

There are no consumer issues jot solves. More over additional ~10^3 magnitude is consumer hostile.

It's hard to see practical strengths, especially with provided code examples. Most of tax code is stack tossing hiding core logic.

Code as structure could be more conveniently expressed as language data structures as structure nowdays.

It would be great to have **kwargs as frozendict by default. It could help with caching decorators to speedup key construction. For example natural key is simply `(args, kwargs)`.

That's my point. Python has convenient and good type design with str.join ignored by other languages.

For example I'm lost which abstract class to inherit in Scala to obtain mkString for my custom container.

From typing perspective there is no sense to have Container[T].join() -> str for any T.

It's funny. One can't simply write a correct C code. Even after years of practice.

    void strclone(const char* str, char** outCpy)
    {
        size_t len = strlen(s) + 1;
        *outCpy = malloc(len);
        memcpy(outCpy, str, len); // wrong dest address 
    }

I don't like double pointer parameters because of it.

It bothers me that majority of languages ignores a nice python approach. `', '.join(any_str_iterable)`. Instead of supporting join for myriads of containers there is a single str method.

Tailwind utilities related to flexbox/grid solved most of layout issues for me. Usually it's flex-1/flex-none to mark dynamic/static parts and gaps to separate elements. Constraint based systems usually require more input data to maintain.

Slices and UB-explicitness are quite nice comparing to C. Makes head free to think about really important things.

The issue with state you should handle it. Compare for example some iterator implementation in Java and Python. Latter needs only one method with coroutine and no state to store on object level.

> the state is already enough to explain a state machine.

I did not talk about explaining state machines but implementing state machines as coroutines. Progression: give an idea of state machines, show how hard is to handle state, present coroutines as way to handle states.

Coroutines as a technique to implement state machines is the first things which comes to my mind. It's a more abstract and requires a way less fundamentals to know comparing to concurrency.

Technically there is dataclass_transform [1]. It's an ungodly hack, I don't know how it passed PEP review. And support by type checkers is questionable. After TS python hints feels like rigid and total unsound mess.

[1]: https://docs.python.org/3/library/typing.html#typing.datacla...

I guess you didn't work with good type system then. Look for TS, for example. How it allows to make strong typing for pydantic-like libraries in FE world. All how it allows to type routers.

For me it's case insensitive LIKE.

> I beg of you, just design it to work well with an LR or Packrat parser generator. For those cases where this is not an option, use Earley.

So many unpleasant to use languages which follow this advise. Authors try to fight generator and make ugly syntax compromises to avoid conflicts.

If you could make a good "story by commits" I assure you: a combined single commit would be as much readable as multiple. Good story is a result of composable changes highly visible without artificial splitting.

Funny thing I never seen a good PR with meaningful multiple commits. At least you need to be quite proactive in history rewrite to make it presentable. Usually it's mere fix/fix/fix looking amazingly bad without squash.

If you want to comment on this matter, you are welcome to share your github examples.