firstname.lastname@example.org (related to academia)
email@example.com (all other)
inventing a new one (this is nothing very clever, new logics are invented all the time) and proving that it is equivalent to some others.
I also seem to have devised what appears to be the first correct concurrency control algorithm, at least going by one commonly held definition.
These days I am working on a proof assistant called Occam, if that's not obvious.
For what it's worth I am a supporter of the Cost of Knowledge effort.
I've been working on the openmathematics.org site again.
You can now make changes to package's readme files and publish them directly from the site.
I'll enumerate the other two major changes:
There is now some support for GitHub.
you can commit the aforementioned changes to readme files to a package's repository at the same time as publishing;
you can edit and create issues;
and you can do the same for comments on issues.
There is support for LaTeX, which can be added to readme files, issues and comments.
The result is that the site now functions at least partially as a kind of maths enabled, GitHub overlay.
You can compare the readme file of the 'minimal-propositional-logic' package across the two sites here and here to get an idea.
16th May 2018
Sorry this is a bit of a long, programmy one...
Lately I've been out in the real world (scary stuff!) talking to other programmers and the subject of Reaction has occasionally come up.
I've found myself dissuading people from watching the 'Reverse Engineering React' series of videos, however, and I now wonder why.
I think part of the reason for this is that I feel things have generally moved on.
So if you come by this website having stumbled across Reaction (as I suspect a significant proportion of the visitors to this site do), then here are some suggestions:
Don't waste too much if any time on the aforementioned 'Reverse Engineering React' videos.
They really are a bit dated, simply because Reaction's code base has changed.
I haven't done a bad job of keeping up the errata, but I haven't done a great job, either.
My suggestion would be, therefore, that you clone the repository and have a look around.
I think the pertinent files are the topmost react.js file, which gives you JSX support;
and all the files in the element directory and its subdirectories,
especially the other react.js file, which implements the all-important ReactElement class.
If you do fancy watching some videos, watch the Rewiring Redux series.
There are far less of them, and four frameworks are discussed rather than just one, namely Reaction+Inference and React+Redux.
More importantly, (I kid myself) I manage to draw a few distinctions between these two pairings which (I again kid myself) may shed some light on each of them.
For example, there is a bare bones implementation of Redux in the redux.js file, which really is
all you need in production (don't tell the BBC, ahem).
Lastly, I've been working on the openmathematics.org site recently, and I felt obliged to use Reaction and Inference, seeing as how I wrote them.
At times it felt like I was cutting my nose off, but things have turned out pretty well.
So you can have a look at the whole lot using your browser's developer tools.
I've also made a bit of an effort with both the Reaction and Inference readme files,
ostensibly to explain the patterns I developed in order to get a data-driven site, as opposed to just a toy site, working.
Finally, I should mention Juxtapose.
I'm a massive fan of JSX and Juxtapose is my take on it, lending JSX support to my Easy elements.
I could bang on about it for ages, but all I'll add here is that it allowed me to turn Occam's view code into a structured whole as opposed to a plate of spaghetti.
I got so excited about it I even wrote some documentation.
31st March 2018
There is a new website for publishing Occam packages as well as a command line package management tool to enable you to do so.
Details can be found here:
2nd December 2017
I've always been a bit rubbish at probability,
and recently a student came to me with the Monty Hall problem.
I waffled for a few minutes before admitting (to myself as much as anyone) that I hadn't a clue what I was talking about.
We then decided to solve it properly.
It took a few lessons on and off but the result was a much clearer
direct calculation (or proof if you prefer).
Occam has its own dedicated page including a section on how you can get it running locally.
The First Correct Concurrency Control Algorithm.
These are not fully peer-reviewed papers and should not be judged as such.
State/event based versus purely Action or State based Logics.
JSX support for Easy elements.
An alternative implementation of React.
A dispatcher in a similar vein to Redux.
Elements that abstract away from the DOM.
Layout elements that work with CSS flexbox.
Drag and drop elements including an explorer and a rubbish bin.
A textarea element that handles and hands off events well.
A collection of utility functions.
An MVC framework with scheduling.
A handful of common CSS styles.
Relates to URL hash fragments.
Last updated 31st July, 2018.