Misplaced Pages

#375624

124-427: While GX addressed many of the problems that QD had, by the time it was made available, most developers had already developed their own solutions to these problems. GX also suffered from causing a number of incompatibilities in existing programs, notably those that had developed their own QD extensions. This, coupled with opposition from an important fraction of the developer market, especially PostScript owner Adobe, and

248-517: A RIP for Raster Image Processor) for the PostScript language was a common component of laser printers during the 1980s and 1990s. However, the cost of implementation was high; computers output raw PS code that would be interpreted by the printer into a raster image at the printer's natural resolution. This required high performance microprocessors and ample memory . The LaserWriter used a 12 MHz Motorola 68000 , making it faster than any of

372-399: A Turing complete programming language, it can be used for many other purposes as well. PostScript was created at Adobe Systems by John Warnock , Charles Geschke , Doug Brotz, Ed Taft and Bill Paxton from 1982 to 1984. The most recent version, PostScript 3, was released in 1997. The concepts of the PostScript language were seeded in 1976 by John Gaffney at Evans & Sutherland ,

496-462: A computer graphics company. At that time, Gaffney and John Warnock were developing an interpreter for a large three-dimensional graphics database of New York Harbor . Concurrently, researchers at Xerox PARC had developed the first laser printer and had recognized the need for a standard means of defining page images. In 1975–76 Bob Sproull and William Newman developed the Press format, which

620-435: A fixed point coordinate system and a variety of curve drawing commands. The system also included a system for "wrapping" existing PostScript Type 1 fonts into its own internal format, which added bitmap preview versions for quick on-screen rendering. This project later took on an expanded role when Apple and Microsoft agreed to work together to form an alternative to PostScript fonts, which were extremely expensive, creating

744-544: A procedural language such as Lua could consist primarily of basic routines to execute code, manipulate data or handle errors while an API for an object-oriented language , such as Java, would provide a specification of classes and its class methods . Hyrum's law states that "With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody." Meanwhile, several studies show that most applications that use an API tend to use

868-420: A software framework : a framework can be based on several libraries implementing several APIs, but unlike the normal use of an API, the access to the behavior built into the framework is mediated by extending its content with new classes plugged into the framework itself. Moreover, the overall program flow of control can be out of the control of the caller and in the framework's hands by inversion of control or

992-555: A trade secret . Paxton worked on several other related improvements, such as font hinting . Adobe was also responsible for porting PostScript to the Canon's Motorola 68000 chip. Apple and Adobe announced the LaserWriter at Apple's annual stockholder meeting on January 23, 1985. It was the first printer to ship with PostScript, sparking the desktop publishing (DTP) revolution in the mid-1980s. The original PostScript royalty

1116-463: A PostScript program: the execution of which results in the original document. This program can be sent to an interpreter in a printer, which results in a printed document, or to one inside another application, which will display the document on-screen. Since the document-program is the same regardless of its destination, it is called device-independent . PostScript is noteworthy for implementing on-the-fly rasterization in which everything, even text,

1240-449: A broad term describing much of the communication on the internet. When used in this way, the term API has overlap in meaning with the term communication protocol . The interface to a software library is one type of API. The API describes and prescribes the "expected behavior" (a specification) while the library is an "actual implementation" of this set of rules. A single API can have multiple implementations (or none, being abstract) in

1364-463: A broadly used modern standard in the form of OpenType Variable Fonts . As the 80s wore on, QuickDraw's architectural limitations began to impose limits on Apple and third-party developers. GX appears to have started in a roundabout fashion, originally as an outline font system that would be added to the Mac OS. Included in the font rendering engine were a number of generally useful extensions, notably

SECTION 10

#1732780469376

1488-517: A business ecosystem. The main policies for releasing an API are: An important factor when an API becomes public is its "interface stability". Changes to the API—for example adding new parameters to a function call—could break compatibility with the clients that depend on that API. When parts of a publicly presented API are subject to change and thus not stable, such parts of a particular API should be documented explicitly as "unstable". For example, in

1612-460: A client would need to know for practical purposes. Documentation is crucial for the development and maintenance of applications using the API. API documentation is traditionally found in documentation files but can also be found in social media such as blogs, forums, and Q&A websites. Traditional documentation files are often presented via a documentation system, such as Javadoc or Pydoc, that has

1736-435: A consistent appearance and structure. However, the types of content included in the documentation differs from API to API. In the interest of clarity, API documentation may include a description of classes and methods in the API as well as "typical usage scenarios, code snippets, design rationales, performance discussions, and contracts", but implementation details of the API services themselves are usually omitted. It can take

1860-534: A given API, it is possible to infer the typical usages, as well the required contracts and directives. Then, templates can be used to generate natural language from the mined data. In 2010, Oracle Corporation sued Google for having distributed a new implementation of Java embedded in the Android operating system. Google had not acquired any permission to reproduce the Java API, although permission had been given to

1984-555: A lack of communication from Apple about the benefits of GX and why users should adopt it, led to the technology being sidelined. QuickDraw GX saw little development after its initial release and was formally "killed" with the purchase of NeXT and the eventual adoption of the Quartz imaging model in Mac OS X . Many of its component features lived on and are now standard in the current Macintosh platform; TrueType GX in particular has become

