Awelon Blue

While David Barbour does tend towards thinking about loud a great deal before coding (which is certainly sensible), he has also previously implemented these ideas in Sirea (https://github.com/dmbarbour/Sirea) and has just released a spec and interpreter for his Awelon language - http://awelonblue.wordpress.com/2013/12/25/awelon-project-progress-rep…

There have been proposals to have global state in programming languages which function like databases with the advantages of monitoring/persistence/naming etc, but also retain the modularity of local state. https://www.scattered-thoughts.net/writing/local-state-is-harmful/ https://awelonblue.wordpress.com/2012/10/21/local-state-is-poison/

Make sure to checkout the blog https://awelonblue.wordpress.com/about/ It has been a source of much inspiration to me for many years.

https://en.wikipedia.org/wiki/Data_lineage I see a similar idea about this with things like self-adjusting computations, excel and https://awelonblue.wordpress.com/category/language-design/reactive-dem… Should help the debugging process a lot.

Global state is actually a good model, see https://awelonblue.wordpress.com/2012/10/21/local-state-is-poison/. The issue is more one of fragmentation; figuring out which file(s) / method(s) are responsible for some item of state can get to be impossible without a powerful debugger, and constantly changing frameworks / libraries don't help.

The thing that distinguishes genuine "declarative" or "goal-based" programming is that the order of expressions in the source language doesn't affect the order of execution[0]. On the other hand, I see the level of abstraction as (roughly) the average number of machine instructions executed for every statement or expression in the source language. With these two definitions, its clear that while "declarative" languages will almost necessarily be at a high-level of abstraction, you can also have languages that operate at a high-level of abstraction without being declarative. caveat: the original link wouldn't load for me, so I don't know if my response makes sense in light of the original article. [0]a more technically correct definition is provided by David Barbour https://awelonblue.wordpress.com/2012/01/12/defining-declarative/

To be fair, there is an "About RDP" link on the page: http://awelonblue.wordpress.com/about/

Exactly. There are loads of people with much more interesting ideas, for example the author of this article: http://awelonblue.wordpress.com/2012/07/01/why-not-events/.

I've not seen these ones on any list here: http://blog.databigbang.com http://blog.nektra.com http://www.yosefk.com/blog http://www.cocos2d-iphone.org/ http://blogs.southworks.net http://awelonblue.wordpress.com/

obvious q is how this differs from frp. the same author (i think?) addresses that here - http://awelonblue.wordpress.com/2011/05/21/comparing-frp-to-rdp/

> I have yet to see a FRP library that allows you to just use a component without introducing boilerplate. I'm the author of https://github.com/calmm-js. I wouldn't necessarily describe it as (pure) FRP, but the combination of techniques used in Calmm pretty much eliminates all boilerplate: in the limit, a truly useful component can be just a single function with a body of a single line of code. Using that component then is just a matter of instantiating the component with desired parameters (no boilerplate). The lack of boilerplate makes it practical to eliminate even small scale repetition with local components. Parameters to components in Calmm can represent read-only (Observable) or read-write (Atom :> Observable) state. RW state can be sliced with lenses and be used as RO state without glue. RO state can be arbitrarily combined to compute desired properties. Thanks to being able to effortlessly slice RW state, components can be easily made independent of the application state as a whole (IOW, a component can be made to take only just the state it needs as parameters) and be made truly reusable. Calmm also makes it simple and easy to create both stateless components (consider #1) and components that can optionally use local state so that the user of the component can actually choose whether the component uses local state or a slice of global state. Calmm also primarily guides you to use stateless, time independent, continuous, observable properties (combine)…