The info that has been gathered so far has been guided by the definition of structured editing (and its synonomous terms) as not allowing for edits that are not syntactically correct, ie. direct editing of the abstract syntax tree AST. There seems to be a grey area that is being parsed out (pun intended) during the period of development of structured editing for which it was not possible to edit without syntactical errors and if this is still considered structured editing. This could be all in my head!

David responds: I suspect we need to be interested in both sides of that historical/conceptual divide. I notice that the Wikipedia article on structure editor talks about grammar rules being interpreted in generative, proscriptive or analytic ways and perhaps that is useful terminology also.

structured editing(or), or
projectional editor, or
syntax directed editor (Khwaja, A. A., & Urban, J. E. (1993))
  1. external representations
    1. -- structure editor
    2. -- iconic editor
      1. ---block editing/er
  2. internal structure type
  3. level of abstraction
    1. -- character, expression, simple statement, or declaritive level
  4. target documents
  5. types of errors
    1. syntactic and static semantic
  6. error handling
    1. abort or continue editing
  7. incremental system
  8. execution level
  9. environmental support



key reading
directly relevant
high priority
further interest
potential interest
scratch
newly added (2 b sorted)

Structured editing projects

(lang:? ; who:? ; when?; where?)
Albe (lang:? ; who:? ; when?; where?)
- Shani, U. (1983) --> ALBE [9]
Alice
Amaya *
- Quint, V., & Vatton, I. (2005)
B# [iconic programming] (auto gen lang: Borland Pascal ; who:? ; when?; where: Nelson Mandela Metropolitan University)
- Xinogalos, S. (2013) B# [32]
Barista
- Ko, A. J., & Myers, B. A. (2006)
BACCII and BACCII++ [iconic programming] (auto gen lang:Pascal, C, Fortan, Basic and C++; who?; when?; where: Texas Tech University)
- Xinogalos, S. (2013) --> ( BACCII [8] and BACCII++ [10])
CHASE
- Oakley, I., Brewster, S., & Gray, P. (2001)
Citrus
- Ko, A. J., & Myers, B. A. (2005)
Codelets
- Oney, S., & Brandt, J. (2012).
CodeSpells
- Esper, S., Foster, S. R., Griswold, W. G., Herrera, C., & Snyder, W. (2014)
- Esper, S., Wood, S. R., Foster, S. R., Lerner, S., & Griswold, W. G. (2014)
- Esper, S., Foster, S. R., & Griswold, W. G. (2013)
Cornell Program Synthesizer [24 line limit] (lang:PL/1 ; who:Tim Teitelbaum; when: 1978; where:ACM Computer Science Conference: Special Interest Group on Computer Science Education)
- Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994) [ (Reps & Teitelbaum, 1989) need to get].
- Khwaja, A. A., & Urban, J. E. (1993)
DrRacket (no reference info - need to search www)
- Marceau, G., Fisler, K., & Krishnamurthi, S. (2011)
DiaGen
- Mazanek, S., Maier, S., & Minas, M. (2008) --> DIAGEN system [7],
DiaMeta
- Maier, S., & Volk, D. (2008)
- Minas, M. (2007)
- Minas, M. (2006)
Eclipse Xtext
Voelter, M., & Solomatov, K. (2010) --> Eclipse Xtext [16]
FLINT (lang:? ; who:? ; when?; where: Western Kentucky University)
- Xinogalos, S. (2013) FLINT ([11], [12]),
Fujaba/MOFLON
- Minas, M. (2006)
FURCAS
Voelter, M., & Solomatov, K. (2010) --> FURCAS [8]
Gandalf (lang:? ; who:?; when?; where:? )
- Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994) --> (Habermann, Garlan & Notkin, 1991; Habermann & Notkin, 1986).
- Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014) --> GANDALF [5],
{ - GNOME -> macGnome, expanded to Genie environments (incls, macGnome), ACSE, progressively
Genie (lang: Pascal; who:? ; when?; where?)
Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994)
GNOME (lang: Pascal, FORTRAN, and LISP.; who:? ; when?; where?)
Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994) --> (Garlan & Miller, 1984).
macGnome (lang: ?; who:? ; when?; where?)
The Advanced Computing for Science Education (ACSE) project
Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994) --> (Pane & Miller, 1993).
}
Iconic Programmer (auto gen lang: pseudocode, Java, Turing and C/C++; who:? ; when?; where?)
- Xinogalos, S. (2013) The Iconic Programmer [33]
Incremental Programming Environment
- Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014) --> (IPE) [4].
Intentional Domain Workbench (IDW) (lang:multiple, c#, )
- Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014) --> [9,10] (intentional programming [2,3])
Voelter, M., & Solomatov, K. (2010) --> [14]
- Simonyi, C., Christerson, M., & Clifford, S. (2006)
JetBrains (lang: multiple languages that can modularized and embedded in other language modules
- Voelter, M., & Solomatov, K. (2010)
- Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014)
JPie
- Birnbaum, B. E., & Goldman, K. J. (2005)
Notes: a meta programming system
MetaEdit+ [iconic editor]
- Voelter, M., & Solomatov, K. (2010) --> MetaEdit+ [15]
- Minas (2006) --> MetaEdit [9],
Monticore
Voelter, M., & Solomatov, K. (2010) --> Monticore [24]
PASES
- Shapiro, E., Collins, G., Johnson, L., & Ruttenberg, J. (1981)
Progranimate [iconic programming] (auto gen lang: Java-like pseudo code or code in Java,VisualBasic.NET, VisualBasic 6.0, Pascal or JavaScript; who:? ; when?; where?)
- Xinogalos, S. (2013) Progranimate ([36], [37])
ProGuide [iconic programming] (lang:? ; who:? ; when?; where?)
- Xinogalos, S. (2013) ProGuide ([29], [30], [31])
RAPTOR [iconic programming] (auto gen lang: ada, C#, C++, java ; who:? ; when?; where?)
- Xinogalos, S. (2013) RAPTOR ([18], [21], [22], [23])
Scratch (introduced 2006)
- see section
SDF
Voelter, M., & Solomatov, K. (2010) --> SDF [22]
SICAS [iconic programming - all 3] , SICAS-COL, & H-SICAS (auto gen lang: pseudo code, C, Java ; who:? ; when?; where?)
- Xinogalos, S. (2013) SICAS [25], SICAL-COL [26], H-SICAS [28]
SFC Editor (lang:C++, Pacal-like format ; who:? ; when?; where?)
- Xinogalos, S. (2013) SFC Editor (Structured Flow Chart Editor) [20]
Tiled Grace
- Homer, M., & Noble, J. (2014)
TouchDevelop
Note: a structured programming web app used on mobile to create for mobile
Visual Logic (lang:Visual Basic ; who:? ; when?; where?)
- Xinogalos, S. (2013) Visual Logic [19]

See Khwaja, A. A., & Urban, J. E. (1993) for a list of 17 structured editors (1981-1991), which includes the Cornell Program synthesizer - all others are unique

(

Alice [1]
HoTMetaL and Grif [18]
)

Structured editing features

*Automatic Generation of Source Code
Xinogolas (2013)
Simonyi, C., Christerson, M., & Clifford, S. (2006)
Distributed-Pair Programming/Networked collaborative programming
Oakley, I., Brewster, S., & Gray, P. (2001)
Xinogolas (2013)
-Flow-chart based programming
Xinogolas (2013)
Mazanek, S., Maier, S., & Minas, M. (2008) - Nassi-Shneiderman diagram (NSD completion)
*Structured Editor Generators
Minas, M. (2006)
*Hybrid Editors (structured/non)
Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014)
Shani, U. (1983)
Mazanek, S., Maier, S., & Minas, M. (2008)
Hiding Code (Ive run into conflicting information about code folding as a part of structured editing and not (wiki))
Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994)
-Iconic Editor: Graphic/Symbolic Representation of data types, variables, and control structures
Xinogolas (2013)
Incremental Sematic Analysis
Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994)
Khwaja, A. A., & Urban, J. E. (1993)
*Language Modularization/ combining languages
*Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014)
*Voelter, M., & Solomatov, K. (2010)
Simonyi, C., Christerson, M., & Clifford, S. (2006)
*Multiple Views/Representations of code: Design Views (projectional?)
Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994)
Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014)
Voelter, M., & Solomatov, K. (2010)
Simonyi, C., Christerson, M., & Clifford, S. (2006)
(Projectional) Language Workbench (Workbench)
Voelter, M., & Solomatov, K. (2010)
Simonyi, C., Christerson, M., & Clifford, S. (2006)
- Program Animation/Software Visualization
Xinogolas (2013)
Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994)
*Structure Editors: Templates and/or Menus
Xinogolas (2013)
Shani, U. (1983)
Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994)
Usage in Mobile Phones
Xinogolas (2013)

.....
projecting editor = multiply views ?



Key Readings: (getting up to date yet)