2108-479: A language suitable for running the entire GUI of a computer. Sun added a number of new commands for timers, mouse control, interrupts and other systems needed for interactivity, and added data structures and language elements to allow it to be completely object oriented internally. A complete GUI, three in fact, were written in NeWS and provided for a time on their workstations. However, the ongoing efforts to standardize

2232-406: A laser printer makes it possible to position high-quality graphics and text on the same page. PostScript made it possible to fully exploit these characteristics by offering a single control language that could be used on any brand of printer. PostScript went beyond the typical printer control language and was a complete programming language of its own. Many applications can transform a document into

2356-441: A modular software library in the 1940s for EDSAC , an early computer. The subroutines in this library were stored on punched paper tape organized in a filing cabinet . This cabinet also contained what Wilkes and Wheeler called a "library catalog" of notes about each subroutine and how to incorporate it into a program. Today, such a catalog would be called an API (or an API specification or API documentation) because it instructs

2480-417: A new software product. The process of joining is called integration . As an example, consider a weather sensor that offers an API. When a certain message is transmitted to the sensor, it will detect the current weather conditions and reply with a weather report. The message that activates the sensor is an API call , and the weather report is an API response . A weather forecasting app might integrate with

2604-470: A number of forms, including instructional documents, tutorials, and reference works. It'll also include a variety of information types, including guides and functionalities. Restrictions and limitations on how the API can be used are also covered by the documentation. For instance, documentation for an API function could note that its parameters cannot be null, that the function itself is not thread safe . Because API documentation tends to be comprehensive, it

SECTION 20

#1732780469376

2728-507: A number of technologies for this task, but most shared the property that the glyphs were physically difficult to change, as they were stamped onto typewriter keys, bands of metal, or optical plates. This changed to some degree with the increasing popularity of dot matrix printers . The characters on these systems were drawn as a series of dots, as defined by a font table inside the printer. As they grew in sophistication, dot matrix printers started including several built-in fonts from which

2852-414: A number of weather sensor APIs, gathering weather data from throughout a geographical area. An API is often compared to a contract . It represents an agreement between parties: a service provider who offers the API and the software developers who rely upon it. If the API remains stable, or if it changes only in predictable ways, developers' confidence in the API will increase. This may increase their use of

2976-462: A printer. When Steve Jobs left Apple and started NeXT , he pitched Adobe on the idea of using PS as the display system for his new workstation computers. The result was Display PostScript , or DPS. DPS added basic functionality to improve performance by changing many string lookups into 32 bit integers, adding support for direct output with every command, and adding functions to allow the GUI to inspect

3100-440: A programmer on how to use (or "call") each subroutine that the programmer needs. Wilkes and Wheeler's book The Preparation of Programs for an Electronic Digital Computer contains the first published API specification. Joshua Bloch considers that Wilkes and Wheeler "latently invented" the API, because it is more of a concept that is discovered than invented. The term "application program interface" (without an -ing suffix)

3224-518: A programmer will find useful and keeping them consistent even if the internal details later change. An API may be custom-built for a particular pair of systems, or it may be a shared standard allowing interoperability among many systems. The term API is often used to refer to web APIs , which allow communication between computers that are joined by the internet . There are also APIs for programming languages , software libraries , computer operating systems , and computer hardware . APIs originated in

3348-643: A shipping company API that can be added to an eCommerce-focused website to facilitate ordering shipping services and automatically include current shipping rates, without the site developer having to enter the shipper's rate table into a web database. While "web API" historically has been virtually synonymous with web service , the recent trend (so-called Web 2.0 ) has been moving away from Simple Object Access Protocol ( SOAP ) based web services and service-oriented architecture (SOA) towards more direct representational state transfer (REST) style web resources and resource-oriented architecture (ROA). Part of this trend

3472-404: A similar mechanism. An API can specify the interface between an application and the operating system . POSIX , for example, specifies a set of common APIs that aim to enable an application written for a POSIX conformant operating system to be compiled for another POSIX conformant operating system. Linux and Berkeley Software Distribution are examples of operating systems that implement

3596-441: A small part of the API. Language bindings are also APIs. By mapping the features and capabilities of one language to an interface implemented in another language, a language binding allows a library or service written in one language to be used when developing in another language. Tools such as SWIG and F2PY, a Fortran -to- Python interface generator, facilitate the creation of such interfaces. An API can also be related to

3720-463: A software system, used for machine-to-machine communication. A well-designed API exposes only objects or actions needed by software or software developers. It hides details that have no use. This abstraction simplifies programming. Building software using APIs has been compared to using building-block toys, such as Lego bricks. Software services or software libraries are analogous to the bricks; they may be joined together via their APIs, composing

3844-454: Is a challenge for writers to keep the documentation updated and for users to read it carefully, potentially yielding bugs. API documentation can be enriched with metadata information like Java annotations . This metadata can be used by the compiler, tools, and by the run-time environment to implement custom behaviors or custom handling. It is possible to generate API documentation in a data-driven manner. By observing many programs that use

QuickDraw GX - Misplaced Pages Continue

3968-415: Is a connection between computers or between computer programs . It is a type of software interface , offering a service to other pieces of software . A document or standard that describes how to build such a connection or interface is called an API specification . A computer system that meets this standard is said to implement or expose an API. The term API may refer either to the specification or to

