The Developer’s Guide to Visual Programming Languages
Traducciones al EspañolEstamos traduciendo nuestros guías y tutoriales al Español. Es posible que usted esté viendo una traducción generada automáticamente. Estamos trabajando con traductores profesionales para verificar las traducciones de nuestro sitio web. Este proyecto es un trabajo en curso.
Most programming languages today are text-based, which means you type code that tells the computer what you want done. There are many paradigms for such code, with procedural, object-oriented, imperative, functional, and declarative being the most common. These paradigms all have one thing in common: the coder must think in an abstract way to turn human concepts into something the computer understands.
Many people want to create applications, but lack the abstract thinking skills developers possess. The dream development environment makes it possible to put blocks together in a visual manner that’s easy to follow. The result would simply work, no coding skills needed. Visual Programming Languages (VPLs) do this. They make it possible to write a certain subclass of an application using little or no code, depending on the language and the application goal. You use a graphical environment to place blocks representing coding actions together to create a program.
VPLs aren’t just new forms-based programming languages, such as that found in modern computer languages like Visual Basic and C#. You aren’t simply adding components together on a form and then writing the code to make those components functional later. The IDE writes some of the code in the background for you, but you’re still working with a text-based programming language. With a VPL, the application consists of blocks that you put together, making this an entirely different sort of graphical programming language. The main focus of VPLs is education. It’s easier to use a VPL to teach the underpinnings of programming than to use a text-based language. VPLs are also used for multimedia, web applications, video games, automation, and robotics. In short, these languages are highly targeted. Here’s a list of common VPLs and the kind of development they’re use for:
- Scratch: Is an multimedia environment that puts the fun into programming. The goal is to do something like tell a story or animate a character. The blocks do things, like have an animated character walk a certain number of steps, turn in a certain direction, or say something (in a speech bubble). It helps you learn to think creatively, work collaboratively, and reason systematically.
- Bubble: Everyone seems to need a web page today, but not everyone knows how to write web code, even developers. Bubble offers a no-code approach to creating certain types of web applications, including: dashboards, Customer Relationship Management (CRM), social networks, marketplaces, and Software as a Service (SaaS) apps. This environment is definitely graphical, but learning to navigate it takes time, and you definitely need some preexisting idea of how web pages work.
- Kodu: Imagine writing a game application for the Xbox using nothing more than a game controller. Of the entries in this list, Kodu comes the closest to achieving the dream goal, if only to write simple games. This language is reminiscent of expert system languages of the past, such as VP-Expert, which rely on rule-based development. This technique replaces the need for learning game programming languages (C# or C++) in the Xbox environment.
- miniBloq: Used for device programming in the sense of automation (e.g. Arduino) and robotics (e.g. Multiplo and Root). Although it first appears these devices would only have educational purposes, they also have industrial applications (among others). This is one case where a VPL makes the transition from education (or fun) to a real world application.
- mBlock: Python is a relatively easy to learn text-based language, but even it can prove challenging. Using mBlock makes learning Python to perform robotics, data science, and AI programming one step easier. You can easily transition between the graphical interface and the text-based interface without having one interfere with the other. In addition, you can write applications using either interface. For example, you can write part of the application using the graphical interface, then write another part using pure Python code.
A new methodology has to provide some sort of payback or else it quickly disappears from the scene. VPLs are an important addition to the computing world because they:
- Make it easier for educators to teach programming
- Allow visually-oriented people to express ideas
- Reduce time required to generate a demonstration or simulation
- Define a method to create applications without programming
- Lessen the impact of specific kinds of development on system functionality
- Improve certain kinds of creative exercises
VPLs aren’t a panacea for eluding development time and costs. They provide a specific kind of environment that supports only certain kinds of development. With this in mind, they do have disadvantages because they:
- Insulate the developer from the hardware, making good programming decisions more difficult
- Require greater platform resource usage
- Execute more slowly than other environments
- Are available only on graphical platforms
- Have limited functionality
- Requirement to add custom modules (when allowed)
- Reduced potential for a development job
Languages are for humans, not for computers. When looking at a computer, the only language the hardware speaks is machine code. An intermediary such as a compiler or interpreter is needed to turn a human user’s ideas into machine code. Text-based programming languages have their origins in math and other forms of abstract thinking. Developers use flow charts to describe a mathematical process, modeling real-world environments to create applications, all of which is a very abstract methodology.
However, today we don’t always need to use abstractions to interact with the hardware. For example, Internet of Things (IoT) devices present a situation where the person using the device really doesn’t care about math. They simply want to create a schedule to control their house’s thermostat. In this case, you can create a language that allows a human to express what temperature to use at what time. Then rely on the underlying interpreter to convert that information into machine code for the device.
VPLs allow another kind of language to express human thought, using concrete goals for a specific environment. Abstractions provide flexibility, concretions provide understandability. In fact, the two are related because concretions are real-world instances of something that implements the functionality described by an abstraction. Consequently, the need for a VPL is expressed in the idea of making an abstraction concrete, so that everyone understands it. However, it comes with the caveat that the result is now less flexible than before, because you’re looking at specific instances.
Every programming language and environment must meet certain requirements, or else an interaction between humans and computers is impossible. These requirements determine the development of any programming language. After all, the goal of programming languages is to translate human thoughts into machine code. Ultimately, VPLs must produce machine code or they don’t work. With this in mind, here is a very brief overview of the steps used to design programming languages:
- A language must be agreed upon for human input that is eventually translated into machine code. The lexical characteristics of this language describe words that belong together to form tokens.
- The tokens are broken down into a parse tree that begins the process of turning the language into machine language codes.
- The parse tree is verified for any anomalies.
- The individual parse entries are converted into machine code. In many cases, this step is broken down into several sub-steps. These include the use of intermediate code that is transported between systems, and then separately compiled into machine code on a specific platform.
Many people associate language with words formed using letters. This is an incorrect assumption. A language can be anything you make it. The Chinese use ideograms and the ancient Egyptians used hieroglyphics to communicate without using individual letters. It’s possible that one day someone creates a compiler based on emojis. The idea of creating a VPL based on graphical symbols isn’t new, it’s simply another way to build a compiler.
The most important takeaway from this guide is that VPLs present a vision of the future. One where anyone can communicate ideas to a computer in a manner that doesn’t require programming. The use of text-based languages continues because they present the most flexible and feature-rich method of communicating with a computer. However, the essential concepts used by VPLs to perform their work remain the same as those used for text-based languages. What language the human user chooses doesn’t matter to the computer, as long as it receives machine code to perform its work.
You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.
This page was originally published on