proj-oot-ootNotes12

in oot, w/o baking in a single message bus implementaioh, can we have a std optional language for wheether a piece of info is an address, a command, just a data update, metadata that will be kept with the dataupdatee (like a trade timestamps) or message-level metadata? this is also a good examplee of what i mean by putting the LANGUAGE into programming langue via conventions. relatd: diplomacy plan suggestion symbols

---

i've heard that: akka is baked into scala deeply but debugging it is too hard

---

some important stuff in Doug's 'classical' library ( https://github.com/drubino/Classical ): hashing dictionaries (doubly generic; keys can be anything in lang) (without javascript default dict implemenetation's keys that collide with yours) rationalized reflection system lazy list comprehension-ish query system

--- " I’ve always liked the idea of building complex logic systems out of a simple primitive that is just powerful enough to construct all logic - particularly in videogames. For example, in LittleBigPlanet?, you can build a Tic-Tac-Toe AI out of physical elements like pistons and magnetic switches. In Minecraft, you can build an ALU out of a primitive construction element that behaves, essentially, as a NOT gate. And, if games aren’t your thing, you can build CMOS logic out of UNIX pipes with a simple “mosfet” program. " -- https://fail0verflow.com/blog/2012/dcpu-16-review.html http://www.youtube.com/watch?v=yUbRFfXEtls http://www.youtube.com/watch?v=LGkkyKZVzug http://www.linusakesson.net/programming/pipelogic/index.php

---

" Let/Const

The ES6 ‘let’ feature is similar to ‘var’, but it aims to simplify the mental model for the variable’s scope. With ‘let’, you can scope variables to blocks of code rather than whole functions. For example:

function f() { let total = 0; let x = 5; for (let x = 1; x < 10; x++) { total += x; } console.log(x); }

f(); outputs 5

Notice how the two ‘let x’ statements do not conflict. This is because the one used in the loop is in a different scope than the one outside of the loop. If we re-wrote this using vars, all ‘x’ vars effectively combine into one, leading to rather confusing output.

function f() { var total = 0; var x = 5; for (var x = 1; x < 10; x++) { total += x; } console.log(x); }

f(); outputs 10 " -- http://blogs.msdn.com/b/typescript/archive/2015/01/16/announcing-typescript-1-4.aspx

---

a good writeup of the haskell record type problem, and pointers to various proposed solns:

the problem: http://nikita-volkov.github.io/record/

various proposed solns:

discussions:

https://news.ycombinator.com/item?id=8909126

---

Haskell module system proposal:

---

Haskell initial blog post on lenses:

---

http://prog21.dadgum.com/203.html

in summary, he says Python isn't a good first language because:

instead, for these reasons, he recommends Javascript.

within the discussion, https://news.ycombinator.com/item?id=8921781 and its replies touch on a related point: sometimes CS curricula start with Racket rather than Python because it lends itself more to teaching core CS concepts, eg complexity of algorithms, functional programming techniques, recursion, data structures. However, many students aren't going to be professional programmers or CS theorists, they are going to do something else with their lives but they need to learn to do a little programming, purely as a tool. For these people, they want to learn to program something as quickly as possible, at the expense of not completely understanding the advanced stuff or the CS theory basics.

---

mb uninteresting: https://www.google.com/search?q=clr+addressing+modes&ie=utf-8&oe=utf-8

---

a learn to program game:

http://play.elevatorsaga.com/documentation.html

https://news.ycombinator.com/item?id=8929314

