Connor Adams connorads

Because cross-compiling binaries for Windows is easier than building natively

I want Microsoft to do better, want Windows to be a decent development platform-and yet, I constantly see Microsoft playing the open source game: advertising how open-source and developer friendly they are - only to crush developers under the heel of the corporate behemoth's boot.

The people who work at Microsoft are amazing, kind, talented individuals. This is aimed at the company's leadership, who I feel has on many occassions crushed myself and other developers under. It's a plea for help.

The source of truth for the 'open source' C#, C++, Rust, and other Windows SDKs is proprietary

You probably haven't heard of it before, but if you've ever used win32 API bindings in C#, C++, Rust, or other languages, odds are they were generated from a repository called microsoft/win32metadata.

About

This 🚧 work-in-progress 🚧 playbook for developing and delivering webinar content, with a focus on delivering live demos...

📚 Playbook

I develop the narrative, e.g. as a high-level outline, using the team as a sounding board to get feedback / inputs early on!
I try and write the least amount of code possible in the amount of time available! I can always fake it, e.g. I just started building this app, the important part is the narrative.
Pre-recorded demos are great, they buy predictability but at the cost of prolonged preparation time, and they allow me to speed up boring parts, like waiting for builds to complete.
My preference is to use ScreenFlow to screen-record my demos.

Reach UI Philosophy

Reach UI is an accessible foundation for React applications and design systems.

The three equally important goals are to be:

Accessible
Composable
Stylable

Architecture

Use Onion architecture
- Dependencies go inwards. That is, the Core domain doesn't know about outside layers
Use pipeline model to implement workflows/use-cases/stories
- Business logic makes decisions
- IO does storage with minimal logic
- Keep Business logic and IO separate
Keep IO at edges

I've been deceiving you all. I had you believe that Svelte was a UI framework — unlike React and Vue etc, because it shifts work out of the client and into the compiler, but a framework nonetheless.

But that's not exactly accurate. In my defense, I didn't realise it myself until very recently. But with Svelte 3 around the corner, it's time to come clean about what Svelte really is.

Svelte is a language.

Specifically, Svelte is an attempt to answer a question that many people have asked, and a few have answered: what would it look like if we had a language for describing reactive user interfaces?

A few projects that have answered this question:

How to add a collapsible section in markdown

1. Example

Click me

Heading

Foo
Bar
- Baz

Qux

If you are like me you find yourself cloning a repo, making some proposed changes and then deciding to later contributing back using the GitHub Flow convention. Below is a set of instructions I've developed for myself on how to deal with this scenario and an explanation of why it matters based on jagregory's gist.

To follow GitHub flow you should really have created a fork initially as a public representation of the forked repository and the clone that instead. My understanding is that the typical setup would have your local repository pointing to your fork as origin and the original forked repository as upstream so that you can use these keywords in other git commands.

Clone some repo (you've probably already done this step)
```
git clone git@github...some-repo.git
```

	# 2023-11-27 MIT LICENSE

	Here's the open source version of my ChatGPT game MonkeyIslandAmsterdam.com.

	It's an unofficial image+text-based adventure game edition of Monkey Island in Amsterdam, my home town.

	Please use it however you want. It'd be nice to see more ChatGPT-based games appear from this. If you get inspired by it, please link back to my X https://x.com/levelsio or this Gist so more people can do the same!

	Send me your ChatGPT text adventure game on X, I'd love to try it!

	/**
	* Takes a predicate and a list of values and returns a a tuple (2-item array),
	* with each item containing the subset of the list that matches the predicate
	* and the complement of the predicate respectively
	*
	* @sig (T -> Boolean, T[]) -> [T[], T[]]
	*
	* @param {Function} predicate A predicate to determine which side the element belongs to.
	* @param {Array} arr The list to partition
	*

	package fpmax

	import scala.util.Try
	import scala.io.StdIn.readLine

	object App0 {
	def main: Unit = {
	println("What is your name?")

	val name = readLine()