4092-579: Is a static data structure made for efficient access and embeds navigational information suitable for interactive viewing. PostScript is a Turing-complete programming language, belonging to the concatenative group of programming languages. It is an interpreted , stack-based language similar to Forth but with strong dynamic typing , data structures inspired by those found in Lisp , scoped memory and, since language level 2, garbage collection . The language syntax uses reverse Polish notation , which makes

4216-512: Is an architectural approach that revolves around providing a program interface to a set of services to different applications serving different types of consumers. When used in the context of web development , an API is typically defined as a set of specifications, such as Hypertext Transfer Protocol (HTTP) request messages, along with a definition of the structure of response messages, usually in an Extensible Markup Language ( XML ) or JavaScript Object Notation ( JSON ) format. An example might be

4340-542: Is an unknown reason for GX's failure in the market. For one thing, GX was very large, by itself requiring as much memory as the rest of the OS. Speed was also an issue, limiting it to running only on Macs with a Motorola 68020 or better. Given that the installed Mac base at the time still contained large numbers of 68000 based machines like the Mac Plus , these requirements restricted the number of machines it could run on. When it

4464-522: Is created in one place dynamically can be posted and updated to multiple locations on the web. For example, Twitter's REST API allows developers to access core Twitter data and the Search API provides methods for developers to interact with Twitter Search and trends data. The design of an API has significant impact on its usage. The principle of information hiding describes the role of programming interfaces as enabling modular programming by hiding

4588-399: Is first recorded in a paper called Data structures and techniques for remote computer graphics presented at an AFIPS conference in 1968. The authors of this paper use the term to describe the interaction of an application—a graphics program in this case—with the rest of the computer system. A consistent application interface (consisting of Fortran subroutine calls) was intended to free

4712-413: Is identical to the original format developed for GX. QuickDraw GX is based on an object oriented model in which graphics objects are aware of and responsible for their own state. Unlike QuickDraw, there is no universal "state", every drawing command can re-construct the state from data stored within it, or various "parent" objects. For instance, a programmer could build a redBox object that first sets

4836-475: Is its handling of fonts . The font system uses the PS graphics primitives to draw glyphs as curves, which can then be rendered at any resolution . A number of typographic issues had to be considered with this approach. One issue is that fonts do not scale linearly at small sizes and features of the glyphs will become proportionally too large or small and start to look displeasing. PostScript avoided this problem with

4960-598: Is needed for such a printer, Ghostscript can be used. There are also a number of commercial PostScript interpreters, such as TeleType Co. 's T-Script or Brother 's BR-Script3 . PostScript became commercially successful due to the introduction of the graphical user interface (GUI), allowing designers to directly lay out pages for eventual output on laser printers. However, the GUIs' own graphics systems were generally much less sophisticated than PostScript; Apple's QuickDraw , for instance, supported only basic lines and arcs, not

5084-537: Is not clear when the projects merged, but this was a common theme in Apple at the time. Middle-managers were involved in an intense turf war for much of the late 1980s and early 1990s, gathering projects together into "über-projects" that contained enough important code to make them "unkillable". Sadly, this often delayed the projects dramatically; one component running behind schedule forced the entire collection to be delayed so they could be released "complete". QuickDraw GX

QuickDraw GX - Misplaced Pages Continue

5208-453: Is now the most common meaning of the term API. The Semantic Web proposed by Tim Berners-Lee in 2001 included "semantic APIs" that recast the API as an open , distributed data interface rather than a software behavior interface. Proprietary interfaces and agents became more widespread than open ones, but the idea of the API as a data interface took hold. Because web APIs are widely used to exchange data of all kinds online, API has become

5332-440: Is possible to write computer programs in PostScript just like any other programming language. A Hello World program , the customary way to show a small example of a complete program in a given language, might look like this in PostScript (level 2): or if the output device has a console PostScript uses the point as its unit of length. However, unlike some of the other versions of the point, PostScript uses exactly 72 points to

5456-475: Is related to the Semantic Web movement toward Resource Description Framework (RDF), a concept to promote web-based ontology engineering technologies. Web APIs allow the combination of multiple APIs into new applications known as mashups . In the social media space, web APIs have allowed web communities to facilitate sharing content and data between communities and applications. In this way, content that

5580-510: Is specified in terms of straight lines and cubic Bézier curves (previously found only in CAD applications), which allows arbitrary scaling, rotating and other transformations. When the PostScript program is interpreted, the interpreter converts these instructions into the dots needed to form the output. For this reason, PostScript interpreters are occasionally called PostScript raster image processors , or RIPs. Almost as complex as PostScript itself

5704-449: The de facto standard for electronic document distribution. On high-end printers, PostScript processors remain common, and their use can dramatically reduce the CPU work involved in printing documents, transferring the work of rendering PostScript images from the computer to the printer. The first version of the PostScript language was released to the market in 1984. The qualifier Level 1

5828-549: The Google Guava library, the parts that are considered unstable, and that might change soon, are marked with the Java annotation @Beta . A public API can sometimes declare parts of itself as deprecated or rescinded. This usually means that part of the API should be considered a candidate for being removed, or modified in a backward incompatible way. Therefore, these changes allow developers to transition away from parts of