Esper, S., Foster, S. R., Griswold, W. G., Herrera, C., & Snyder, W. (2014). CodeSpells: bridging educational language features with industry-standard languages. In Proceedings of the 14th Koli Calling International Conference on Computing Education Research (pp. 05–14). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2674684

Potentially relevant as a current example of structured editing being used to introduce programming education/functionality/interest in the larger context of video games as a function of the game - program spells to be used in the game. [David comments: and also interesting to think about the metaphor of programming as spell casting - this environment surfaces some of the ideology surround computing in a productive way.]

Hall, C. (2014). HCI metacomputing: universal syntax, structured editing, and deconstructible user interfaces (pp. 21–24). ACM Press. doi:10.1145/2660252.2660258

Probably relevant as it discusses combining universal binary syntax with a universal structured editor such as to overcome the tensions between user-friendly and expert-friendly user interfaces by solving a host of issues while making the software more flexible and "how it can be used to add a self-descriptive capacity to information representations ranging from data formats to user interfaces, and finally, how that creates new outlets for end-users to apply tiers of computational literacy for their own empowerment." [David comments: yes, good stuff: what is most interesting about this is the way the work is positioned as a critique of "app culture" - there's that great line in there about "not the killer app - but to kill the app". How did you find this one?]

*Khwaja, A. A., & Urban, J. E. (1993). Syntax-directed editing environments: Issues and features. In Proceedings of the 1993 ACM/SIGAPP symposium on Applied computing: states of the art and practice (pp. 230–237). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=162882

Relevant as it describes syntax-directed editing along with usability and design issues and features

Ko, A. J., & Myers, B. A. (2006). Barista: An implementation framework for enabling new tools, interaction techniques and views in code editors. In Proceedings of the SIGCHI conference on Human Factors in computing systems (pp. 387–396). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1124831

Potentially relevant - describes Barista, a tool for embedding interactive tools, annotations, and alternate views in the code itself by simplifying "the implementation of editors that represent code internally as an abstract syntax tree and maintain a corresponding, fully structured visual representation on-screen..., (while) providing designers of editors with a standard text-editing interaction technique that closely mimics that of conventional text editors, overcoming a central usability issue of previous structured code editors."

Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994). Evolution of novice programming environments: The structure editors of Carnegie Mellon University. Interactive Learning Environments, 4(2), 140–158.

Relevant as it discusses earlier structured editors (Gandalf and Cornell Program Synthesizer) influencing the progressive design of GNOME, macGNOME, Genie Environments, and ACSE respectively and the changes implemented at each stage leading to a more multimedia environment (ACSE).

Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014). Towards user-friendly projectional editors. In Software Language Engineering (pp. 41–61). Springer. Retrieved from http://link.springer.com/chapter/10.1007/978-3-319-11245-9_3

Probably relevant for it reviews issues with projectional editing, a style of editing that allows for the combination of diverse notational styles such as text, symbols, tables, and graphics by directly manipulating the abstract syntax tree , and discusses strategies for overcoming these issues (which on first glance seem to be mainly grounded in software development and will minimized for live coding),


*Xinogalos, S. (2013). Using flowchart-based programming environments for simplifying programming and software engineering processes. In Global Engineering Education Conference (EDUCON), 2013 IEEE (pp. 1313–1322). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6530276

Probably relevant for it discusses iconic, flowchart-based programming (for novice education), which is based on structure editing and program animation and recently has included collaborative activities,distributed pair programming and usage in mobile devices.

top

Directly Relevant:

Birnbaum, B. E., & Goldman, K. J. (2005). Achieving flexibility in direct-manipulation programming environments by relaxing the edit-time grammar. In Visual Languages and Human-Centric Computing, 2005 IEEE Symposium on (pp. 259–266). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1509511

Potentially relevant an example of a structured editor for Java that separates edit-time grammar from the run-time grammar such as to add flexibility to the structured editor

Esper, S., Foster, S. R., Griswold, W. G., Herrera, C., & Snyder, W. (2014). CodeSpells: bridging educational language features with industry-standard languages. In Proceedings of the 14th Koli Calling International Conference on Computing Education Research (pp. 05–14). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2674684

Potentially relevant as a current example of structured editing being used to introduce programming education/functionality/interest in the larger context of video games as a function of the game - program spells to be used in the game.

Esper, S., Wood, S. R., Foster, S. R., Lerner, S., & Griswold, W. G. (2014). Codespells: how to design quests to teach java concepts. Journal of Computing Sciences in Colleges, 29(4), 114–122.

Potentially relevant as it discusses the results of a study that focused on the creation of the quests (levels of the video game) that incorporate scaffolding for learning support for programming.

Esper, S., Foster, S. R., & Griswold, W. G. (2013). On the nature of fires and how to spark them when you’re not there. In Proceeding of the 44th ACM technical symposium on Computer science education (pp. 305–310). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2445290

Potentially relevant as it discusses a study with 40 female students learning programming for the first time not in the traditional classroom environment using Codespells

Futrelle, R. P., & Barta, G. (1978). Towards the design of an intrinsically graphical language. In ACM SIGGRAPH Computer Graphics (Vol. 12, pp. 28–32). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=807365

Potentially relevant for early examples of structured editing for graphical languages and its design strategy

Hall, C. (2014). HCI metacomputing: universal syntax, structured editing, and deconstructible user interfaces (pp. 21–24). ACM Press. doi:10.1145/2660252.2660258

Probably relevant as it discusses combining universal binary syntax with a universal structured editor such as to overcome the tensions between user-friendly and expert-friendly user interfaces by solving a host of issues while making the software more flexible/adaptible and "how it can be used to add a self-descriptive capacity to information representations ranging from data formats to user interfaces, and finally, how that creates new outlets for end-users to apply tiers of computational literacy for their own empowerment."

Homer, M., & Noble, J. (2014). Combining tiled and textual views of code. In Software Visualization (VISSOFT), 2014 Second IEEE Working Conference on (pp. 1–10). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6980206

Potentially relevant as it describes the structured editor ("jigsaw puzzle drag and drop") Tiled Grace that is designed to move from structured editing to unstructured with the language Grace.

Khwaja, A. A., & Urban, J. E. (1993). Syntax-directed editing environments: Issues and features. In Proceedings of the 1993 ACM/SIGAPP symposium on Applied computing: states of the art and practice (pp. 230–237). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=162882

Relevant as it describes syntax-directed editing along with usability and design issues and features

Ko, A. J., Aung, H. H., & Myers, B. A. (2005). Design requirements for more flexible structured editors from a study of programmers’ text editing. In CHI’05 extended abstracts on human factors in computing systems (pp. 1557–1560). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1056965

Potentially relevant as it describes the development of a structured editor that is based on a study that found most programmers do not utilize the full flexibility of unstructured editing and rely on a small set of editing patterns to achieve there outcomes.

Ko, A. J., & Myers, B. A. (2005). Citrus: a language and toolkit for simplifying the creation of structured editors for code and data. In Proceedings of the 18th annual ACM symposium on User interface software and technology (pp. 3–12). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1095037

Potentially relevant as it discusses a toolkit for the development of structured editors

Ko, A. J., & Myers, B. A. (2006). Barista: An implementation framework for enabling new tools, interaction techniques and views in code editors. In Proceedings of the SIGCHI conference on Human Factors in computing systems (pp. 387–396). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1124831

Potentially relevant - describes Barista, a tool for embedding interactive tools, annotations, and alternate views in the code itself by simplifying "the implementation of editors that represent code internally as an abstract syntax tree and maintain a corresponding, fully structured visual representation on-screen..., (while) providing designers of editors with a standard text-editing interaction technique that closely mimics that of conventional text editors, overcoming a central usability issue of previous structured code editors."

Maier, S., & Volk, D. (2008). Facilitating language-oriented game development by the help of language workbenches. In Proceedings of the 2008 Conference on Future Play: Research, Play, Share (pp. 224–227). ACM. Retrieved from
http://dl.acm.org/citation.cfm?id=1497029

This may be relevant as it discusses the ability to move between free-hand and structured editing but also through the use of language workbenches to (re)generate (visual) language by introducing a meta-level of development (in game development)- I understood this to be some form of evolutionary prototyping that might be useful in live coding contexts.

Malan, D. J., & Leitner, H. H. (2007). Scratch for budding computer scientists. In ACM SIGCSE Bulletin (Vol. 39, pp. 223–227). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1227388

Potentially relevant to promoting the positive impact of structured editing (Scratch) for novice programmers (@ Havard) who are able to learn the basics of programming without the burden of syntax

Maloney, J., Resnick, M., Rusk, N., Silverman, B., & Eastmond, E. (2010). The Scratch Programming Language and Environment. ACM Transactions on Computing Education, 10(4), 1–15. doi:10.1145/1868358.1868363

Relevant in describing Scratch and promoting self-directed learning through tinkering and collaboration.

Marceau, G., Fisler, K., & Krishnamurthi, S. (2011). Do values grow on trees?: expression integrity in functional programming. In Proceedings of the seventh international workshop on Computing education research (pp. 39–44). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2016921
Language: DrRacket

