Snap! (programming language) GudangMovies21 Rebahinxxi LK21

Snap! (formerly Build Your Own Blocks) is a free block-based educational graphical programming language and online community. Snap allows students to explore, create, and remix interactive animations, games, stories, and more, while learning about mathematical and computational ideas. While inspired by Scratch, Snap! has many advanced features. The Snap! editor, and programs created in it, are web applications that run in the browser (like Scratch) without requiring installation. It is built on top of Morphic.js, a Morphic GUI, written by Jens Mönig as 'middle layer' between Snap! itself and 'bare' JavaScript.




User interface


In Snap!, the screen is organized in three resizable columns containing five regions: the block group selector (top of left column), the blocks palette (left column), the main area (middle column), and the stage area (top of right column) with the sprite selector (also called the sprite corral) showing sprite thumbnails below it.
In the interactively resizable stage area are shown the graphical results of the scripts running in the script area and/or interactively double-clicked individual blocks in any palette. Individual blocks can be dragged from the palette onto the scripts area to be associated with the selected sprite.

Snap!'s blocks are divided into eight groups: Motion, Looks, Sound, Pen, Control, Sensing, Operators, and Variables. The layout of these groups in the block group selector is shown in the table below.
The central area can show scripts, costumes/backdrops, or sounds associated with the selected sprite. What that area shows depends on the selected tab.




Features


The most important features that Snap! offers, but Scratch does not, include:

Expressions using anonymous functions, represented by a block inside a gray ring, having one or more empty slot(s)/argument(s) that are filled by a "higher order function" (the one that is calling the anonymous one). (Their computer-science theoretical basis is first class functions, which in turn have lambda calculus as their even more abstract and mathematical foundation)
Lists that are first class (including lists of lists/arrays)
First class sprites (or in other words, prototype-based programming)
"Hyperblocks": functions whose natural domain is scalars (text or numbers), extended to accept lists as inputs and apply the underlying function to the scalars in the list or a sublist
Nestable sprites
Codification of Snap! programs to text languages such as Python, JavaScript, C, etc.
Metaprogramming, reflection, and macros




Mascot



Alonzo, the mascot of Snap!, bears the name of Alonzo Church, the inventor of a model of computation in which a universal function, represented by lambda, can create any function behavior by calling it on itself in various combinations. The mascot is a modified version of Gobo from Scratch, with permission of the Scratch Team. Because Alonzo Church's work is called lambda calculus, the mascot's hair is shaped as the Greek letter lambda.




Special-purpose blocks (libraries)


Extended sets of blocks can be found in Snap! libraries, such as the 'streams' library that enables one to make the complete, infinite Fibonacci sequence, for example, using the special blocks ('stream', 'show stream', 'tail of stream', and 'map ( ) over stream' block) from the library.
Many other libraries are available, such as the 'list utilities' library, the 'words, sentences' library, the 'iterations' library, the 'animation' library, the 'frequency distribution' library, the 'audio computation' library, the 'bar charts' library, the 'world map' library, the 'colors and crayons' library, the 'strings and multi-line input' library, the 'parallelization' library, etc. for other special purposes.




Limitations


While the software itself has little restraints, it does have some limitations.
These include as follows:

No native cloud variables
10 megabyte file cap for uploading (Snap! Cloud only)
Users have to manually enable Javascript when loading a project




History


The web-based Snap! and older desktop-based BYOB were both developed by Jens Mönig for Windows, OS X and Linux with design ideas and documentation provided by Brian Harvey from University of California, Berkeley and have been used to teach "The Beauty and Joy of Computing" introductory course in computer science (CS) for non-CS-major students. Jens was a member of the Scratch Team before creating Snap!. BYOB is still available for downloading.




License


The source code of Snap! is GNU Affero General Public License (AGPL) licensed and is hosted on GitHub. The earlier, desktop-based 3.x version's code is available under a license that allows modification for only non-commercial uses and can be downloaded from the UC Berkeley website or CNET's download.com and TechTracker download page.




Platforms