5952-579: The Harlequin RIP , both by Global Graphics . A free software version, with several other applications, is Ghostscript . Several compatible interpreters are listed on the Undocumented Printing Wiki. Some basic, inexpensive laser printers do not support PostScript, instead coming with drivers that simply rasterize the platform's native graphics formats rather than converting them to PostScript first. When PostScript support

6076-686: The Java language in particular. In the 1990s, with the spread of the internet , standards like CORBA , COM , and DCOM competed to become the most common way to expose API services. Roy Fielding 's dissertation Architectural Styles and the Design of Network-based Software Architectures at UC Irvine in 2000 outlined Representational state transfer (REST) and described the idea of a "network-based Application Programming Interface" that Fielding contrasted with traditional "library-based" APIs. XML and JSON web APIs saw widespread commercial adoption beginning in 2000 and continuing as of 2021. The web API

6200-512: The Java remote method invocation API uses the Java Remote Method Protocol to allow invocation of functions that operate remotely, but appear local to the developer. Therefore, remote APIs are useful in maintaining the object abstraction in object-oriented programming ; a method call , executed locally on a proxy object, invokes the corresponding method on the remote object, using the remoting protocol, and acquires

6324-556: The Linux Standard Base provides an ABI. Remote APIs allow developers to manipulate remote resources through protocols , specific standards for communication that allow different technologies to work together, regardless of language or platform. For example, the Java Database Connectivity API allows developers to query many different types of databases with the same set of functions, while

SECTION 50

#1732780469376

6448-476: The TrueType effort based on Apple's existing efforts. Another project, apparently unrelated at first, attempted to address problems with the conversion from QuickDraw into various printer output formats. Whereas developers had earlier been forced to write their own code to convert their QuickDraw on-screen display to PostScript for printing, under the new printer architecture such conversions would be provided by

6572-535: The X11 system led to its introduction and widespread use on Sun systems, and NeWS never became widely used. The PDF and PostScript share the same imaging model and both documents are mutually convertible to each other. Both documents produce the same result when printed. The difference between the PDF and PostScript is that the PDF lacks the general-purpose programming language framework of the PostScript language. A PDF document

6696-601: The array and dictionary types, but cannot be declared to the type system, which sees them all only as arrays and dictionaries, so any further typing discipline to be applied to such user-defined "types" is left to the code that implements them. The character "%" is used to introduce comments in PostScript programs. As a general convention, every PostScript program should start with the characters "%!PS" as an interpreter directive so that all devices will properly interpret it as PostScript. Typically, PostScript programs are not produced by humans, but by other programs. However, it

6820-460: The "level" terminology in favor of simple versioning) came at the end of 1997, and along with many new dictionary-based versions of older operators, introduced better color handling and new filters (which allow in-program compression/decompression, program chunking, and advanced error-handling). PostScript 3 was significant in terms of replacing the existing proprietary color electronic prepress systems, then widely used for magazine production, through

6944-417: The 1940s, though the term did not emerge until the 1960s and 70s. An API opens a software system to interactions from the outside. It allows two software systems to communicate across a boundary — an interface — using mutually agreed-upon signals. In other words, an API connects software entities together. Unlike a user interface , an API is typically not visible to users. It is an "under the hood" portion of

7068-461: The API that will be removed or not supported in the future. Client code may contain innovative or opportunistic usages that were not intended by the API designers. In other words, for a library with a significant user base, when an element becomes part of the public API, it may be used in diverse ways. On February 19, 2020, Akamai published their annual “State of the Internet” report, showcasing

7192-435: The API. The term API initially described an interface only for end-user-facing programs, known as application programs . This origin is still reflected in the name "application programming interface." Today, the term is broader, including also utility software and even hardware interfaces . The idea of the API is much older than the term itself. British computer scientists Maurice Wilkes and David Wheeler worked on

7316-782: The GX printing architecture, though the text management and color management architectures survived. Elements of the text management architecture became part of the TrueType Specification and elements of the color management architecture became part of the International Color Consortium specification. With the advent of Mac OS X, portions of GX live on in Apple Type Services for Unicode Imaging (ATSUI), and in ColorSync , whose file format

7440-544: The Interpress language. Warnock left with Chuck Geschke and founded Adobe Systems in December 1982. They, together with Doug Brotz, Ed Taft and Bill Paxton created a simpler language, similar to Interpress, called PostScript, which went on the market in 1984. Meanwhile, in the spring of 1983, Steve Jobs came to visit Adobe and was dazzled by PostScript's potential, especially for the new Macintosh computer he

7564-478: The Macintosh computers to which it was attached. When the laser printer engines themselves cost over a thousand dollars the added cost of PS was marginal. But, as printer mechanisms fell in price, the cost of implementing PS became too great a fraction of overall printer cost. In addition, with desktop computers becoming more powerful during the 1990s than their attached printers, it no longer made sense to offload

SECTION 60

#1732780469376

7688-411: The OS. Additionally the new system was deliberately engineered to be as flexible as possible, supporting not only QD and PS printers, but potentially other standards such as Hewlett-Packard 's PCL as well. The system also supported "desktop printers" (printers that appeared as icons on the user's desktop), a long sought-after feature missing from QD, and added improved printing dialogs and controls. It

