Structured+Editing

 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
 * 2) -- structure editor
 * 3) -- iconic editor
 * 4) ---block editing/er
 * 5) internal structure type
 * 6) level of abstraction
 * 7) -- character, expression, simple statement, or declaritive level
 * 8) target documents
 * 9) types of errors
 * 10) syntactic and static semantic
 * 11) error handling
 * 12) abort or continue editing
 * 13) incremental system
 * 14) execution level
 * 15) 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?) - Shani, U. (1983) --> ALBE [9] Alice Amaya * - Quint, V., & Vatton, I. (2005) - Xinogalos, S. (2013) B# [32] Barista - Ko, A. J., & Myers, B. A. (2006) - Xinogalos, S. (2013) --> ( BACCII [8] and BACCII++ [10]) - 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) - Marceau, G., Fisler, K., & Krishnamurthi, S. (2011) - Mazanek, S., Maier, S., & Minas, M. (2008) --> DIAGEN system [7], - Maier, S., & Volk, D. (2008) - Minas, M. (2007) - Minas, M. (2006) Voelter, M., & Solomatov, K. (2010) --> Eclipse Xtext [16] - Xinogalos, S. (2013) FLINT ([11], [12]), Fujaba/MOFLON - Minas, M. (2006) Voelter, M., & Solomatov, K. (2010) --> FURCAS [8] - 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], Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994) Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994) --> (Garlan & Miller, 1984). Miller, P., Pane, J., Meter, G., & Vorthmann, S. (1994) --> (Pane & Miller, 1993). } - Xinogalos, S. (2013) The Iconic Programmer [33] - Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014) --> (IPE) [4]. - 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 - Voelter, M., & Solomatov, K. (2010) --> MetaEdit+ [15] - Minas (2006) --> MetaEdit [9], Voelter, M., & Solomatov, K. (2010) --> Monticore [24] PASES - Shapiro, E., Collins, G., Johnson, L., & Ruttenberg, J. (1981) - Xinogalos, S. (2013) Progranimate ([36], [37]) - Xinogalos, S. (2013) ProGuide ([29], [30], [31]) - Xinogalos, S. (2013) RAPTOR ([18], [21], [22], [23]) Scratch (introduced 2006) - see section Voelter, M., & Solomatov, K. (2010) --> SDF [22] - 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 - Xinogalos, S. (2013) Visual Logic [19]
 * Albe** (lang:? ; who:? ; when?; where?)
 * B#** [iconic programming] (auto gen lang: Borland Pascal ; who:? ; when?; where: Nelson Mandela Metropolitan University)
 * BACCII and BACCII++** [iconic programming] (auto gen lang:Pascal, C, Fortan, Basic and C++; who?; when?; where: Texas Tech University)
 * CHASE**
 * DrRacket** (no reference info - need to search www)
 * DiaGen**
 * DiaMeta**
 * Eclipse Xtext**
 * FLINT** (lang:? ; who:? ; when?; where: Western Kentucky University)
 * FURCAS**
 * Gandalf** (lang:? ; who:?; when?; where:? )
 * { - GNOME -> macGnome, expanded to Genie environments (incls, macGnome), ACSE, progressively**
 * Genie** (lang: Pascal; who:? ; when?; where?)
 * GNOME** (lang: Pascal, FORTRAN, and LISP.; who:? ; when?; where?)
 * macGnome** (lang: ?; who:? ; when?; where?)
 * The Advanced Computing for Science Education (ACSE) project**
 * Iconic Programmer** (auto gen lang: pseudocode, Java, Turing and C/C++; who:? ; when?; where?)
 * Incremental Programming Environment**
 * //Intentional Domain Workbench (IDW//)** (lang:multiple, c#, )
 * MetaEdit+ [iconic editor]**
 * Monticore**
 * 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?)
 * ProGuide** [iconic programming] (lang:? ; who:? ; when?; where?)
 * RAPTOR** [iconic programming] (auto gen lang: ada, C#, C++, java ; who:? ; when?; where?)
 * SDF**
 * SICAS** [iconic programming - all 3] **, SICAS-COL, & H-SICAS** (auto gen lang: pseudo code, C, Java ; who:? ; when?; where?)
 * Visual Logic** (lang:Visual Basic ; who:? ; when?; where?)

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

..... 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 &amp; 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