Probably relevant as the paper looks at expression integrity in various programming environments including structured editing and introduced me to scratch as a concrete example of strict structured editing.

Mazanek, S., Maier, S., & Minas, M. (2008). Auto-completion for diagram editors based on graph grammars. In Visual Languages and Human-Centric Computing, 2008. VL/HCC 2008. IEEE Symposium on (pp. 242–245). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=4639094

Probably relevant as it discusses combining free-hand and structured editing which would benefit the beginner and the expert allowing for the ability to quickly create complex diagrams which would be beneficial in performance.

Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994). Evolution of novice programming environments: The structure editors of Carnegie Mellon University. Interactive Learning Environments, 4(2), 140–158.

Relevant as it discusses earlier structured editors (Gandalf and Cornell Program Synthesizer) influencing the progressive design of GNOME, macGNOME, Genie Environments, and ACSE respectively and the changes implemented at each stage leading to a more multimedia environment (ACSE).

Minas, M. (2006). Generating visual editors based on Fujaba/MOFLON and DiaMeta. Proc. Fujaba Days. Technical Report Tr-Ri-06-275-University of Paderborn, 35–42.

Potentially relevant as it discusses DiaMeta, a tool for generating visual editors that support freehand and structured editing - the generation of micro live coding languages?

Oakley, I., Brewster, S., & Gray, P. (2001). Can you feel the force? An investigation of haptic collaboration in shared editors. In proceedings of EuroHaptics (pp. 54–59). Retrieved from http://ftp.dcs.glasgow.ac.uk/~stephen/papers/Eurohaptics2001_oakley.pdf

Potentially relevant for it discusses haptic collaboration in shared editors that are connected to a structured editor (CHASE)

Oney, S., & Brandt, J. (2012). Codelets: linking interactive documentation and example code in the editor. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (pp. 2697–2706). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2208664

Probably relevant as it presents the idea treating examples (instructive code for learning) as "first-class" objects in the code editor through the use of codelets which are presented inline with the user’s code, and consists of a block of example code and an interactive helper widget (structured editor) that assists the user in understanding and integrating the example - would allow for broader experimentation in improvisation contexts.

Paoli, J. (1995). Cooperative work on the network: edit the WWW! Computer Networks and ISDN Systems 27, 841–847.

Potentially relevant for it describes the creation of a collaborative www authoring tool that relies on a structured editing tool

Quint, V., & Vatton, I. (2005). Towards active web clients. In Proceedings of the 2005 ACM symposium on Document engineering (pp. 168–176). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1096646

Potentially relevant as it discusses structured editing for the web.

Shani, U. (1983). Should program editors not abandon text oriented commands? ACM SIGplan Notices, 18(1), 35–41.

Potentially relevant as it discusses the hybrid editor approach while providing positives and negatives of both sides.
Language: Albe

Shapiro, E., Collins, G., Johnson, L., & Ruttenberg, J. (1981). PASES: a programming environment for PASCAL. ACM SIGPLAN Notices, 16(8), 50–57.

Potentially relevant for it discusses the design and development as well as lessons learned from creating PASES, a structured editor for Pascal.

Simonyi, C., Christerson, M., & Clifford, S. (2006). Intentional software. In ACM SIGPLAN Notices (Vol. 41, pp. 451–464). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1167511

Potentially relevant as it provides a good brief description of what a structured editor is and the types (syntax directed editor and projecting editor) and their relevancy in intentional software as well as the notion of generative programming, being able to define, create, edit, transform and integrate multiple domains, and a discussion of previous problems with structured editing.

Voelter, M., & Solomatov, K. (2010). Language modularization and composition with projectional language workbenches illustrated with MPS. Software Language Engineering, SLE, 16.

Potentially relevant to the development of languages for structured editing as it describes and provides an example of a modular + projectional (structured editing) language, which is described as a minimal core language with a library of language modules that can be imported based on the task at hand that does not use grammars or parsers.

Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014). Towards user-friendly projectional editors. In Software Language Engineering (pp. 41–61). Springer. Retrieved from http://link.springer.com/chapter/10.1007/978-3-319-11245-9_3

Probably relevant for it reviews issues with projectional editing, a style of editing that allows for the combination of diverse notational styles such as text, symbols, tables, and graphics by directly manipulating the abstract syntax tree , and discusses strategies for overcoming these issues (which on first glance seem to be mainly grounded in software development and will be minimized for live coding),

Voigtländer, J. (2012). Programming language approaches to bidirectional transformation. In Proceedings of the Twelfth Workshop on Language Descriptions, Tools, and Applications (p. 1). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2427049

Probably relevant for it discusses bidirectional transformations (going back and forth between 2+ data domains) which is applicable in "view-update propagation in databases, model-driven engineering, and programming environments like structured editors, among others."

*Xinogalos, S. (2013). Using flowchart-based programming environments for simplifying programming and software engineering processes. In Global Engineering Education Conference (EDUCON), 2013 IEEE (pp. 1313–1322). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6530276

Probably relevant for it discusses iconic, flowchart-based programming (for novice education), which is based on structure editing and program animation and recently has included collaborative activities,distributed pair programming and usage in mobile devices.

Zelkowits, M. V. (1984). A small contribution to editing with a syntax directed editor. ACM Sigplan Notices, 19(5), 1–6.

Potentially relevant for it discusses structured editing from the point of view of maintenance.

top

High Priority:

Akpotsui, E., Quint, V., & Roisin, C. (1993). Type modelling for document transformation in structured editing systems. Submitted to Mathematical and Computer Modelling.
Akpotsui, E., Quint, V., & Roisin, C. (1997). Type modelling for document transformation in structured editing systems. Mathematical and Computer Modelling, 25(4), 1–19. doi:10.1016/S0895-7177(97)00021-6

Arefi, F., Hughes, C. E., & Workman, D. A. (1990). Automatically generating visual syntax-directed editors. Communications of the ACM, 33(3), 349–360.

Potentially relevant as an early example of automatically generating syntax directed editors for visual languages

Bonhomme, S., & Roisin, C. (1996). Interactively restructuring HTML documents. Computer Networks and ISDN Systems 28, 1075–1084.

Potentially relevant for early web based structured editing

Bouyakoub, S., & Belkhir, A. (2011). SMIL builder: An incremental authoring tool for SMIL Documents. ACM Transactions on Multimedia Computing, Communications, and Applications, 7(1), 1–30. doi:10.1145/1870121.1870123
Chuang, T.-R., & Lin, J.-L. (2004). On modular transformation of structural content. In Proceedings of the 2004 ACM symposium on Document engineering (pp. 201–210). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1030436
Cohen, E. (1982). Text-oriented structure commands for structure editors. ACM SIGplan Notices, 17(11), 45–49.
Desai, N., & Szafron, D. (2011). Descriptions: a viable choice for video game authors. In Proceedings of the 6th International Conference on Foundations of Digital Games (pp. 268–270). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2159408

De Jesus, E. (2011). Teaching Computer Programming with Structured Programming Language and Flowcharts. Presented at the OSDOC’11, ACM. Retrieved from http://portal.acm.org/toc.cfm?id=1378063

Potentially relevant in supporting the claim that structured editing + projectional editing (bidirectional flow between visual and code) aids novice programmers in learning the basics

Donzeau-Gouge, V., Huet, G., Lang, B., & Khan, G. (1980). Programming environments based on structured editors : the Mentor experience (Research Report No. RR-0026).

Potentially relevant for informing the development strategies for live coding structured editors.

Eid, M., Alamri, A., Melhem, J., & El Saddik, A. (2008). Evalutation of UML CASE tool with haptics. In Proceedings of the 2008 Ambi-Sys workshop on Haptic user interfaces in ambient media systems (p. 4). ICST (Institute for Computer Sciences, Social-Informatics and Telecommunications Engineering). Retrieved from http://dl.acm.org/citation.cfm?id=1413911
Fähndrich, M. (2014). Lessons from a web-based IDE and runtime (pp. 1–2). ACM Press. doi:10.1145/2543728.2543746

Garlan, D. B., & Miller, P. L. (1984). GNOME: An introductory programming environment based on a family of structure editors. ACM Sigplan Notices, 19(5), 65–72.

Potentially relevant as an early example of structured editing based on previous structured editors and used in Novice learning environments.

Goldenson, D. R., Chandhok, R. P., Garlan, D. H., Meter, G., Miller, P. L., Pane, J., … Skwarecki, E. J. (1992). GENIE: Developing and Assessing State-of-the-Art Integrated Programming Environments. SIGCHI Bulletin, 24(2). Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/1060000/1055544/p39-goldenson.pdf?ip=130.113.111.210&id=1055544&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419024207_81a74e1316db2a5e2a7f346da407f87d
Gruźlewski, T., & Weiss, Z. (1991). Semantic correctness of structural editing. ACM SIGPLAN Notices, 26(8), 111–120.
Guzdial, M. (2004). Programming environments for novices. Computer Science Education Research, 2004, 127–154.
Hall, G. A., Schuetzle, J., LaVallee, D., & Gupta, U. (1992). An architecture for the development of real-time fault diagnosis systems using model-based reasoning. Telematics and Informatics, 9(3), 163–172.

