Other textual and visual languages

Programming languages, both textual and visual, can range in scope from domain-specific languages to general-purpose languages. Additionally, programming languages are designed for users of varying experience, from professional software developers to complete novices.
This page lists a number of languages, and briefly describes them in terms of their scalability and scrutability.
TEXTUAL LANGUAGES
SQL – A query language for retrieving information from relational databases. In terms of scalability, this language is highly constrained, only applicable to the database domain. It has a reasonable learning curve, with complex queries requiring considerable experience, but simple queries can be created and understood by novice users, giving it good scrutability.
MATLAB – This is a textual language for use by mathematicians, scientists and engineers for data manipulation and mathematical modelling purposes. It includes many general-purpose concepts that allow it to extend beyond these specific scientific tasks for good scalability, but still requires considerable learning time for a novice user, particularly for the advanced data manipulation processes, lowering its scrutability.

AppleScript – This is Apple’s bespoke scripting language for automating tasks on Mac machines. It attempts to lower the barrier to programming by emulating natural language where possible. On its own it allows for basic data processing, with the potential for expansion through additional scripting libraries, and its full scope is reliant on Mac applications including ‘scripting dictionaries’ of objects and operations on them. Allowing the language to be extended through ‘scripting additions’ gives it high scalability, although it is still not ideally suited to standalone applications.
Its natural language metaphor reduces the learning curve associated with high-level textual languages, but even this natural syntax needs to be learned, and syntactical errors are still easily made. However, its scrutability still greatly surpasses that of  other high-level programming languages.
 
C++ – This is perhaps the most widely used general-purpose programming language, with no limit to applications that can be developed, representing the peak of scalability. This comes at the cost of a steep learning curve to an end-user with a very low scrutability, and it exemplifies the compromise that has to be made between the two measures.
 
VISUAL LANGUAGES (VARIOUS TYPES)

LabVIEW – National Instruments LabVIEW is a dataflow visual programming language for professional engineers and scientists to design and code engineering systems. It has a large number of components, or “Virtual Instruments”, which connect together to produce potentially highly complex diagrams. Its scope is limited to that of engineering systems, and is not suitable for general-purpose programming, and thus is low in both scalability and scrutability. This does not detract from the fitness-for-purpose of LabVIEW, which is ideally suited to the domain professionals who have learned its syntax.
Kodu – Kodu is a visual language that supports children in learning programming through allowing them to develop their own games. The language is highly simplified, yet maintains high expressive power in its domain. In Kodu, users specify game-specific rules involving ‘sensors’ and ‘actuators’ to determine how characters will behave. Its low learning barrier and simplicity makes it highly scrutable to even non-programmers, but it cannot be used or expanded beyond the 3D game environment in which it is integrated, giving it low scalability.
Prograph – Prograph is another dataflow programming language, representing specifications as “executable flowcharts”. It attempts to allow general-purpose programming, unlike the majority of other visual languages that are applicable to specific domains. In Prograph, objects, methods, classes and control flow are all representable in the flowchart paradigm. Our experience of Prograph shows it to be a powerful means of specifying a wide variety of applications with a high degree of scalability, but apart from the reduction in syntax errors, suffers from the same scrutability issues as high-level textual programs.
VISUAL LANGUAGES (BLOCK-BASED)

Scratch – Scratch is a block-based visual language designed to teach children programming concepts through allowing them to create animations. The block language visualises code constructs such as loops, actions, and variables as jigsaw puzzle-like blocks that can be intuitively connected together to represent program flow. Numerous user evaluations have shown this metaphor to be highly scrutable to the novice user, and its inclusion of various textual programming constructs give it reasonable scalability in addition, although it is by no means a general-purpose language, and offers limited support to extend available blocks.
 
Alice – Alice is another block language designed for educational purposes, allowing users (primarily young people learning programming) to develop their own 3D graphical environments. Alice is built on the Python programming language, and uses visual tiles, which are dragged, dropped, and modified with specific parameters to specify how a 3D object looks and behaves. As with most other visual languages, it is specific to the domain of 3D graphics, but covers a large number of textual programming concepts. It is thus similar in scalability and scrutability to that of Scratch, covering various general-purpose programming concepts while providing no mechanism to extend beyond its original domain.
Fabcode – Fabcode is a novel block language that uses the same block library as Scratch, giving it a highly similar appearance and identical interaction mechanism. However, although it encourages computational thinking by novice users, its primary purpose is a domain-specific language for designing artefacts for digital fabrication. Its blocks are restricted to shapes, and 3D operations on these shapes. Thus, it is easily learnable and comprehensible by novice users (high scrutability) but cannot be used for programming outwith this highly constrained domain (low scalability).