Snap! runs on the major web-browsers on Windows, iOS, MacOS and Linux devices.
Supported web-browsers such as

Firefox
Chrome (and most Chromium based browsers.)
Opera GX
Microsoft Edge
Safari




Implementation


Snap! is built on top of Morphic.js, a Morphic GUI, which serves as 'middle layer' between Snap! itself and 'bare' JavaScript. It uses an HTML5 Canvas application programming interface (API).
All things visible in Snap! are morphs themselves, i.e. all buttons, sliders, dialog boxes, menus, entry fields, text rendering, blinking cursors etc. are created with morphic.js rather than using HTML DOM elements. Snap! caches the shapes of sprites so the sprite doesn't have to be re-drawn onto a new Canvas element every time the mouse moves over its bounding box. It does not cache blocks, however. Instead it manages the insides of C-shaped blocks through the morphic "holes" mechanism.
All user interaction is triggered by events, which are passed on from the root element "the world" to its submorphs. Dropping a morph causes it to become embedded in a new 'owner' ('parent') morph. In Morphic the preferred way to run an animation is to register it with the World by adding it to the World's animation queue. The World steps each registered animation once per display cycle independently of the Morphic stepping mechanism.




Recognition


Snap! has been recognized by the Logo Foundation, and reviewed in an online magazine for programmers. As of December 2014, 100 New York City (NYC) high schools introduced University of California, Berkeley's “Beauty and Joy of Computing” as a new AP Computer Science Principles course, using Snap!. Jens and Brian received the National Technology Leadership Summit (NTLS) 2020 Educational Leadership Award for lifetime achievement based in part on Snap!.




Notes






References






External links


Official website

SNAP (programming language) GudangMovies21 Rebahinxxi LK21

SNAP, short for Stylized, Natural, Procedural, is an educational programming language designed by Michael Barnett while working at RCA in 1968 and later used at Columbia University to teach programming in the humanities. It is an imperative programming language, like many languages of the 1960s, but was deliberately verbose, attempting to look more like conversational English in the fashion of HyperText and later languages. Unlike other educational languages of the era, SNAP was not intended to be interactive and was designed to be programmed via punch cards. To save cards, multiple period-separated statements could be written on every card, so the resulting code often looked like a single paragraph.




History


In 1964, Michael Barnett joined RCA's newly-formed Graphic Systems Division which had been formed to commercialize the photo-typesetting technology they had licensed from Rudolf Hell. Originally known as Digiset, RCA sold the systems under the name Videocomp. About 50 Videocomp systems were sold over its history.
In 1964 and 1965, Barnett developed a page description language known as PAGE-1 to write programs that resulted in Videocomp output, similar to the way the later PostScript language produces pages on laser printers. One of the early applications of this system was to publish Social Sciences Index by the H. W. Wilson Company.
This led to Barnett's interest in the social sciences and his increasing interactions with H. W. Wilson and Columbia University's humanities department. Barnett took a position at H. W. Wilson in 1969. He had also started to teach courses on library automation at the Columbia School of Library Service, and in 1970, computer programming in the humanities. He joined the Columbia faculty full-time in 1975.
The first version of SNAP was written by William Ruhsam of RCA in FORTRAN IV for the RCA Spectra 70, although a version for the IBM 360 in OS-360 was also produced. some time in 1967 or 1968. The language generated a fair amount of comment, especially in the early 1970s, but appears to have had little direct influence on later languages.




Description






= General concepts

