## Candlewood Lake Vacation, etc

* TOC
{: toc }

As expected, I haven't gotten much done here the past few weeks. I was
on vacation and wanted to do more freelance stuff, which I did. I'm
also reading a great series of novels by Robin Hobb which are
distracting. However, I'm excited about all the chatter around my
podcast, tweeters, on the Slack group. Thanks to all that listen, and
especially to those that write in - even just to say hi!

### Foundations

I've been thinking a lot what we take for granted, and questioning
everything. So why not the foundations. There's the Turing Machine
(wah ich is the epitome of inelegant) and Lambda Calculus (which is a
million times better by comparison). But can we do better? Are there
other alternatives? I did some Wikipedia-ing, but didn't come up with
much interesting. Here are some links:

*
https://www.reddit.com/r/AskComputerScience/comments/78wnv4/is_there_an
_alternative_to_lambda_calculus_as_a/
* https://en.wikipedia.org/wiki/Process_calculus
*
https://en.wikipedia.org/wiki/Category:Term-rewriting_programming_langu
ages

I'm going to this [whacky workshop in
Italy](https://programme.hypotheses.org/autumn-workshop-formalisms-at-t
he-interface-with-machines-languages-and-systems) next month that will
hopefully encourage me to think outside the box on these topics. What
even *is* a computer program?

### Misc links

* [Datafun](http://www.rntz.net/datafun/) - functional query language!
Very cool. Along the lines of the question I've been having about why
we have different data structures in databases vs in our languages.
* [Wolfram on Math
Notation](https://www.stephenwolfram.com/publications/mathematical-nota
tion-past-future/) - very good. Thought provoking!

### OAP - open authorial principle

I've been having fun Twitter conversations with
[Antranig](https://twitter.com/amb26ponder) (who I think lives in
London!). He has [a really cool paper on this
OAP](https://github.com/amb26/papers/blob/master/onward-2016/onward-201
6.pdf), which is very similar in spirit to r0ml's notion of "liberal
software." Many of the examples were in about object inherentance in
Java which I am allergic to, but I love the idea of formalisizing this
ideal.

What are the key actions that need to be enabled for this principle:

1. Finding/understanding all relevant sections in the code. (This is
related to my recent work.)
2. Making the change (including previewing it)
3. Managing various versions

I also had two other interesting, random thoughts:

1. The "Settings Menu" is a list of global variables you can set to
range of pre-defined constants
2. Where does composability play into the OAP?

### Todo 9/8/18

* "Future work" - better "notations" for higher-order streams (as in
Reflex). I should be able to get 5-10 hours here this week. That's the
goal at least.
* Organize "FoC Thinking" - I've been collecting a list of things to
think about in my inbox, but I'd like to get that somewhere public.
	* at the top: https://eugenkiss.github.io/7guis/
* Organize "FoC Research" - same idea but more for things to read for
inspiration, like papers
	* at the top: https://github.com/hypotext/notation

log.md

@@ -88,3 +88,4 @@ The data for this page is pulled from the commit message history for this reposi
   ga('send', 'pageview');
 </script>
 <script repoPath="stevekrouse/futureofcoding.org" type="text/javascript" src="/unbreakable-links/index.js"></script>
+