stefncb

I think that's something the language does. I struggle to understand how iOS would do it.

Why is that?

It's not necessarily about the size itself, but more about the fact that it has to go through a memory allocator and it has to be GC'd if that's applicable, while a simple integer doesn't. Copies are more involved too.

Using strings for identifiers is almost always a bad idea.

Out of curiosity, what for?

Compound nouns are likely my favourite linguistic feature ever. Can't tell you why.

I think a more appropriate title would be 'Reasons why I don't write', as it's more indicative of the original.

This is really fun. The year picker is surprisingly good on mobile.

If I look directly at a point, the illusion goes away there. And I don't really see anything strong anyway, so I wonder how you see it.

For me it weakens with one eye closed, but I still see it.

Fair point, but I don't think my constraints are _that_ extreme. I think it's doable, but we'll never know unless someone seriously attempts it.

Make a very high-quality noise-free image of your signature, with a transparent background. Drop it onto an equally high-quality PDF and skew it a bit. Add some toner noise to the whole image and skew the image a small bit.

I think you can make it look decent. Haven't tried it though.

Go is fast, cgo is slow. Cgo is also annoying to set up on windows. It kills the simplicity of a simple go build.

If you want ugly look at the MSVC std.

That's not what I'm saying. I want rust, but with the simplicity of go. I want a compiler that's super portable and it itself compiles in a few minutes. I want a straightforward build system that doesn't leave me confused. I want less language features.

I also want a more lightweight syntax but beggars can't be choosers.

My personal issue with Rust isn't the borrow checker. I actually find it quite intuitive. What I don't like is the extreme complexity of everything. There's just so much... stuff.

What I want is a Rust, but with almost everything stripped away. Complexity similar to Go.

You might as well make a scan of your actual signature and make the generator overlay the image instead.

Then no algorithm holds state, because an algorithm is just a ruleset.

This is what I see: https://0x0.st/oFPu.png

The bottom row gets cropped. Resolution is 1366x768. Let me know if you need additional info.

The UI looks great though!

This is kind of nitpicky, but I'll say it anyway.

An algorithm that does the same thing given the same input is deterministic aka referentially transparent aka pure, not stateless.

Even this little snippet of Haskell is stateful:

    statefulFunction :: Int -> Int
    statefulFunction x =
        let y = x * x
        y + y

The binding 'y' is state. Even if it's implicit, as in ((x * x) + (x * x)), it's still state.

People seem to use "stateless" as a word for "doesn't mutate anything", which is kind of weird. Mutability has _nothing_ to do with having state.

Making an equivalent of this was one of my first ever projects when I started learning programming. I'd read about it recently and was amazed when it actually started beating me every time.

Latency is still relatively high in LOTS of areas around the world. Not high enough to make online FPS games unplayable, but high enough to make sending packets in lockstep unplayable. Discriminating against those people wouldn't be fair (especially since they're not a particularly small minority).

The OS is already "intrusive" by that definition. What you described has a different issue though; my own computer letting some software run in some container that I can't touch is insane. That's Black Mirror kind of spooky and I hope it never becomes a reality.

> What I meant was that there are classes of algorithms that are stateless.

Can you give me an example?

Huh? Computation can't happen without state. Everything you make has a state, otherwise it won't really do anything interesting.

I've genuinely had the same general idea (minus the ML part), and I've started working on it once but abandoned it. I might get back on that some day.

Another thing I considered was that, instead of the lisp, you'd have a math-y language and compose everything together. This has the added benefit that it compiles easily to GPU code. So like a chroma key thing would be a function that chooses one buffer over the other based on pixel color. You the compose that with other functions to create a frame. An APL-like language could be amazing here.

I feel like there's _a lot_ of potential here.

I think that's something inherent to programming. It's not even the only field to have this "problem" - screenplays are written on paper but watched on a stage. Movies are that, but with yet another level of indirection.

There's sourcehut, though it's quite a paradigm shift from github.

I have an iPad. There seem to be two kinds of toggle switches in the native apple apps; one of them slides and animates, but the other one can only be pressed and it doesn't animate the transition. The latter is less common, but I've seen both in the same app before (settings I think).

It's likely a strange bug, but I think it's relevant since you can't _always_ slide it.