rezmason @rezmason@merveilles.town

Either way, the music video does a pretty swell job alluding to these other videos, considering how obscure they are, right?

And that third video is Keane's music vid for their song "Spiraling":

https://www.youtube.com/watch?v=ZG72J2ylUGE

I think they're using the uncanny valley purposely as a metaphor for the singer's sense of superficiality. Or maybe its message is like, "Just as the folks in the 80s thought these animations were realistic, and now they're dated, at first I thought my love was realistic, and now I can see past its facade".

Then there's this, uh, 1985 super bowl commercial for cans. Like, in general. Somehow they found a way to give them sex appeal.

https://vimeo.com/154210999

When I think of CG from this era, I think of motion graphics from TV shows and the start of VHS tapes. But apparently, the maker of the third video was heavily inspired by these.

Hot on the tails of @neauoire 's links to The Mind's Eye, I'd like to share three related videos.

First, Hawaiian Punch (1987). Some guy from Devo was apparently involved. Overall it's pretty catchy.

Note the dance move at the 38-second mark.

https://www.youtube.com/watch?v=SIfh0XMrg6w

#theStudio

I wouldn’t be surprised if one day FP will be easier to leverage across the entire project, but I encourage you to try applying it at least centrally, to the code you control. Evaluate your options: there may be an immutable data library or syntactic pattern on your tool chain of choice, and if it suits you, then look what you have to gain. 🤩

For now, when I need to change a web page element’s color and position, I straight up change it. I apply unrelated solutions to scope those changes to specific domains.

For now, this is fine. I leverage the core strength of functional programming in my core code, and some of what those bigger-thinking FP folks have told me for a decade are starting to make sense. I write functions that take functions and return functions. Not all the time, but when it makes sense. And surprisingly, it does! ⚙️

So what do we do about the world? Adopt solar, according to Merveilles, and I hear some nice things about storing compressed air, but anyway.

I’m not advocating extending pure functional programming to the outside world at this time. It can serve us in a central capacity, and then we wrap it in imperative code.

Typically the functional core encompasses our business logic— rules, in other words— and the imperative code resembles our business deals— the bartering we do with APIs and the browser.

If you afford me that conceit, take a look at what we have now: data blobs that represent state, and functions (or clumps of functions) that represent logic. Not only is it easy to test the logic now, but it’s easy to snap the logic together into more complex things. We can build out all the game’s logic this way!

To a point.

Because at some point, we need to mess with the outside world, AKA mutate the world, and we’re sure as hell not going to copy THE WORLD, change the copy and return it. 🌏

We can’t let our rule change the data blob we pass in, so we must have it make a copy of the blob, change that copy, and hand us the copy.

Immediately we see red flags and sirens, right? 🚩🚨 🚩🚨 How the hell can a program make copies all the time?! That sounds super expensive!

Here’s reassurance #1: this is a solved problem. Just like we don’t flinch when we download a test framework (I use mocha), we can download a library that makes these data operations cheap and easy (I use Immer).

The answer is, make these functions pure— make them only work on what goes in, and only impact what goes out.

Like a circuit component, we can just attach things to the leads and see whether or not the functions catch on fire.

A rule has no state. It’s only a bundle of functions, and their logic operates only on a blob of data I pass in.

It’s not hard to write a pure function that lists all legal moves or validates a move. But what about the one that changes things?

I’m making a board game, as you know. It’s written in JavaScript, which supports lots of different programming paradigms.

My game has rules, so I started by writing tests for the rules, and then the rules themselves.

For me, a rule is basically three functions: one lists what legal moves are possible, one validates a move, and one plays a move, aka *changes the game state*.

Let’s forget about paradigms for a second. How do I make this easy to test?

I think most of us get introduced to functional programming through an evangelist, whose enthusiasm and willingness to share are uplifting, but who can’t articulate the concept without running aground on alien concepts, and never fully address our concerns as skeptical outsiders.

We ask, “If there’s no side effects, how do we do anything?” and get answers like, “We’ll you use a monad—“ and we know where THAT leads.

I’m evangelizing this time. So let’s get practical straightaway.

I’m about to type a lot about anecdotal coding bliss. First, though, I’ll paste the relevant link:

https://www.destroyallsoftware.com/talks/boundaries

#programming #FunctionalCoreImperativeShell

#ui #boardgame

What's up Merveilles! New Fuligo gameplay video is out. If you've got the time, take a peek! 😊

While it took me a while to reach this milestone— partly because I spent too much time evaluating RxJS— I've still gotten this far in just a year and a half, compared to the five year slog to nowhere that its previous incarnation was.

AI opponents are next! Somehow! And a UI puppet system so NPCs and networked opponents use the same buttons that we do.

https://vimeo.com/346519994

Does anyone here know of an example of good UI design in a board game for mobile devices? I'd like to get a sense of how they handle different screen aspect ratios, etc.