7812-502: The POSIX APIs. Microsoft has shown a strong commitment to a backward-compatible API, particularly within its Windows API (Win32) library, so older applications may run on newer versions of Windows using an executable-specific setting called "Compatibility Mode". An API differs from an application binary interface (ABI) in that an API is source code based while an ABI is binary based. For instance, POSIX provides APIs while

7936-402: The PS system in the computer rather than the printer. This led to the natural evolution of PS from a printing system to one that could also be used as the host's own graphics language. There were numerous advantages to this approach; not only did it help eliminate the possibility of different output on screen and printer, but it also provided a powerful graphics system for the computer, and allowed

8060-524: The PostScript licensing deal, and Adobe had to shift focus immediately from high-end, high-resolution printing devices to the consumer-oriented Apple LaserWriter laser printer. At that time, the 300-dpi Canon laser printing engine to be used in LaserWriters was seen as good enough only for proof printing (i.e., for crude rough drafts of material whose final drafts would be sent to professional high-resolution devices), but Jobs presented Adobe with

8184-561: The announcement of TrueType, Adobe published the specification for the Type 1 font format. Retail tools such as Altsys Fontographer (acquired by Macromedia in January 1995, owned by FontLab since May 2005) added the ability to create Type 1 fonts. Since then, many free Type 1 fonts have been released; for instance, the fonts used with the TeX typesetting system are available in this format. In

8308-401: The application programming interface separately from other interfaces, such as the query interface. Database professionals in the 1970s observed these different interfaces could be combined; a sufficiently rich application interface could support the other interfaces as well. This observation led to APIs that supported all types of programming, not just application programming. By 1990, the API

8432-400: The architect and technical lead for QuickDraw GX. He had worked on Color QuickDraw , and went on to become an early member of Rocket Science Games and WebTV. Keith McGreggor was the manager of the graphics group and the primary developer of the color architecture for QuickDraw GX, and Robert Johnson was the resident mathematician. Other developers on the project include: Dave G. Opstad was

8556-405: The architect of the typography engine and the shaping tables in Apple's fonts. He went on to become tech lead at Monotype Imaging. Others who worked on TrueType GX include: PostScript PostScript ( PS ) is a page description language and dynamically typed , stack-based programming language . It is most commonly used in the electronic publishing and desktop publishing realm, but as

8680-617: The basis for handling PostScript outlines in OpenType fonts. The CID-keyed font format was also designed, to solve the problems in the OCF/Type 0 fonts , for addressing the complex Asian-language ( CJK ) encoding and very large character set issues. The CID-keyed font format can be used with the Type 1 font format for standard CID-keyed fonts, or Type 2 for CID-keyed OpenType fonts. To compete with Adobe's system, Apple designed their own system, TrueType , around 1991. Immediately following

8804-452: The challenge of making PostScript render high-quality output to such a low-resolution device (which for most consumers would be their only printing device). In response, Warnock and Brotz solved the so-called "appearance problem" of making the stem width of letters scale properly so that they look good at all resolutions. Their breakthrough was so important that Adobe has never patented the technology, in order to keep its details concealed as

8928-548: The change in printing systems presented serious real-world issues. While PostScript printing had never been easy, over the years since the release of the original LaserWriter , developers had built up a library of solutions to common problems. With the change in architecture for GX, most of these stopped working. New "GX drivers" were needed for printers as well, and Apple didn't supply drivers for all of their own printers, let alone any third-party ones. Printing problems were endemic, and so difficult to fix that users often gave up on

9052-434: The color to red, and then draws a square. From that point on the program no longer has to explicitly set the color before drawing, the GX system itself will always correctly set the drawing color when asked to draw a redBox , and reset it when finished. Since this state was private, and sent to GX if and when needed, GX theoretically allowed the Mac OS to support protected memory, as state was no longer shared directly between

9176-454: The complex B-splines and advanced region filling options of PostScript. In order to take full advantage of PostScript printing, applications on the computers had to re-implement those features using the host platform's own graphics system. This led to numerous issues where the on-screen layout would not exactly match the printed output, due to differences in the implementation of these features. As computer power grew, it became possible to host

9300-460: The composition without changing the source character string, for instance, the ligature ffi is placed at the position of capital Y in Adobe font products, and "Adobe Offices" is composed by typing "Adobe O" <change font> "Y" <change font> "ces". In the layout the character string is broken, and in PDF made from streamed PostScript the characters f+f+i can only be reconstructed, if the name of

9424-542: The diagram. Additionally, a set of "bindings" was provided to allow PS code to be called directly from the C programming language . NeXT used these bindings in their NeXTStep system to provide an object oriented graphics system. Although DPS was written in conjunction with NeXT, Adobe sold it commercially and it was a common feature of most Unix workstations in the 1990s. Sun Microsystems took another approach, creating NeWS . Instead of DPS's concept of allowing PS to interact with C programs, NeWS instead extended PS into

9548-415: The early 1990s, there were several other systems for storing outline-based fonts, developed by Bitstream and Metafont for instance, but none included a general-purpose printing solution and they were therefore not widely used. In the late 1990s, Adobe joined Microsoft in developing OpenType , essentially a functional superset of the Type 1 and TrueType formats. When printed to a PostScript output device,

