crystal report export to pdf without viewer c# : Delete pages of pdf reader software SDK dll winforms windows asp.net web forms Applescript1-part494

English
thefirstcharacterofeverywordwhosestyleisbold
Japanese
French
le premier caractµere de tous les mots dont style est gras
Professional
fwords j style == bold g.character[1]
Figure 5. Illustrationofdialects.
run on multiple preemptive threads on Mac OS X. Script
objects can also be sent to another machine,making mobile
code possible.
3.4 Parsing andInternationalization
The AppleScript parser integrates the terminology of ap-
plications with its built-in language constructs. For ex-
ample, when targeting the Microsoft Excel
TM
application,
spreadsheet terms are known bythe parser—nouns like
cell
and
formula
, and verbs like
recalculate
. The statement
tell application ‘‘ Excel ’’
introduces a block in which
the Excel terminology is available. The terminology can
contain names that are formed from multiple words; this
means that the lexical analyzer must be able to recognize
multiple words as a single logical identifier. As a result,
lexical analysis depends upon the state of the parser: on en-
tering a tell block, the lexical analysis tables are modified
with new token definitions. The tables are reset when the
parser reaches the end ofthe block. This approach increases
flexibility but makes parsing more difficult. I believe the
added complexity in lexing/parsing makes it more difficult
for users to write scripts.
Apple also required that AppleScript, like most of its
other products, support localization, so that scripts could be
read andwritten in languages otherthanEnglish. Scripts are
stored in a language-independent internal representation. A
dialectdefinesapresentationfortheinternallanguage.Di-
alects contain lexing and parsing tables, and printing rou-
tines.Ascriptcanbepresentedusinganydialect—so ascript
written using the English dialect can be viewed in Japanese.
Examples are given in Figure 5. For complete localization,
the application terminologies must also include entries for
multiple languages. Apple developed dialects for Japanese
andFrench. A “professional”dialect, whichresembles Java,
was created but not released.
There are numerous difficulties in parsinga programming
language that resembles a natural language. For example,
Japanese does not have explicit separation between words.
This is not a problem for language keywords and names
from the terminology, but special conventions were required
to recognize user-defined identifiers. Other languages have
complexconjugation and agreement rules thatare difficultto
implement. Nonetheless, the internal representation of Ap-
pleScript andthe terminology resources contain information
to support these features.
The AppleScript parser was created using Yacc [29], a
popular LALR parser generator. Poor error messages are a
common problem with LALR parsing [1]. I wrote a tool
that produces somewhat better error messages by including
asimplified version of the follow set at the point where the
error occurred. The follow set was simplified by replacing
some common sets of symbols (like binary operators) with
ageneric name, so that the error message would be “ex-
pected binary operator”instead of a list of every binary op-
erator symbol. Despite these improvements, obscure error
messages continue to be one of the biggest impediments to
using AppleScript.
3.5 AppleScript Implementation
During the design of AppleScript in mid-1991, we consid-
ered building AppleScript on top of an existing language
or runtime. We evaluated Macintosh Common Lisp (MCL),
Franz Lisp, and Smalltalk systems from ParcPlace and Dig-
italk. These were all good systems, but were not suitable as
afoundation for AppleScript for the same reason: there was
not sufficient separation between the development environ-
ment and the runtime environment. Separating development
from execution is useful because it a allows compiled script
to be executed in a limited runtime environment with low
overhead. The full environment would be needed only when
compiling ordebugging a script.
Instead,we developed ourownruntime andcompiler.The
runtime includes a garbage collector and byte-code inter-
preter. The compiler and runtime were loaded separately to
minimize memory footprint.
One AppleScript T-shirt had the slogan “We don’t patch
outtheuniverse”.Manyprojects atApple wereimplemented
by “patching”: installing new functions in place of kernel
operating system functions. The operating system had no
protection mechanisms, so any function could be patched.
Patches typically had to be installed in a particular order,or
else they would not function. In addition, a bug in a patch
could cause havoc for a wide range of applications.
AppleScript did not patch any operating system func-
tions.Instead the systemwas carefullypackagedas a thread-
safe QuickTime component. QuickTime components are a
lightweight dynamic library mechanism introduced by the
QuickTime team. Only one copy of the AppleScript com-
piler and runtime was loaded and shared by all applica-
tions on a machine. The careful packaging is one of the rea-
sons AppleScript was able to continue running unchanged
through numerous operating system upgrades,and even onto
the PowerPC.
1-11
Delete pages of pdf reader - software SDK dll:C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use C# Code to Extract PDF Pages, Copy Pages from One PDF File and Paste into Others
www.rasteredge.com
Delete pages of pdf reader - software SDK dll:VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Detailed VB.NET Guide for Extracting Pages from Microsoft PDF Doc
www.rasteredge.com
Integers
Lists
Strings
Compile
GetSource
Display
Data
CoerceFromDesc
CoerceToDesc
Execute
Storage
Format
Load
Store
ExecuteEvent
Text
Objects
Commands
Script
Text 
Data
Key: Interface 
Scripts
Figure 6. OverviewoftheOpenScriptingAPI.
The AppleScript runtime is implemented inC++.The en-
tire system,including dialects, is 118K lines ofcode,includ-
ing comments and header files. Compiling the entire Apple-
Script runtime took over an hour on the machines used by
the development team. After the alpha milestone, the devel-
opment team was not allowed to produce official builds for
the testing team. Instead, the code had to be checked in and
built by a separate group on a clean development environ-
ment.This process typically took 8 to 12 hours, because the
process was not fully automated, so there was sometimes a
significant lagbetweenidentifying abug anddelivering afix
to the quality assurance team. This was a significant source
offrustration for the overall team.
4. Script Management
Open Scripting Architecture (OSA) allows any application
to manipulate and execute scripts [11]. The Open Scripting
API is centered around the notion of ascript, as shown in
Figure 6. A script is either a data value or a program. Many
ofthe routines in the APIare for translating between scripts
and various external formats.
Compile
parses script text and
creates a script object, while
GetSource
translates a script
object back into human-readable script text.
Display
trans-
lates a value into a printed representation. When applied to
astring, e.g.
‘‘Gustav’’
,
GetSource
returns a program lit-
eral
‘‘Gustav’’
,while
Display
just returns the text
Gustav
.
CoerceFromDesc
and
CoerceToDesc
convert AppleScript
values to and from Apple Eventdescriptors.
Load
and
Store
convert to/from compact binary byte-streams that can be in-
cluded in a file.
The
Execute
functionruns a scriptina context.A context
is a script that contains bindings for global variables.
At its simplest, the script management API supports the
construction of a basic script editor that can save scripts as
stand-alone script applications.
The OSA API does not include support for debugging,
although this was frequently discussed by the team. How-
ever,other companies have worked around this problem and
created effective debugging tools (Section6.3).
4.1 Embedding
The script management API also supports attaching scripts
to objects in an existing application.Suchscripts canbe trig-
gered during normal use of the application. This usage is
supported by the
ExecuteEvent
function, which takes as in-
put a script andan Apple Event.The event is interpreted as a
method call to the script. The corresponding method decla-
ration inthe script is invoked.Inthis way an application can
pass Apple Events to scripts that are attached to application
objects.
Embedded scripts allow default application behavior to
be customized,extended,or evenreplaced. Forexample,the
Finder can run a script whenever a file is added to a folder,
or an email package can run a script when new mail is re-
ceived.Scripts can also be attached to new or existing menu
items to add new functionality to an application. By em-
bedding a universal scripting languages, application devel-
opers do not need to build proprietary scripting languages,
and users do not need to learn multiple languages. Users
can also access multiple applications from a single script.
AppleScript demonstrated the idea that a single scripting
language could be used for all applications, while allowing
application-specific behaviors to be incorporated so that the
language was specialized for use in each application.
Embedding can also be used to create entire applications.
In this case there is no predefined application structure to
which scripts are attached. Instead, the user builds the ap-
plicationobjects —for data and user interfaces, and then at-
taches scripts tothem.Severalapplicationdevelopment tools
based on AppleScript are described in Section 6.
4.2 Multiple Scripting Languages
Halfway through the development of AppleScript, Apple
management decided to allow third-party scripting lan-
guages to be used in addition to AppleScript. A new API
formanagingscripts andscripting language runtime engines
had to be designed and implemented. These changes con-
tributed to delays in shipping AppleScript. However, they
also led to a more robust architecture for embedding.
In February of 1992, just before the first AppleScript al-
pha release, Dave Winerconvinced Apple management that
having one scripting language would not be good for the
Macintosh. At that time, Dave Winer was an experienced
Macintosh developer, having createdone of the first outliner
applications,ThinkTank.Inthe early1990s,Dave created an
alternative scripting system, called Frontier. Before I joined
the project, Apple had discussed the possibility of buying
Frontier and using it instead of creating its own language.
For some reason the deal fell through, but Dave continued
developing Frontier. Apple does not like to take business
away from developers, so when Dave complained that the
impending release of AppleScript was interfering with his
product,AppledecidedtheAppleScriptshouldbeopenedup
to multiple scriptinglanguages.The AppleScript teammod-
1-12
software SDK dll:VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
doc.Save(outPutFilePath). How to VB.NET: Delete Consecutive Pages from PDF. doc.Save(outPutFilePath). How to VB.NET: Delete Specified Pages from PDF.
www.rasteredge.com
software SDK dll:C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
doc.Save(outPutFilePath); Demo Code: How to Delete Consecutive Pages from PDF in C#.NET. Demo Code: How to Delete Specified Pages from PDF in C#.NET.
www.rasteredge.com
ified the OSA APIs so that they could be implemented by
multiple scripting systems, not just AppleScript. As a result,
OSA is a generic interface between clients of scripting ser-
vices and scripting systems that supportascripting language.
Eachscriptis taggedwiththe scriptingsystemthatcreatedit,
so clients can handle multiple kinds of script without know-
ing which scripting system they belong to.
Dave Winer’s Frontier is a complete scripting and ap-
plication development environment that eventually became
available as an Open Scripting component. Dave went on
to participate in the design of web services and SOAP [4].
Tcl,JavaScript, Pythonand Perl have also been packaged as
Open Scripting components.
4.3 Recording Events as Scripts
The AppleScript infrastructure supports recording of events
inrecordable applications, which publishevents inresponse
to user actions. Donn Denman, a senior software engineer
on the AppleScript team with a BS in Computer Science
andMath from Antioch College, designed andimplemented
muchoftheinfrastructure forrecording.AtAppleheworked
on Basic interpreters. He was involved in some of the early
discussions ofAppleScript,worked on Apple Events and ap-
plication terminologies in AppleScript. In addition, Donn
created MacroMaker, a low-level event record and play-
back system for Macintosh OS System 5. Working on Mar-
coMaker gave Donn a lot of experience in how recording
should work.
Recording allows automatic generation of scripts for re-
peatedplaybackofwhat would otherwise berepetitive tasks.
Recorded scripts can be subsequently generalized by users
for more flexibility.This approach to scripting alleviates the
“staring at a blank page”syndrome that can be so crippling
to new scripters. Recording is also useful for learning the
terminology ofbasic operations ofan application,because it
helps users to connect actions in the graphical interface with
their symbolic expression in script.
Recording high-level events is different from recording
low-level events of the graphical user interface. Low-level
events include mouse andkeyboardevents.Low-levelevents
can also express user interface actions, e.g. “perform Open
menu item in the File menu”, although the response to this
event is usually to display a dialog box, not to open a par-
ticular file. Additional low-level events are required to ma-
nipulate dialog boxes by clicking on interface elements and
buttons. Low-level events do not necessarily have the same
effect if played back on a different machine, or when dif-
ferent windows are open. High-level events are more robust
because they express the intent of an action more directly.
For example, a high-level event can indicate which file to
open.
Recording is supported by a special mode in the Apple
Event manager, based on the idea that a user’s actions in
manipulating a GUI interface can be described by a corre-
sponding Apple Event. For example, if the user selects the
File Open menu, then finds and selects a file named “Re-
sum´e”in a folder named “Personal”, the corresponding Ap-
ple Event would be a FileOpen event containing the path
“Personal:Resum ´e”. To be recordable, an application must
post Apple Events that describe the actions a user performs
with the GUI.
Recordable applications can be difficult to build, since
they must post an Apple Event describing each operation
performed by a user. The AppleScript team promoted an ar-
chitecture that turned this difficulty into a feature.We advo-
cated that applications should be factored into two parts, a
GUI and a back end, where the only communication from
the GUI to the back end is via Apple Events. With this ar-
chitecture, all the core functionality of the application must
be exposed via Apple Events, so the application is inher-
ently scriptable. The GUI’s job becomes one of translating
low-level user input events (keystrokes and mouse move-
ments) into high-level Apple Events. An application built in
this way is inherently recordable; the Apple Event manager
simply records the Apple Events that pass from the GUI to
the back end. If an application is already scriptable, it can
be made recordable by arranging for the user interface to
communicate with the application model only through Ap-
ple Events.
The reality of recording is more complex, however. If
there is a
type
Apple Event to add characters into a docu-
ment, the GUI must forward each character immediately to
the back end so that the user will see the result of typing.
During recording, if the user types “Hello”the actions will
record an undesirable script:
type ‘‘H"
type ‘‘e"
type ‘‘ l"
type ‘‘ l"
type ‘‘o"
It would be better to record
type ‘‘ Hello"
. To get this
effect, the GUI developer could buffer the typing and send
asingle event. But then the user will not see the effect of
typing immediately. AppleEvents has the ability to specify
certain events asrecord-only, meaning that it is a summary
of auser’s actions and shouldnot beexecuted. Creatingsuch
summaries makes developing a recordable application quite
difficult.
In 2006 twenty-five recordable applications were listed
on Apple’s website and in the AppleScript Sourcebook [8],
one ofseveralrepositories ofinformation aboutAppleScript.
Some, but fewer than half, of the major productivity appli-
cations are recordable. Recordable applications include Mi-
crosoftWord and Excel,Netscape Navigator,QuarkExpress
(via a plugin) and CorelDRAW.
One of the inherent difficulties of recording is the am-
biguity of object specification. As the language of events
becomes more rich, there may be many ways to describe a
given user action. Each version might be appropriate for a
1-13
software SDK dll:C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
VB.NET Page: Insert PDF pages; VB.NET Page: Delete PDF pages; VB.NET Annotate: PDF Markup & Drawing. XDoc.Word for XImage.OCR for C#; XImage.Barcode Reader for C#
www.rasteredge.com
software SDK dll:C# PDF Page Insert Library: insert pages into PDF file in C#.net
how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C# .NET, how to reorganize PDF document pages and how
www.rasteredge.com
given situation,but the systemcannotpickthecorrectaction
without knowing the intent of the user. For example, when
closing a window, is the user closing the front window or
the window specifically named “Example”? This is a well-
known problem in research on programming by example,
wheremultiple examplesofagivenactioncanbeusedtodis-
ambiguate the user’s intent. Allen Cypher did fundamental
researchonthis problemwhile atApple.He builta prototype
system called Eager that anticipated user actions by watch-
ing previous actions [21, 22]. AppleScript does not have
built-in support for analyzing multiple examples. There are
also ambiguities when recording and embedding are com-
bined: if a recorded event causes a script to execute, should
the original event or the events generated by the script be
recorded? Application designers must decide what is most
appropriate for a given situation. Cypher worked with Dave
Curbow in writing guidelines to help developers make these
difficult choices [26].
Recording can also be used for other purposes. For ex-
ample, a help system can include step-by-step instructions
defined by a script. The steps can be played as normal
scripts, or the user can be given the option of performing
the steps manually underthe supervision ofthe help system.
By recording the user’s actions, the help system can pro-
vide feedback or warnings when the user’s actions do not
correspond to the script.
5. Development Process
Unlike most programming languages, AppleScript was de-
signed within a commercial software development project.
The team members are listed in Figure 7. AppleScript was
designed by neither an individual nor a committee; the
team used a collaborative design process, with significant
user testing and evaluation. The project leaders guided the
process and made final decisions: there was lively debate
within the group about how things should work. The ex-
tended team included project management, user interface
design and testing, documentation,and product marketing.
The AppleScript project had a strong quality assurance
(QA) team. They created a large test suite which was run
against nightly builds. From a management viewpoint, the
QA group also had significant control over the project, be-
cause they were required to give final approval of a release.
The project was code-named “Gustav”after Donn’s mas-
sive Rottweiler dog. The dog slimed everything it came in
contact with,and was the impetus behind a T-shirt that read
“Script Happens”. The project tag line was “Pure Guava”
because Gary Bond was designinga t-shirtthat said “Apple-
Script: Pure Gold”and Warren Harris got him to change it
to Pure Guava after the Ween album he was in love with at
the time.
AppleScript and the associated tools were designed and
implementedbetween 1990 and1993.Figure 8gives a time-
line of the development process.The line labeled “changes”
Jens Alfke
Developer
Greg Anderson
Developer,
ScriptableFinder
MikeAskins
Engineering Project Man-
ager
Gary Bond
QA
Scott Bongiorno
QA, User Testing
B. BruceBrinson
Developer
Kevin Calhoun
Manager
JenniferChaffee
UserInterfaceDesign
Dan Clifford
Developer
William Cook
Architect, Developer,
Manager
SeanCotter
Documentation
DaveCurbow
UserInterfaceDesign
Donn Denman
Developer
SueDumont
Developer, QA
MikeFarr
Marketing
MitchGass
Documentation
Laura ClarkHamersley
Marketing
WarrenHarris
Architect, Developer
Eric HouseQA,Developer
RonKarr
QA, Apple Events Devel-
oper
Edmund Lai
Developer, AppleEvents
RonLichty
Manager, Finder
Bennet Marks
Developer
MarkMinshull
Manager
Kazuhisa Ohta
Developer, Dialects
DonaldOlson
QA, Manager
Chuck Piercey
Marketing
Kurt Piersol
Architect
James Redfern
QA, Developer
Brett Sher
Developer, QA
LaileDiSilvestro
QA, Developer
SalSoghoian
ProductManager
Francis Stanbach
Developer,
Scriptable Finder
Kazuhiko Tateda
Japanese Dialect
Larry Tesler
Manager, VP
MarkThomas
Evangelist
Susan Watkins
Marketing
Figure 7. AppleScriptandrelatedprojectteammembers.
1-14
software SDK dll:VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Page: Insert PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Insert PDF Page. Add and Insert Multiple PDF Pages to PDF Document Using VB.
www.rasteredge.com
software SDK dll:VB.NET PDF delete text library: delete, remove text from PDF file
Visual Studio .NET application. Delete text from PDF file in preview without adobe PDF reader component installed. Able to pull text
www.rasteredge.com
0
20
40
60
80
100
120
140
160
180
200
6/1/91
7/1/91
7/31/91
8/30/91
9/29/91
10/29/91
11/28/91
12/28/91
1/27/92
2/26/92
3/27/92
4/26/92
5/26/92
6/25/92
7/25/92
8/24/92
9/23/92
10/23/92
11/22/92
12/22/92
1/21/93
2/20/93
3/22/93
4/21/93
5/21/93
6/20/93
7/20/93
8/19/93
9/18/93
10/18/93
11/17/93
12/17/93
1/16/94
2/15/94
f1
Final
f3
b1
Beta
b2
b3
b5
b4
AppleScript 1.0
a1
a17
a10
a3
AppleScript 1.1
Alpha
b2
f1
b5
b3
Develoment
Beta
Alpha
Dev.
a6
a4
a1
Final
0
2000
4000
6000
8000
10000
12000
14000
16000
18000
20000
changes
Number of file changes
umber of release candidate builds
Figure 8. Developmentstatistics:numberoffilechangesandcandidatebuilds.
shows the cumulative number of files changed during de-
velopment (the scale is on the left). The second line shows
the cumulative number of candidate release builds. The fi-
nal candidate builds were created by Apple source control
group from a clean set of sources and then given to the test-
ing team. By placing source code control between develop-
ment and testing, Apple ensured that each build could be
recreatedona cleandevelopment environmentwith archived
sources.Note that the number offile changes in the alpha or
beta phases starts off slowly, then increases until just before
the next milestone, when changes are no longer allowed un-
less absolutely necessary.
The AppleScript Beta was delivered in September 1992.
In April 1993 the AppleScript 1.0 Developer’s Toolkit
shipped, including interface declaration files (header files),
sample code, sample applications and the Scripting Lan-
guage Guide.
The first end-user version, AppleScript 1.1, was released
in September 1993 and included with System 7 Pro. In De-
cember 1993, the 1.1 Developer’s Toolkit and Scripting Kit
versions both released. In 1994, AppleScript was included
as part of System7.5.
In January 1993, Apple management decided that the
next version of AppleScript had to have more features than
AppleScript 1.1, but that the development must be done
with half the number of people. Since this was not likely
to lead to a successful development process, Warren and I
decided to leave Apple. Without leadership, the AppleScript
group was disbanded.Manyoftheteammembers,including
Jens Alfke, Donn Denman, and Donald Olson, joined Kurt
Piersol on the OpenDoc team, which was working on visual
integration of applications. AppleScript was integrated into
the OpenDoc framework.
5.1 Documentation
Internal documentation was ad hoc. The team made exten-
sive use of an early collaborative document managemen-
t/writing tool called Instant Update, that was used in a wiki-
like fashion, a living document constantly updated with the
current design. Instant Update provides a shared space of
multiple documents that were viewed and edited simultane-
ously by any number of users. Each user’s text was color-
coded and time-stamped. I have not been able to recover a
copy of this collection of documents.
No formal semantics was created for the language, de-
spite the fact that my PhD research and work at HP Labs
was focused entirely on formal semantics of programming
languages.One reasonwas that only one person on the team
was familiar with formal semantics techniques, so writing a
formal semantics would not be an effective means of com-
munication. In addition,there wasn’t muchpointin develop-
ing a formal semantics for the well-known features (objects,
1-15
software SDK dll:C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
batch changing PDF page orientation without other PDF reader control. NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split
www.rasteredge.com
software SDK dll:C# PDF delete text Library: delete, remove text from PDF file in
Delete text from PDF file in preview without adobe PDF reader component installed in ASP.NET. C#.NET PDF: Delete Text from Consecutive PDF Pages.
www.rasteredge.com
inheritance, lexical closures, etc.), because the goal for this
aspect of the language was to apply well-known constructs,
not define new ones. There was no standard formal seman-
tic framework for the novel aspects of AppleScript, espe-
cially the notion of references for access to external objects
residing in an application. The project did not have the lux-
ury of undertaking extensive research into semantic founda-
tions;itscharterwas todevelopandshipapractical language
in a short amount of time. Sketches of a formal semantics
were developed, but the primary guidance for language de-
sign came from solving practical problems and from user
studies, rather than froma priori formal analysis.
Thepublic documentationwas developed by professional
writers who worked closely with the team throughout the
project. The primary document isInsideMacintosh:Inter-
application Communication,whichincludesdetailsonthe
Apple Event Manager and Scripting Components [11]. The
AppleScript language is also thoroughly documented [2],
and numerous third-party books have been written about
it, for examples see [31, 24]. Mitch Gass and Sean Cotter
documented Apple Events and AppleScript for external use.
Mitch has a bachelor’s degrees in comparative literature and
computerscience,and workedat Tandem and Amiga before
joining Apple. Mitch worked during the entire project to
provide that documentation, and in the process managed to
be a significant communication point for the entire team.
5.2 User Testing
Following Apple’s standard practice, we user-tested the lan-
guage in a variety of ways. We identified novice users and
asked them, “What do you think this script does?”The fol-
lowing questions illustrate the kinds of questions asked dur-
ing user testing.
PartI.Pleaseanswerthefollowingmultiplechoiceques-
tions about AppleScript.
3. Given the handler:
on doit from x to y with z
return (x ⁄ y) + z
end doit
What does the following statement evaluate to?
doit with 3 from 8 to 5
a) 29
b) 43
c) error
d) other:
PartII.Please state e which h of the e following g AppleScript
statements you prefer.
8.
a)
put ‘‘a ’’, f‘‘b ’’, ‘‘c’’g into x
b)
put f‘‘a ’’, f‘‘b ’’, ‘‘c’’gg into x
9.
a)
window named ‘‘fred’’
b)
window ‘‘fred ’’
10. a)
window 1
b)
window #1
11. a)
word 34
b)
word #34
12. a)
‘‘apple’’ < ‘‘betty ’’
b)
‘‘apple’’ comes before ‘‘betty ’’
Part III.Thissectionshowssequencesofcommandsand
then asks questions about various variables afterthey are
executed.
15. Given the commands:
put f1, 2, 3g into x
put x into y
put 4 into item 1 of x
What is x?
a)
f1, 2, 3g
b)
f4, 2, 3g
c)
error
d) other:
What is y?
a)
f1, 2, 3g
b)
f4, 2, 3g
c)
error
d) other:
Part IV.Inthissection,assumethatallAppleScriptstate-
ments refer to
window 1
,which contains the following
text:
this is a test
of the emergency broadcast system
18. What does the following statementevaluate to?
count every line of window 1
a) 2
b) 4, 5
c) 9
d) 14,33
e) 47
f) error
g) other:
1-16
Whatdoes the following statement evaluate to?
count each line of window 1
a) 2
b) 4, 5
c) 9
d) 14, 33
e) 47
f) error
g) other:
21. What does the following statement evaluate to?
every line of window 1
whose flrst character = ‘‘x ’’
a)
fg
b)
error
c) other:
One result of user testing concerned the choice of verb
for assignment commands. The average user thought that
after the command
put x into y
the variable
x
no longer
retained its old value. The language was changed to use
copy x into y
instead. We also conducted interviews and
around-table discussion about what kind of functionality
users wouldlike to seein the system. Inthesummerof1992,
Applebriefed50keydevelopers andcollectedreactions.The
user interface team conducted controlled experiments of the
usability of the language in early 1993, but since these took
place during the beta-testing period,they were toolate in the
product development cycle to have fundamental impact.
6. AppleScript Applications and Tools
Much of the practical power of AppleScript comes from
the applications and tools that work with scripts and han-
dle events. From the viewpoint of AppleScript, applications
are large, well-designed and internally consistent libraries
of specialized functionality and algorithms. So, when used
with a database application, AppleScript can perform data-
oriented operations. When used with a text layout applica-
tion,AppleScript can automate typesetting processes.When
used with a photo editing application, AppleScript can per-
form complex image manipulation.
Since new libraries can be created to cover any applica-
tion domain, only the most basic data types were supported
in AppleScript directly. For example, string handling was
minimalin AppleScript. AppleScript’s capabilities were ini-
tially limited by the availability of scriptable applications.
Success of the project required that many applications and
diverse parts of the operating system be updated to support
scripting.
Asecond benefit of pervasive scripting is that it can be
used to provide a uniform interface to the operating sys-
tem. With Unix, access to information in a machine is idio-
syncratic, in the sense that one program was used to list
print jobs, anotherto listusers,anotherfor files, and another
for hardware configuration. I envisioned a way in which all
these differentkinds ofinformation couldbe referenced uni-
formly.
Auniform naming model allows every piece of infor-
mation anywhere in the system, be it an application or the
operating system, to be accessed and updated uniformly.
Application-specific terminologies allow applications to be
accesseduniformly; anoperating systemterminologywould
provide access toprinterqueues, processorattributes,or net-
work configurations. Thus, the language must support mul-
tiple terminologies simultaneously so that a singlescript can
access objects from multiple applications and the operating
system at the same time.
6.1 Scriptable Finder
Having a scriptable Finder was a critical requirement for
AppleScript,since theFinderprovides accesstomost system
resources. However, it was difficult to coordinate schedules
and priorities because the Finder and AppleScript teams
were in different divisions within Apple. The Finder team
was also pulled in many directions at once.
As a result, Finder was not fully scriptable when Apple-
Script shipped in 1992. The Finder team created a separate
library, called the “Finder scripting extension”, to provide
some additional Finder script commands. The Finder had
been rewritten in C++ from the ground up for System 7 to
be extensible.But extensions reliedoninternal C++dispatch
tables, so the Finder was not dynamically extensible: it had
to be recompiled for each extension. The Finder extension
mechanism had been designed so that Finder functionality
could grow incrementally. It was the mechanism for adding
large quantities of new functionality to support a specific
project.
Itwas notuntil1997 thata scriptable Finderwas released.
Ayear later the Finder supported embedding, which greatly
increased its power. Embedding allowed scripts to be trig-
gered from within the Finder in response to events, for ex-
ample opening a folder or emptying the trash.
6.2 Publishing Workflow
Automation of publishing workflows is a good illustration
of AppleScript and scriptable applications.Consider the au-
tomation of a catalog publishing system. An office-products
company keeps all its product information in a FileMaker
Pro
TM
databasethatincludes descriptions,prices,special of-
fer information,and a product code. The product code iden-
tifies a picture of the product in a Kudos
TM
image database.
The finalcatalogis a QuarkXPress
TM
document thatis ready
forprinting. Previously,the catalog was produced manually,
1-17
atask that took a team of twenty up to a month for a single
catalog.
An AppleScript script automates the entire process. The
scriptreads the priceanddescriptive textfromthe FileMaker
Pro database and inserts it into appropriate QuarkXPress
fields. The script applies special formatting: it deletes the
decimal point in the prices and superscripts the cents (e.g.
34
99
)
.To make the text fit precisely in the width of the en-
closing box, the script computes a fractional expansion fac-
tor for the text by dividing the width of the box by the width
of the text (this task was previously done with a calculator).
It adjusts colors and sets the first line of the description in
boldface type. Finally, it adds special markers like “Buy 2
get 1 free”and “Sale price $17
99
”where specified by the
database.
Once this process is automated, one person can produce
the entire catalog in under a day, a tiny fraction of the time
taken by the manual process. It also reduced errors during
copying and formatting.Of course, creatingandmaintaining
the scripts takes time, but the overall time is significantly
reduced over the long run.
6.3 Scripting Tools
AppleScript included a simple and elegant script editor cre-
ated by Jens Alfke, who had graduated from Caltech and
worked with Kurt Piersol at Xerox Parc on Smallktalk-80
applications. Jens was one of the key developers on the Ap-
pleScript team; he focused on tools,consistencyof the APIs
andusability of the overall system.
Soon after AppleScript was released, more powerful
script development environments were created outside Ap-
ple. They addressed one of the major weaknesses of Apple-
Script:lackofsupportfor debugging. One developeroutside
Apple who took on this challenge is Cal Simone, who has
also been an unofficial evangelist for AppleScript since its
inception. Cal createdScripter,whichallows usersto single-
step through a script. It works by breaking a script up into
individual lines that are compiled and executed separately.
The enclosing
tell
statements are preserved around each
line as it is executed.Scripter also allows inspection of local
variables and execution of immediate commands within the
context of the suspended script.ScriptDebuggeruses a dif-
ferent technique:itadds aspecialApple Eventbetweeneach
line of a script. The Apple Event is caught by the debugger
and the processing of the script is suspended. The current
values of variables can then be inspected. To continue the
script,the debugger simply returns from the event.
AppleScript also enables creation of sophisticated inter-
face builders. The interface elements post messages when
auser interacts with them. The user arranges the elements
into windows, menus, and dialogs. Scripts may be attached
to any object in the interface to intercept the messages be-
ing sent by the interface elements and provide sophisticated
behavior and linking between the elements. Early applica-
tion builders included Frontmost
TM
,a window and dialog
builder, and AgentBuilder
TM
,which specialized in commu-
nication front-ends. Version 2.2 of HyperCard, released in
1992, included support for OSA, so that AppleScript orany
OSA language could be used in place of HyperTalk.
Two major application builders have emerged recently.
FaceSpan, originallyreleased in1994,has grown into a full-
featured application development tool. FaceSpan includes
an integrated script debugger. Apple released AppleScript
Studio in 2002 as part of its XCode development platform.
Acomplete application can be developed with a wide range
of standard user interface elements to which scripts can be
attached. AppleScript Studio won Macworld Best of Show
Awards at the 2001 Seybold Conference in San Francisco.
In 2005 Apple released Automator, a tool for creating
sequences of actions that define workflows. Automator se-
quences are not stored or executed as AppleScripts, but can
contain AppleScripts as primitive actions. The most inter-
estingthing about Automator is thateach action has aninput
and an output, much like a command in a Unix pipe. The
resulting model is quite intuitive and easy to use for simple
automation tasks.
Although Apple Events are normally handled by appli-
cations, it is also possible to installsystemeventhandlers.
When an Apple Event is delivered to an application, the ap-
plicationmayhandlethe event orindicate thatitwasnothan-
dled.When an application does nothandle an event,the Ap-
ple Event manager searches for a system event handler. Sys-
tem event handlers are packaged inscriptextensions (also
known as OSAX) and are installed on the system via Script-
ing Additions that are loaded when the system starts up.
6.4 Scriptable Applications
Eventually, a wide range of scriptable applications became
available: there are currently 160 scriptable applications
listed on the Apple web site and the AppleScript source-
book [8]. Every kind of application is present, including
word processors, databases, file compression utilities, and
development tools. Many of the most popular applications
are scriptable, including Microsoft Office, Adobe Photo-
shop, Quark Expression, FileMaker, and Illustrator. In ad-
dition, most components of the Mac OS are scriptable,
including the Finder, QuickTime Player, Address Book,
iTunes, Mail, Safari Browser, AppleWorks, DVD Player,
Help Viewer, iCal, iChat, iSync, iPhoto,and control panels.
Other systems also benefitted fromthe infrastructure cre-
ated by AppleScript. The Macintosh AV
TM
speech recogni-
tion system uses AppleScript, so any scriptable application
can be driven using speech.
7. Evolution
After version 1.1, the evolution of AppleScript was driven
primarily by changes in the Macintosh OS. Since Apple-
Scriptwasfirst released,the operatingsystemhas undergone
twomajorshifts,first whenApple moved fromthe Motorola
1-18
68000 to the PowerPC chip, and then when it moved from
the Classic Macintosh OS to the Unix-based OS X. Few
changes were made to the language itself, while scriptable
applications and operating system components experienced
rapid expansion and evolution. A detailed history with dis-
cussion of new features, bugs, and fixes can be found in the
AppleScript Sourcebook [8],which we summarize here.
The first upgrade to AppleScript, version 1.1.2, was cre-
ated for Macintosh OS 8.0, introduced in July 1997. De-
spite the rigorous source code configuration process (see
Section 5), Apple could not figure out how to compile the
system and contracted with Warren Harris to help with the
job. A number of bugs were fixed and some small enhance-
mentswere madetoconformto MacintoshOS8.0standards.
Atthe same time several systemapplications and extensions
were changedin ways that couldbreak old scripts.The most
important improvement was a new scriptable Finder, which
eliminated the need for a Finderscripting extension.
In 1997 AppleScript was at the top of the list of features
to eliminate in order to save money. Cal Simone, mentioned
in Section 6.3, successfully rallied customers to rescue Ap-
pleScript.
In October 1998 Apple released AppleScript 1.3 with
UNICODE support recompiled as a native PowerPC exten-
sion; however, the Apple Events Manager was still emulated
as Motorola 68000 code. The dialect feature was no longer
supported; English became the single standard dialect. This
version came much closer to realizing the vision of uni-
form access to all system resources from scripts. At least
30differentsystemcomponents,includingFile Sharing,Ap-
ple Video Player and Users & Groups,were now scriptable.
New scriptable applications appeared as well,including Mi-
crosoft Internet Explorer and Outlook Express.
The PowerPC version of AppleScript received an Eddy
Award from MacWorld as “Technology of the Year” for
1998 and was also demonstrated in Steve Jobs’ Seybold
1998 address. In 2006, MacWorld placed AppleScript as
#17 on its list of the 30 most significant Mac products ever.
AppleScript was a long-term investment in fundamental in-
frastructure that took many years to pay dividends.
The most significant language changes involved the
tell
statement. For example, the
machine
class used to identify
remote applications was extended to accept URLs (see Sec-
tion 3.2), allowing AppleScript control of remote applica-
tions via TCP/IP.
When Mac OSXwas releasedinMarch 2001,it included
AppleScript 1.6. In porting applications and system compo-
nents to OSX,Apple sometimes sacrificedscriptingsupport.
Asa result,therewas asignificant reductioninthenumberof
scriptable applications after the release of OS X.Full script-
ability is being restored slowly inlaterreleases.
In October2006,Google reported anestimated 8,570,000
hits forthe word “AppleScript”.
8. Evaluation
AppleScript was developed by a small group with a short
schedule, a tight budget and a big job. There was neither
time nor money to fully research design choices.
AppleScriptandAppleEvents introducedanewapproach
to remotecommunicationinhigh-latencyenvironments [33].
Object references are symbolic paths, or queries, that iden-
tify one ormore objects in anapplication.Whena command
is applied to an object reference, both the command and the
object reference are sent (as an Apple Event containing an
object specifier) to the application hosting the target object.
The application interprets the object specifier and then per-
forms the action on the specified objects.
In summary, AppleScript views an application as a form
of object-oriented database. The application publishes a
specialized terminology containing verbs and nouns that
describe the logical structure and behavior of its objects.
Names in the terminology are composed using a standard
query language to create programs that are executed by the
remote application. The execution model does not involve
remote object references and proxies as in CORBA. Rather
than send each field access and method individually to the
remote application and creating proxies to represent inter-
mediate values, AppleScript sends the entire command to
the remote application for execution. From a pure object-
orientedviewpoint,the entire application is the only real ob-
ject; the “objects”within it are identified only by symbolic
references, orqueries.
After completing AppleScript, I learned about COM
and was impressed with its approach to distributed object-
oriented programming. Its consistent use of interfaces en-
ables interoperability between different systems and lan-
guages.Although interface negotiationis complex,invoking
amethod through an interface is highly optimized. This ap-
proach allows fine-grained objects that are tightly coupled
through shared binary interfaces. For many years I believed
that COM and CORBA would beat the AppleScript com-
munication model in the long run.However, recent develop-
ments have made me realize that this may not be the case.
AppleScript uses a large-granularity messaging model
that has many similarities to the web service standards that
began to emerge in 1999 [10]. Both are loosely coupled and
supportlarge-granularitycommunication.Apple Eventsdata
descriptors are similar to XML in that they describe arbi-
trary labeled tree structures without fixed semantics. Apple-
Script terminologies are similar to web service description
language (WSDL) files. It is perhaps not an accident that
Dave Winer, who worked extensively with AppleScript and
Apple Events, is also one of the original developers of web
service models. There may be useful lessons to be learned
for web services, given that AppleScript represents a sig-
nificant body of experience with large-granularity messag-
ing. One difference is that AppleScript includes a standard
query model for identifying remote objects. A similar ap-
1-19
proach could be useful for web services.As Iwrite in 2006,
Isuspect that COM and CORBA will be overwhelmed by
web services, although the outcome is farfrom certain now.
AppleScript is also similar to traditional database inter-
faces like ODBC [38]. In AppleScript the query model is
integrated directly into the language, rather than being exe-
cuted as strings as in ODBC. A similar approach has been
adopted by Microsoft for describing queries in .NET lan-
guages [3].
User tests revealed that casual users don’t easily under-
stand the ideaof references, or having multiple references to
the same value. It is easier to understand a model in which
values arecopiedormoved,ratherthanassigningreferences.
Thefeedbackfromusertestsinearly 1993was too late in the
development cycle to address this issue with anything more
than a cosmetic change, to use
copy
instead of
set
for as-
signment.
Writing scriptable applications is difficult. Just as user
interface design requires judgment and training, creating a
good scripting interface requires a lot of knowledge and
careful design. It is too difficult for application developers
to create terminologies that work well in the naturalistic
grammar. They must pay careful attention to the linguistic
properties of the names they choose.
The experiment in designing a language that resembled
natural languages (English and Japanese) was not success-
ful. It was assumed that scripts should be presented in “nat-
ural language”so that average people could read and write
them. This lead to the invention of multi-token keywords
and the ability to disambiguate tokens without spaces for
Japanese Kanji. In the end the syntactic variations and flex-
ibility did more to confuse programmers than to help them
out. It is not clear whether it is easier for novice users to
work with a scripting language that resembles natural lan-
guage,withallits specialcases and idiosyncrasies.Themain
problem is that AppleScript only appears to be a natural
language: in fact, it is an artificial language, like any other
programming language.Recording was successful, but even
small changes tothe scriptmayintroduce subtlesyntacticer-
rors that baffle users. It is easyto read AppleScript,but quite
hard to write it.
When writing programs or scripts, users prefer a more
conventional programming language structure. Later ver-
sions of AppleScript dropped support for dialects. In hind-
sight, we believe that AppleScript should have adopted the
Professional Dialect that was developed but nevershipped.
Finally, readability was no substitute for an effective se-
curity mechanism. Most people just run scripts—they don’t
read or write them.
9. Conclusion
AppleScript is widely used today and is a core technol-
ogy of Mac OS X. Many applications, including Quark Ex-
press, Microsoft Office, and FileMaker, support scripting.
Small scripts are used to automate repetitive tasks. Larger
scripts have been developed for database publishing, docu-
ment preparation, and even web applications.
There are many interesting lessons to be learned from
AppleScript. On a technical level, its model of pluggable
embedded scripting languages has become commonplace.
The communication mechanism of Apple Events, which is
certainly inferior to RPC mechanisms for single-machine or
in-process interactions, may turn out to be a good model
for large-granularity communication models such as web
services. Many of the current problems in AppleScript can
be traced to the use of syntax based on natural language;
however,theabilitytocreate pluggable dialects mayprovide
asolution in the future, by creating a new syntax based on
conventional programming languages.
Acknowledgments
Thanks to Jens Alfke, Paul Berkowitz, Bill Cheeseman,
Chris Espinosa, Michael Farr, Steve Goldband Tom Ham-
mer, David Hoerl, Alexander Kellett, Wayne Malkin, Matt
Neuburg, Chuck Piercey, Hamish Sanderson, and Stephen
Weyl, for discussions about this paper. Special thanks to
Andrew Black and Kathleen Fisher for their guidance, en-
couragement, flexibility, and careful reading of my work in
progress.
References
[1] Alfred V. Aho and Jeffrey D. Ullman. Principles of
CompilerDesign (Addison-Wesleyseriesincomputerscience
and information processing). Addison-WesleyLongman
Publishing Co.,Inc., Boston, MA, USA, 1977.
[2] AppleComputerInc.AppleScriptLanguageGuide. Addison-
Wesley, 1993.
[3] Gavin Bierman, Erik Meijer, and Wolfram Schulte. The
essence of data access in c
!
. InEuropeanConferenceon
Object-Oriented Programming.SpringerVerlag,2005.
[4] Don Box, David EhneBuske, Gopal Kakivaya, Andrew
Layman, Noah Mendelsohn, Henrik Frystyk Nielson, Satish
Thatte, and DaveWiner. Simple object access protocol 1.1.
http://www.w3.org/TR/SOAP
.
[5] Gilad Bracha and William Cook. Mixin-based inheritance.
InProc.ofACMConf.onObject-OrientedProgramming,
Systems, Languagesand Applications,pages303–311,1990.
[6] Peter Canning, William Cook, Walt Hill, John Mitchell,
and Walter Olthoff. F-bounded polymorphism for object-
oriented programming. InProc.ofConf.onFunctional
Programming Languagesand Computer Architecture,pages
273–280, 1989.
[7] Peter Canning, William Cook, Walt Hill, and Walter Olthoff.
Interfaces for strongly-typed object-oriented programming.
InProc.ofACMConf.onObject-OrientedProgramming,
Systems, Languagesand Applications,pages457–467,1989.
[8] Bill Cheeseman. Applescript sourcebook.
http://www.
AppleScriptSourcebook.com
.
1-20
Documents you may be interested
Documents you may be interested