90s_dev

Yeah those apps were my inspiration: use the native UI and share logic as a lib.

I don't even have a Mac yet, so no point in shipping for that if I can't debug it.

If sales are good, I'd be glad to buy a cheap macbook off ebay and port it.

This is the entire source:

    #include <X11/Xlib.h>
    #include <stdlib.h>

    #define stk(s)    XKeysymToKeycode(d, XStringToKeysym(s))
    #define on(_, x)  if (e.type == _) { x; }
    #define map(k, x) if (e.xkey.keycode == stk(k)) { x; }
    #define grab(...) const char *l[] = { __VA_ARGS__, 0 }; \
                        for (int i = 0; l[i]; i++) XGrabKey(d, stk(l[i]), Mod4Mask, r, 1, 1, 1);

    int main() {
      Display *d = XOpenDisplay(0); Window r = DefaultRootWindow(d); XEvent e;
      XSelectInput(d, r, SubstructureRedirectMask);
      grab("n", "q", "e");

      while (!XNextEvent (d, &e)) {
        on(ConfigureRequest, XMoveResizeWindow(d, e.xconfigure.window, 0, 0, e.xconfigure.width, e.xconfigure.height));
              on(MapRequest, XMapWindow(d, e.xmaprequest.window);
                            XSetInputFocus(d, e.xmaprequest.window, 2, 0));
                on(KeyPress, map("n", XCirculateSubwindowsUp(d, r); XSetInputFocus(d, e.xkey.window, 2, 0))
                            map("q", XKillClient(d, e.xkey.subwindow))
                            map("e", system("dmenu_run &")));
      }
    }

I have to say, I'm not usually a huge fan of C macros, but it works here so well, it feels so elegant and clean somehow.

> Most software today is crappy. Do you really need all the bells and whistles? Probably not.

I agree that most software today is bloated, but I wouldn't say crappy. There are legitimate reasons to choose bloat, for example using SDL or Electron to speed up development and have easier portability. But for some reason I do strongly enjoy writing and using minimalist software. That's why I removed C++, SDL and other libs from my app (hram.dev) and just used C, native Win32 APIs, and D3D, getting it down to 1.4mb and speeding up compilation a lot. So projects like this always appeal to me, and I love seeing different ways we can be minimalist without sacrificing too much functionality or convenience.

