Community hub
0 subscribers7 pages, 0 posts
Recent from talks
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Welcome to the community hub built to collect knowledge and have discussions related to SiMPLE.
Nothing was collected or created yet.
SiMPLE
View on Wikipediafrom Wikipedia
 | This article needs additional citations for verification. (August 2017) |
 | This article may need to be rewritten to comply with Wikipedia's quality standards. (May 2020) |
SiMPLE (a recursive acronym for SiMPLE Modular Programming Language & Environment) is a programming development system that was created to provide easy programming capabilities for everybody, especially non-professionals.
Following the death of SiMPLE creator Bob Bishop, the SiMPLE Codeworks website and forums are now offline, however they can be accessed via the internet archive.[1]
History
[edit]In 1995, Bob Bishop and Rich Whicker, (both former Apple Computer Engineers) decided to create a new programming language that would be easy enough for everyone to understand and use. (They felt that other existing languages such as C++ and their environments were far too complicated for beginners.) The programming language that they created was called SiMPLE.
Inspiration
[edit]SiMPLE is vaguely reminiscent of the AppleSoft BASIC programming language that exists on Apple II computers. However, SiMPLE is not (and was never intended to be) merely a "clone" of Applesoft BASIC. It was merely "inspired" by it. There are many features of Applesoft that needed to be improved. For example, Applesoft was an interpreted language, and so it ran somewhat slowly (even for a 1MHz processor). SiMPLE, on the other hand, compiles into an executable (.EXE) file. So it produces programs that run faster, and those programs can even run on computers that don't have SiMPLE installed.
Another difference between the two languages is in the use of line numbers. Applesoft required them; SiMPLE doesn't even use them. (Instead of typing program statements onto the black Apple screen, SiMPLE uses a text editor.) Furthermore the "FOR-NEXT" loops in Applesoft have been replaced by "Do-Loop" instructions in SiMPLE. (But they function in much the same way).
However, aside from a few differences in their outward appearances, writing programs in SiMPLE has a similar "feel" to what one experienced when writing programs in Applesoft. For example, when using SiMPLE in command-line mode, a program is run by simply typing the word "RUN" on a black screen (just as was done on the Apple!)
Versions
[edit]"Simple" is a generic term for three slightly different versions of the language: Micro-SiMPLE, Pro-SiMPLE, and Ultra-SiMPLE.
- Micro-SiMPLE is an introductory programming language designed to use only 4 keywords: Call, Set, If, and Goto. An example of a Micro-SiMPLE program listing (and a snapshot of the output display it generates) is shown in the figure below:
- Pro-SiMPLE is the DOS-based version of SiMPLE requiring the use of only 23 keywords. Its graphics capabilities are limited to only 16 colors with a resolution of only 640 x 480 pixels. Its sound capabilities are limited to simple "beeps" through the computer's built-in speaker.
- Ultra-SiMPLE is the Windows-based version of SiMPLE. It utilizes exactly the same 23 keywords as Pro-SiMPLE. Its graphics capabilities allow millions of colors in whatever resolution the user's system provides. Its sound capabilities allow the user to play any type of media file (including movies).
Prior to 2011 June, SiMPLE was available only for 32-bit computers. Since then, a newer version (which can be used on either 32-bit computers or 64-bit computers) is now the standard version. In this newer version of SiMPLE, the terms "Pro-SiMPLE" and "Ultra-SiMPLE" have been replaced by the terms "Dos-SiMPLE" and "Win-SiMPLE" respectively. However, in an effort to provide as much backward compatibility as possible, both of those obsolete terms ("Ultra-SiMPLE" and "Pro-SiMPLE") are still accepted as being legitimate compiler directives.
In addition, the design of the newer version of SiMPLE is more "streamlined". The old original version of SiMPLE was designed to be used only in the closed environment of Command-line mode. (The "Drag & Drop" mode of operation wasn't added until many years later.) Consequently the old SiMPLE's Command-line mode required dozens of commands (to support such capabilities as deleting source listings, renaming files, creating new project folders, etc.). The newer version of SiMPLE integrates the SiMPLE environment with the Windows environment so that many of the old SiMPLE's Command-line commands are no longer necessary and have been eliminated.
Modes of operation
[edit]SiMPLE programs can be run in either "Drag & Drop" mode (intended primarily for beginning programmers), or in "Command-Line" mode (for more advanced programmers):
- In "Drag & Drop" mode, the user simply creates a program source listing (a text document), and then runs that program by dragging the source listing document onto a special icon.
- In "Command-Line" mode, the user creates and runs programs by typing commands and listings into a DOS window.
Keywords used by SiMPLE
[edit]And Break Call
Common Continue Display
Do Else End
Float (or Decimal) Float2 (or Decimal2) Goto
If Int (or Whole) Int2 (or Whole2)
Loop Or Return
Set Step Task
Text To
SiMPLE will run on Windows 95 and newer systems.
An example program is like the following:
Do n = 240 To 25
stars @
rocket (320, 2*n, -3) @
ufo (295+n, 25, -8) @
delay (20)
Loop n
explode (320, 35) @
quit
Append G: toys
which will give you this output: https://web.archive.org/web/20150412025158/http://www.simplecodeworks.com/example.gif[2]
References
[edit]- ^ "SiMPLE -- The Computer Programming Language For Kids!". 2015-08-04. Archived from the original on 4 August 2015. Retrieved 2024-11-07.
- ^ "SiMPLE -- the Computer Programming Language for Kids!". Archived from the original on 2012-08-18. Retrieved 2012-08-24.
External links
[edit]- SiMPLE is available as a free download from the [dead link] SiMPLE Codeworks website.
- SiMPLE website and forums (archive.org).
SiMPLE
View on Grokipediafrom Grokipedia
SiMPLE, a recursive acronym for SiMPLE Modular Programming Language & Environment, is an interactive programming language and development system designed primarily for beginners, including children, to facilitate easy experimentation with coding concepts similar to those in early Apple II BASIC dialects.[1] Developed by Bob Bishop and Rich Whicker, pioneering Apple II programmers and former Apple employees (Bishop as employee number 187, hired in 1978), SiMPLE was created starting in 1995 as a response to the decline of accessible, interactive programming environments on modern platforms like Windows PCs, where languages such as C++ lacked the immediate feedback and simplicity of Applesoft BASIC.[2]
The language emphasizes modularity and interactivity, allowing users to write, test, and execute code in real-time while supporting advanced features like high-resolution graphics and sophisticated sound generation, inspired by Bishop's earlier work on Apple II graphics and sound.[1] Unlike more complex modern languages, SiMPLE enables the creation of self-executing modules alongside its interpretive mode, bridging educational accessibility with practical application on post-Apple II hardware.[1] Originally distributed as a free download via the SiMPLE Codeworks website, the project became unavailable following Bishop's death on September 28, 2014, though archived versions persist for historical access.[1][3]
This single-line program displays "Hello World!" in a window or full-screen mode.[3]
For more dynamic applications, SiMPLE supports graphics and animation through modular building blocks. A representative example is an animation of a rocket launching through stars, encountering a UFO, and ending in an explosion. This uses a
The
Introduction
Overview and Purpose
SiMPLE is a recursive acronym standing for SiMPLE Modular Programming Language & Environment. It is a programming development system designed to facilitate easy programming experiences for users without professional expertise.[3] Developed by Bob Bishop and Rich Whicker in 1995, the core purpose of SiMPLE centers on making programming accessible by prioritizing simplicity, modularity, and user-friendliness, allowing individuals to create functional software without the steep learning curves associated with more complex languages. This system aims to democratize coding by providing an intuitive environment where basic programs can be developed and executed efficiently. SiMPLE reflects early efforts to bridge the gap between technical barriers and everyday computing needs, inspired by the interactive style of Applesoft BASIC on the Apple II and targeted at Windows PCs.[1][4][3] SiMPLE targets a broad audience, including children, non-professionals, and anyone intimidated by intricate programming paradigms such as those in C++. By emphasizing ease of use, it seeks to foster creativity and computational thinking among beginners, enabling them to explore programming as an approachable tool rather than an elite skill.[3]Design Philosophy
SiMPLE was developed with the primary goal of democratizing programming by making it accessible to non-professionals and beginners, eschewing the complexity of languages like C++ that demand extensive technical expertise. Its creators emphasized a design that prioritizes intuitive syntax and minimal barriers to entry, allowing users to focus on problem-solving rather than syntactic intricacies. This educational orientation positions SiMPLE as a tool for learning core programming concepts without overwhelming novices, fostering an environment where programming feels approachable and engaging.[3] Central to SiMPLE's philosophy is ease of use through simplified constructs and user-friendly interfaces, such as text-based editing and drag-and-drop execution modes that eliminate traditional command-line hurdles. The language employs a limited keyword set with simple, English-like instructions to promote clarity and reduce cognitive load, while structured control flows like Do-Loop replace cumbersome loops from earlier paradigms. This modular architecture enables tailored versions suited to different skill levels, starting with basic subsets for absolute beginners and scaling to fuller feature sets for intermediate users, all while maintaining consistency in core syntax.[3][5] Unlike its interpreted predecessors, SiMPLE adopts compilation to generate standalone executables, enhancing performance for faster execution and enabling programs to run independently without requiring the development environment. This shift addresses key limitations of slower, platform-dependent interpreted languages, providing portability and efficiency that align with modern computing needs while preserving an intuitive feel inspired by early accessible dialects like AppleSoft BASIC. By compiling to native binaries, SiMPLE ensures that educational programs can be shared and run seamlessly across compatible systems, reinforcing its commitment to practical usability.[3]History
Origins and Development
SiMPLE was developed starting in 1995 by Bob Bishop and Rich Whicker, both former engineers at Apple Computer, as an effort to revive accessible programming in an era dominated by increasingly complex languages like C++.[2] The project stemmed from their frustration with the loss of user-friendly, interactive programming environments that had characterized early personal computers, such as the Apple II, and aimed to provide beginner-friendly tools that allowed non-professionals, including children, to easily create software leveraging modern hardware capabilities like enhanced graphics and sound.[1][2] Initial design work focused on combining the simplicity of legacy BASIC dialects with modular compilation to produce standalone executables, addressing the limitations of interpreted languages while maintaining an approachable syntax.[2] Over the following years, Bishop and Whicker refined SiMPLE into a complete development system, including a compiler, editor, and libraries, which was released as free software for Windows platforms through SiMPLE Codeworks.[1] This marked the language's initial availability to the public, emphasizing its role as a tool for experimentation and education rather than professional software engineering.[2] Following Bob Bishop's death in September 2014, the SiMPLE Codeworks website and associated forums went offline, though archived versions remain accessible via the Internet Archive for historical reference.[6][1]Inspiration from AppleSoft BASIC
SiMPLE draws inspiration from the accessible programming environment of AppleSoft BASIC, the dialect of BASIC provided with Apple II computers, which empowered users to easily create their own software without advanced technical knowledge. This influence manifests in SiMPLE's design philosophy, positioning it as a modern reincarnation of the Apple II era's emphasis on simplicity and user-driven development, though it is an original language rather than a direct adaptation.[3][7] The language shares a familiar "feel" with classic BASIC implementations, including interactive execution via straightforward commands on a command-line interface, evoking the black-screen sessions typical of AppleSoft BASIC programming. SiMPLE retains an intuitive, English-like syntax that prioritizes readability, avoiding heavy use of special characters like colons, semicolons, or braces to make source code easy to understand at a glance. This approach echoes the straightforward command style of AppleSoft BASIC, allowing beginners to focus on logic rather than syntax intricacies.[3][7] To address limitations of interpreted languages like AppleSoft BASIC, SiMPLE introduces compilation to standalone .EXE files, enabling faster execution speeds and portability across Windows systems without requiring the interpreter to be installed. Programs are developed using standard text editors, promoting a more flexible workflow compared to direct input in an integrated environment. Additionally, SiMPLE incorporates modular "building blocks" for reusable code components, extending the simplicity of BASIC while adding structure for larger projects. These enhancements maintain the core familiarity of AppleSoft BASIC while adapting it for contemporary use.[3]Versions and Evolution
SiMPLE was developed starting in 1994 by Bob Bishop, a former Apple engineer, in collaboration with Rich Whicker, another ex-Apple employee.[2][1] The project aimed to recreate the interactive, beginner-friendly experience of Applesoft BASIC on modern Windows hardware, addressing the lack of simple programming environments after the Apple II era.[1] Initial design focused on modularity and ease of use, with no line numbers required and support for compiling programs into standalone .exe files for faster execution, unlike purely interpretive BASIC dialects.[2] It replaced Applesoft's FOR-NEXT loops with Do-Loop constructs while maintaining a similar programming feel. SiMPLE incorporated Windows capabilities, including high-resolution graphics in millions of colors and playback of sound files.[2] Programs could be run interactively via a command-line "RUN" mode or by dragging text files onto an executable icon, simplifying development without complex setup.[2] The language was distributed as a free Windows download through the SiMPLE Codeworks website until Bishop's death on September 28, 2014, after which the site became unavailable, though archived copies of some materials persist.[1] No distinct versions such as Micro-SiMPLE, Pro-SiMPLE, Dos-SiMPLE, Ultra-SiMPLE, or Win-SiMPLE are documented in available sources.Core Features
Modes of Operation
SiMPLE operates in two primary modes designed to accommodate users of varying experience levels, allowing flexibility in how programs are executed and managed. The Drag & Drop mode enables beginners to run programs without interacting with a command line; users can copy a source listing to the Windows Clipboard, paste it into a new text document using any text editor such as Notepad, and drop that document onto the SiMPLE icon to compile and execute it automatically.[3] This approach simplifies the process, eliminating the need for manual commands and making it ideal for novice programmers or educational settings where ease of use is prioritized.[3] In contrast, the Command-Line mode caters to more advanced users who prefer direct control over program development and execution. This mode involves using traditional command-line methods to edit listings, run programs, and manage files.[3] It provides greater functionality for iterative development but requires familiarity with command syntax, making it suitable for experienced developers handling complex projects.[3] When running a program in either mode, SiMPLE compiles the source code into a fast executable (.exe) file using a full C++ compiler behind the scenes. Programs can run in a window or full-screen mode and do not require SiMPLE to be installed on the target machine for execution.[3]Keywords and Syntax
SiMPLE's keyword set is deliberately minimal to promote accessibility, drawing from BASIC-like structures but streamlined for non-experts. The syntax emphasizes readability and eschews line numbers, allowing statements to flow naturally in plain text files editable with any standard editor. Programs begin execution from the top, with examples including basic output likeDisplay "Hello World!" and loops such as Do n = 240 To 25 ... Loop n.[5] Arithmetic and logical operations use intuitive operators.[3]
Control flow in SiMPLE includes iteration via the Do-Loop structure, as shown in examples where a variable iterates over a range, executing statements like module calls inside the loop.[5]
Modularity is a cornerstone of SiMPLE's design, facilitated by features that support subroutine-like functionality. Programs incorporate pre-written modules (e.g., "rocket", "ufo") called with @ prefix and parameters, such as @ rocket (320, 2*n, -3). The Append keyword integrates external libraries (e.g., Append G: toys), allowing programmers to incorporate pre-built functions seamlessly. Users can create and share their own modules, promoting code reuse.[3] Detailed syntax rules and full keyword lists are not comprehensively documented in available sources following the project's discontinuation in 2014.
Capabilities
Graphics and Sound Support
SiMPLE provides built-in support for graphics and sound through modular building blocks, enabling users to create visual animations and audio effects with minimal complexity, which is particularly valuable for educational programming tasks such as developing simple games and interactive demonstrations.[5] Graphics capabilities allow for engaging outputs like plotted shapes and simple animations using modular functions, with support for windowed or full-screen modes providing control over screen output. Representative functions includerocket(x, y, speed) for rendering and animating a launching rocket, ufo(x, y, speed) for depicting a moving unidentified flying object, and explode(x, y) for generating an explosion effect at specified coordinates, often combined in loops to produce interactive sequences like space-themed simulations.[5]
Sound support includes generating basic tones, sound effects, and music programs via modules, as well as capabilities for reading audio input devices such as a microphone and processing with tools like Fast Fourier Transforms.[3]
Integration of graphics and sound is achieved through core keywords and timing controls, such as Display for outputting text or visuals to the screen and delay(milliseconds) for synchronizing animations with pauses, ensuring smooth playback without overwhelming beginners with threading or event loops. For instance, a program might alternate calls to drawing functions with delays to mimic motion, optionally appending sound effects from loaded modules. These features underscore SiMPLE's educational value, empowering non-expert users—especially students—to build multimedia applications like games or animations rapidly, fostering creativity while abstracting low-level details and promoting modular design principles with reusable "building blocks" similar to LEGO.[5]
Compilation and Execution
SiMPLE programs are written as plain text files containing source code listings, which are then compiled into standalone executable (.EXE) files for execution. The compilation process employs a SiMPLE translator to convert the source code into equivalent C++ code, followed by compilation using a full C++ compiler that integrates SiMPLE's system libraries and any appended libraries as building blocks. This approach contrasts with interpreted languages like AppleSoft BASIC, enabling the generation of efficient, native executables rather than relying on runtime interpretation.[3] Once compiled, SiMPLE executables offer significant performance advantages, executing faster than equivalent programs in interpreted environments due to the absence of an interpreter overhead during runtime. These standalone .EXE files can run on any compatible Windows system without the need for the SiMPLE environment to be installed, facilitating easy distribution and independent operation. Programs may display in a standard window or full-screen mode, providing complete control over screen output.[3] Execution of SiMPLE programs supports two primary methods tailored to different user levels. In the beginner-friendly drag-and-drop mode, users copy the source listing to the clipboard, paste it into a text file using any editor like Notepad, and drop the file onto the SiMPLE icon, which automatically compiles and launches the program. For advanced users, a command-line mode allows direct input of commands and listings into a DOS window to compile and run code, including the use of a "RUN" directive to execute programs from within the environment. SiMPLE also allows optional integration of C++ statements for advanced functionality.[3]Examples and Usage
Sample Programs
SiMPLE uses English-like commands resembling classic BASIC for readability. A simple introductory program demonstrates text output:Display "Hello World!"
Display "Hello World!"
Do...Loop for iteration, module calls for visuals (denoted by @), and delay for timing.
Do n = 240 To 25
stars
@ rocket (320, 2*n, -3)
@ ufo (295+n, 25, -8)
@ delay (20)
Loop n
explode (320, 35)
@ quit
Append G: toys
Do n = 240 To 25
stars
@ rocket (320, 2*n, -3)
@ ufo (295+n, 25, -8)
@ delay (20)
Loop n
explode (320, 35)
@ quit
Append G: toys
@ symbol precedes calls to pre-built modules like rocket, ufo, and delay. Append G: toys saves the code to a library module. This example leverages modules for rapid development of animations.[3]
Common patterns in SiMPLE include loops with Do...Loop for iteration and module calls for graphics and effects, maintaining simplicity while enabling engaging programs.[3]