when i say i want Oot to be 'languagey', one thing i mean is that the core concepts and syntax of oot should usefully transfer even to DSLs that build on top of it, even when they have to override the implementation/interpretation of these concepts and syntax (by 'usefully transfer' i mean that the DSL authors should want to reuse these concepts and syntax because they are useful; i don't mean that oot should mandate that, although maybe it should, i havent thought about that yet).

sort of in the way that ppl talk about 'Pythonic' interfaces to foreign libraries; these reuse Python concepts like dicts, OOP, properties (__get and __set overriding rather than explicit getter and setter methods), etc (what else?)

i suppose one aspect of that is that i want much of Oot to be 'declarative' and 'first-class'; for example, i want to have 'binding' or symlinks to be a first-class concept within Oot, and i want people to be able to say (eg when writing dynamic websites or web frameworks) that the value in this DOM element is bound to that value in the database, or to that local variable; but when they say this, i want it to be in the form of a first-class declaration ("this is bound to that") that various metaprogramming frameworks (eg web frameworks) can then look at (is this reflection, or is it not, because it is so first-class and so declarative from the get-go?) and implement differently. Eg people talk about ember.js vs angular v1's vs rubino's classical's way of syncing these things that are supposed to be bound together, and they are different, but the basic idea that this is supposed to be bound to that is shared.

another example is the way that llvm does garbage collection; they don't provide an actual garbage collection module, but they do provide a language for telling the garbage collector the things it might need to know (eg @llvm.gcroot ; see http://llvm.org/docs/GarbageCollection.html#in-your-compiler), and for leaving extension points in your code for the garbage collector (eg llvm.gcread, llvm.gcwrite.

and another example is the idea of following a path of getattrs and obeying the __get and __set metaprogramming along the way.

E.g. you might say 'a.b.c.d.e = 4', but maybe d doesn't 'actually' exist and is merely being virtually simulated by c via a.b.c.__get and a.b.c.__set. Oot implements the most general case here, checking each node for __get and __set as it is traversed; but the metaprogramming in a.b.c might virtually simulate both d and e at once via a 2-d table. Still, the language of paths, effective addresses, (and even __get and __set??) should be usefully reused.

Haskell looks at pure expressions as a special case of deterministic side-effectful functions, that is, pure expressions are functions with no side effects.

However, the reason that this doesn't always work well in programming is that sometimes you want to change some guy deep in the call chain to have side effects, eg caching or logging or whatever. Another way of looking at this is that functions are things that return a value, and functions that both return a value and have a side-effect are a special kind of function that returns a value.

---

React v0.13.0 Beta 1 discussion

https://news.ycombinator.com/item?id=8958731

---

we should provide multiple choices for which minimal 'kernel' of methods to override to implement a represeentation (via circular defns?). For example, in order to derive all of <, <=, >, >=, ==, you only need to define some subset of these; <= and == will do, as will <= and <, or < and >; so in Oot, you could define this typeclass by providing an abstract implementation for all five of these methods, and then a representation could override only two of these (but which two is up to the implementation).

(see also haskell's derived instances of Ord)

---

MS's open source .NET runtime uses CMake:

https://news.ycombinator.com/item?id=8992656

ixtli 2 hours ago

link

Even more reason to port all of your C/C++ code to CMake. I'm excited to see upstream contribution from MS.

reply

stinos 1 hour ago

link

Exactly, CMake getting more traction like this should be good. I know quite some devs who're like CMake? Why don't you just use good old Makefiles? and then struggle with it's syntax and/or fail to provide working Windows or even Mac builds of their software simply because they stick with plain makefiles. (don't get me wrong, they work fine, just not so much for cross-platform projects)

reply

stefantalpalaru 2 minutes ago

link

The alternative is not plain Makefiles, but Autotools: https://autotools.io/index.html

reply

---

i still don't think Oot is quite broad enough yet for:

---

well at least for the above, the 4-role 'grammatical' oot assembly idea seems to fit. It seems like a lot of things can be divided into object or rhs or input params, subject or lhs or output params, a verb or instruction or construct identifier, and mode modifiers. And getting a second level of these allows you to express even more (eg modes on of the input). It also imparts a rather strong flavor to the language, maybe a little strong for my taste, but some flavor is good, probably even for metaprogramming, as it presumably creates conventions (well, pre-conventions; cognitive structures that probably tend to lead different people to thinking of similar conventions).

Also the idea of having the '/' sign be 'arrow' gives you a lot; grammars, logic, and simulations all seem to be phrased in terms of tables of rules of the form: a -> b

which might be written a / b in oot

What else do these things have aside from tables?

---

i guess one other problem with Haskell is that it's not really that portable in practice. This comes from two sources:

My impression is that the GHC extensions tend to be type system extensions. Which suggests that a language with a more extensible type system (so that most of these type system extensions would be libraries that run on any implementation of the language) would not have this problem quite as much.

You would think i wouldnt care about this so much, because i like languages with one canonical implementation, but i guess i do. Non-portability prevents things like Haskell and Python from being run on top of Javascript in the browser, or on mobile devices, etc, which makes them vulnerable to quickly becoming out of date when a new platform like the Web or Mobile comes along.

---

i am becoming more impressed with the JVM and with Java as i learn more about languages and language implementation.

note that the JVM has weathered the shift to mobile relatively well.

---

an example of regrettable lack of standardization in Wordpress post formats:

https://www.doitwithwp.com/saying-goodbye-post-formats/

---

an example of tradeoffs that most languages have between code that is easy for newbies and code that is good:

"While programmers like myself start convulsing when we have to wade through such code, less experienced programmers actually like it, because it is easier for them to work with. Because the "template functions" are in the global namespace, they work anywhere. Because the data returned by the database is in a global variable, you don’t have to use any tricks to get at it. It makes extending, enhancing, and modifying the code easier for newbies." -- https://github.com/WordPress/book/blob/master/Content/Part%201/2-b2-cafelog.md

(was that from http://web.archive.org/web/20050901152840/http://revjim.net/comments/3955/ ? i dont see it there)

---

a book on the history of wordpress! toread/toskim (i skimmed Part 1 already):

https://github.com/WordPress/book/tree/master/Content

---

a Clojure survey on what features users wanted http://tech.puredanger.com/2013/11/19/state-of-clojure-language-features/

---

some discussion on features in various Python notebook systems:

https://news.ycombinator.com/item?id=9004689

---

(not about monads, it's about some MS shell framework)

http://www.jsnover.com/Docs/MonadManifesto.pdf

---

some ideas relating to generalizing/translating the instructions of Nock:

to review, the Nock instructions (see also my notes on Nock