Hartmann, B. (2009). Gaining design insight through interaction prototyping tools. Stanford University. Retrieved from http://bjoern.org/dissertation/hartmann-diss.pdf

Potentially relevant with a brief overview of structured editing but possibly further relevant as it is discussed in the context of design tools for prototyping and learning

Holsapple, C. W., Park, S., & Whinston, A. B. (1992). Generating structure editor interfaces for OR procedures. Zeitschrift Für Operations Research, 36(3), 295–313.
Hudak, P. (1988). Exploring Parafunctional Programming: Separating the What from the How. IEEE Software. Retrieved from http://journals1.scholarsportal.info.libaccess.lib.mcmaster.ca/pdf/07407459/v05i0001/54_eppstwfth.xml
Kaiser, G. E., Feiler, P. H., Jalili, F., & Schlichter, J. H. (1988). A retrospective on DOSE: an interpretive approach to structure editor generation. Software: Practice and Experience, 18(8), 733–748.
Ko, A. J., & Myers, B. A. (2005). Human factors affecting dependability in end-user programming. ACM SIGSOFT Software Engineering Notes, 30(4), 1–4.

Maier, S., & Minas, M. (2008). A Static Layout Algorithm for DiaMeta. Electronic Communications of the EASST, 10. Retrieved from http://journal.ub.tu-berlin.de/index.php/eceasst/article/view/147

Potentially relevant as it discusses DIAMETA which utilizes meta-model based language specifications and supports free-hand as well as structured editing.

Meter, G., & Miller, P. (n.d.). Engaging Students and Teaching Modern Concepts: Literate, Situated, Object-Oriented Programming. SIGSCE, 1994. Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/200000/191161/p329-meter.pdf?ip=130.113.111.210&id=191161&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419027997_3a8520a52ef28b77258aa526ca378a11

Meyrowitz, N., & Van Dam, A. (1982). Interactive editing systems: Part II. ACM Computing Surveys (CSUR), 14(3), 353–415.

Minas, M. (2007). Generating meta-model-based freehand editors. Electronic Communications of the EASST, 1. Retrieved from http://journal.ub.tu-berlin.de/index.php/eceasst/article/view/83

Potentially relevant as it discusses DiaMeta, a tool for generating visual editors that support freehand and structured editing - the generation of micro live coding languages?

Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994). Evolution of novice programming environments: The structure editors of Carnegie Mellon University. Interactive Learning Environments, 4(2), 140–158.
Minas, M. (2006). Syntax analysis for diagram editors: a constraint satisfaction problem. In Proceedings of the working conference on Advanced visual interfaces (pp. 167–170). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1133300
Morgan, J. T., Gilbert, M., McDonald, D. W., & Zachry, M. (2013). Project talk: Coordination work and group membership in WikiProjects. In Proceedings of the 9th International Symposium on Open Collaboration (p. 3). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2491058
Neal, L., & Szwillus, G. (1990). Report on the CHI’90 workshop on structure editors. ACM SIGCHI Bulletin, 22(2), 49–53.
Nelson, J., Bathe, I., Campbell-Grant, I., Coon, M., Fischer, K., Kirstein, P., … Mabrouk, M. (1991). The role of teh PODA project in the adoption and development of ODA. Computer Networks and ISDN Systems 21, 175–185.
Pech, V., Shatalin, A., & Voelter, M. (2013). JetBrains MPS as a tool for extending Java (p. 165). ACM Press. doi:10.1145/2500828.2500846
Power, R., & Evans, R. (2004). WYSIWYM with wider coverage. In Proceedings of the ACL 2004 on Interactive poster and demonstration sessions (p. 30). Association for Computational Linguistics. Retrieved from http://dl.acm.org/citation.cfm?id=1219074
Quint, V., & Vatton, I. (1992). Combining hypertext and structured documents in Grif. In Proceedings of the ACM conference on Hypertext (pp. 23–32). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=168482

Quint, V., & Vatton, I. (2004). Techniques for authoring complex XML documents. In Proceedings of the 2004 ACM symposium on Document engineering (pp. 115–123). ACM. Retrieved from http://dl.acm.or/citation.cfm?id=1030422

Potentially relevant as it discusses structured editing for the web

Repenning, A. (2013). Conversational programming: exploring interactive program analysis. In Proceedings of the 2013 ACM international symposium on New ideas, new paradigms, and reflections on programming & software (pp. 63–74). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2509591

Roisin, C., Claves, P., & Akpotsui, E. (1997). Implementing the Cut-and-Paste Operation in a Structured Editing System. Mathl. Comput. Modelling, 26(1), 85–96.

Potentially relevant as it discusses a a method for creating cut and paste operations in structured editors

potentially relevant as it discusses a a method for creating cut and paste operations in structured editors

Sage, M. (2000). FranTk-a declarative GUI language for Haskell. ACM SIGPLAN Notices, 35(9), 106–117.

Potentially relevant as the article describes a GUI that has been implemented on various small structured editing languages.

Sandewall, E. (1978). Programming in an Interactive Environment: the“Lisp”Experience. ACM Computing Surveys (CSUR), 10(1), 35–71.
Strömfors, O., & Jonesjö, L. (1981). The implementation and experiences of a structure-oriented text editor. (Vol. 16). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=806450

Teitelbaum, T., & Reps, T. (1981). The Cornell program synthesizer: a syntax-directed programming environment. Communications of the ACM, 24(9), 563–573.

Potentially relevant as an early example for structured editing

Thery, L., Bertot, Y., & Kahn, G. (1992). Real Theorem Prover Deserve Real User-Interfaces. ACM. Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/150000/143760/p120-thery.pdf?ip=130.113.111.210&id=143760&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419027906_9ee720a970cfac3791d50e4d00449853
Tillmann, N., Moskal, M., de Halleux, J., Burckhardt, S., Ball, T., & Bishop, J. (2014). TouchDevelop: create rich mobile apps on touch devices (tutorial) (pp. 1–2). ACM Press. doi:10.1145/2593902.2593903
Tillmann, N., Moskal, M., de Halleux, J., & Fahndrich, M. (2011a). TouchDevelop: programming cloud-connected mobile devices via touchscreen. In Proceedings of the 10th SIGPLAN symposium on New ideas, new paradigms, and reflections on programming and software (pp. 49–60). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2048245
Tillmann, N., Moskal, M., de Halleux, J., & Fahndrich, M. (2011b). TouchDevelop: programming cloud-connected mobile devices via touchscreen. In Proceedings of the 10th SIGPLAN symposium on New ideas, new paradigms, and reflections on programming and software (pp. 49–60). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2048245
Tillmann, N., Moskal, M., de Halleux, J., Fahndrich, M., Bishop, J., Samuel, A., & Xie, T. (2012). The future of teaching programming is on mobile devices. In Proceedings of the 17th ACM annual conference on Innovation and technology in computer science education (pp. 156–161). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2325336

Stallman, R. (1978). Structured Editing with a Lisp. Surveyors’ Forum, 10(4). Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/360000/356754/p505-stallman.pdf?ip=130.113.111.210&id=356754&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419022930_e94126bcd5f709a6a7b3f955efbdcadf

Wayner, P. (2011, November 9). Computer Programming for Children, Minus Cryptic Syntax. The New York Times. Retrieved from http://www.nytimes.com/2011/11/10/technology/personaltech/computer-programming-for-children-minus-cryptic-syntax.html

Van Rest, O., Wachsmuth, G., Steel, J. R., S¨uß, J. G., & Visser, E. (2013). Robust real-time synchronization between textual and graphical editors. In Theory and Practice of Model Transformations (pp. 92–107). Springer. Retrieved from http://link.springer.com/chapter/10.1007/978-3-642-38883-5_11

Potentially relevant for dealing with synchronization issues between textual and graphical representations of code.

Van den Bosch, P. (1982). The translation of programming languages through the use of a graph transformation language. ACM SIGPLAN Notices, 17(3), 83–92.
Van Den Brand, M., & Visser, E. (1996). Generation of formatters for context-free languages. ACM Transactions on Software Engineering and Methodology (TOSEM), 5(1), 1–41.
Voigtländer, J., Hu, Z., Matsuda, K., & Wang, M. (2010). Combining syntactic and semantic bidirectionalization. In ACM Sigplan Notices (Vol. 45, pp. 181–192). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1863571
Wertz, H. (1982). The design of an integrated, interactive and incremental programming environment. In Proceedings of the 6th international conference on Software engineering (pp. 157–165). IEEE Computer Society Press. Retrieved from http://dl.acm.org/citation.cfm?id=807758
Wolter, J., & Kastens, U. (2014). Encapsulating Interaction Techniques of 3D Language Editors in Visual Patterns (pp. 68–77). ACM Press. doi:10.1145/2636240.2636840

