GP (programming language)

This article has links to websites or programs outside of Scratch and Wikipedia. Remember to stay safe while using the internet, as we cannot guarantee the safety of other websites.

This article or section needs additional citations for verification. Its information may not be accurate. Editors can help by adding references. (August 2016)

This article or section may not have content matching Scratch Wiki editing standards. Please improve it according to Scratch Wiki:Guidelines and Scratch Wiki:Editing Conventions. (May 2020)

GP is a programming language in development that will enable more advanced programming with a Scratch-like design. GP stands for "Extensible Portable General purpose Block Language for Casual Programmers". Future goals for GP include making it run fast and on any platform. It also blurs the boundaries between block-based and textual programming and will have fewer usage restrictions than a learning language like Scratch, which must have them by design.^{[citation needed]}

One can try the GP Blocks editor by visiting this website.

GP is created by Jens Mönig, John Maloney and Yoshiki Oshima; all working for the UDG Labs, headed by Alan Kay and sponsored by SAP.

GP Beta Published in July 2017

• New GP Homepage and Youtube Videos of the GP Workshop 22.7.2017 at Scratch2017BDX with John Maloney, Jens Mönig and Yoshiki Oshima
  • https://gpblocks.org/
  • yt:FamVvpVhI98 (6 min)
  • yt:gsCoI1IhQjg (2:30 h)

'Outdated: The latest version of GP is a non-published pre-alpha for testing purposes, which was demoed at a hands-on-workshop on 08/15/2015 at the Scratch2015AMS.

Target of GP

As the name suggests, GP is built to be flexible and for general purpose use.^{[citation needed]} John said that the target user will be the casual programmer, who is not an expert, but knows enough programming to fulfill their own needs for "small spontaneous custom-made software". Besides that, GP and it's graphical development environment will be implemented in GP itself.

It is interesting what changes will come about from using GP. The transition from a novice Scratch programmer to professional programmer is always abundant. For more people, programming can be self-evident, such as reading and writing, even if this skill is not expert level. With Scratch, anyone can easily learn to program, but other languages such as GP could become a natural part of everyday life for many.

Alpha Workshop

The first workshop showing off the pre-alpha GP was held in the European Scratch Conference in Amsterdam. This workshop gave about 30 people experience with GP on their own laptop: Mac, PC, or Linux. The workshop ended up being overbooked.

At the workshop, participants could try out sample GP programs that came with the installation. Many participants felt a feeling of success and enthusiasm, so they looked forward to the full release of GP. The makers of GP also rejoiced at this good news. Below is an image of the European Scratch Conference 2015 workshop about GP. Many videos of the presentation of GP at Scratch2015AMS can be found in the section Videos.

Background

Roots & History: "Parent" programming languages of GP

GP was inspired by Scratch (developed by the team of Mitch Resnik in the 2000s at MIT), including older foundations like the "Scratch-mother" Logo (developed by the team of Seymour Papert in the 70's at MIT) and the "Scratch father" Squeak-Smalltalk + E-Toys + Morphic (developed by a team of Alan Kay in the 90's including John Maloney first at Apple then at Disney and later as an open source movement. Squeak itself is based on the first Smalltalk-Version Alans team made, that has its roots in 70's-80's at XeroX-PARC: Yes, at that research department, where Steve Jobs and Bill Gates are said to have "stolen" the ideas for Mac and Windows, when paying a visit to the Smalltalk team.).

GP's "nearest relative" is the "Scratch child" Snap! (developed by Jens Mönig and Brian Harvey in the 2010's and was originally named BYOB).

Development Team