9672-402: The font by specifying values for the variation axes before they could use it, GX allowed the user to specify the font directly for a layout style, and then dynamically vary the axis values and immediately observe the effect on the layout of the text. This technology became the core of what Microsoft and Adobe would adopt in 2016, with its development of OpenType Variable Fonts . Cary Clark was

9796-420: The form of different libraries that share the same programming interface. The separation of the API from its implementation can allow programs written in one language to use a library written in another. For example, because Scala and Java compile to compatible bytecode , Scala developers can take advantage of any Java API. API use can vary depending on the type of programming language involved. An API for

9920-529: The glyph follows a glyph naming list. Contextual substitutions can be controlled by enabling or disabling the composition options of a TrueType GX font in WorldText on the Mac OS 9 CD or in TextEdit in Mac OS X. Fonts commonly have features called "common ligatures" (such as the "fl" example), "rare ligatures" (such as inscriptional ME and MD ligatures), "archaic non-terminal s" (for automatically substituting

10044-476: The growing trend of cybercriminals targeting public API platforms at financial services worldwide. From December 2017 through November 2019, Akamai witnessed 85.42 billion credential violation attacks. About 20%, or 16.55 billion, were against hostnames defined as API endpoints. Of these, 473.5 million have targeted financial services sector organizations. API documentation describes what services an API offers and how to use those services, aiming to cover everything

10168-490: The implementation details of the modules so that users of modules need not understand the complexities inside the modules. Thus, the design of an API attempts to provide only the tools a user would expect. The design of programming interfaces represents an important part of software architecture , the organization of a complex piece of software. APIs are one of the more common ways technology companies integrate. Those that provide and use APIs are considered as being members of

10292-426: The implementation. In contrast to a user interface , which connects a computer to a person, an application programming interface connects computers or pieces of software to each other. It is not intended to be used directly by a person (the end user ) other than a computer programmer who is incorporating it into software. An API is often made up of different parts which act as tools or services that are available to

10416-405: The inch. Thus: For example, in order to draw a vertical line of 4 cm length, it is sufficient to type: More readably and idiomatically, one might use the following equivalent, which demonstrates a simple procedure definition and the use of the mathematical operators mul and div : (Technically, most printers have a construction-implied unprintable margin around the physical borders of

10540-431: The inclusion of font hinting , in which additional information is provided in horizontal or vertical bands to help identify the features in each letter that are important for the rasterizer to maintain. The result was significantly better-looking fonts even at low resolution. It had formerly been believed that hand-tuned bitmap fonts were required for this task. At the time, the technology for including these hints in fonts

10664-566: The introduction of smooth shading operations with up to 4096 shades of grey (rather than the 256 available in PostScript Level 2), as well as DeviceN, a color space that allowed the addition of additional ink colors (called spot colors ) into composite color pages. Prior to the introduction of Interpress and PostScript, printers were designed to print character output given the text—typically in ASCII —as input. There were

10788-608: The letter "s" with the archaic form that looked more like an "f", except at the ends of words), and even choices between entirely separate sets of glyph designs, such as more and less ornate forms. The rules for performing contextual substitutions are implemented as state machines built into the font, and interpreted by the LLM Line Layout Manager, the counterpart of the CMM Color Management Module for ColorSync services. Text management in

10912-408: The licensing fees for their implementation of PostScript for printers, known as a raster image processor or RIP . As a number of new RISC -based platforms became available in the mid-1980s, some found Adobe's support of the new machines to be lacking. This and issues of cost led to third-party implementations of PostScript becoming common, particularly in low-cost printers (where the licensing fee

11036-428: The operating system allowed QuickDraw GX to accept character strings with any mix of writing systems and scripts, and compose the strings automatically, whether the encoding was Unicode 1.0 or 8 bit and 8/16 bit encodings. Another interesting feature was font "variations," which were the GX equivalent of Adobe's " multiple master " fonts. Whereas Adobe's fonts required the user explicitly create an "instance" of

11160-419: The order of operations unambiguous, but reading a program requires some practice, because one has to keep the layout of the stack in mind. Most operators (what other languages term functions ) take their arguments from the stack, and place their results onto the stack. Literals (for example, numbers) have the effect of placing a copy of themselves on the stack. Sophisticated data structures can be built on

11284-494: The printers to be "dumb" at a time when the cost of the laser engines was falling. In a production setting, using PostScript as a display system meant that the host computer could render low-resolution to the screen, higher resolution to the printer, or simply send the PS code to a smart printer for offboard printing. However, PostScript was written with printing in mind, and had numerous features that made it unsuitable for direct use in an interactive display system. In particular, PS

11408-400: The programmer can organize drawing to draw groups of similarly styled objects at the same time and thereby save time. The disadvantage of this approach is that it is easy to "forget" to change state and end up causing problems, so easy that programmers often saved and restored the complete state before every drawing command, thereby potentially lowering performance. The drawing state under GX

11532-614: The programmer from dealing with idiosyncrasies of the graphics display device, and to provide hardware independence if the computer or the display were replaced. The term was introduced to the field of databases by C. J. Date in a 1974 paper called The Relational and Network Approaches: Comparison of the Application Programming Interface . An API became a part of the ANSI/SPARC framework for database management systems . This framework treated

11656-416: The programmer. A program or a programmer that uses one of these parts is said to call that portion of the API. The calls that make up the API are also known as subroutines , methods, requests, or endpoints . An API specification defines these calls, meaning that it explains how to use or implement them. One purpose of APIs is to hide the internal details of how a system works, exposing only those parts

11780-408: The programs and graphics system. This contrasts strongly with the original QuickDraw, where the programmer was responsible for all state changes. For instance, if one were to draw a redBox and then a series of lines, the lines would also appear in red unless the programmer explicitly changed the color first. The advantage to this approach is that it minimizes the number of commands needed to set state;

11904-435: The rasterization work onto the resource-constrained printer. By 2001, few low-end printer models came with onboard support for PostScript, largely due to growing competition from much cheaper non-PostScript inkjet printers, and new software-based methods to render PostScript images on computers, making them suitable for any printer. PDF , a descendant of PostScript, provides one such method, and has largely replaced PostScript as

12028-471: The region between a change of text direction, GX itself would provide the smarts to determine which character position in the original text corresponded to the click. An important distinction in GX was drawn between a character and a glyph , a distinction also found in the Unicode Standard. A character was an abstract symbol from the character set of a writing system, such as the letter "f" in

12152-442: The result to be used locally as a return value. A modification of the proxy object will also result in a corresponding modification of the remote object. Web APIs are the defined interfaces through which interactions happen between an enterprise and applications that use its assets, which also is a Service Level Agreement (SLA) to specify the functional provider and expose the service path or URL for its API users. An API approach

12276-451: The sheet, and the 0 0 coordinates are calibrated to its corner, so you might have to use a different starting point to actually see something.) Most implementations of PostScript use single-precision reals (24-bit mantissa), so it is not meaningful to use more than 9 decimal digits to specify a real number, and performing calculations may produce unacceptable round-off errors. API An application programming interface ( API )