top

Further Interest:

Alberga, C. N., Brown, A. L., Leeman Jr, G. B., Mikelsons, M., & Wegman, M. N. (1981). A program development tool. In Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (pp. 92–104). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=567543
Arnon, D. S., Attali, I., & Franchi-Zannettacci, P. (1997). A Document Manipulation System Based on Natural Semantics. Mathl. Comput. Modelling, 25(4), 37–56.

Baecker, R., & Marcus, A. (1986). Design principles for the enhanced presentation of computer program source text. In ACM SIGCHI Bulletin (Vol. 17, pp. 51–58). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=22348

Potentially relevant from a historical perspective as the article describes making source code more readable.

Bahlke, R., & Snelting, G. (1985). The PSG - Programming System Generator. ACM. Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/810000/806824/p28-bahlke.pdf?ip=130.113.111.210&id=806824&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419025916_64171f531d106c86b17e4eb0a3e1c942
Bernardy, J.-P. (2009). Lazy functional incremental parsing. In Proceedings of the 2nd ACM SIGPLAN symposium on Haskell (pp. 49–60). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1596645
Brade, M., Brändel, C., Salmen, A., & Groh, R. (2012). SketchViz: a sketching interface for domain comprehension tasks illustrated by an industrial network use case. In Proceedings of the 12th International Conference on Knowledge Management and Knowledge Technologies (p. 30). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2362494
Brieler, F., & Minas, M. (2008). Recognition and processing of hand-drawn diagrams using syntactic and semantic analysis. In Proceedings of the working conference on Advanced visual interfaces (pp. 181–188). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1385599
Carrasquel, J., Roberts, J., & Pane, J. (1989). The design tree: a visual approach to top-down design and data flow. In ACM SIGCSE Bulletin (Vol. 21, pp. 17–21). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=65296
Cignoni, P., Corsini, M., & Ranzuglia, G. (2008). Meshlab: an open-source 3d mesh processing system. Ercim News, 73, 45–46.
Cutkosky, M. R., Tenenbaum, J. M., & Glicksman, J. (1996). Madefast: collaborative engineering over the Internet. Communications of the ACM, 39(9), 78–87.
Feiler, P. H. (1987). Relationship between IDL and structure editor generation technology. ACM SIGPlan Notices, 22(11), 87–94.
Fors, N., & Hedin, G. (2013). Implementing semantic feedback in a diagram editor (pp. 42–50). ACM Press. doi:10.1145/2489820.2489827
Flores, F. C., Quint, V., & Vatton, I. (2006). Templates, microformats and structured editing. In Proceedings of the 2006 ACM symposium on Document engineering (pp. 188–197). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1166211
Freund, S. N., & Roberts, E. S. (1996). Thetis: An Ansi C Programming Environment Designed For Introductory Use. SIGCSE. Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/240000/236560/p300-freund.pdf?ip=130.113.111.210&id=236560&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419027587_48e90be80c4e175cd3fb0efba3b7b8b2
Frisch, M., Schmidt, S., Heydekorn, J., Nacenta, M. A., Dachselt, R., & Carpendale, S. (2010). Editing and Exploring Node-link Diagrams on Pen- and Multi-touch-operated Tabletops. In ACM International Conference on Interactive Tabletops and Surfaces (pp. 304–304). New York, NY, USA: ACM. doi:10.1145/1936652.1936732
Goldenson, D. R. (1989). The Impact of Structure Editing on Introductory Computer Science Education: The Results So Far. SIGCSE Bulletin, 21(3). Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/80000/70599/p26-goldenson.pdf?ip=130.113.111.210&id=70599&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419023348_896d888f545cda7195e048ee81d8b79c
Goldenson, D. R., & Lewis, M. B. (1988). Fine tuning selection semantics in a structure editor based programming environment: some experimental results. ACM SIGCHI Bulletin, 20(2), 38–43.
Gong, J., Chen, C.-T., & Kucukcakar, K. (1998). Architectural rule checking for high-level synthesis. In Design, Automation and Test in Europe, 1998., Proceedings (pp. 949–950). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=655983
Haake, A., Lukosch, S., & Schümmer, T. (2005). Wiki-templates: adding structure support to wikis on demand. In Proceedings of the 2005 international symposium on Wikis (pp. 41–51). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1104978
Kelleher, C., & Pausch, R. (2005). Lowering the barriers to programming: A taxonomy of programming environments and languages for novice programmers. ACM Computing Surveys (CSUR), 37(2), 83–137.
Kennedy, K., McKinley, K. S., & Tseng, C.-W. (1991). Interactive Parallel Programming Using the ParaScope Editor. IEEE Transactions on Parallel and Distributed Systems, 2(3). Retrieved from http://journals1.scholarsportal.info.libaccess.lib.mcmaster.ca/pdf/10459219/v02i0003/329_ipputpe.xml
Khwaja, A. A., & Urban, J. E. (1993). Syntax-directed editing environments: Issues and features. In Proceedings of the 1993 ACM/SIGAPP symposium on Applied computing: states of the art and practice (pp. 230–237). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=162882
Kimura, G. D. (1986). A structure editor for abstract document objects. Software Engineering, IEEE Transactions on, (3), 417–435.
Kuo, Y.-S., Shih, N. C., Tseng, L., & Hu, H.-C. (2005). Generating form-based user interfaces for XML vocabularies. In Proceedings of the 2005 ACM symposium on Document engineering (pp. 58–60). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1096619
Lau, T., Wolfman, S. A., Domingos, P., & Weld, D. S. (2001). Learning repetitive text-editing procedures with SMARTedit. Your Wish Is My Command: Giving Users the Power to Instruct Their Software, 209–226.
Louden, K. (1989). LOGO as a Prelude to Lisp: Some Surprising Results. SIGCSE Bulletin, 21(3). Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/80000/70601/p35-louden.pdf?ip=130.113.111.210&id=70601&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419028044_1650fd5f6c6b6b6e6c44e741d3919f75
Lumley, J., Gimson, R., & Rees, O. (2008a). A demonstration of a configurable editing framework. In Proceedings of the eighth ACM symposium on Document engineering (pp. 217–218). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1410184
Lumley, J., Gimson, R., & Rees, O. (2008b). Configurable editing of XML-based variable-data documents. In Proceedings of the eighth ACM symposium on Document engineering (pp. 76–85). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1410155
Maier, S., & Minas, M. (2008). A generic layout algorithm for meta-model based editors. In Applications of Graph Transformations with Industrial Relevance (pp. 66–81). Springer. Retrieved from http://link.springer.com/chapter/10.1007/978-3-540-89020-1_6
Mendes, A. (2008). Work in progress-structure editing of handwritten mathematics. In Frontiers in Education Conference, 2008. FIE 2008. 38th Annual (p. T2A–5). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=4720333
Meyer, B. (1988). Cepage: Toward computer-aided design of software. Journal of Systems and Software, 8(5), 419–429.
Morgan, J. T., Gilbert, M., McDonald, D. W., & Zachry, M. (2014). Editing beyond articles: diversity & dynamics of teamwork in open collaborations (pp. 550–563). ACM Press. doi:10.1145/2531602.2531654
Nanard, J., & Nanard, M. (1991). Using structured types to incorporate knowledge in hypertext. In Proceedings of the third annual ACM conference on Hypertext (pp. 329–343). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=123006

Newman-Wolfe, R. E., & Pelimuhandiram, H. K. (1991). MACE: A Fine Grained Concurrent Editor. ACM. Retrieved from http://delivery.acm.org.libaccess.lib.mcmaster.ca/10.1145/130000/122855/p240-newman-wolfe.pdf?ip=130.113.111.210&id=122855&acc=ACTIVE%20SERVICE&key=FD0067F557510FFB%2ED816932E3DB0B89D%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&CFID=610049202&CFTOKEN=96482024&acm=1419026290_c106068f81d545e3a621fdae5c6073c2
Olsen, D. R. (1986). Editing templates: a user interface generation tool. Computer Graphics and Applications, IEEE, 6(11), 40–45.

Pane, J. F., Myers, B. A., & Miller, L. B. (2002). Using HCI techniques to design a more usable programming system. In Human Centric Computing Languages and Environments, 2002. Proceedings. IEEE 2002 Symposia on (pp. 198–206). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1046372

Possibly relevant as it describes an alternative to conventional programming syntax using natural language that does not use conflicting language that has different meanings in other contexts (void, static, dim, x=x+10)