=
SNAP allowed multiple statements to be placed on a single line, and used the period as the statement separator. This produced code that looked like English sentences, and was generally organized into blocks that looked like paragraphs.
SNAP did not use line numbers for editing, and instead used in-code labels for branch targets, as was the case in FORTRAN. In SNAP, a label could be placed anywhere in the code by surrounding the textual name in parentheses like (FIRST LABEL). Labels were not separate statements, and did not require a period after them.
Variables names could contain spaces, which is relatively rare for programming languages even today. Variables could hold strings or numbers, but different syntax was used to assign each one. For numbers, a simple syntax was used, SET I TO 1. SET was also used to perform mathematical operations, like SET I TO THE PRODUCT OF 10 AND J. A simpler syntax was offered for the more common increment and decrement operations, INCREASE M BY 1. or DECREASE M BY 2.
For strings, a longer syntax was typically used, CALL "THIS IS A STRING" THE NEWSTRING. Substrings were accessed using a HyperTalk-like syntax by referring to the ordinal position, for instance, CALL THE J-TH CHARACTER OF NEWSTRING THE NEWCHAR., or CALL THE M-TH THROUGH N-TH CHARACTERS OF THE INPUT THE OUTPUT.
SNAP also offered array-like collections known as "lists". Internally, these were stored as comma-delimited strings. Most of the string-related commands could be used to work with these by adding THE ... LIST. to the end. For instance, one could read a series of cards using READ THE CARD LIST., which would read each card as a separate string into the CARD variable. Items within a list were accessed using the same ordinal syntax, for instance PRINT THE 5-TH CARD, or COPY "NEW STRING" AND CALL IT THE 7-TH CARD. Lists of numbers could be created using SET THE NUMBER LIST TO 1,2,3,4,5.
String variables can also be used as lists, or arrays. This was accomplished using the same ordinal position syntax but referring to the variable name and not the CHARACTER. For instance, CALL "HELLO" THE 1-ST PART. CALL "WORLD" THE 2-ND PART. would create an array called PART with two strings in it.
An important point of the SNAP system is that the CALL statement is not static; it does not define KEY as the character at location J when it is encountered in the code, but when any following code accesses KEY. For instance, SET J TO 1. PRINT KEY. INCREASE J BY 1. PRINT KEY. would result in two different strings being printed. In this fashion, CALL has more in common with the BASIC programming language's DEF FN user-defined functions than it does with the SET statement, which is static.
A static copy of a string could be made by COPY OLDSTRING, AND CALL IT NEWSTRING. Other string functions included APPEND one string TO another string., OVERWRITE string-expression ON THE M-TH [AND SUBSEQUENT] CHARACTER[S] OF string-name., DELETE THE M-TH [THROUGH N-TH] CHARACTER[S] OF string-name. and INSERT string-expression (BEFORE|AFTER) THE M-TH CHARACTER OF string-name.
Unconditional branches were called using CONTINUE, for instance, CONTINUE WITH THE FIRST LABEL. There was also the alternative form REPEAT THE FIRST LABEL.. There was no difference between them, although the context of the surrounding code generally meant one form or the other was more natural to read. One could also refer to the start of the program with CONTINUE FROM THE BEGINNING. "As follows" could be used to refer to the next statement, CONTINUE AS FOLLOWS., which could be used to clarify branches.
Conditional branches used an if–then(–else) structure:

As in most languages, the OTHERWISE section was optional. Note the use of AND to make a compound statement within the then section, offering a block structure. For string comparisons, one used IS or the optional IS THE SAME AS.
SNAP included a number of other keywords that had no behaviour of their own that were added simply for syntactic sugar. Among them were THE, A, FROM which the programmer could add in many locations to make the syntax more readable. Typical uses included READ A RECORD and REPEAT FROM THE LOOP START.




= Statements

=
From A Natural Language. Variables and expressions are in italic. Optional forms are separated by vertical bars, |. Braces surround optional items, while angle-brackets surround required items that have more than one form. value refers to a numeric constant or variable, string to a quote-delimited string constant or string variable.
Flow control:

(string constant)
defines a program label
[WITH|FROM]
jump to the named label, the start of the program, or continue on to the next statement
IF value|string [THE SAME AS] value|string expression[,AND expression...] [, OTHERWISE expression[,AND expression...]]
if-then-else construct, with any number of expressions within the then and else sections
-string comparisons allowed substring tests like IS THE value[-TH] AND [SUBSEQUENT|PRECEDENT] CHARACTERS OF string
-numeric comparisons included EQUAL TO, LESS THAN, GREATER THAN, UNEQUAL TO, GREATER THAN OR EQUAL TO, LESS THAN OR EQUAL TO
-the end-of-file could be tested with IF THE INPUT IS EXHAUSTED.
TERMINATE
stops the program
EXECUTE
runs the program. Was to be expanded to allow execution to start at a given label, but was not implemented in the versions described in the references
Mathematics:

SET numeric variable TO value - assigns a value to a numeric variable
SET numeric variable TO THE [SUM|DIFFERENCE|PRODUCT|QUOTIENT|REMAINDER|CEILING|GREATER|LESSER] OF value AND value
perform mathematical functions with two operands
INCREASE variable BY value - simplified notation for addition
DECREASE variable BY value - ...and subtraction
String manipulation:

CALL string [THE] string variable - create a string function
[FORM A] COPY [OF] string AND CALL IT [THE] string variable - copy a string from one variable to another
APPEND string TO string variable - append a string variable with another string
LINK string TO string - appends the first string to the second, but does not copy it, future changes to the second string will be tracked as in a CALL
DELETE THE value[-TH] [THROUGH value [-TH]] CHARACTER[S] OF string variable - trim a string from the selected character on, or a given range
OVERWRITE string ON THE value[-TH] [AND SUBSEQUENT|PRECEDENT] CHARACTER[S] OF string variable - replaces one character of a string with another, or that character and those running forward or backward from the selected position.
Input/output related:

SELECT number [FOR ]
used to select a device for other input/output operations
READ [A|THE] string variable
reads a single punch card
REQUEST [A|THE] string variable
asks for user input from the console
FETCH [A|THE] string variable
reads one record from the most recently SELECTed device
PRINT [A|THE] variable
sends output to the line printer
TYPE [A|THE] variable
sends output to the console
PUNCH [A|THE] variable
sends output to the card punch
PERFORATE [A|THE] variable
sends output to paper tape
WRITE [A|THE] variable
sends data to the last SELECTed device
Others:

CONTROL various
a temporary command used to control the language as new features were added
RESERVE SPACE FOR number similar to the DIM statement in BASIC, sets aside a specified amount of memory to hold a string, or a given number of strings from a list. Using RESERVE avoided memory operations as the string or list was built and improved performance




Example


Here is the largest example of a practical program given in SNAP, which reads strings from cards and then prints out the individual words found in them:

For clarity, the following version simply spaces out the statements onto separate lines and adds appropriate whitespace:

The program READs a single card and assigns the string data found on it to the variable named RECORD. It then sets up two pointers, I and J. A function called KEY is CALLed that returns the Jth character of RECORD.
It then examines the Jth character to see if it is a word-breaking character or off the end of the string. If neither of these are true, it moves to the next character and tries again. This loop continues until it finds a word-breaking character or falls off the end of the card at the 80th character. If it has hit the end of the card, it jumps to the OUTPUT ACTION.
If it does find a word-breaking character, it jumps to BACKUP, which backs up one character to skip the punctuation it just examined. It then naturally falls through to the OUTPUT ACTION. That code prints out the string between the starting position in I to the current position in J.
If we have not reached the end of the card, move J forward by two characters to skip over the punctuation we previously avoided and move the pointer to the start of the next (potential) word. Then set I to J to position our next word's starting position from this point, and return to LOOP START. If we are at the end of the card, start the entire program over and read another card.




Notes






References






= Citations

=




= Bibliography

=
Barnett, Michael; Ruhsam, William (May 1969). Harrison Fuller (ed.). SNAP: an experiment in natural language programming. AFIPS '69, Spring Joint Conference. Boston. pp. 75–87. doi:10.1145/1476793.1476815.
Barnett, Michael; Ruhsam, William (August 1968). "A Natural Language Programming System for Text Processing". IEEE Transactions on Engineering Writing and Speech. 11 (2): 45–52. doi:10.1109/TEWS.1968.4322334. JSTOR 30199362. S2CID 51670564.
Barnett, Michael (March 1970). "SNAP: A Programming Language for Humanists". Computers and the Humanities. 4 (4): 225–240. doi:10.1007/BF02404375. JSTOR 30199362.