12400-452: The similar OpenJDK project. Judge William Alsup ruled in the Oracle v. Google case that APIs cannot be copyrighted in the U.S. and that a victory for Oracle would have widely expanded copyright protection to a "functional set of symbols" and allowed the copyrighting of simple software commands: To accept Oracle's claim would be to allow anyone to copyright one version of code to carry out

12524-566: The standard outline font technology for both Windows and the Macintosh. Today, third-party PostScript-compatible interpreters are widely used in printers and multifunction peripherals (MFPs). For example, CSR plc 's IPS PS3 interpreter, formerly known as PhoenixPage, is standard in many printers and MFPs, including those developed by Hewlett-Packard and sold under the LaserJet and Color LaserJet lines. Other third-party PostScript solutions used by print and MFP manufacturers include Jaws and

12648-406: The state to be set for an entire complex object. One part of the overall drawing state was the gxMapping . This was a 3-by-3 matrix which could express arbitrary linear transformations in two dimensions, including perspective distortions. All GX objects had an associated mapping as part of its drawing state, which allowed for things like rotations and translations. Although all of this state

12772-547: The system in frustration. User uptake of GX was very close to zero, as was the case for most of the new technologies Apple released in the early 1990s. It might have seen widespread use as a part of the Copland project, but Copland never launched. Although Apple continued to state GX was the future of graphics on the Mac, by 1995 it was clear they were no longer "pushing" it, frustrating its supporters. Mac OS 8 dropped support for

12896-449: The system—a problem most Apple products of the era suffered from (see PowerTalk for instance). As a result, the developer appeal was limited; a lot of effort would be required to use the system in programs, and the resulting application could only run on a subset of the installed base. The number of GX-based (as opposed to GX- compatible ) programs numbered less than six, including Pixar's Typestry and Softpress's UniQorn . Additionally,

13020-472: The technology were left with the Type 3 Font (also known as PostScript Type 3 Font , PS3 or T3 ). Type 3 fonts allowed for all the sophistication of the PostScript language, but without the standardized approach to hinting. The Type 2 font format was designed to be used with Compact Font Format (CFF) charstrings, and was implemented to reduce the overall font file size. The CFF/Type2 format later became

13144-424: The two abstract characters "f" and "l" occurred in sequence in the source text. This distinction was important in that such contextual substitutions occurred at rendering time, without any changes to the source character string. Thus they had no impact on editing or searching of the text. PostScript Type 1 font files have one to one mapping only, and as ligatures are many to one mappings, they can not be inserted into

13268-460: The unneeded parts of the OpenType font are omitted, and what is sent to the device by the driver is the same as it would be for a TrueType or Type 1 font, depending on which kind of outlines were present in the OpenType font. Adobe supported Type 1 fonts in its products until January 2023, when it fully removed support in favor of OpenType fonts. In the 1980s, Adobe drew most of its revenue from

13392-461: The user could select, and some models allowed users to upload their own custom glyphs into the printer. Dot matrix printers also introduced the ability to print raster graphics . The graphics were interpreted by the computer and sent as a series of dots to the printer using a series of escape sequences . These printer control languages varied from printer to printer, requiring program authors to create numerous drivers . Vector graphics printing

13516-526: The writing systems of the Latin script. Whereas a glyph was a specific graphic shape from a particular font, whether the shape represented a single character or a set of characters. Thus, for example, the Hoefler Text font had glyphs to represent the letters "f" and "l". It also had another glyph to represent the ligature "fl", which could be automatically composed (instead of the individual glyphs) wherever