Partsch, H., & Steinbrüggen, R. (1983). Program transformation systems. ACM Computing Surveys (CSUR), 15(3), 199–236.
Pruša, D. (2001). Two-dimensional context-free grammars. ITAT, 2001, 27–40.
Quint, V., & Vatton, I. (2007a). Editing with style. In Proceedings of the 2007 ACM symposium on Document engineering (pp. 151–160). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1284460
Quint, V., & Vatton, I. (2007b). Structured templates for authoring semantically rich documents. In Proceedings of the 2007 international workshop on Semantically aware document processing and indexing (pp. 41–48). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1283889
Raggett, D. (2014). Testsuite and harness for browser based editing. In Proceedings of the companion publication of the 23rd international conference on World wide web companion (pp. 579–582). International World Wide Web Conferences Steering Committee. Retrieved from http://dl.acm.org/citation.cfm?id=2578035
Reiss, S. P. (1986). Programming environments today. Annual Review of Computer Science, 1(1), 181–195.
Rosen, B. K. (1981). Linear cost is sometimes quadratic. In Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (pp. 117–124). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=567545
Silva, M., & Oliveira, T. (2011). Towards detailed software artifact specification with SPEMArti. In Proceedings of the 2011 International Conference on Software and Systems Process (pp. 213–217). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1987912
Si, M., Marsella, S. C., & Pynadath, D. V. (2005). Thespian: Using multi-agent fitting to craft interactive drama. In Proceedings of the fourth international joint conference on Autonomous agents and multiagent systems (pp. 21–28). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1082477
Van der Hoeven, J. (2004). Gnu TeXmacs. ACM SIGSAM Bulletin, 38(1), 24–25.
Wagner, T. A., & Graham, S. L. (1997). Incremental analysis of real programming languages. In ACM SIGPLAN Notices (Vol. 32, pp. 31–43). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=258920
Wang, W., & Rada, R. (1998). Structured hypertext with domain semantics. ACM Transactions on Information Systems (TOIS), 16(4), 372–412.

top

Potential Interest:

Alkhateeb, F. (2010). BibTeX document generating using semantic web technologies. In Proceedings of the 1st International Conference on Intelligent Semantic Web-Services and Applications (p. 2). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1874592
Allen, T., Nix, R., & Perlis, A. (1981). PEN: A hierarchical document editor. ACM SIGOA Newsletter, 2(1-2), 74–81.
Auffret, G., Carrive, J., Chevet, O., Dechilly, T., Ronfard, R., & Bachimont, B. (1999). Audiovisual-based hypermedia authoring: using structured representations for efficient access to AV documents. In Proceedings of the tenth ACM Conference on Hypertext and hypermedia: returning to our diverse roots: returning to our diverse roots (pp. 169–178). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=294620
Azevedo, R. G. de A., Santos, R. C. M., Araújo, E. C., Soares, L. F. G., & Soares Neto, C. de S. (2013). Multimedia authoring based on templates and semi-automatic generated wizards (p. 205). ACM Press. doi:10.1145/2494266.2494283
Billington, J., Wheeler, G. R., & Wilbur-Ham, M. C. (1988). PROTEAN: A High-level Petri Net Tool for the Specification and Verification of Communication Protocols. IEEE Transactions on Software Engineering, 14(3). Retrieved from http://journals1.scholarsportal.info.libaccess.lib.mcmaster.ca/pdf/00985589/v14i0003/301_pahpntsavocp.xml
Bloomberg, D. S., & Moran, T. P. (2005). Method and system for transcribing and editing using a structured freeform editor. Google Patents. Retrieved from http://www.google.com/patents/US6952803
Christophides, V., & Rizk, A. (n.d.). Querying Structured D ocum ents with H ypertext Links.
Cutts, Q., Esper, S., Fecho, M., Foster, S. R., & Simon, B. (2012). The abstraction transition taxonomy: Developing desired learning outcomes through the lens of situated cognition. In Proceedings of the ninth annual international conference on International computing education research (pp. 63–70). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2361290
Dewan, P., & Choudhard, R. (1991). Flexible User Interface Coupling in a Collaborative System. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (pp. 41–48). New York, NY, USA: ACM. doi:10.1145/108844.108851
Dewan, P., & Solomon, M. (1990). An approach to support automatic generation of user interfaces. ACM Transactions on Programming Languages and Systems (TOPLAS), 12(4), 566–609.
Di Iorio, A., Vitali, F., & Zacchiroli, S. (2008). Wiki content templating. In Proceedings of the 17th international conference on World Wide Web (pp. 615–624). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1367581
Ennals, R. J., & Garofalakis, M. N. (2007). MashMaker: mashups for the masses. In Proceedings of the 2007 ACM SIGMOD international conference on Management of data (pp. 1116–1118). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1247626
Favre, J.-M., Lämmel, R., Schmorleiz, T., & Varanovich, A. (2012). 101companies: a community project on software technologies and software languages. In Objects, Models, Components, Patterns (pp. 58–74). Springer. Retrieved from http://link.springer.com/chapter/10.1007/978-3-642-30561-0_6
Frisch, M., Heydekorn, J., & Dachselt, R. (2009). Investigating multi-touch and pen gestures for diagram editing on interactive surfaces. In Proceedings of the ACM International Conference on Interactive Tabletops and Surfaces (pp. 149–156). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1731933
Halasz, F., & others. (1988). Reflections on Notecards: Seven issues for the next generation of hypermedia systems. Communications of the ACM, 31(7), 836–852.
Harel, D. (1980). And/or programs: a new approach to structured programming. ACM Transactions on Programming Languages and Systems (TOPLAS), 2(1), 1–17.
Igarashi, T. (2006). Sketch-based Interfaces for Interactive Computer Graphics. In ACM SIGGRAPH 2006 Courses. New York, NY, USA: ACM. doi:10.1145/1185657.1185764
Igarashi, T. (2007a). Sketch-based Interfaces for Interactive Computer Graphics. In ACM SIGGRAPH 2007 Courses. New York, NY, USA: ACM. doi:10.1145/1281500.1281515
Igarashi, T. (2007b). Sketch-based interfaces for interactive computer graphics. In ACM SIGGRAPH 2007 courses (p. 4). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1281515
Ijiri, T., Owada, S., Okabe, M., & Igarashi, T. (2005). Floral diagrams and inflorescences: interactive flower modeling using botanical structural constraints. In ACM Transactions on Graphics (TOG) (Vol. 24, pp. 720–726). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1073253
Johovich, J. J. (1985). EEES: the “Manhattan Project” for systems engineering. In Proceedings of the second annual Washington Ada symposium on Ada: Ada in the mainstream: applications and education (pp. 19–42). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=325624
Jourdan, M., Layaïda, N., Roisin, C., Sabry-Ismaïl, L., & Tardif, L. (1998). Madeus, and authoring environment for interactive multimedia documents. In Proceedings of the sixth ACM international conference on Multimedia (pp. 267–272). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=290780
Lee, M. J., & Ko, A. J. (2011). Personifying programming tool feedback improves novice programmers’ learning. In Proceedings of the seventh international workshop on Computing education research (pp. 109–116). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2016934
Martin, G. (2006). Overview of the MPSoC design challenge. In Proceedings of the 43rd annual Design Automation Conference (pp. 274–279). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1146980
Matson, R. (2001). Re-forming information: a case study in teaching content encapsulation. In Proceedings of the 19th annual international conference on Computer documentation (pp. 116–121). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=501540
Moreno, L., Martínez, P., & Ruiz, B. (2008). Guiding accessibility issues in the design of websites. In Proceedings of the 26th annual ACM international conference on Design of communication (pp. 65–72). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1456550
Nanard, M., Nanard, J., King, P. R., & Gaillard, L. (2007). Genre driven multimedia document production by means of incremental transformation. In Proceedings of the 2007 ACM symposium on Document engineering (pp. 111–120). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1284452
Quint, V., Roisin, C., Sire, S., & Vanoirbeek, C. (2010). From templates to schemas: Bridging the gap between free editing and safe data processing. In Proceedings of the 10th ACM symposium on Document engineering (pp. 61–64). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1860572
Saund, E., Fleet, D., Larner, D., & Mahoney, J. (2003). Perceptually-supported image editing of text and graphics. In Proceedings of the 16th annual ACM symposium on User interface software and technology (pp. 183–192). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=964717
Shaffer, D. W. (2006). Epistemic frames for epistemic games. Computers & Education, 46(3), 223–234. doi:10.1016/j.compedu.2005.11.003
Sundararaman, J., & Back, G. (2008). HDPV: interactive, faithful, in-vivo runtime state visualization for C/C++ and Java. In Proceedings of the 4th ACM symposium on Software visualization (pp. 47–56). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1409729
Vander Zanden, B. T., & Halterman, R. (2001). Using model dataflow graphs to reduce the storage requirements of constraints. ACM Transactions on Computer-Human Interaction (TOCHI), 8(3), 223–265.

top

Scratch (many more to come)

