html: http://goo.gl/1XilSW pdf: http://goo.gl/5uzP4N edit: http://goo.gl/2rbg2g
irc://irc.freenode.net/lemonparty
lemon is:
- a work-in-progress projectional editor, an attempt to do it right, with some focus on natural language-like syntaxes, and to explore the continuum (hybrid-, semi-). For a justification of projectional editing, see related projects.
- attempts at a language/shell inside it. In tunes lingo, the HLL-. This might be based on python/lua and compiling to it, or picolisp, or dunno..
- experiments on the side: fish frontend, semweb stuff, documentation formats…
- collecting resources:(not lemon specific) high level shell / snippets system / db stuff
- at planning/dreaming stage:
HLL+: http://tunes.org/HLL/
- just dreaming: desktop ui/gui things
- curiousity about things that make computing better, an attempt to organize them and make them more accesible / findable from without and within lemon
why not use X instead of lemon
unified interface to (desktop) programs
high level, DSLy, declarative etc
Emacs! we need a paragraph about emacs!
general and/or philosophy and/or programming and/or interesting and/or fun reading
old - design document-ish questions
introduction
motivation
structured editors are cool:
https://www.youtube.com/watch?v=F13wg2ApCdc
http://www.lighttable.com/2014/05/16/pain-we-forgot/
http://peaker.github.io/lamdu/
an experiment: i believe that a smart way of going about user (programmer) interaction in a projectional editor will allow the programming language built around it to reach new levels. The biggest inspiration is Inform 7.
lemon should become a structured editor / ide / base of an interface for a programming language / a knowledge management interface / a daily computer use language with some natural-like language features, plus the usual bells and whistles that projectional editors offer or promise. Ultimately, it will become a desktop environment and take over the world.
The design and nature of implementation of the language is still unclear. i have a lot of reading to do, and the editor should first be finished - as a proof of concept, and to show its strengths and weaknesses - the editor and the language should co-evolve.
features that i’m aiming for
- hybrid editing: mix text with menu-selected identifiers/constructs (im starting to think this is rendered unnecesary by marpa)
- multiple syntaxes: levels of detail, localization, mathy vs wordy..
- all languages (node types and syntaxes) are defined with the base language constructs (“internal” DSLs)
- shell-like UI mode: just you, a menu of everything in the system, and a blinking cursor.
- terminal and graphical frontends
goodies i keep in sight: distributed UI, live graphics (VPython?), dbpedia lookup...
current goals
basic projectional editor with unintuitive but working editing functionality
frontend: drawing text, menu, cursor, sending back events
interpreter: nice but not crucial for prototype, code generation easier?
parser integration
ponderings
core: tree element, widgets, tokens, grammars?, nodes, tags, placeholder
compilation, menu: lexical scope, recombination?, scoring of menu items.
type system how? - ML, coq, subtext research? -
syntaxes of nodes are kept inside node declarations for now,
must add child types to names, point to python classes or..
editing - menu driven system?could clarify the requirements of the frontend, possible operations etc
the frontend can be implemented in another language and its input and output can be fairly well defined, and it can take on more functionality, for example scrolling, or leave it to the core
moving widgets to the hypothetical frontend seems messy - they have to keep their own state. ultimately doable and maybe right, but must be researched
why not use X instead of lemon
i7
CAN be made useful for general purpose programming, the toyness can be worked around, at least to have something working, (python wrapper)...something that could be used to create another language / whatever, at least. But youre still stuck with the quirkiness. and the unnecessary limits. it IS an option...might even end up the only one:)
ACE
is only data / rule description
again.a better editor for ACE would be awesome..
(currently looking into making some declarative-only nodes for a special-purpose app, with a RDF vocabulary)
add natural presentation to existing language?
maybe will be able to re-evaluate that option after learning more
editors
MPS: huge,different goals
eastwest: it’s embarassing but i dont know ocaml. the author writes “its the nature of the beast” that some things are hard in a structured editor, probably not a good base for lemon. However, he shows that some things are easy, and structured editing just is a different way
the natlang/core UX vision
todo
https://github.com/koo5/lemon-operating-language/blob/refugee_branch/mockup1.odt?raw=true
<sirdancealo2> inform 7 already exists and works pretty well, for how stupidly its
<sirdancealo2> built. If i slapped a good structure-aware (as is nowdays modern) editor
<sirdancealo2> onto it, 80% of the task would be accomplished. But im not sure inform
<sirdancealo2> would ever evolve the remaining 20%. So the logical thing to do is to
<sirdancealo2> build something new.
<sirdancealo2> you struggle with the idea of natural language programming. for one, you struggle with the english language. you probably had to adopt a different mindset to programming in a foreign language than native english speakers
<sirdancealo2> you percieve the language as a barrier
<sirdancealo2> english isnt my native language, but im an anglophile
<sirdancealo2> i pretty often find myself thinking in english
<sirdancealo2> especially when it comes to programming or other topics i usually read about and discuss in english
<sirdancealo2> again, i think i7 is almost there. Yes the parser is complex, and employs concepts about time and space and uncertainity and linguistics, obviously
<sirdancealo2> but its there and it almost works, for my purposes
<sirdancealo2> i am trying to achive something similar. Maybe (and the best i can hope for), ill just push things a little bit forward. Maybe somebody smart will then come around and create inform 8:)
<sirdancealo2> so forget about thinking machines, think im just trying to merge two existing solutions that i think belong to each other
(21:36:03) ram boo: suppose you declare a banana object somewhere in your code
(21:36:43) ram boo: i want to follow i7 and give objects binary properties
(21:37:16) ram boo: there will be constructs for setting and testing them
(21:37:35) ram boo: "banana is yellow"
(21:38:01) ram boo: but the editor has to make much more sense from it
(21:38:51) ram boo: so thats where the interactivity comes in
(21:39:32) ram boo: by the time you typed banana, the banana you declared earlier remains in the palette as the only option
21:40
(21:40:10) ram boo: so if you dont do anything special and press spacebar to start typing the next word, the text transforms into a block
(21:40:58) ram boo: etc etc
(21:42:50) ram boo: you type "is", and maybe this time you have to press escape to differentiate it from another, longer word starting with "is"
(21:42:58) ram boo: and it transforms into a block again
(21:43:09) ram boo: and it knows it's the "is" keyword
(21:43:16) ram boo: which is kinda multipurpose but nvm
(21:43:33) ram boo: it knows its not a variable or anything else
(21:44:47) ram boo: it has never heard of "yellow", so theres some kind of interaction to estabilish it as a new thing
(21:44:58) ram boo: then when the sentence is complete, editor matches it with a pattern for setting binary properties
21:45
(21:45:36) ram boo: and you confirm it
(21:46:32) ram boo: and at this point the 3 words should become nodes of a new block
(21:47:28) ram boo: so im not sure if i wouldnt start fighting with blockly at this point
(21:47:50) ram boo: all i can imagine is that typing the sentence like this would lay parentless blocks one by one on the canvas
(21:48:22) ram boo: and the editor would have to remember they are associated
(21:48:33) ram boo: bleh
(21:49:11) ram boo: the example i was actually thinking first is testing for the properties
(21:49:27) ram boo: you write "if" and press space and an if block is created
(21:49:35) ram boo: cursor moves to its expression slot
21:50
(21:50:13) ram boo: you write banana and its a valid expression, so it joins into the slot
(21:50:55) ram boo: but cursor would have to move beyond banana and let you add more blocks in case you are intending a more complicated experssion starting with banana
<sirdancealot8> 1) An editor for lisp...a structured one, tree view
<sirdancealot8> 2) give every structure a descriptive structure that will shuffle around the order of its items (arguments)
<sirdancealot8> 3) remake some basic sentences from inform7
<sirdancealot8> 4) add to the descriptive structures a list of synonyms, have every program item surrounded by a cloud of those, allow to display one of the synonyms instead of the primary word
<sirdancealot8> 5) have the editor, when you type some word or synonym let you easily choose what you mean, choose the most probable meaning by default
<sirdancealot8> so you can be writing your program in almost-english and just confirming right meanings with spacebar
<sirdancealot8> typing "a house is an object": "a house" -> editor is clueless, offers "a house - something new", confirm
<sirdancealot8> "is an" -> editor perks up, matches "is an" with is, which is some function, also sees is is supposed to have something new on the left side and something known on the right
<sirdancealot8> object, known, voila, enter
lemon shell/desktop?
a language with DSLs inside a projectional editor as a desktop shell, a frontend to desktop environment settings, implementation language for stuff, [frontend to / database of] legacy functionality
examples:
power management:
the gui structure could be like this:
- computer/desktop settings
- power management
- legacy
- kde
- active?
- on AC power
- screen brightness
- set?
- value
- ..
- on battery power…
- sleepd
- installation helper / instructions
- settings
- lemon
- ?
other ideas:
winpopup functionality for linux
package management
power management, freedombox gui
https://www.freedomboxfoundation.org/news/
“Plinth, our user interface tool, is now connected to a number of running systems on the box including PageKite, an XMPP chat server, local network administration if you want to use the FreedomBox as a home router, and some diagnostic and general system configuration tools.”
more generally:
hypothetical goal desktop environment:
apps made in various high level reflecting langs
compatibility on high level
what do you think gnome3 was about? what did it bring besides assholic UI experimentation and an api for an unified notification area
what did i learn, why do i need another "language"? #or restart lemon-3...in python..((minneron, vsh), ipython, pyke?)..?
user interface as high level programming, one language system, accessibility of a programming language/ide to programmers of all backgrounds...
I think im starting to see a common pattern here. The keywords are existing functionality and huge codebases unhackable by us mere mortals, and the undercurrent under our efforts for one-language desktops is desperation. If we only had the perfect language, we could rewrite it all ourselves and better, it would be hackable and awesome...
start building a common interface to existing code. A gui, even, a console of sorts, giving unified documented searchable access to: command line versions of programs (for example gimp) and running instances of daemons (for example bitcoin) and even gui programs (pidgin).
many programs are well suited for that, and the rest can be fun to hack in this way.
lemon 3 had several xscreensaver hacks chopped up and running in parallel in one opengl window. my focus is now empowering myself and other UX people, rather than inventing the perfect GUI right away.
also look at unity, kde's "converged desktop", original gnome3 effort (they seem
to be doing the right things, like with GOA as opposed to UOA)
could even look into tighter integration of unity lenses with lemon.
but most of all, this seems to be the lowes common denominator, the mainstream attempt
at high level computing. We should plug ourselves there somewhere.
All these ideas here arent new ideas, but things tried and retried...
what does it all mean?
unified interface to (desktop) programs
database of / interface to existing programs, possibly with a frontend
usable by lemon and other projects
unified searchable access to: command line programs, daemons and gui programs.
examples: some power management daemon, bitcoin, pidgin, gimp --batch
(old) https://gist.github.com/koo5/5624786
could start building the database, but useless without an ui
idea of a basic ui:
no natural language understanding, just text search of database
command name: 'use'
$ use turn off monitor
$ use get package source picolisp
-> code snippets
https://github.com/chriskiehl/Gooey
https://github.com/pickhardt/betty/tree/dev
https://github.com/BmanDesignsCanada/TaskOn2
lemon language
base
what should be the main base language?
http://lua-users.org/wiki/LuaGrammar http://metalua.luaforge.net/
https://github.com/jddurand?tab=repositories
http://software-lab.de/doc/tut.html
basing lemon on python:
http://roscidus.com/blog/blog/2013/06/09/choosing-a-python-replacement-for-0install/
a different take on why replace Python:
statically linked: cython(?)
performance: pypy, cython, nuitka
.NET: ironpython
java: jython..
js: asm.js
LINQ:...
laziness: https://www.google.cz/search?q=python+lazy
distributedness: hot topic for me now:)
types: https://www.google.cz/search?q=python+static+analyzer
http://langpop.com/ is python (or something similar) here to stay as a de facto, increasingly more declarative, with tools for user-configurable type checking etc..?
https://mail.python.org/pipermail/pypy-dev/2007-February/003548.html
http://stefan-marr.de/papers/ieee-soft-marr-et-al-are-we-there-yet/
http://www.piumarta.com/software/maru/
linearly between static and dynamic typing...
by i7 feature...
rule system: before / after / instead of…
- could be prototyped with decorators
- https://www.google.cz/search?client=ubuntu&channel=fs&q=rule+dispatch+python
- http://ericlippert.com/2015/05/11/wizards-and-warriors-part-five/
multiple dispatch
https://www.google.cz/search?q=python+multiple+dispatch
http://www.aiai.ed.ac.uk/~jeff/clos-guide.html
sections
- appearing in tracebacks is just a nicety
- as a feature of the editor..
- shouldnt be so hard to allow multiple font sizes in lemon
physical units..
logic.../ LINQ?
- repeat with associate running through every chatty not grumpy spiffy person begin; say "Hi [associate]."; end repeat;
- logpy, but what above it? pyke?
implicit variables/context
do we need a structural editor? With marpa, probably not. We certainly need a smart one, tho.
- with a language workbench:
- https://eclipse.org/Xtext/7languagesDoc.html#scripting
- or wait for python / lua / ? in MPS?
testing:
a formalization of unit testing and other goodies: http://cobra-language.com/docs/
wiki based ide/snippets:
i7 syntax:
https://www.google.cz/search?q=mixfix+notations
inspiration
https://news.ycombinator.com/item?id=9126772
http://en.wikipedia.org/wiki/Kaleidoscope_programming_language#Example
https://groups.google.com/d/topic/enoughmail/qjpbdA8QYrI/discussion
http://www.dickgrune.com/Programs/teckel/
http://en.wikipedia.org/wiki/Epigram_%28programming_language%29
i7-like rules, rulebooks (AOP:p)
fsm block
boolean properties
what..does it mean..for the programming language? which part are we simplifying?
knowledge bases
logic programming
dataflow programming: http://www.jpaulmorrison.com/fbp/concepts.shtml
encapsulation
speed of rewiring?
i would like to differentiate myself from dataflow programming..it will be useful later, for certain cases...on higher levels, but its not the cure-all
like boolean function tables, but for everything...nice visualization
unification: generally acessible language? editing other languages?
Dataflow visualization:
Provide encapsulation through the metaphor of building blocks
Join blocks to create logic sequences
-as well as control flow
Problem:
How do you solve the problem of concurrent programming?
How do you represent complex tasks?
FSMs
http://www.datahaven.net/automats.html
An inspirative piece of software. i like the (internal) feel of this app, designed in ms visio, generated python classes for fsms, you can, at runtime, inspect the state of each fsm, events, packets, logs.. Worth studying. They are working on version two, hopefully will be more useful.
c2.com/cgi/wiki?AlternateHardAndSoftLayers
c2.com/cgi/wiki?CollectionOrientedProgramming
c2.com/cgi/wiki?MinimalTable
http://en.wikipedia.org/wiki/Tacit_programming
- not the implicitness of i7, but interesting too
https://www.firebase.com/blog/2014-08-21-blaze-security-language.html
http://latentflip.com/imperative-vs-declarative/
https://github.com/kivy/kivy/wiki/Data-driven-variables-with-kivy-properties
http://elm-lang.org/blog/announce/0.14.elm
http://www.vpri.org/pdf/tr2011004_steps11.pdf
https://github.com/damelang/gezira/tree/master/nl
LINQ - cshell.net
https://github.com/tangentstorm/j
https://github.com/tangentstorm/coinops/blob/master/sha256.ijs
http://ceylon-lang.org - types, marpa
http://cobra-language.com/docs/quality/ - “first class” tests
old sketches
currently two kinds of things here, the structures and the textual appearances
before you run off in a laughing disbelief, realize it isnt the language appearance but the one language - one desktop environment that is hard to believe
https://gist.github.com/koo5/6611262
https://gist.github.com/koo5/6551885
https://docs.google.com/document/d/1Qo9yanAmvdW9Oq5L0c2I9Ye2RP2PVq1rN4veQ1aKBN0/edit
https://github.com/koo5/cytron/blob/master/footnotes.txt
type system & data model &...
http://lambda-the-ultimate.org/node/4771
ast data format: todo: graph library vs rdf vs citrus vs homemade node classes ..
compostable, internally defined grammars - languages
http://scg.unibe.ch/research/helvetia/petitparser
but what about type system?
and what are the essential building blocks?
sugared and desugared forms of nodes
n3
grammar for grammar
http://marpa-guide.github.io/chapter2.html
related projects / links
possible bases for lemon:
cedalion (and by extension lemon) (internal DSLs) vs language workbenches MPS: see http://www.cs.tau.ac.il/~amiramy/SoftwareSeminar/cedalion-tau1.pdf
and other cedalion papers
different definition of internal/external (MPS is internal DSLs, because the languages are integrated, even if the definitions are kept separate):
CITRUS
http://www.cs.cmu.edu/~NatProg/citrus.html
http://www.cs.cmu.edu/~NatProg/barista.html
not finished, probably only the ToDo demo works (a nice todo app, tho)
i didnt get my hands on barista yet
It will take some time to study the source. could use the model logic and the nice serialization and maybe everything? One problem is that lemon allows (or will allow) for a much easier way to define new functions or nodes, the syntax (view) is implicit in the definition. The natlang text stuff would prolly fit nicely in citrus. Im just lazy to learn a whole new codebase, more so since i know i would want to do some heavy changes right from the start. Or would they be heavy?
The citrus pdfs reference several interesting projects, among them:
-> http://harmonia.cs.berkeley.edu/harmonia/index.html
(interesting) http://harmonia.cs.berkeley.edu/harmonia/projects/codelink/index.html
eastwest
https://sites.google.com/site/rathereasy/eastwest/tutorial
ocaml library for creating structured editor for a language + sample languages
seems dead since 2010
http://code.google.com/p/oset/source/list
http://code.google.com/p/oset-curses/source/list
cedalion
i couldnt figure out how to make current eclipse (3.8.1)
load the plugin, so i tried building it, which works, but at runtime i get an Unexpected Exception (doh..). Probably from the prolog wrapper.
ProjecturEd
general purpose editor for existing textual languages (java, javascript, cl) other “domains” (book, statemachine, filesystem). Nice generalization of the whole projecting business, it seems. Everything in CL, and domains are made up of other domains (number, text, list..).
from my current perspective, the hardest part are the internal data structures and editing behavior. I understand prejectured provides that in the form of CL code? Also, i only see them implementing editors for existing languages. Could it be used only as a projecting frontend?
as of 21.2, installation and running procedure is whacky but doable
larch
https://sites.google.com/site/larchenv/the-larch-env
http://www.ubiquitouslarch.com/get_it
has “the other” views, -> jump tables(subtext), ..?..
no support for the kind of AST editing we want..yet - would have to start creating that from scratch?
other small projectional
http://www.reddit.com/r/programming/comments/2rk1iz/conspire_a_programming_environment_for_nowhere/
subtext
decision tables
eco
https://news.ycombinator.com/item?id=8505382
lamdu
http://peaker.github.io/lamdu/
https://code.google.com/p/enough
also:
https://groups.google.com/d/topic/enoughmail/qjpbdA8QYrI/discussion
contact this guy / write something to the list?
is the “enough” plan still where lamdu is headed?
pivotal
http://www.cs.kent.ac.uk/projects/pivotal/index.html
SC
http://sclang.sourceforge.net/index.php?p=Media
language workbenches
https://www.google.com/search?q=comparison+of+language+workbenches
“”participating tools should be language workbenches, that is, tools that are designed specifically for efficiently defining, integrating and using domain specific languages in an Integrated Development Environment (IDE). Embedded, fixed-language or library-based solutions do not meet this criterion.””
MPS
http://www.jetbrains.com/mps/docs/tutorial.html
http://campagnelab.org/software/nyosh/
https://www.google.cz/search?q=mps+jetbrains+semantic+web
cant find anything..
http://confluence.jetbrains.com/display/MPS/MPS+public+roadmap
why not base lemon on MPS: MPS does not have a language for defining languages,
the model of the language is edited thru the gui. This is a pretty fundamental difference, although im sure they could implement the “internal” approach if they wanted. Also, marpa.
Hopefully, language models are/will be reusable across projects.
eclipse Xtext?
(used by cedalion)
http://www.cs.cmu.edu/~marmalade/
eclipse has sorta matured over the years and there are interesting projects around it ( https://www.youtube.com/watch?v=bhdGNTm4PzI )
intentional
http://en.wikipedia.org/wiki/Intentional_programming ?
http://www.intentsoft.com/intentional-technology/intentional-platform/
more
http://www.student.informatik.tu-darmstadt.de/~xx00seba/projects/sugarj/
https://strategoxt.org/Spoofax/Tour
CNL
ACE
http://attempto.ifi.uzh.ch/site/docs/authoring_tools.html
http://attempto.ifi.uzh.ch/acerules_ti/
“Attempto Controlled English (ACE) is a controlled natural language, i.e. a rich subset of standard English designed to serve as knowledge representation language. “ Links to other projects.
SHRDLU
https://en.wikipedia.org/wiki/SHRDLU
http://www.semaphorecorp.com/misc/shrdlu.html
“ SHRDLU is often described as an initially impressive program that only appears to succeed because of the limited blocks world domain it understands. On the other hand, it's hard to find many subsequently implemented projects that were as ambitious or as general as SHRDLU. Considering how many applications could benefit from even limited intelligence, why is SHRDLU-style technology still so difficult to find or exploit? One popular excuse is that subsequent efforts to generalize SHRDLU techniques were supposedly not fruitful, with the result that SHRDLU-style projects fell out of favor. Or perhaps the complexity required in SHRDLU just to attain rudimentary intelligence scared off anyone who might attempt a more sophisticated system, because SHRDLU code already exceeded the design and engineering capabilities of most programmers. Creating a program that understands "pick up anything green, at least three of the blocks, and either a box or a sphere which is bigger than any brick on the table" is not an easy task. “
SHRDLU isnt a programming language..
inform 7
programming language + player command parser
http://www.ifwiki.org/index.php/Inform_7_for_Programmers/Part_1#In_a_Nutshell
“Easy To Read, Hard To Write. Empirically, Inform has proven to be easy to read but hard to
write. The natural language appearance can be a will-o-wisp at times, luring the author from
the path of clear grammar, as there are many phrasings that Inform "ought" to recognize, but
does not. Conversely, creating uncommented code beautiful enough to be worth publishing is
a viable sport. Such code can deliver its meaning even to those who aren't programmers.”
"The Amazing Interactive Turing Machine" by "J.D. Clemens"
https://gist.github.com/koo5/4129213
http://inform7.com/learn/man/WritingWithInform.txt
http://inform7.com/learn/documents/WhitePaper.pdf (§1b. The adoption of natural language)
other
http://www.whenappsfly.com/how-it-works/
http://sourceforge.net/projects/supernova/
high level, DSLy, declarative etc
this is it, higher and higher. expert systems and libraries of more declarative, high level functionality. this is the spice of the future. the lemon editor attempts to be merely one of the user interfaces to a library of declarative functionality that could be distilled from these projects. (?)
rebol
http://www.rebol.org/script-index.r
PWCT
http://doublesvsoop.sourceforge.net/
provides a kind of a visual language?
Utilizing public APIs to connect disparate services to automate tasks
http://techcrunch.com/2014/10/06/stamplay-is-ifttt-for-back-end-development/
“”There is no real direct competitor at this time but the space is very crowded. On one side we have BAAS like Parse, Kinvey and FeedHenry that targets mobile developer by offering server-side hosting and data storage,? Iacobelli said. ?Then, we have more vertical services like Firebase or Hull.io to solve specific problems. Finally, on the opposite side, there are website builders like Squarespace, Weebly or Wix.com, but they are for end users and just let you build mostly static websites.””
scratch-y
http://snap.berkeley.edu/snapsource/snap.html
scratch clone in js
very well documented
smalltalk?
+both language and editor exist
getting tired of these, blockly, scriptblocks, snap, http://www.modk.it/ (personally this one would be neat for putting my Stellarises to use. Also check how it promises toggling between code and blocks view....the hardware tab is totally unrelated and disconnected, tho:()
http://developer.catrobat.org/
A visual programming language for android (typeless programming language)
stuff
http://lambda-the-ultimate.org/node/5040
David Barbour
https://groups.google.com/forum/#!topic/pilud/p_lNAicBseE
link collections
https://delicious.com/vinodkd/pl-next
https://delicious.com/kirillosenkov/structurededitors
mailing lists
https://groups.google.com/forum/?fromgroups#!forum/augmented-programming
https://groups.google.com/group/tunes-project
esoteric data strucures
zigzag
http://users.jyu.fi/~antkaij/plinzz.html
docs http://www.nongnu.org/gzz/gi/gi.html (missing pics, complete in the source)
-dead since 2000
entrelacs
http://www.reddit.com/r/entrelacs
https://github.com/BradWBeer?tab=repositories
“Create a Document Object Model similar to modern web browsers DOM API. The ability to work with 2D and 3D with the same tools and a single language should produce a powerful system for displaying, editing and sharing documents of any kind. “
like limit theory?
dataflow
http://www.jpaulmorrison.com/fbp/concepts.shtml
tangentstorm in #learnprogramming on freenode.net
literate programming
https://gist.github.com/tangentstorm/4666614
https://github.com/minneron/minneron
http://tangentstorm.github.io/mr0.pas.html
tangentstorm also does a low level stack, building a pascal interpreter in a forth vm, building up to another language and ultimately the minneron environment?
everything goes in a relational database (common idea with spaciousness) - data adressing? one language environment?
https://github.com/guitarvydas/vsh
Cyrus:
https://github.com/DuncanCragg/Cyrus/blob/master/src/server/vm1/static.db
Amino Lang
https://github.com/joshmarinacci?tab=repositories
https://groups.google.com/forum/message/raw?msg=augmented-programming/QPQW776oz0Q/83hRW6WAEikJ
?
Modeless Structure Editing
www.cs.ox.ac.uk/people/bernard.sufrin/edit.pdf
a code editor that can display some domain specific values in another way (images), and it creates a very concise story in the code, thanks to the guis of the scripted apps..
another picture embedding one, this time controlling robots
http://raptor.martincarlisle.com/raptor_picture.html
control flow diagrams visual programming
is there something like this for real C?
say anything: :p
are there other current natural-likes?
NYoSH
...
visual languages papers:
http://www-ist.massey.ac.nz/plyons/776/VPL%20papers.html
http://www.lighttable.com/2014/05/16/pain-we-forgot/
oh come on..
http://blog.stephenwolfram.com/2010/11/programming-with-natural-language-is-actually-going-to-work/
http://research.microsoft.com/en-us/people/smcdirm/liveprogramming.aspx?2
http://research.microsoft.com/apps/pubs/default.aspx?id=201333
http://citeseerx.ist.psu.edu/viewdoc/summary;?doi=10.1.1.110.3146
http://citeseerx.ist.psu.edu/viewdoc/summary;?doi=10.1.1.21.6495
http://joshondesign.com/2014/10/06/typoplwrapup
https://groups.google.com/forum/print/msg/augmented-programming/QPQW776oz0Q/GKzdioTZDCsJ
lambda-the-ultimate.org/node/5036
https://github.com/shurcooL/Conception-go
semirelated stuff
i try to extract the more existing/mature projects into https://github.com/koo5/BronzeAge . I dont have the resources to start creating/collecting installer scripts/packages for these projects, maybe just make an awesome- list
https://github.com/vinta/awesome-python
https://github.com/kozross/awesome-cl
meta
http://en.wikipedia.org/wiki/Path_dependence
http://en.wikipedia.org/wiki/Conflation
http://docs.lvl.ru/tunes/www/Review/index.html
full stack rewrite
http://apenwarr.ca/log/?m=201708#10
https://news.ycombinator.com/item?id=8041288
http://www.vpri.org/pdf/tr2012001_steps.pdf
http://forum.syllable.org/viewtopic.php?t=2149
todo:haiku, plan9
also compare linuxen with openbsd
also see android, gnome shell
kOS
https://news.ycombinator.com/item?id=8476111
irc: #tunes
http://c2.com/cgi/wiki?TunesProject
http://c2.com/cgi/wiki?TunesWiki
http://tnovelli.net/dream/tunes2010.html
os rewriting is a popular sport. why do i think fixing lower layers isn’t the way? or is it?
https://github.com/minneron/minneron
current best tools/practices
fish/zsh
http://fishshell.com/ https://github.com/bpinto/oh-my-fish
what coud be added: live/context sensitive keybindings display/help
snippets / command metadata, that is, autocompletion, searching, based on whats typed, a database of metadata/snippets with textual descriptions. For example: replace x with y -> sed…
whats needed: add an autocompletion function that searches stuff and calls other fish functions, a difference from the rest of fish autocompletion is that upon selection, the typed text (or some last part of it, like after a pipe) is deleted and replaced. i think zsh does this
bash syntax highlighting: i’d expect bash isnt that customizable and youd have a hard time hacking the internals to even show any color, so a new line editor might be better. I dont think theres much functionality to replicate, line editing, history, .. python cmd again or whatitwas?
C
http://mbeddr.com/ or http://s4a.cat/ ? (if youre coding for bare metal)
considered Rust yet? haskell?
maybe SC programming language ?
http://jeffreykegler.github.io/Ocean-of-Awareness-blog/individual/2010/11/better-than-literate.html
undefined behavior, static analyzers, valgrind, clang, lint
http://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html
http://www.locklessinc.com/articles/obscurec/
python
one more layer:
http://docs.hylang.org/en/latest/
https://github.com/lihaoyi/macropy - dead?
editors:
http://www.reinteract.org/ (build from source, much new stuff, but py2 only)
http://ipython.org/notebook.html
http://www.sagemath.org/ #todo:overview of math software?
http://www.ubiquitouslarch.com/
logic programming
http://yieldprolog.sourceforge.net/ - over my head!
http://pyke.sourceforge.net/about_pyke/index.html - not suitable, cant handle objects
https://sites.google.com/site/pydatalog/ - maybe datalog by design isnt suitable? works with objects, but derived from their class with magic that broke lemon when i was trying it, prolly wouldnt anymore
https://code.google.com/p/fuxi/ - not for mere mortals but im told the guy knows what hes doing
http://en.wikipedia.org/wiki/Flora-2 - theres some paper about mixing it with python
https://bitbucket.org/softdevteam/unipycation seems good (best), albeit a temporary solution. Would complicate distribution of lemon but not a problem at this phase. And its a nice project, i want to play with it. Also get in touch with pypy, since rpython is what lemon might be in future rewritten to. Without unipycation, obviously. building unipycation: https://gist.github.com/koo5/393746b19624debb2472
kanren:
https://github.com/logpy/logpy - logpy seems nice so far
https://github.com/mrocklin/unification
https://github.com/jtauber/pykanren
https://github.com/darius/pythological
with hy: https://github.com/algernon/adderall
http://mullr.github.io/micrologic/literate.html
parsing
http://jeffreykegler.github.io/Marpa-web-site/ - libmarpa seems a great fit for lemon
https://github.com/dabeaz/ply/blob/master/example/BASIC/basiclex.py
typing
www.mypy-lang.org/tutorial.html
https://github.com/illume/static_checking_python
http://ceronman.com/2013/03/12/a-powerful-unused-feature-of-python-function-annotations/
https://www.jetbrains.com/pycharm/webhelp/type-hinting-in-pycharm.html
semigizmo
http://senko.net/maybe-monad-in-python
https://www.google.com/search?q=physical+units+python
gizmos
https://characteristic.readthedocs.org/en/stable/
https://pypi.python.org/pypi/hypothesis/
productivity,python
https://plugins.jetbrains.com/?pycharm
https://wiki.python.org/moin/DevelopmentTools
www.jeffknupp.com/blog/2013/12/04/my-development-environment-for-python/
threading/logging
http://www.aminus.net/wiki/PyConquer
https://github.com/vinta/awesome-python#logging
alternative OOP/AOP/multiple dispatch/traits...
http://cseweb.ucsd.edu/~wgg/Software/AB/stand-alone.html
http://loup-vaillant.fr/articles/classes-as-syntactic-sugar
http://lambda-the-ultimate.org/node/5023
http://www.aspectroid.com/the-project.html
https://sites.google.com/site/yoopforg/
http://peak.telecommunity.com/DevCenter/Trellis
https://github.com/enthought/traits
https://github.com/frasertweedale/elk
http://matthewrocklin.com/blog/work/2014/02/25/Multiple-Dispatch/
http://www.aspectroid.com/episodes.html
http://smallcultfollowing.com/babysteps/blog/2014/09/30/multi-and-conditional-dispatch-in-traits/
http://opendylan.org/documentation/intro-dylan/multiple-dispatch.html
http://rustbyexample.com/trait.html
http://www.nurkiewicz.com/2013/09/instanceof-operator-and-visitor-pattern.html
correctness proofs
http://c2.com/cgi/wiki?ProofOfCorrectness
http://coq.inria.fr/a-short-introduction-to-coq
http://adam.chlipala.net/cpdt/html/Intro.html
http://en.wikipedia.org/wiki/BitC
http://williamdemeo.github.io/2014/02/27/learn-you-an-agda/
http://www-formal.stanford.edu/pub/clt/ARS/systems.html
“
I think that the biggest advance of the last 20 years has been sound and flexible polymorphic typing (parametric or template polymorphism). I say 20 years as a compromise between 30 years ago, when most of the work was done in academia, and 10 years ago, when you started seeing the results of this work in mainstream PLs. Right now "correct-by-construction" is the academic big thing; I expect to see real-world languages that support this concept reasonably about 2030 if I live that long.
To close where Markus opened: Underlying the idea that PLs need to be improved is the assumption that much of the difficulty and complexity of programming today is still what Brooks famously called "accidental": due to poor tools or processes rather than inherent in the problem to be solved. I don't know how true I believe this to be. More and more as I get older, I find that my bugs are from not understanding what I was trying to do, and my low productivity is because I'm solving hard problems. YMMV.
--Bart
“ ->http://adam.chlipala.net/cpdt/html/Intro.html
-> http://homepages.inf.ed.ac.uk/stg/NOTES/
“ The present state of programming
is that well-designed modern imperative languages such as Java [AG96] come close to offering
the type security and programming convenience which functional programming languages
offered in the 1970’s. The interest in and increasing adoption of this language should be
viewed as an encouraging, if slow, shift away from the miserliness which has bedevilled
programming practice since the inception of the profession."
stuff
hash-adressability of stuff
“Spaciousness is also about HCI, with the goal to turn daily computer usage into high level programming”
“BaseParadigm [..] is [..] content addressable data management.
The Spaciousness Shell will be a graphical interface for browsing, authoring, and searching BaseParadigm graph data.“
http://norvig.com/adapaper-pcai.html
we will be lucky to evolve into making at least half-working less stinking piles of crap. AI comes above/after this imho. So this guy, in this article, is missing a step. Is what im saying. A programming language/system step. Yes. I know who he is. Yes, it is funny to say he is wrong. Yes, he is the head of google research now. Could he start with fixing google docs?
take this chalk and write 1000x: “I will not hardcode text colors”. Eclipse and MPS, you too.
http://c2.com/cgi/wiki?WikiIde
random stuff
http://hyperpolyglot.org/ml#polymorphism
http://dwave.wordpress.com/2011/06/01/learning-to-program-the-d-wave-one-introduction-to-binary-classification/ - another neural nets tutorial
http://stenoknight.com/wiki/Main_Page
http://en.wikipedia.org/wiki/Society_of_Mind
http://forums.ltheory.com/viewtopic.php?f=6&t=1573
http://www.gnu.org/software/guile/
https://github.com/jashkenas/coffee-script/wiki/List-of-languages-that-compile-to-JS
http://home.pipeline.com/~hbaker1/ForthStack.html
http://en.wikipedia.org/wiki/Semantic-oriented_programming#SymADE - dead
https://news.ycombinator.com/item?id=7743002
http://docs.racket-lang.org/xrepl/index.html
http://webcredits.org/ - micropayments(although agreggating might work too) as a solution to accesibility of useful APIs
http://www.reddit.com/r/MechanicalKeyboards/wiki/3dprinting
Emacs! we need a paragraph about emacs!
http://c2.com/cgi/wiki?EmacsAsOperatingSystem
“... and Emacs' buffers are a remarkably simple unified interface to everything on the earth, comparable to CommandLineInterface.”
http://www.damtp.cam.ac.uk/user/sje30/emacs/ell.html
beginners/menu/systemwide autocompletion:
http://www.emacswiki.org/emacs/Icicles
https://github.com/emacs-helm/helm
Emacs is mis-marketing itself as a text editor. it is a lisp OS. so, lemon as a part of emacs? Lemmacs? xiki in emacs, projectured in emacs..
voice:
http://www.emacswiki.org/emacs/EmacsVersor
http://shorttalk-emacs.sourceforge.net/
http://www.emacswiki.org/emacs/EmacSpeak
http://emacspeak.sourceforge.net/applications.html
http://emacspeak.sourceforge.net/publications/semantic-www.html
“The very nice Emacs philosophy of only working with text comes very handy here- Emacspeak can (and does) implement special voice enabling features for nearly every widespread major and minor mode.”
eulergui
http://deductions.sourceforge.net/architecture.pdf
jmv goes beyond describing business model, to describing more app functionality
(declarative guis) (x QML)
also relevant for N3 and reasoning as the possible base language…
and for use of ACE, to describe lemon object model maybe
also, advanced “semantic web browser” / search, triple editor. data store, basically lots of functionality that should one day be available thru lemon gui
http://svn.code.sf.net/p/eulergui/code/trunk/eulergui/html/semantic_based_apps_review.html
python interoperation
http://stackoverflow.com/questions/7634618/jena-tdb-in-python
http://code.google.com/p/python-graphite/
http://lawlesst.github.io/notebook/pyjniusvivo.html
https://jena.apache.org/documentation/tdb/commands.html#tdbquery
linked data guis:
http://www.w3.org/wiki/Ontology_editors
http://www.irisa.fr/LIS/ferre/sparklis/osparklis.html
http://www.irisa.fr/LIS/softwares/sewelis
general and/or philosophy and/or programming and/or interesting and/or fun reading
http://www.martinfowler.com/articles/languageWorkbench.html
http://rosettacode.org/wiki/Rosetta_Code
http://worrydream.com/LearnableProgramming/
http://alarmingdevelopment.org/
http://awelonblue.wordpress.com/
http://www.everything2.com/index.pl?node_id=1406540
http://thedailywtf.com/Articles/An-IDE-Impostor.aspx
http://teebrz.wordpress.com/2013/07/20/on-holistic-programming-languages/
http://blog.samibadawi.com/2013/05/lisp-prolog-and-evolution.html
http://chriskohlhepp.wordpress.com/law-of-tangental-complexity/
http://en.wikipedia.org/wiki/Comparison_of_code_generation_tools
http://research.microsoft.com/en-us/projects/liveprogramming/typography.aspx
http://elm-lang.org/learn/What-is-FRP.elm
https://al3x.net/2014/09/16/thoughts-on-five-years-of-emerging-languages.html
http://en.wikipedia.org/wiki/Lithe_%28programming_language%29
http://pyside.github.io/docs/pyside/
https://pypi.python.org/pypi/smiley/0.1.0
http://effbot.org/tkinterbook/canvas.htm#Tkinter.Canvas.create_text-method
http://architects.dzone.com/articles/solving-problem-dsls-adoption
http://dl.acm.org/citation.cfm?doid=1056808.1056965
http://scg.unibe.ch/research/softwarecartography
http://nicklothian.com/blog/2014/09/25/why-question-answering-is-hard/
http://c2.com/cgi/wiki?LispMachinesAreComingBack
http://semantic-programming.blogspot.cz/
http://ventrellathing.wordpress.com/2013/08/11/hunter-gatherer-programmer/
https://github.com/PharkMillups/beautiful-docs
http://tunes.org/Review/OSes.html#LispOS
https://github.com/alebcay/awesome-shell > bronzeage
http://steve.vinoski.net/blog/category/rpc/
http://norvig.com/python-lisp.html
http://stackoverflow.com/questions/36504/why-functional-languages
interesting languages
http://elixir-lang.org/ actors here, actors there, how does it compare?
http://www.squeak.org/Projects
uis
http://tunes.org/cliki/user_20interface.html
http://c2.com/cgi/wiki?TheHumaneInterface
http://c2.com/cgi/wiki?GuiEngineGoals
http://www.softpanorama.org/OFM/Standards/ofm_standard2012.shtml
semantic terminal
smarter terminal emulator:
fork libvte if you want to just do your own rendering
use libvterm for a lightweight but probably incomplete solution, to mess with the internals
smarter shell:
fish, zsh. could use a lot of love in acutally *autogenerating* autocompletion options. Perhaps they would allow some sort of ncurses-like plugin for a lemon-like UX
structured, own model, own presentation:
finalterm
>>
>> i would break it down into two parts: the editor-is-terminal part, i
>> think that is also a functionality in emacs, and the "semantic"
>> terminal part:
>>
termkit
>> in http://acko.net/blog/on-termkit/ (which seems to have died several
>> years ago right after getting some publicity), commands are strictly
>> made to speak in some JSON encoded format, and plain old ordinary
>> commands run wrapped. You can draw a parallel to a fully structured
>> editor.
sort of post-mortem to termkit from the author:
http://www.reddit.com/r/programming/comments/137kd9/18_months_ago_termkit_a_nextgeneration_terminal/
also: https://news.ycombinator.com/item?id=2559734
but see forks on github.
>> towards the other side of the continuum is (and that enlightenment thing)
>> which runs bash inside, and only tries to extract information from the
>> text stream. Thats like a semantically aware ide:)
>>
>> i dont know where xiki stands in this, they say "wiki-ish text
>> syntax", i guess it might be a nice middle way.
>> Anyway, judging by the google group activity, xiki seems to be a long
>> running project and i hope it gets far, and i will give it a try
>> sometime
>> (another project to mention might be
>> https://github.com/guitarvydas/vsh , but pretty dead too)
>>
>
>heres another: xpipe
>https://vimeo.com/68400623
>
https://github.com/zsh-users/zaw
plan9 terminal too(?)
http://satyajit.ranjeev.in/2014/07/06/introducing-edi.html
http://waywardmonkeys.org/2014/10/10/rich-command-shells/
semanticizing:
picolisp docs: done: https://github.com/koo5/lol/blob/master/scrape2.py
rosettacode: pondering,
https://github.com/acmeism/RosettaCodeData
https://github.com/ingydotnet/rosettacode-pm
https://github.com/aocole/RosettaCodeExplorer
https://github.com/sytelus/HackerNewsData
this fucking document: depends on lemon:)
semantic ls
the options we have when semanticizing existing functionality
https://github.com/unconed/TermKit/blob/master/Node/shell/builtin/ls.js
https://news.ycombinator.com/item?id=7882211
http://mywiki.wooledge.org/ParsingLs
https://github.com/koo5/hackery/blob/master/diredls/ls.py
www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/ls.1?query=ls&sec=1
https://www.gnu.org/software/emacs/manual/html_node/emacs/ls-in-Lisp.html#ls-in-Lisp
stackoverflow.com/questions/4115465/emacs-dired-too-much-information
lemon stuff - old
start something about:.....
nontextual or different projections
TwoDGraphicTag
dataflow?
use dataflow to connect larger blocks of code?
structured scribbles (
structural navigation (jumping from node to node..)
in case the projectional approach becomes too messy from the pov of programming the user interaction with nodes:
what are the advantages of:
textual projection and how to get them in a structured editor?
freedoms...
removing the projecting stage but still normalizing everything into the grid, keeping cursor
no messing with newlines, indent spaces
unasked questions
what does lemon stand for?
Language Editor MONster!
old - design document-ish questions
What is the current problem?
ttp://tunes.org/papers/WhyNewOS/WhyNewOS.html
Why is visual programming a better alternative?
http://alarmingdevelopment.org/?p=680
Will the abstraction lead to a loss of control in what programmer's want to achieve?
AKA Does the visual nature of the language lead to a “dumbing” down of the possibilities that can be achieved?
Are visual languages predominantly object-oriented?
How do current implementations solve the above problems and what are the drawbacks?
visual languages:
scratch:: yeah, lets google that.
is not keyboard-friendly -> is not real programmer friendly
->its a learning language
various visual app creators targetting mobile os's:
falling back on c-like languages?
http://blockly-demo.appspot.com/static/apps/turtle/en.html
visual programming language workflow:
1)a menu of available constructs, click on one and drag it to the work area
2)connect more pieces
a person can reach a state of flow with mouse as well as with keyboard
4. What are the drawbacks of such systems?
scratch:
visual languages are either beginner languages, or constrained to a specific domain, or at least not adding any expressivity for the programmer to use...
haxe, everybodys different, dont give me macros, problems of livecoding
5. controlled natural languages
ACE and friends:
http://attempto.ifi.uzh.ch/site/docs/
"One of the problems of controlled natural languages is that the restrictions of the language have to be learned in order to write correct sentences. "
“A possible solution for this problem is to provide predictive authoring tools. Such an authoring tool guides the user during the creation or modification of sentences. It makes sure that only valid sentences can be created. Thus, parsing these sentences with the ACE parser will never lead to errors. “
IMPORTANT: I also realize your goal is to create a functional system and this approach might be more academic. Definitely try to push it in a way that is more hands-on rather than potential writing BS
build upon inform7 and make it writable:
get beyond code-completion
get beyond avoiding syntax errors by making a language mouse-only
#side stuff: what would be the easiest made ide for i7 solving its problems?
centering on usability
usability is not noob friendliness (scratch)
randomness
voice recognition
todo:something about reasons of failures of natural language command systems
http://cmusphinx.sourceforge.net/
better start playing with this sooner than later, could affect the data structures of lemon
->phonemes(?) have probabilities…
->see emacs
as a service
provide grammar or examples..so..nope? maybe yes..at least for the shell part. this could be amazing
web annotation/overlay etc
http://spqr.cerch.kcl.ac.uk/?page_id=94
https://addons.mozilla.org/en-US/firefox/addon/wikipediaplus/ - recommended
http://www.xthink.com/mathjournal_solutions.html
http://w3c.github.io/web-annotation/protocol/wd/
immediate mode gui
http://lambda-the-ultimate.org/node/4561
http://www.johno.se/book/imgui.html
http://blog.piston.rs/2014/08/30/conrod-update/
https://github.com/ocornut/imgui
links to be sorted
https://wiki.debian.org/FedericoCeratto/Sandbox
http://tratt.net/laurie/blog/entries/fast_enough_vms_in_fast_enough_time
https://kev.inburke.com/kevin/invalid-username-or-password-useless/
theres more to be said about password usability, but..
https://groups.google.com/d/topic/marpa-parser/lh9Jpji-_pk/discussion
https://github.com/rusthon/Rusthon
http://nixos.org/nixos/about.html
http://www.doc.ic.ac.uk/~klc/dalt03.html go!
http://sourceforge.net/projects/genyris/
rpc, pizco, python
http://augustl.com/blog/2013/zeromq_instead_of_http/ routing http-style
https://github.com/hgrecco/pizco/issues/19 naming service
plover
open source computer stenography
https://raw.github.com/FauxFaux/ploversearch/master/dict.json
https://plover.goeswhere.com/#test
https://docs.google.com/drawings/d/1Ff2X6xwHICfjn_SYd2RDleIb60OUASG3zSmhYdN-5Ss/edit
http://stenoknight.com/wiki/FAQ#How_does_it_work.3F
cringe time
a way to describe libraries on a high level - inputs and outputs.. should write something more about it..it was a working concept…
see also deductions
acessing knowledgebases
https://github.com/acmeism/RosettaCodeData
https://github.com/lucjon/Py-StackExchange
gui ux stuff
todo:i7 player command parser
...
http://sourceforge.net/projects/vwm/
http://sourceforge.net/projects/twin/
http://en.wikipedia.org/wiki/Comparison_of_command_shells#Command_builder
ZUIs
http://c2.com/cgi/wiki?ZoomableUserInterface
http://eaglemode.sourceforge.net/philosophy.html
limit theory (“nodal” interface) http://www.youtube.com/user/LimitTheory
http://c2.com/cgi/wiki?GooglifyDeepMenus
http://adamfurman.privatepage.sk/PythonOS/
https://lwn.net/Articles/605064/
http://blogs.gnome.org/aday/2014/07/23/sandboxed-applications-for-gnome-part-2/
fuzzy matching
http://en.wikipedia.org/wiki/Levenshtein_distance
http://en.wikipedia.org/wiki/Stochastic_context-free_grammar
https://github.com/makoConstruct?tab=repositories
log
24.5.15 CNLC:collab tools augmented programming flashy things, graphics agi tau? netention gui nario
trying to write a text editor from scratch...is a lot of work. I tried to work out why it would be necesary, and came up with levels of functionality that we actually need from a textarea:
textbox ui levels:
-1: it doesnt even allow custom attributes of text. Autocompletions have to be inserted as plain text, no semantic disambiguation except whatever we manage to manage outside the widget
(probably for the browser version)
0: we have attributes, so we keep metadata within text, links to meaning nodes and other info. Parser can utilize that
(i hope we can start with this level)
1: we can get info about positions of individual characters/elements from the textbox. Now we can once again underlay ast blocks
(we can interact with the code visually thru the blocks then, but it would be nice to...)
2: copy pieces of text to the blocks when needed, perhaps to new instances of the text widget within the blocks. Go without too much glitching between the text and structural mode
(i mean we should be able to copy a bit of text into an ast block when going into structural mode, and when the block is positioned right over the original text, then rendering should be roughly same)
20.03
working on a new version in java as a part of opennars gui, with a new interaction design driven by sseehh, and with a clean data model that my current knowledge suffices for (narsese is a simple untyped language).
Studying: Idris
todo: racket?
21.02
dev merged. the editor is now somewhat usable again. Im reflecting and looking into serious nodes representation (rdf..)
23.01
parser now works in a thread. elements keypress handling is all declarativized and nice and there is a context sensitive help sidebar. cleaned up parametric types. there are multiple font sizes. a few more things before i merge this all back into master.
01.01
dev branch:i have a new event handling system and an asynchronus menu is coming up
04.12
whats new in the high level land:
http://www.future-programming.org/program.html
http://svn.code.sf.net/p/deductions/code/html/ontology/doas.owl.ttl
whats new in lemon:
the dev branch is still a mess, the plan is to improve dirtiness/event handling and then put everything back into place somehow, without rpc but more or less ready for splitting, maybe will do a split off menu client. Next i can optimize the tags system a bit more and try cythonizing projection or/and drawing.
For master, im trying to find the best way to do sorted views of Statements in a module…, reference python functions, classes, lemon-defined syntax…
im trying to learn unit testing so i can help with some failing tests in pizco
24.11:
it parses numbers and strings and function calls with marpa_cffi. Trying logpy. Figuring out what to use to split lemon into several processes (zerorpc, pizco…)
reasons for splitting it:
speed:rendering the frames all in one process is expensive. Another alternative would be to optimize things with cython. Would that have better maintenance/flexibility tradeoffs?
Multithread? Lock nodes down to collect tags, (how many?), then spawn a projecting thread? Would keep event handling in one process..
This splitting is quite an undertaking, cython would have been easier i think. Some advantages tho: Next up to split off is the parser. as with rendering, more machines = faster. (ok, could try ipython..). Multiple windows on multiple machines rendering them on one machine, then sending the contents..ugly. Would end up with some sort of dumb frontend? Project on server, render on client, handle events on server? And what about pyro?
“
In parallel computing, all processors may have access to a shared memory to exchange information between processors.[17] In distributed computing, each processor has its own private memory (distributed memory). Information is exchanged by passing messages between the processors.[18]
“ http://en.wikipedia.org/wiki/Distributed_computing#Parallel_and_distributed_computing
my quick research into DUIs didnt yeild anything else than dull research papers. Another relevant thing is FRP, which i have yet to read about more.
2.10:
thoughts about projection:
brackets around elements are needed so that, simply put, even a zero length node
(like an empty Text) is accessible. I added them for just debugging purposes,
but they have that function and they also convey structure of code and
boundaries of nodes. It works nicely, i think.
perhaps something should be said about why i picked the character stream projection and if the reasons are valid. It comes from the idea of text-like freedom and freeform editing, none of that is implemented yet. Besides the buggy Parser allowing to have text and nodes on one line.
Thats where it gets interesting, because it deals with items that arent nodes, and so arent enclosed in brackets. It kinda needs its own inner projection system. and that sucks. Even if its known what on-screen char belongs to which item.
Then theres the issue that opening brackets belong to the parent. Because the cursor is always regarded to be on the node owning the character to the right of it.
Anyway i think what we perhaps need is to keep attributes of the spaces between characters. I guess that would allow zero-length elements and we could give the opening brackets back to their owners.
Maybe i should learn from some simple word processor.
Or throw it all away and go hard structure style (CITRUS(?) and MPS). But then, MPS has "hybrid editing" planned (js demo availabe). MPS itself btw doesnt seem a viable option (see cedalion pdf).
All in all my one pet idea is this supercool ux, but the other is getting the language going. But work on the language isnt blocked by the imperfect projection, but by the model. CITRUS would solve that. Dunno about Cedalion.
Theres also the option of getting fun stuff done and presented without a proper model and language and persistence, with the console (repl). (and the console can be made to work xiki-style easily:) ) Build in more functions, enhance the menu. Especially for the desktop shell/environment ideas.
I might start sketching that out in MPS. (or something else?) I also have rekindled interest in Eclipse. Could the modelling framework help? I can start trying to write the DE DSLs. Other topics are a hypothetical convergence of those and N3 and "tabular" stuff, at some high level it all has to become equivalent on a practical level.
Try splitting some piece of code into several levels, increasingly abstracting stuff away.
Learn about Cyc, is it even practically possible to integrate the data at some points in a lemon/nonlogic program?
23.9:
we have a proof-of-concept curses frontend, im playing with brython. Im working on getting basic serialization working (after a period of overthinking it). I have started https://github.com/koo5/BronzeAge. I’m meaning to take a step back and learn MPS, or seriously research if i could use cedalion or projectured or larch or.. (read: throw all my work out the window.) There is only so much energy one can spend on this and hacking on our own little codebases is so much easier….
18.7:
something like a type system added! Playing with Unipycation, there is life on the channel - wow. Lemon is at a point where the natlike structural editing is somewhat presentable (as a demo, with explanation). Im trying to figure out new priorities. Logic programming for the typesystem, compiler etc? enhance gui with widgets? core language features?
18.5:
still trying to add a type system…
18.4.14
trying to add a type system, reworking pyswip integration, builtins module, Syntaxed
removed some of the toys, like settings nodes, so i can focus on the main stuff, replaced them with optargs
http://journal.stuffwithstuff.com/2010/10/29/bootstrapping-a-type-system/
http://lambda-the-ultimate.org/node/3145
7.3.14
3.3.14
18.2.14
https://github.com/koo5/new_shit
current plan is to continue with "mock-up" language nodes
<sirdancealot> i started a crude replacement for pyglets text functions, and am rewriting stuff to fit with it and add some sanity
<sirdancealot> so if you get bored, currently its no logic programming, no compiler writing, no ACEs, no lisps, just python and the user interaction idea
<sirdancealot> im back from my detour into SICP and prolog :)
<sirdancealot> + spent two days playing around with eulergui and friends
<sirdancealot> not there yet, but maybe on the verge of being comfortable with my knowledge of those
<sirdancealot> i might have an idea how a basic "triple" node or somesuch would work in lemon....from the ui point of view, so far
<sirdancealot> a naive idea now is that the only remaining big topic i have to scratch is ML languages and coq
<sirdancealot> but thats hopefully for unforseeable future, should be able to implement a mockup type system without that
-> subtextual
before: lemon-operating-language
looks nice, but is mostly mockup. settings nodes are fun.
https://github.com/koo5/lemon-operating-language/blob/master/aside_gui.py
i didnt feel like advancing the ide prototype you see above, it was approaching a point of needing a rewrite dumping pyglets text module. There was no language functionality, just also mostly nonfuncional UI code. Realizing i have no idea how to practically go about building the language (the options man, the options!), i started learning PicoLisp. http://picolisp.com/
my first more serious venture into lisp and logic programming, this will take a while.
picolisp is: down to the metal: you can segfault it with bad lisp code
picolisp has: pilog, a built in prolog engine. Playing with Pyke was getting awkward.
picolisp is: minimal. perfect for me at this point.
current playground: https://github.com/koo5/lol
phase 2
lets get fully visual, with syntax too, scratch style
what’s done:
a tree of objects for the gui (control, label, textbox, list, block)
move cursor up and down
what’s missing:
move cursor left / right
focus element under cursor
highlight focused element
phase 1...26 Feb 2013
keyboard input, with autocompletion of individual tokens
editor has no idea about syntax -> syntax errors are possible
seamlessly confirming autocompleted words, or selecting from a menu
-> user is interactively “tokenizing” the code
programmers are used to editing text
beyond simple languages with restricted vocabulary, is keyboard not necessary?
effectivity, speed of work?
advantages over visual languages:
keyboard-oriented
https://github.com/koo5/secret-banana/blob/8b448464a7f56c805d146e9c54ab7ab9bc9f47e9/main.py
abandoned after learning about parsers.
great testing out of the menu idea and splitting of tasks between language user and programmer, it seems sane.
before:
i played with i7: https://github.com/koo5/melon
Carry out serving a request:
if the file of request exists:
read file of request into table of arguments;
let count be number of filled rows in table of arguments;
if count > 0:
repeat through table of arguments:
say "[name entry]: [value entry][line break]";
process the request;
blank out the whole of the table of arguments;
write file of request from table of arguments;
i concluded i7 is awesome but the textualness is killing it, and proceeded to reinvent a structured editor.
before:
i played with coffeescript: https://github.com/koo5/coffeetime
save =()->
if not path.existsSync exports.paths.home
fs.mkdirSync exports.paths.home, 0700
fs.writeFileSync exports.paths.time, JSON.stringify exports.time
console.log "saved"
before:
i experimented with making a windowless DE (in C): desktop environment
thats where my search for a better language started.
My previous experience was BASIC, pascal, (delphi), VB, PHP etc.
m
https://github.com/Vivtek/Decl
http://forum.osdev.org/viewtopic.php?f=11&t=29487