= Further reading

=
Barnett, Michael (1969). Computer Programming in English. Harcourt, Brace & World. OL 5754250M.

Kata Kunci Pencarian:

• Scratch (bahasa pemrograman)
• Haskell
• Snap! (programming language)
• SNAP (programming language)
• Scratch (programming language)
• List of programming languages
• Snap
• Snap! (disambiguation)
• List of programming languages by type
• Visual programming language
• Snapchat
• Prototype-based programming

Snap Language™

Snap! (programming language) - Wikipedia

_CHX3pyKqzMxvwq7ARnQ_lLTsS03pzya4sodNVEbO8g6sxNvd3vsw5dea1y-t ...

Snap! (programming language) - Alchetron, the free social encyclopedia

Category:Snap! (programming language) - Wikimedia Commons

Category:Snap! (programming language) - Wikimedia Commons

About Snap Language™

Logic programming in Snap! - AI in Snap! - Snap! Forums

Open - Snap Programming Language Logo Clipart (#2215598) - PinClipart

Snap! (programming language) - Scratch Wiki

Snap! (programming language) - Scratch Wiki

Snap! (programming language) - Scratch Wiki

snap programming language

Daftar Isi

• Snap! Build Your Own Blocks
• Snap! Build Your Own Blocks
• Snap! (programming language) - Wikipedia
• Snap! Build Your Own Blocks
• The Snap! Programming Language. For the Intro to Computer ...
• SNAP (programming language) - Wikipedia
• Snap! Build Your Own Blocks - University of California, Berkeley
• Snap! - Snap! Wiki
• Snap! (programming language) - Wikiwand
• Snap! Build Your Own Blocks

Snap! Build Your Own Blocks

Snap! is a blocks-based programming language built by UC Berkeley and used by hundreds of thousands of programmers around the world.

Snap! Build Your Own Blocks

Snap! is a visual programming language that allows users to create their own blocks and build interactive programs.

Snap! (programming language) - Wikipedia

(formerly Build Your Own Blocks) is a free block-based educational graphical programming language and online community. Snap allows students to explore, create, and remix interactive animations, games, stories, and more, while learning about mathematical and …

Snap! Build Your Own Blocks

Snap! is more than a programming language. It's a fun way to learn coding for people of all ages. Snap! makes coding interesting for beginners and experts alike. Snap!'s block-based approach simplifies complicated ideas, making them fun and easy to understand.

The Snap! Programming Language. For the Intro to Computer ...

Jul 12, 2015 · For the Intro to Computer Science class, we will be teaching a programming language called Snap! It is a browser-based graphical programming language that lets students create animations and...

SNAP (programming language) - Wikipedia

SNAP, short for Stylized, Natural, Procedural, is an educational programming language designed by Michael Barnett while working at RCA in 1968 and later used at Columbia University to teach programming in the humanities.

Snap! Build Your Own Blocks - University of California, Berkeley

Snap! is a broadly inviting programming language for kids and adults that’s also a platform for serious study of computer science. Take a look at some examples or check out the reference manual to learn more about it, or head straight into the editor and start programming right away!

Snap! - Snap! Wiki

Feb 10, 2025 · (programming language) which is licensed under CC BY-SA 4.0. Snap ! (Build Your Own Blocks) is an extended reimplementation of Scratch featuring first class procedures, first class lists, and first class sprites with inheritance.

Snap! (programming language) - Wikiwand

(formerly Build Your Own Blocks) is a free block-based educational graphical programming language and online community. Snap allows students to explore, create, and remix interactive animations, games, stories, and more, while learning about mathematical and …

Snap! Build Your Own Blocks

Snap! (formerly BYOB) is a visual, drag-and-drop programming language. It is an extended reimplementation of Scratch (a project of the Lifelong Kindergarten Group at the MIT Media Lab) that allows you to Build Your Own Blocks. It also features first class [1] lists, first class procedures, and first class continuations [2].