Programming Models and Techniques Quiz

EUP Models

• EUP Models presentation by Thiago Rocha Silva, Associate Professor at SDU.
• Presentation for EUD - Fall 2024.
• Contact email: [email protected]

Programming Models

• A programming model is a set of abstractions that facilitates the development of computer programs.
• Programming models can be low-code or not, domain-specific or general-purpose.
• The programming model perspective emphasizes common techniques for writing, reading, and executing programs.

Key Low-Code Techniques

• Visual programming languages (VPLs): Utilize visual components arranged on a canvas for program creation.
• Programming by demonstration (PBD): Users demonstrate the desired behavior, and the system records the actions as a program.
• Programming by natural language (PBNL): Users provide natural language instructions, and the system generates the corresponding program.
• Rule-based: Programs are created based on defined rules.
• Text-based: Programs are created through textual input.

Low-Code Users and Techniques

• The presentation includes a diagram illustrating low-code users (citizen developers, semi-developers, professional developers) and the programming languages they use (visual programming language, domain-specific language, and general-purpose programming language).

Building Blocks

• Code canvas: visually represents code (e.g., as a flow graph).
• Palette: provides components for drag-and-drop selection.
• Text box: holds natural language text for code search, description, or generation.
• Player: controls functions like capture, replay, pause, and step for code execution.
• Stage: displays the effects of code execution.
• Configuration pane: allows users to customize components graphically (via checkboxes, sliders), or textually (e.g., typing formulas).

Visual Programming Languages

• Visual programming languages (VPLs) enable direct manipulation of visual representations to create programs.
• Two prominent VPL representations: boxes-and-arrows (like BPMN diagrams), and interlocking puzzle pieces (like Scratch).

Boxes-and-arrows

• Describes a visual programming paradigm using boxes and arrows.
• Boxes represent actions or steps, and arrows represent the flow between actions/steps.
• Presented with an example of a booking process in an airline system.

VPL Strengths

• Easy to read using domain-specific notation already familiar to the user.
• More unambiguous than other methods (like text-based PBD or PBNL).
• Helps programmers control programs, thus reducing errors. This is built into the structure of programming, which prevents many common code errors.
• Rules out syntax and even simple type errors by construction.

VPL Weaknesses

• Not always self-explanatory, requiring user training.
• Visual notations may consume a significant amount of screen space.
• Design may require configuration panes or modular language constructs.
• Large palettes may hinder discoverability by users

VPL Compared to Textual Languages

• VPLs are typically co-dependent on their visual programming environment, hindering tools like code diffing, search, and use of external tools.
• Mitigation strategy: Backing VPLs with a textual domain-specific language.

Programming by Demonstration (PBD)

• Programming by demonstration lets users create programs by performing the desired actions via mouse and keyboard, and subsequently recording the actions.
• This can then create automatic programs that reproduce the actions of the user.

PBD: Strengths

• Direct interaction with software applications.
• Well-suited for citizen developers with no programming experience.
• More tangible than other methods (e.g. programs in different paradigms) and creates a clear flow of control and data.

PBD: Weaknesses

• Difficult to correctly generalize user intent.
• Can be very brittle when the graphical application changes.
• Overly-specific demonstrations are difficult to understand as they may contain extraneous steps resulting in overly large programs.

Programming by Natural Language (PBNL)

• Natural language text (typed or spoken) is translated into a program by the system using natural language processing (NLP).
• Can optionally be rendered using a VPL.
• Can employ a controlled natural language (a controlled subset of natural language) which disambuguates possible meanings within the language in order to produce a clearer program intent.

PBNL: Strengths

• Low code complexity.
• Well-suited for users with limited programming knowledge (citizen developers).
• Less need for complex programming constructs.
• Recent NLP advancements from large language models improve PBNL performance.

PBNL: Weaknesses

• Generated programs can be flawed (often due to human ambiguities).
• NLP technology involved can be imperfect and is prone to misinterpreting context.
• Results can lead to more complex code that may be unwieldy.
• Encouraging simpler text input can resolve many of these difficulties.

Comparing Key Low-Code Techniques

• A comparison table presents the methods used for writing, reading, and executing code for visual programming languages, programming by demonstration, and programming by natural language. Data includes complexity and ease of use.

Rule-Based

• A programming method focusing on enabling end users to customize the behavior of smart devices, IoT (Internet of Things) systems, and Ambient Intelligence (AmI) applications.
• It emphasizes personalization and encompasses hardware and software aspects.

Trigger-Action Programming (TAP)

• TAP supports the management and execution of automations.
• It relies on users defining events/conditions and desired actions.
• Triggers can relate to users' emotional/physical states, environment, and available devices/applications.
• Trigger information comes from sensors, applications, and services.
• Triggers can be composed of events and/or conditions.

TAP: Issues with multiple automation rules

• Rule conflicts or rule prevention: execution of one rule might block a trigger for another.
• Unexpected rule chains: running one rule could trigger another unintended or unanticipated rule.

Scenario-Based Specifications

• Using scenarios for software requirements is common.
• Scenarios using natural language enhance user-friendliness.
• Behaviour-Driven Development (BDD) can create runnable specifications, balancing natural language with formalism.

BDD Scenarios: Gherkin Syntax

• A dedicated syntax for defining BDD (Behaviour-Driven Development) scenarios (using keywords like Given, When, Then).

A Domain-Specific Language (DSL) for BDD

• DSL provides a syntax for describing BDD scenarios.
• State machines can describe BDD scenarios.
• The DSL can handle declarative and imperative features.

A DSL for BDD Scenarios

• A dedicated Domain Specific Language (DSL) for BDD scenarios based on state machines provides both declarative and imperative features.

Further Reading

• Provides a list of recommended articles and publications for in-depth study on the topics covered. Includes specific authors, article titles, and venues.