Adams, J. C. (2010). Scratching middle schoolers’ creative itch. In Proceedings of the 41st ACM technical symposium on Computer science education (pp. 356–360). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1734385
Alternatives to Scratch - Scratch Wiki. (n.d.). Retrieved January 2, 2015, from http://wiki.scratch.mit.edu/wiki/Alternatives_to_Scratch
Armoni, M. (2012). Social programming communities as a bridge for CS education: a case for the Scratch community. ACM Inroads, 3(2), 13–14.
Bell, S., Frey, T., & Vasserman, E. (2014). Spreading the word: introducing pre-service teachers to programming in the K12 classroom (pp. 187–192). ACM Press. doi:10.1145/2538862.2538963
Boe, B., Hill, C., Len, M., Dreschler, G., Conrad, P., & Franklin, D. (2013). Hairball: Lint-inspired static analysis of scratch projects. In Proceeding of the 44th ACM technical symposium on Computer science education (pp. 215–220). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2445265
Brennan, K., & Resnick, M. (2013). Stories from the scratch community: connecting with ideas, interests, and people. In Proceeding of the 44th ACM technical symposium on Computer science education (pp. 463–464). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2445336
Burke, Q., & Kafai, Y. B. (2010). Programming & storytelling: opportunities for learning about coding & composition. In Proceedings of the 9th International Conference on Interaction Design and Children (pp. 348–351). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1810611
Chitsaz, M. (2011). Scratch as the first programming language: tutorial presentation. Journal of Computing Sciences in Colleges, 26(3), 102–103.
Chiu, C.-F. (2014). Use of Problem-solving Approach to Teach Scratch Programming for Adult Novice Programmers (Abstract Only). In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (pp. 710–711). New York, NY, USA: ACM. doi:10.1145/2538862.2544284
Dahotre, A., Zhang, Y., & Scaffidi, C. (2010). A qualitative study of animation programming in the wild. In Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (p. 29). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1852825
Esper, S., Foster, S. R., & Griswold, W. G. (2013). On the nature of fires and how to spark them when you’re not there. In Proceeding of the 44th ACM technical symposium on Computer science education (pp. 305–310). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2445290
Federici, S. (2011). A minimal, extensible, drag-and-drop implementation of the C programming language. In Proceedings of the 2011 conference on Information technology education (pp. 191–196). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2047646
Feldhausen, R., Bell, S., & Andresen, D. (2014). Minimum Time, Maximum Effect: Introducing Parallel Computing in CS0 and STEM Outreach Activities Using Scratch (pp. 1–7). ACM Press. doi:10.1145/2616498.2616568
Fesakis, G., & Serafeim, K. (2009). Influence of the familiarization with scratch on future teachers’ opinions and attitudes about programming and ICT in education. In ACM SIGCSE Bulletin (Vol. 41, pp. 258–262). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1562957
Fields, D. A., Giang, M., & Kafai, Y. (2014). Programming in the wild: trends in youth computational participation in the online scratch community (pp. 2–11). ACM Press. doi:10.1145/2670757.2670768
Franklin, D., Conrad, P., Boe, B., Nilsen, K., Hill, C., Len, M., … others. (2013). Assessment of computer science learning in a scratch-based outreach program. In Proceeding of the 44th ACM technical symposium on Computer science education (pp. 371–376). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2445304
ft_gateway.pdf. (n.d.-a). Retrieved from http://dl.acm.org.libaccess.lib.mcmaster.ca/ft_gateway.cfm?id=1709974&ftid=740048&coll=DL&dl=ACM&CFID=467870621&CFTOKEN=93562489
ft_gateway.pdf. (n.d.-b). Retrieved from http://dl.acm.org.libaccess.lib.mcmaster.ca/ft_gateway.cfm?id=1839607&ftid=828505&coll=DL&dl=ACM&CFID=467870621&CFTOKEN=93562489
Gans, P. (2010). THE BENEFITS OF USING SCRATCH TO INTRODUCE BASIC PROGRAMMING CONCEPTS IN THE ELEMENTARY CLASSROOM. The Journal of Computing Sciences in Colleges, 235.
Giannakos, M. N., Jaccheri, L., & Proto, R. (2013). Teaching Computer Science to Young Children through Creativity: Lessons Learned from the Case of Norway. In Proceedings of the 3rd Computer Science Education Research Conference on Computer Science Education Research (pp. 103–111). Open Universiteit, Heerlen. Retrieved from http://dl.acm.org/citation.cfm?id=2541927
Gordon, M., Marron, A., & Meerbaum-Salant, O. (2012). Spaghetti for the main course?: observations on the naturalness of scenario-based programming. In Proceedings of the 17th ACM annual conference on Innovation and technology in computer science education (pp. 198–203). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2325346
Kafai, Y. B., & Burke, Q. (2013). The social turn in K-12 programming: moving from computational thinking to computational participation. In Proceeding of the 44th ACM technical symposium on Computer science education (pp. 603–608). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2445373
Lewis, C., Esper, S., Bhattacharyya, V., Fa-Kaji, N., Dominguez, N., & Schlesinger, A. (2014). Children’s perceptions of what counts as a programming language. Journal of Computing Sciences in Colleges, 29(4), 123–133.
Lewis, C. M. (2010). How programming environment shapes perception, learning and goals: logo vs. scratch. In Proceedings of the 41st ACM technical symposium on Computer science education (pp. 346–350). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1734383
Lewis, C. M., & Shah, N. (2012). Building upon and enriching grade four mathematics standards with programming curriculum. In Proceedings of the 43rd ACM technical symposium on Computer Science Education (pp. 57–62). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2157156

Malan, D. J., & Leitner, H. H. (2007). Scratch for budding computer scientists. In ACM SIGCSE Bulletin (Vol. 39, pp. 223–227). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1227388

Potentially relevant to promoting the positive impact of structured editing (Scratch) for novice programmers (@ Havard) who are able to learn the basics of programming without the burden of syntax
Marceau, G., Fisler, K., & Krishnamurthi, S. (2011). Do values grow on trees?: expression integrity in functional programming. In Proceedings of the seventh international workshop on Computing education research (pp. 39–44). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2016921

Maloney, J. H., Peppler, K., Kafai, Y., Resnick, M., & Rusk, N. (2008). Programming by choice: urban youth learning programming with scratch. In ACM SIGCSE Bulletin (Vol. 40, pp. 367–371). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=1352260
Maloney, J., Resnick, M., Rusk, N., Peppler, K. A., & Kafai, Y. B. (2008). Media designs with Scratch: What urban youth can learn about programming in a computer clubhouse. In Proceedings of the 8th international conference on International conference for the learning sciences-Volume 3 (pp. 81–82). International Society of the Learning Sciences. Retrieved from http://dl.acm.org/citation.cfm?id=1599974
Maloney, J., Resnick, M., Rusk, N., Silverman, B., & Eastmond, E. (2010). The Scratch Programming Language and Environment. Trans. Comput. Educ., 10(4), 16:1–16:15. doi:10.1145/1868358.1868363
Meerbaum-Salant, O., Armoni, M., & Ben-Ari, M. (2011). Habits of Programming in Scratch. In Proceedings of the 16th Annual Joint Conference on Innovation and Technology in Computer Science Education (pp. 168–172). New York, NY, USA: ACM. doi:10.1145/1999747.1999796
Mishra, S., Balan, S., Iyer, S., & Murthy, S. (2014). Effect of a 2-week scratch intervention in CS1 on learners with varying prior knowledge (pp. 45–50). ACM Press. doi:10.1145/2591708.2591733
Papadakis, S., Kalogiannakis, M., Orfanakis, V., & Zaranis, N. (2014). Novice Programming Environments. Scratch & App Inventor: A First Comparison. In Proceedings of the 2014 Workshop on Interaction Design in Educational Environments (pp. 1:1–1:7). New York, NY, USA: ACM. doi:10.1145/2643604.2643613
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., … Kafai, Y. (2009). Scratch: Programming for All. Commun. ACM, 52(11), 60–67. doi:10.1145/1592761.1592779
Richards, M., Petre, M., & Bandara, A. K. (2012). Starting with Ubicomp: using the SenseBoard to introduce computing. In Proceedings of the 43rd ACM technical symposium on Computer Science Education (pp. 583–588). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2157306
Rizvi, M., & Humphries, T. (2012). Scratch Programming for Undergraduates. J. Comput. Sci. Coll., 27(3), 107–107.
Rizvi, M., Humphries, T., Major, D., Jones, M., & Lauzun, H. (2011). A cs0 course using scratch. Journal of Computing Sciences in Colleges, 26(3), 19–27.
Roque, R., Kafai, Y., & Fields, D. (2012). From tools to communities: Designs to support online creative collaboration in Scratch. In Proceedings of the 11th International Conference on Interaction Design and Children (pp. 220–223). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2307130
Ruf, A., Mühling, A., & Hubwieser, P. (2014). Scratch vs. Karel: impact on learning outcomes and motivation (pp. 50–59). ACM Press. doi:10.1145/2670757.2670772
Scaffidi, C., Dahotre, A., & Zhang, Y. (2012). How well do online forums facilitate discussion and collaboration among novice animation programmers? In Proceedings of the 43rd ACM technical symposium on Computer Science Education (pp. 191–196). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2157195
Smith, N., Sutcliffe, C., & Sandvik, L. (2014). Code club: bringing programming to UK primary schools through scratch (pp. 517–522). ACM Press. doi:10.1145/2538862.2538919