GP is a result of cooperation between John Maloney, who has been 11-years the chief developer for Scratch, and Jens Mönig, who has worked for many years on block-based programming languages (starting with his hobby project Chirp in 2008, continuing with BYOB and later Snap!). The GP team is reinforced by other Squeak-Smalltalk developers of UDG Labs: Yoshiki Oshima (official team member), and Bert Freudenberg (did already an experimental GP-VM port to JavaScript, like he did a Squeak-VM implementation in JavaScript that means that there's also Scratch 1.4 running in a browser).

John and Jens are Squeak-Smalltalk professionals, and although John had worked for many years directly in the Squeak development team, Jens had only recently returned because of his enthusiasm for Scratch, also abandoning his position as Lawyer Chancery. After working at Scratch 1.x and BYOB at the same code base in Squeak Smalltalk, both John and Jens had left Smalltalk for a while. John implemented Scratch 2.0 in Flash Action Script, and Jens chose Javascript to implement Snap! (BYOB 4.0 renamed) the successor of BYOB 3.0. Both implementing language choices had the same reason: Scratch 2.0 and Snap! should run without Installation in a Webbrowser. And both language choices, that spat the until then common codebase of Scratch and Snap!, had advantages and disadvantages: Flash Action Script was established but already somewhat "history" whereas Javascript was not established enough and somewhat "future".

Implementation

When beginning to create GP, the developers used Squeak for a code base. Later, they switched to C for speed benefits.

The developer's final target is to have the Virtual Machine (VM), that interprets the GP block-code, be implemented in GP itself and be easily and quickly transferable to any hardware/operation-system. They will use the same technique that is used in Squeak:

Squeak-VM structure as a blueprint for the GP-VM

Squeak contains a Smalltalk-to-C compiler that is used to compile Smalltalk-Sourcecode to C source code. Additionally, it contains a Virtual Machine (VM), an interpreter that is needed to run Squeak on certain platforms. Both, the C-Compiler and the Squeak-VM (and many other tools, like the development environment of Squeak), are written in Smalltalk as a part of Squeak. Squeak can be interpreted by the VM using Squeak itself, and the VM can be changed, extended and debugged in the Squeak development environment itself (while Squeak is running on that VM). An interesting side-effect is that you can run Squeak on a Squeak VM that runs on a Squeak VM that runs on a Squeak VM and so... but, at the end, there must be a VM sitting on the real platform. How can this real platform VM be built? Very easily: You use that "Smalltalk to C"-compiler mentioned above to compile the VM to C. So making the C-Sourcecode of a VM is only compiling, besides a few so-called "primitives" you have to program manually in C to build a base that connects it to the target platform. To make an executable VM you can then just use a C-Compiler, which is available for nearly every Hardware/Operating-System. Porting Squeak to all platforms is very fast and easy and that portability of Squeak was also the reason,^{[citation needed]} that Scratch 1.x exists on PC, Mac, Linux and many other Platforms. The Smalltalk-Objectmemory of Squeak (the so-called "image", a big file that is loaded into the VM) is bit-compatible for all Squeak-VMs on any platform. In the details, there is a bit more, like "Slang", "change.set" etc. but we only want to draw a rough picture here.

Platform Independence

GP will be the first block based language that is implemented in itself (a process known as bootstrapping). This recursive implementation will be used as proof that it can be used for serious projects and, as the author thinks, so it could also be used to implement a future Version of Scratch. The main benefit of having the "GP VM" and a "GP to C" compiler implemented in GP will be the fast transfer of GP to any platform. This means that GP can be used on all platforms, including web browsers and maybe even without an operating system. At the 2015 AMS workshop, alpha GP implementations were seen on Windows, Mac and Linux. Additionally, a C-based GP-VM and a Javascript-based GP-VM are said to already be experimentally implemented.

Videos

• yt:FamVvpVhI98 Scratch2017BDX - GP Workshop part1 - 22.7.2017 (John Maloney, Jens Mönig, Brian Harvey and others)
• yt:gsCoI1IhQjg Scratch2017BDX - GP Workshop part2 - 22.7.2017
• yt:Cnvoz_5_YiI - 4:58 - GP Introduction lecture by John Maloney
• https://vimeo.com/140660699 - 3:31min - official Conference Video Impression "SCRATCH Amsterdam 2015 John, Jens, Yoshiki workshop"
• https://vimeo.com/136418503 - 0:54min - Jens & John starting the "hands-on" phase
• yt:gikl43V9ohI - 2:31 - Jens showing how GP is blurring the boundaries between block-based and textual programming
• yt:QAB7eWAMO1U - 4:01 - John demoing
• yt:qAaKo_ZVDF4 - 2:34 - Jens & John demoing the "additional blocks option feature"
• yt:ob9Ki9roNFM - 1:41 - John demoing the speed feature of GP
• yt:VJIZVJyAxgk - 4:17 - Jens presenting "Nestable Sprites for Scratch" (also feature of GP, older demo)

Screenshots

• 
• 
• 
• 
• 
• 
• 
• 
• 
• 
• 
•