Hello,programming
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: https://track4.mixtape.moe/ozwwcx.pdfPLEASE: NO PLAGIARISM :(the attached file is a sample. might be helpful to do the work and organize it.
smaple.docx
Unformatted Attachment Preview
APL
OVERVIEW
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
operators.
HISTORY
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.
Extensions
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.
FEATURES
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.
Power
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
https://en.wikipedia.org/wiki/APL_(programming_language)
http://www.users.cloud9.net/~bradmcc/APL.html
http://microapl.com/APL/introduction_chapter1.html
https://www.dyalog.com/dyalog/index.htm
https://www.dyalog.com/blog/2014/12/quicksort-in-apl/
http://courses.cs.vt.edu/~cs5314/Lang-PaperPresentation/Papers/HoldPapers/APL.pdf
https://www.whoishostingthis.com/resources/apl/
http://www.computerhistory.org/atchm/the-apl-programming-language-sourcecode/
http://www.vaxman.de/publications/apl_slides.pdf
...
Purchase answer to see full
attachment