Funny enough, I came across WiX the other day when I was looking into windows installers like msix, nsis, etc. Eventually settled on self-contained exe (and it's only 1.4 mb, woo!) but seeing the name wix took me back, I vaguely remembered it from around 2005 or so when I was first trying to make "real" windows programs (as opposed to visual basic ones). Took 20 years, but I finally did it, and written entirely in C, too! Anyway yeah, different wix than the popular one. Tom, you may want to rename this post.

I did something similar ones as a vs code extension for love2d which I called live2d, so that you could develop your game while it was running. It was incredibly fun, but incredibly hard to use, and nobody had any interest in it, so I abandoned it and lost the source code eventually. But it worked so well. I had invented this thing called magic tables to go along with it and make it easier to use, I forgot what they did, I just remember the name and how cool it was.

The readme just looks like it was written by AI, and the initial commit is the entire code. It just seems like AI was used at least somewhat. Just curious how much, if at all.

I submitted a link to a project[0] with similar characteristics a few days ago, before I realized it was probably entirely made by AI. That's what got me wondering this in the first place.

[0] https://news.ycombinator.com/item?id=44642557

How much was AI used to help create this?

Right but it comes after a long line of similar CSS frameworks with the same promise, starting with Bootstrap, and there were large movements about 10 years ago of whole orgs deserting those frameworks because of serious issues. Are you saying Tailwind somehow has resolved those? That was the main reason I didn't try to learn it considering it to be just yet another CSS framework's conventions.

I forgot to ask, that day that the Go team did an AMA here: did AI have any influence or sway or advice etc in choosing Go over other solutions?

I've been writing CSS manually since it came out. The latest additions make it less difficult, like & and nesting, variables, etc.

But overall, CSS is just really difficult to scale well properly. I should probably learn Tailwind at this point, instead of continually rolling my own CSS.

So now I have DaisyUI bookmarked since the site is excellent and looks so useful.

Someone requested clarification on another post, so here it is:

It's a native Win32 app, with a window of 320x180 pixels, which scales upwards as you resize bigger. By itself the program does nothing except read and run a specific Lua file located in AppData. Drawing to the screen is the main operation of the program.

The Lua API has a few built in modules:

- "image" for dealing with gpu images, which includes the screen

- "lpeg" so you can write a custom parser

- "asm" so you can compile and run assembly code from Lua

- "memory" so you can read and write to real memory addresses

It uses real memory:

All the APIs, including the assembly you write, can access real memory addresses. So you can write to 0x20000 and read from it, either in Lua or Asm, and it just works. And you get raw pointers as Lua integers that you can pass around, which lets you pass them through assembly and back.

The app has a few competing primary purposes:

- Learn or practice writing x64 win32 assembly

- Learn or practice writing a programming language

- Learn or practice writing video games like it's 1979

- Learn or practice writing programs that manage raw memory

Did x64 linux asm change that much in the last 14 years?

Note that you can also get TSX in native Node.js with minimal configuration[0]. This is accomplished via module hooks and TypeScript's own compiler (or bring your own compiler like swc).

[0]: https://github.com/sdegutis/immaculata

Plain guess work, and excitement, and fads, and people profiting from being "the experts", and in general social noise that overcomplicates the simplicity of life.

I went from vim to emacs and used that for a few years, then moved to VS Code for the next 10 years or so. It's showing its age a bit lately, so I'm sure I'll try another one soon, which is why I looked at Helix. But I'm very glad there are very different editors for very different types of minds, just like how there are different ways to indent/format code. Programmers do not have one-size-fits-all minds, and we shouldn't design anything assuming they do/should. (Looking at you, Golang.)

My comment was after having learned and gotten very good at vim about 15 years ago and used it primarily (via neovim) for at least a while, probably a few years, before moving to emacs, and finally VS Code. I still use vim for quick edits on the command line. I know how to edit modally, it just feels unnatural for me.

I used vim for a few years about 15 years ago, yes.

It's not that it's difficult for me, it's that it's unnatural for me.

Different people's minds work differently.

It looks very interesting and I'd love to support it, but editors that must be modal are difficult for me to use, personally. Editors that are not modal can be made modal, but can modal editors be made non-modal?

Thanks, I'll be using this.

What I don't understand is why assembly feels so hard to learn in the first place?

I mean, isn't it just a simple language with a few function calls (instructions) and types (operand sizes) and fixed number of variables (registers) and a small number of control flow operators, and that's it? Why does it feel so mysterious?

I came across this trick a few months ago when I was dealing with what seemed to be a race condition from a chrome-only API, and I just felt so clever! I don't remember though whether the race condition actually was one or not though, and I eventually had to rip that entire class out of my codebase. But it's such a good feeling to know I came up with a solution that clever all by myself.

For now.

https://github.com/tc39/proposal-type-annotations

Please do!

The first HN link in my comment addresses that. The short version: learn the earliest asms first, then progressively learn the newer ones until you get to today, and none of the knowledge will be wasted. Kind of like fast-forwarding.

I came to the party way to late. A month ago, I found out asmjit was a thing, and now it's happily embedded in my app. But I don't know assembly! I tried to learn a few times since the early 2000s but the timing was never right. But hand written asm as a feature fits perfectly into my upcoming app, so now I am on a roll learning assembly! Here are some more resources I found so far:

https://news.ycombinator.com/item?id=22279051

https://sonictk.github.io/asm_tutorial/#introduction/setting...

https://cs.brown.edu/courses/cs033/docs/guides/x64_cheatshee...

https://people.freebsd.org/~lstewart/articles/cpumemory.pdf

https://learn.microsoft.com/en-us/cpp/build/x64-calling-conv...

[flagged]

I was unclear. The "Truth and Life" dramatized audio New Testament that I referenced, is not made with AI but with excellent voice acting work from names like John Rhys-Davies, Malcolm McDowell, Neal McDonough, Stacy Keach and other people that AI will never be able to compete with. I recommend dropping the audio bible feature and just pointing people to this one, which is cheap, and the Gospel of Mark is eve free.

A bit off topic, but since you mentioned doing your best thinking in the bathroom, two things you should try are (a) no caffeine, and (b) no soy. These should dramatically cut down on the number of times you have to go and how long it takes.

> de-staff and de-fund organizations whose existence is enshrined in law

> nobody in the executive branch, of any given party, independent, or otherwise should be granted these powers

Then who should be able to defund and destaff organizations? Nobody? Should they last forever simply because they were legislated at one point?

---

[ EDIT since I can't comment anymore today ]

My mistake, I did not see the word "congress" in the text I was quoting.

My mind has been shut down for about 49 days. It's difficult to think at all.

I rarely read the Bible anymore. When I first became a Christian, I was reading it all the time, I couldn't put it down. Eventually life got the better of me and I stopped reading it. A few times since then, I decided to start reading it, and every single time, it turned out to be a really great experience that I was surprised I put off for so long. And then once again, life would get in the way and I wouldn't read it for a while, thinking it was too boring or pointless.

So great job making an app to make this easier.

For your core features, the "instant verse lookup" and "reading progress that sticks" look very useful.

But KJV audio? I think you'd be competing with the excellent dramatized audio book Truth and Life (RSVCE), which nobody can top.

I can only post a couple times per day now, and I've already posted a few times today, so I don't know if this will go through. Thanks Tom. But I'll try anyway.

I fully agree that software has gotten substantially more complex. There seem to be far too many levels of abstractions on top of abstractions. I do miss the days of QBasic, and that's why I'm working on the product I legitimately need to release before the end of the month.

But not every layer has the same level of low quality. For example, you brought up lazy loading. It actually can take a lot more work to properly support lazy loading, unless your framework supports it. I'm not sure what Slack uses beyond just Electron, but even in vanilla JS it's not easy to get lazy loading working properly, although the animations are very easy to get wrong with canned code.

On the note of Electron, I'm very happy to report that the last time I checked the size of my Release build for my pure Win32 app, it was sitting at 312 kb total, as a single standalone .exe file. It will of course be a bit bigger than this when I finally release it, but still, there's something so satisfying about making something with such extreme minimalism.