13640-418: Was added when Level 2 was introduced. PostScript Level 2 was introduced in 1991, and included several improvements: improved speed and reliability, support for in-Raster Image Processing (RIP) separations, image decompression (for example, JPEG images could be rendered by a PostScript program), support for composite fonts , and the form mechanism for caching reusable content. PostScript 3 (Adobe dropped

13764-401: Was based on the idea of collecting up PS commands until the showpage command was seen, at which point all of the commands read up to that point were interpreted and output. In an interactive system, this was clearly not appropriate, nor did PS have any sort of interactivity built in; for example, supporting hit detection for mouse interactivity obviously did not apply when PS was being used on

13888-416: Was built around a number of types of objects which were premade, though a full set of API calls was available for examining and manipulating them: GX shapes could be of various types: The typography features of GX were integrated in the form of 3 types of gxShape: The GX API also provided hit-testing functions, so that for example if the user clicked on a layout shape in the middle of a ligature , or in

14012-421: Was bundled with System 7.5 later that year and it was not successful. The package was large enough to strain the memory of most existing Macintosh computers of the era, and arguments like "you can now print to PostScript" were less than impressive considering many existing programs had already added such support. Users and developers generally ignored GX, and a market for the system simply never appeared. There

14136-484: Was carefully guarded, and the hinted fonts were compressed and encrypted into what Adobe called a Type 1 Font (also known as PostScript Type 1 Font , PS1 , T1 or Adobe Type 1 ). Type 1 was effectively a simplification of the PS system to store outline information only, as opposed to being a complete language (PDF is similar in this regard). Adobe would then sell licenses to the Type 1 technology to those wanting to add hints to their own fonts. Those who did not license

14260-455: Was defined simply as "a set of services available to a programmer for performing certain tasks" by technologist Carl Malamud . The idea of the API was expanded again with the dawn of remote procedure calls and web APIs . As computer networks became common in the 1970s and 80s, programmers wanted to call libraries located not only on their local computers, but on computers located elsewhere. These remote procedure calls were well supported by

14384-437: Was developing at Apple . To John Sculley 's frustration, Jobs licensed the PostScript technology from Adobe by offering a $ 1.5 million advance against PostScript royalties, plus $ 2.5 million in exchange for 20 percent of Adobe shares. During a series of meetings in 1983, Jobs also repeatedly offered for Apple to buy Adobe outright, but the founders kept turning him down. In December 1983, the two companies finally signed off on

14508-623: Was eventually used in the Xerox Star system to drive laser printers. But Press, a data format rather than a language, lacked flexibility, and PARC mounted the Interpress effort to create a successor. In 1978, John Gaffney and Martin Newell then at Xerox PARC wrote J & M or JaM (for "John and Martin") which was used for VLSI design and the investigation of type and graphics printing. This work later evolved and expanded into

14632-455: Was first released, one review noted, "QuickDraw GX isn't for everyone and requires more RAM than many Macs have to spare." Additionally, the API for the system was very large, filling several books. Implementing a GX program was no easy feat, even though the development was supposed to be easier. This was not a problem of the GX architecture itself, but a side effect of the "all-inclusive" nature of

14756-506: Was five percent of the list price for each laser printer sold, which was $ 350 of the original LaserWriter list price of $ 6,995, and such royalties provided nearly all of Adobe's income during its early years. (Apple later renegotiated the contract to pay a licensing fee based on volume of printers shipped.) The combination of technical merits and widespread availability made PostScript the language of choice for graphical output for printing applications. An interpreter (sometimes referred to as

14880-452: Was held in the gxMapping for that object, GX also provided "wrapper" commands like "rotate" to make the API simpler to use. Unlike QuickDraw, QuickDraw GX allowed for fractional coordinates. However, these were fixed-point values, rather than floating-point . At the time GX was being developed (late 1980s to early 1990s), there was still a significant performance penalty in using floating-point arithmetic. The GX graphics architecture

15004-430: Was hierarchical. A default drawing mode was created with every window, as it was under QD, and drawing objects with no other state changes would use these defaults. The programmer could then change state in the objects themselves, as in our redBox example, or alternately change the state of all drawing by setting the state in the window object. GX objects could be easily collected into groups, themselves objects, allowing

15128-511: Was left to special-purpose devices, called plotters . Almost all plotters shared a common command language, HPGL , but were of limited use for anything other than printing graphics. In addition, they tended to be expensive and slow, and thus rare. Laser printers combine the best features of both printers and plotters. Like plotters, laser printers offer high quality line art, and like dot-matrix printers, they are able to generate pages of text and raster graphics. Unlike either printers or plotters,

15252-470: Was one such victim, and delays and changes of direction in TrueType and other problems greatly delayed the introduction of GX. Discussions of GX technology started appearing in various trade magazines around 1992, notably Apple's own develop . At the time it appeared release was imminent, perhaps late 1992 or early 1993. GX was initially released in about January 1994, as a separate package. Version 1.1.1

15376-450: Was the sticking point) or in high-end typesetting equipment (where the quest for speed demanded support for new platforms faster than Adobe could provide). At one point, Microsoft licensed to Apple a PostScript-compatible interpreter it had bought called TrueImage , and Apple licensed to Microsoft its new font format, TrueType . Apple ended up reaching an accord with Adobe and licensed genuine PostScript for its printers, but TrueType became

#375624