Select Page

language: Scheme.Instructions:Prepare a Wikipedia-style article on Scheme programming
language. Include the following sections. Note that these questions are
intended to get you started, not an exhaustive list.OVERVIEW: What kind of language is it? Where and when was it
written? Why? What is/was the language primarily used for? What are its
most notable features? Did this language mark the first appearance of
some language feature? This section is a brief summary providing a
high-level summary of the language.HISTORY: Here you’ll discuss in more detail the origins of the
language. What were the primary design features? What were the goals?
What was the design process? What need was it intended to address? How
does this language differ from what came before it? What changes were
made from ancestor languages, if there were any? How widely was it used,
and in what areas? Is the language still in use? Why (or why not)? Were
parts of it adopted into other languages, or did it become a dead end?
Why? Basically talk about why someone thought this language was needed,
what went into it, and how it worked out. FEATURES: Describe the language in some detail. At the very least,
discuss what native data types are available, and what control
structures are available. Classify the language based on the various
criteria we’ve been discussing (imperative, object-oriented, functional,
declarative, etc). Is it strongly or weakly typed? Is typing static or
dynamic? How is iteration handled? What about selection? Or are they
(some languages don’t have iteration constructs)? What features does it
support? Where does the language really shine? What are its biggest
drawbacks? For this section, you can assume that your reader is
technically literate (e.g. an upper-level computer science
undergraduate) who’s not necessarily knowledgeable about this specific
language. If the language has some arcane features, explain them, but
it’s not necessary to explain what a compiler is. Evaluate the language on the criteria discussed in chapter 1 and the
material from Sebesta: How readable is the language? How writeable? How
reliable? Is it highly orthogonal? How expressive? How well does it
support abstraction? How does its execution speed compare to other
languages of the same era? Support your positions on these issues.EXAMPLES: Provide a sample of what code in the language looks like,
using some simple, well-known algorithm. Adding items in a list, sorting
a numeric list, or converting a string to all lower-case would be
examples. Provide something big enough to give a taste of what the
language is like. (If sorting a list is a one-line function call, you
might want to pick something else, or perhaps show how to
explicitly/manually sort a list instead.) If a language is strongly
associated with a particular IDE or development environment, you may
want to include a screenshot or two.FURTHER READING: Provide a list of resources you used in assembling
your report or where the reader could find more information about that
language. You should have at least 5 references other than your textbook
or other class materials. You may list no more than 1 Wikipedia article
in this section. You should link to other pages in the wiki as appropriate. You are
also responsible for making at least 2 entries on the Timeline page.——- PLEASE read the instructions carefully. If you need any more information, please let me know ASAP. Also make it WELL-ORGANIZED and CLEAR.For the “Evaluate the language on the criteria discussed in chapter 1” Part, you may find chapter one on this link: NO PLAGIARISM :(the attached file is a sample. might be helpful to do the work and organize it.

Unformatted Attachment Preview

Don't use plagiarized sources. Get Your Custom Essay on
Scheme: Wiki Project Paper
Just from $10/Page
Order Essay

APL is a dynamic programming language developed in the 1960s by Kenneth E.
Iverson. Iverson was hired by IBM in 1960, and in his famous 1962 book “A
Programming Language” is what APL stands for. It has influenced the development of
concept modeling, spreadsheets, computer math packages and functional programming
especially. APL was for mathematics with an emphasis on array processing. It has also
inspired some other programming languages such as J, K, Nial. By 2018, it is still used
for some applications as APL or APLX. Its central data type is multidimensional arrays
and it uses a large range of special graphic symbols to represent functions and
In the 1950s, a Harvard University professor created a mathematical notation
system that was useful for manipulating complex arrays of information. This professor
was Kenneth Iverson. APL was developed by Iverson at Harvard University starting in
1957, and it has published in his A Programming Language in 1962. In 1960, he began
work for IBM and he was working with Adin Falkoff, who was known for his work on the
APL programming language and systems for IBM, created APL based on the notation
that he developed. This notation has used inside IBM for short research report on
computer systems. APL was initially used at IBM to perform research on computer
systems. Thru the 1960s, acceptance of APL was limited since its unusual syntax which
includes many graphical symbols which was not be easily represented on computers at
that time. Therefore, stand-in keyword representations had to be used rather than the
actual symbols Iverson had intended. All of that has changed in the late 1960s, when
IBM has released a special typeball which could produce the special symbols used in
APL. In the early 1980s, IBM released an updated version of the programming language,
APL2, which introduced some enhancements including the concept of nested
multidimensional arrays. By 198, Iverson was no longer in control of APL and he was
left to join I P Sharp Associates, a competing developer of APL implementations who
had just released a branded version of the language it called Sharp APL which is a
product whose future development they were happy to have Iverson take over. IBM was
able to overcome I P Sharp in establishing their version of APL, APL2, as the industrystandard APL implementation. To this day, modern APL implementations typically cite
APL2 compatibility.
The development of the APL language has continued in the 21st century. Whilst
retaining compatibility with APL2, APLX Version 4 adds object-oriented language
extensions. Various implementations of APL by APLX, Dyalog include extensions for
object-oriented programming, support for .NET Framework, XML-array conversion
primitives, graphing, operating system interfaces, and lambda calculus expressions.
Data Handling
Handling with generalized array data without complicated programming is one of
APL’s strongest points. APL lets you define and name every single item of data, a list of
items, or table of them, or indeed arrays of more dimensions. The extra work caused by
such an instruction is handled by APL internally. It goes through the named arrays of
data, successively selecting and adding corresponding items, and it stops automatically
when it finds that the items are exhausted. Consequently, there’s usually no need for
counts, loops or any of the mechanisms traditionally used to control such operations in
other programming languages: the structure of the data effectively does this for you.
APL has a large range of functions, which includes a full range of high level
mathematical functions and a range of data manipulative functions that can do anything
from a simple sorting to a matrix inversion. APL also has operators which modify the
way in which functions are applied. This gives you a range of general purpose buildingblocks which can easily be combined in a very flexible and consistent manner. This
flexibility combined with APL’s ability to handle complicated data makes it a uniquely
powerful language.
APL Symbols
Most of the programming languages’ syntax is only limited with the ASCII
character set, as a result, most programming languages resort to compromises such as
using the asterisk symbol for multiply, and compound symbols such as <= to mean 'lessthan-or-equal' or ** to mean 'power'. Yet, APL is not limited to the ASCII characters; instead, it uses a range of symbols to represent its built-in functions. For many years, the use of special symbols by APL, and the special keyboards and display devices associated with them, was seen by many people as a big disadvantage of the language. Nowadays, with Unicode fonts and easy-to-use input methods, the special symbols are no longer such an issue. The meaning of many other symbols is not readily apparent to non-APL programmers, such as, ⍴: rho, used to return the shape of an array or reshape an array. ⌽: circle stile, reverses the order or an array or rotates an array in a multidimensional direction. ⍋ and ⍒: grade up and grade down, rearranges an array in descending or ascending order. Right to Left Evaluation Every APL expression is thus evaluated from right to left. So, “3 × 4 + 5” yields 27 using APL, not 17. This makes the use of parenthesis in many cases superfluous which adds to the expressional power of APL. Modularity While giving you some functions that are built in to the language, APL also lets you define your own. In fact, what you might normally think of as a 'program' consists, in APL, of a collection of user-written functions each of which does a part of the total task. These functions also able to call or exchange data between them. This has two very useful consequences. First, debugging is much easier since each function can be tested separately and errors are easy to isolate. Second, it imposes a natural top-down structure on your programs. APLX even takes APL further by having some concepts of OOP from other languages which allows you to define classes and to create and use instances of those classes in a natural APL style. You are even able to use classes written is C#, Visual Basic, Java or Ruby. Convenience APL is a convenient language for many reasons. First of all, it is concise since only a few lines of APL code can do a lot of work. Also, it is an essentially interactive and fully dynamic language. In addition, it has a very useful concept called the workspace. This is basically a collection of the data items, functions, and classes which you set up for doing a particular job. The workspace is in computer memory while you work, making everything you want immediately accessible. It can be saved in its entirety when you stop, and loaded back into memory next time you want to use it. Ease of Learning Even though APL is not the easiest language to learn, it is still a great language to start with since it makes you be able to do many simple things almost immediately. After you just started you can explore the language by discovering the functions and techniques. APL is totally consistent and does not have many arbitrary rules like many other languages by giving feedback. Productivity While many programming languages was designed to match the ways in that a computer works internally, APL was not. It was intended to help people define procedures for solving problems. This makes it efficient for people to use, though it may give the computer a little more work to do in the process. Advantages & Disadvantages APL is an interactive language that return answers immediately, it is easy to learn and use, if you make a mistake, easy to fix, coding in APL takes less time to write or debug than any other high-level language which makes it one of the most efficient languages. On the other hand, since it is an interpreter, APL runs slower than most compilers, yet it runs much faster than other interpreters such as Basic. The programs are much shorter, which makes APL be able to spend most of its time working on the problem, not interpreting the commands. You also get the advantages of an interpreter interactive writing and debugging. Functions are defined by name as in Forth or Logo, and you can define local variables, so it is easy to define new functions as you go along. APL is extremely powerful programming language for many reasons, such as it is recursive and self-modifying, with dynamic allocation of data storage. It makes calculations on entire arrays at once, not just element by element. This power has it's disadvantages, the primary one being memory limitations. Arrays require lots of memory. On a 512k Mac, the largest two-dimensional array of integers you can deal with is about 225 by 225, which isn't big enough for many problems. How Does APL Compare with other Languages? Since APL is a very concise language, it is normal for APL programs to have onefifth as many instructions as programs written in other languages, and one-tenth to onetwentieth the number of instruction lines. By being a symbolic language, those symbols replace multiple lines of code. Here is a simple comparison of some languages in the same era as a numerical sort in BASIC, FORTRAN, and APL: APL is very different from Fortran, C, Forth, or Lisp. The symbols, syntax, and natural algorithms all take some getting used to. So, we can say that it is a reliable language even if it has a little complicated writability, when you first began learning, and symbols makes it more readable language. EXAMPLES We are going to see two examples. First, here is a well-known program that finds all prime numbers from 1 to R: APL processes expressions from right to left, except when the order of evaluation is changed by using parentheses. 1. Select the highest number in desired range, and assign to R (e.g., 6; R equals scalar value: 6) 2. Generate vector of all integers 1 thru R (1, 2, 3, 4, 5, 6). [iota function] 3. Drop first element from the vector (drop: 1, retain: 2, 3, 4, 5, 6). [down arrow function] 4. Set R to the vector (R equals: 2, 3, 4, 5, 6). [left arrow function] 5. Generate "outer product" of R multiplied by R [i.e., the multiplication table for R by R]. [R circle dot × R function] (See right) 6. Build a vector the same length as R, but with 1 in each place where the corresponding number in R is in the table [true=1], and 0 where the corresponding number is not [false=0] (0, 0, 1, 0, 1). [set inclusion function] 7. Logically negate the values in the vector (change zeros to ones and ones to zeros) (1, 1, 0, 1, 0). [negation function] 8. Select the items in R, for which the corresponding element in vector from #7 is one (2, 3, 5). [slash function, evaluated now due to parentheses] Quicksort in APL Q←{1≥≢⍵:⍵ ⋄ S←{⍺⌿⍨⍺ ⍺⍺ ⍵} ⋄ ⍵((∇S))⍵⌷⍨?≢⍵} The pivot “⍵⌷⍨?≢⍵” is randomly chosen. ((∇S)) is a fork, selecting the parts of ⍵ which are less than the pivot, equal to the pivot, and greater than the pivot. The function is recursively applied to the first and the last of these three parts. ⎕io←0 ⋄ ⎕rl←7*5 ⎕←x←?13⍴20 3 2 19 16 11 4 18 17 9 17 7 3 Q x 1 2 3 3 4 7 9 11 16 17 17 18 19 The variant Q1 obtains by enclosing each of the three parts. Its result exhibits an interesting structure. The middle item of each triplet is the value of the pivot at each recursion. Since the pivot is randomly chosen, the result of Q1 can be different on the same argument, as illustrated below: The enlist of the result of Q1 x is the same as Q x, the sort of x: ∊ Q1 x 1 2 3 3 4 7 9 11 16 17 17 18 19 Q x 1 2 3 3 4 7 9 11 16 17 17 18 19 This note is meant to explore the workings of a classical algorithm. To actually sort data in Dyalog-compliant APL language engine, it is more convenient and more efficient to use {⍵[⍋⍵]}. FURTHER READING ... Purchase answer to see full attachment

Order your essay today and save 10% with the discount code ESSAYHSELP