top

Newly added (to be sorted)

Alice.org. (n.d.). Retrieved January 2, 2015, from http://www.alice.org/index.php
blockly - Web-based visual programming editor - Google Project Hosting. (n.d.). Retrieved January 2, 2015, from https://code.google.com/p/blockly/
CodeSpells. (n.d.). Retrieved January 2, 2015, from http://codespells.org/
Deluge Script - User Friendly Scripting Language. (n.d.). Retrieved January 2, 2015, from https://www.zoho.com/creator/overview/deluge-script.html
Enginursday: Visually Programming Arduino - News - SparkFun Electronics. (n.d.). Retrieved January 2, 2015, from https://www.sparkfun.com/news/1291
Entice Designer - Dprogramming.com - The D programming language. (n.d.). Retrieved January 2, 2015, from http://www.dprogramming.com/entice.php
Esper, S., Foster, S. R., Griswold, W. G., Herrera, C., & Snyder, W. (2014). CodeSpells: bridging educational language features with industry-standard languages. In Proceedings of the 14th Koli Calling International Conference on Computing Education Research (pp. 05–14). ACM. Retrieved from http://dl.acm.org/citation.cfm?id=2674684
Exploring the deep structure of code | InfoWorld. (n.d.). Retrieved January 2, 2015, from http://www.infoworld.com/article/2668520/application-development/exploring-the-deep-structure-of-code.html
Flow-based programming. (2014, December 17). In Wikipedia, the free encyclopedia. Retrieved from http://en.wikipedia.org/w/index.php?title=Flow-based_programming&oldid=637722324
French, G. (2013, January). The Larch Environment - Python programs as visual, interactive literature (masters). University of East Anglia. Retrieved from https://ueaeprints.uea.ac.uk/42343/
French, G. W., Kennaway, J. R., & Day, A. M. (2014). Programs as visual, interactive documents: PROGRAMS AS VISUAL, INTERACTIVE DOCUMENTS. Software: Practice and Experience, 44(8), 911–930. doi:10.1002/spe.2182
gasolin/BlocklyDuino · GitHub. (n.d.). Retrieved January 2, 2015, from https://github.com/gasolin/BlocklyDuino
Go Beyond One Hour. (n.d.). Retrieved January 2, 2015, from http://code.org/learn/beyond
Homer, M., & Noble, J. (2014). Combining tiled and textual views of code. In Software Visualization (VISSOFT), 2014 Second IEEE Working Conference on (pp. 1–10). IEEE. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6980206
HTML Egg Pro for Mac. (n.d.). Retrieved January 2, 2015, from http://www.macupdate.com/app/mac/52540/html-egg-pro
IBM Knowledge Center - Structure Editing. (2013, January 1). [CT701]. Retrieved January 2, 2015, from http://www-01.ibm.com/support/knowledgecenter/ssw_aix_53/com.ibm.aix.graPHIGS/doc/phigsund/StructEdit.htm%23hdrstredit
IntentionalProgramming.ppt. (n.d.). Retrieved from http://www.lutzroeder.com/paper/IntentionalProgramming.ppt
InteractiveSourceCode.ppt. (n.d.). Retrieved from http://www.lutzroeder.com/paper/InteractiveSourceCode.ppt
JetBrains::Meta Programming System — environment for creating Language Extensions and for creating and using Domain Specific Languages. (n.d.). Retrieved January 2, 2015, from http://www.jetbrains.com/mps/concepts/
JetBrains onBoard Online Magazine :: Language Oriented Programming: The Next Programming Paradigm. (n.d.). Retrieved January 2, 2015, from http://www.onboard.jetbrains.com/is1/articles/04/10/lop/
Kelso, J. (2002). A visual programming environment for functional languages. Citeseer.
Language Workbenches: The Killer-App for Domain Specific Languages? (n.d.). Retrieved January 2, 2015, from http://martinfowler.com/articles/languageWorkbench.html
Learn. (n.d.). Retrieved January 2, 2015, from http://code.org/learn
Lego Mindstorms NXT. (2015, January 1). In Wikipedia, the free encyclopedia. Retrieved from http://en.wikipedia.org/w/index.php?title=Lego_Mindstorms_NXT&oldid=635666458
Lutz Roeder’s Talks & Publications. (n.d.). Retrieved January 2, 2015, from http://www.lutzroeder.com/paper/
Made With Prograph List. (n.d.). Retrieved January 2, 2015, from http://www.tritera.com/prograph.html
MIT App Inventor | Explore MIT App Inventor. (n.d.). Retrieved January 2, 2015, from http://appinventor.mit.edu/explore/
Natural Programming. (n.d.). Retrieved January 2, 2015, from http://www.cs.cmu.edu/~NatProg/barista.html
.NET Undocumented: Whidbey May Miss the Next Coding Revolution. (n.d.). Retrieved January 2, 2015, from http://wesnerm.blogs.com/net_undocumented/2004/06/whidbey_may_mis.html
New to Java Programming Center - Young Developers. (n.d.). Retrieved January 2, 2015, from http://www.oracle.com/technetwork/topics/newtojava/youngdevelopers/index.html
NI LabVIEW - Improving the Productivity of Engineers and Scientists - National Instruments. (n.d.). Retrieved January 2, 2015, from http://www.ni.com/labview/
Ogawa, T. (n.d.). Double-Click and Drag-and-Drop in Visual Programming Environment for CafeOBJ.
Osenkov, K. (2007). Designing, implementing and integrating a structured C# code editor. Brandenburg University of Technology, Cottbus. Retrieved from http://www.osenkov.com/diplom/KirillOsenkovDiplom.pdf
Pipes: Rewire the web. (n.d.). Retrieved January 2, 2015, from http://pipes.yahoo.com/pipes/
Pocket Programming Language 2.0 by Arianesoft. (n.d.). Retrieved January 2, 2015, from http://www.ppl-lang.com/
Programming Without Coding Technology. (n.d.). Retrieved January 2, 2015, from http://sourceforge.net/projects/doublesvsoop/
Program Tree Editor. (n.d.). Retrieved January 2, 2015, from http://www.programtree.com/
PureBuilder. (n.d.). Retrieved January 2, 2015, from https://translate.googleusercontent.com/translate_c?depth=1&rurl=translate.google.com&sl=ru&tl=en&u=https:sites.google.com/site/purebuilder/&usg=ALkJrhgxB7W36DDE-0lSxSFV71mlQGnw8g
Reflector5.ppt. (n.d.). Retrieved from http://www.lutzroeder.com/paper/Reflector5.ppt
Search for PrographLanguage. (n.d.). Retrieved January 2, 2015, from http://c2.com/cgi/fullSearch
Simulink - Simulation and Model-Based Design. (n.d.). Retrieved January 2, 2015, from http://www.mathworks.com/products/simulink/
Software | Hummingbird Robotics Kit. (n.d.). Retrieved January 2, 2015, from http://www.hummingbirdkit.com/learning/software
Sprog! (n.d.). Retrieved January 2, 2015, from http://sprog.sourceforge.net/
Structure editor. (2014, December 11). In Wikipedia, the free encyclopedia. Retrieved from http://en.wikipedia.org/w/index.php?title=Structure_editor&oldid=635887585
Structure editors, IDEs, and another Lisp flashback · { random memes }. (n.d.). Retrieved January 2, 2015, from http://bannister.us/weblog/2005/structure-editors-ides-and-another-lisp-flashback/
Subtext programming language. (n.d.). Retrieved January 2, 2015, from http://www.subtext-lang.org/
The Lava Programming Environment. (n.d.). Retrieved January 2, 2015, from http://lavape.sourceforge.net/
Top 10 Free Source Code Editors – Reviewed. (n.d.). Retrieved January 2, 2015, from http://www.hongkiat.com/blog/free-code-editors-reviewed/
Two-way Dataflow. (2014). Retrieved from http://vimeo.com/106073134
usefulness-syntax-directed-editors-19860616-18.pdf. (n.d.). Retrieved from http://bat8.inria.fr/~lang/papers/trondheim86/usefulness-syntax-directed-editors-19860616-18.pdf
Visual programming language. (2015, January 2). In Wikipedia, the free encyclopedia. Retrieved from http://en.wikipedia.org/w/index.php?title=Visual_programming_language&oldid=640694190
Wayner, P. (2011, November 9). Computer Programming for Children, Minus Cryptic Syntax. The New York Times. Retrieved from http://www.nytimes.com/2011/11/10/technology/personaltech/computer-programming-for-children-minus-cryptic-syntax.html
Weebly is the easiest way to create a website, store or blog. (n.d.). Retrieved January 2, 2015, from http://www.weebly.com/#drag-drop
Why top universities teach drag and drop programming//. (2014). Retrieved from https://www.youtube.com/watch?v=_Mwc1gc77dc&feature=youtube_gdata_player

top