An application programming interface (API) is a specification intended to be used as an interface by software components to communicate with each other. An API may include specifications for routines, data structures, object classes, and variables. An API specification can take many forms, including an International Standard such as POSIX or vendor documentation such as the Microsoft Windows API, or the libraries of a programming language, e.g. Standard Template Library in C++ or Java API.

An API differs from an application binary interface (ABI) in that the former is source code based while the latter is a binary interface. For instance POSIX is an API, while the Linux Standard Base is an ABI.^[1]

Language used[link]

An API can be:

• language-dependent, meaning it is only available by using the syntax and elements of a particular language, which makes the API more convenient to use.
• language-independent, written so that it can be called from several programming languages. This is a desirable feature for a service-oriented API that is not bound to a specific process or system and may be provided as remote procedure calls or web services. For example, a website that allows users to review local restaurants is able to layer their reviews over maps taken from Google Maps, because Google Maps has an API that facilitates this functionality. Google Maps' API controls what information a third-party site can use and how they can use it.

The term API may be used to refer to a complete interface, a single function, or even a set of APIs provided by an organization. Thus, the scope of meaning is usually determined by the context of usage.

Detailed explanation[link]

An API may describe the ways in which a particular task is performed. In procedural languages like C language the action is usually mediated by a function call. Hence the API usually includes a description of all the functions/routines it provides. For instance: the math.h include file for the C language contains the definition of the function prototypes of the mathematical functions available in the C language library for mathematical processing (usually called libm). This file describes how to use the functions included in the given library: the function prototype is a signature that describes the number and types of the parameters to be passed to the functions and the type of the return value. The behavior of the functions is usually described in more details in a human readable format in printed books or in electronic formats like the man pages: e.g. on Unix systems the command man 3 sqrt will present the signature of the function sqrt in the form: <source lang="C"> SYNOPSIS

           #include <math.h>
           double sqrt(double X);
           float  sqrtf(float X);

DESCRIPTION

      DESCRIPTION
      sqrt computes the positive square root of the argument. ...

RETURNS

      On success, the square root is returned. If X is real and positive...

</source>

That means that the function returns the square root of a positive floating point number (single or double precision) as another floating point number. Hence the API in this case can be interpreted as the collection of the include files used by the C language and its human readable description provided by the man pages.

Documentation[link]

Many program development environments provide the documentation associated with an API in some digital format, e.g. perl comes with the tool perldoc: <source lang="perl"> $ perldoc -f sqrt

      sqrt EXPR
      sqrt    #Return the square root of EXPR.  If EXPR is omitted, returns
              #square root of $_.  Only works on non-negative operands, unless
              #you've loaded the standard Math::Complex module.

</source>

python comes with the tool pydoc:

<source lang="python"> $ pydoc math.sqrt Help on built-in function sqrt in math: math.sqrt = sqrt(...)

   sqrt(x)
   Return the square root of x. 

</source>

ruby comes with the tool ri: <source lang="ruby"> $ ri Math::sqrt

Math::sqrt

    Math.sqrt(numeric)    => float

    Returns the non-negative square root of _numeric_.

</source>

Java comes with the documentation organized in HTML pages (JavaDoc format), while Microsoft distributes the API documentation for its languages (Visual C++, C#, Visual Basic, F#, etc...) embedded in Visual Studio's help system.

API in object-oriented languages[link]

In object-oriented languages, an API usually includes a description of a set of class definitions, with a set of behaviors associated with those classes. A behavior is the set of rules for how an object, derived from that class, will act in a given circumstance. This abstract concept is associated with the real functionalities exposed, or made available, by the classes that are implemented in terms of class methods (or more generally by all its public components hence all public methods, but also possibly including any internal entity made public, like fields, constants, nested objects, enums...).

The API in this case can be conceived as the totality of all the methods publicly exposed by the classes (usually called the class interface). This means that the API prescribes the methods by which one interacts with/handles the objects derived from the class definitions.

More generally, one can see the API as the collection of all the kinds of objects one can derive from the class definitions, and their associated possible behaviors. Again: the use is mediated by the public methods, but in this interpretation, the methods are seen as a technical detail of how the behavior is implemented.

For instance: a class representing a Stack can simply expose publicly two methods push() (to add a new item to the stack), and pop() (to extract the last item, ideally placed on top of the stack).

In this case the API can be interpreted as the two methods pop() and push(), or, more generally, as the idea that one can use an item of type Stack that implements the behavior of a stack: a pile exposing its top to add/remove elements. The second interpretation appears more appropriate in the spirit of object orientation.

This concept can be carried to the point where a class interface in an API has no methods at all, but only behaviors associated with it. For instance, the Java language and Lisp (programming language) API include the interface Serializable, which is a marker interface that requires that each class that implements it should behave in a serialized fashion. This does not require to have any public method, but rather requires that any class that implements it to have a representation that can be saved (serialized) at any time (this is typically true for any class containing simple data and no link to external resources, like an open connection to a file, a remote system, or an external device).

Similarly the behavior of an object in a concurrent (multi-threaded) environment is not necessarely determined by specific methods, belonging to the interface implemented, but still belongs to the API for that Class of objects, and should be described in the documentation.^[2]

In this sense, in object-oriented languages, the API defines a set of object behaviors, possibly mediated by a set of class methods.

In such languages, the API is still distributed as a library. For example, the Java language libraries include a set of APIs that are provided in the form of the JDK used by the developers to build new Java programs. The JDK includes the documentation of the API in JavaDoc notation.

The quality of the documentation associated with an API is often a factor determining its success in terms of ease of use.

API libraries and frameworks[link]

An API is usually related to a software library: the API describes and prescribes the expected behavior while the library is an actual implementation of this set of rules. A single API can have multiple implementations (or none, being abstract) in the form of different libraries that share the same programming interface.

An API can also be related to 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 hands of the framework via inversion of control or a similar mechanisms.^[3]

API and protocols[link]

An API can also be an implementation of a protocol.

In general the difference between an API and a protocol is that the protocol defines a standard way to exchange requests and responses based on a common transport and agreeing on a data/message exchange format, while an API (not implementing a protocol) is usually implemented as a library to be used directly: hence there can be no transport involved (no information physically transferred from/to some remote machine), but rather only simple information exchange via function calls (local to the machine where the elaboration takes place) and data is exchanged in formats expressed in a specific language.^[4]

When an API implements a protocol it can be based on proxy methods for remote invocations that underneath rely on the communication protocol. The role of the API can be exactly to hide the detail of the transport protocol. E.g.: RMI is an API that implements the JRMP protocol or the IIOP as RMI-IIOP.

Protocols are usually shared between different technologies (system based on given computer programming languages in a given operating system) and usually allow the different technologies to exchange information, acting as an abstraction/mediation level between the two worlds. While APIs can be specific to a given technology: hence the APIs of a given language cannot be used in other languages, unless the function calls are wrapped with specific adaptation libraries.

Object API and protocols[link]

An object API can prescribe a specific object exchange format, an object exchange protocol can define a way to transfer the same kind of information in a message sent to a remote system.

When a message is exchanged via a protocol between two different platforms using objects on both sides, the object in a programming language can be transformed (marshalled and unmarshalled) in an object in a remote and different language: so, e.g., a program written in Java invokes a service via SOAP or IIOP written in C# both programs use APIs for remote invocation (each locally to the machine where they are working) to (remotely) exchange information that they both convert from/to an object in local memory.

Instead when a similar object is exchanged via an API local to a single machine the object is effectively exchanged (or a reference to it) in memory: e.g. via the memory allocated by a single process, or among multiple processes using shared memory or other sharing techologies like tuple spaces.

API sharing and reuse via virtual machine[link]

Some languages like those running in a virtual machine (e.g. .NET CLI compliant languages in the Common Language Runtime and JVM compliant languages in the Java Virtual Machine) can share APIs.

In this case the virtual machine enables the language interoperation thanks to the common denominator of the virtual machine that abstracts from the specific language using an intermediate bytecode and its language binding.

Hence this approach maximizes the code reuse potential for all the existing libraries and related APIs.

Web APIs[link]

When used in the context of web development, an API is typically defined as a set of Hypertext Transfer Protocol (HTTP) request messages, along with a definition of the structure of response messages, which is usually in an Extensible Markup Language (XML) or JavaScript Object Notation (JSON) format. While "Web API" is virtually a synonym for web service, the recent trend (so-called Web 2.0) has been moving away from Simple Object Access Protocol (SOAP) based services towards more direct Representational State Transfer (REST) style communications.^[5] Web APIs allow the combination of multiple services into new applications known as mashups.^[6]

Web use to share content[link]

The practice of publishing APIs has allowed web communities to create an open architecture for sharing content and data between communities and applications. In this way, content that is created in one place can be dynamically posted and updated in multiple locations on the web.

1. Photos can be shared from sites like Flickr and Photobucket to social network sites like Facebook and MySpace.
2. Content can be embedded, e.g. embedding a presentation from SlideShare on a LinkedIn profile.
3. Content can be dynamically posted. Sharing live comments made on Twitter with a Facebook account, for example, is enabled by their APIs.
4. Video content can be embedded on sites which are served by another host.
5. User information can be shared from web communities to outside applications, delivering new functionality to the web community that shares its user data via an open API. One of the best examples of this is the Facebook Application platform. Another is the Open Social platform.^[7]

Implementations[link]

The POSIX standard defines an API that allows a wide range of common computing functions to be written in a way such that they may operate on many different systems (Mac OS X, and various Berkeley Software Distributions (BSDs) implement this interface); however, making use of this requires re-compiling for each platform. A compatible API, on the other hand, allows compiled object code to function without any changes to the system implementing that API. This is beneficial to both software providers (where they may distribute existing software on new systems without producing and distributing upgrades) and users (where they may install older software on their new systems without purchasing upgrades), although this generally requires that various software libraries implement the necessary APIs as well.

Microsoft has shown a strong commitment to a backward compatible API, particularly within their Windows API (Win32) library, such that older applications may run on newer versions of Windows using an executable-specific setting called "Compatibility Mode".^[8]

Apple Inc. has shown less concern, breaking compatibility or implementing an API in a slower "emulation mode"; this allows greater freedom in development, at the cost of making older software obsolete.^{[citation needed]}

Among Unix-like operating systems, there are many related but incompatible operating systems running on a common hardware platform (particularly Intel 80386-compatible systems). There have been several attempts to standardize the API such that software vendors may distribute one binary application for all these systems; however, to date, none of these have met with much success. The Linux Standard Base is attempting to do this for the Linux platform, while many of the BSD Unixes, such as FreeBSD, NetBSD, and OpenBSD, implement various levels of API compatibility for both backward compatibility (allowing programs written for older versions to run on newer distributions of the system) and cross-platform compatibility (allowing execution of foreign code without recompiling).

Release policies[link]

The two options for releasing API are:

1. Protecting information on APIs from the general public. For example, Sony used to make its official PlayStation 2 API available only to licensed PlayStation developers. This enabled Sony to control who wrote PlayStation 2 games. This gives companies quality control privileges and can provide them with potential licensing revenue streams.
2. Making APIs freely available. For example, Microsoft makes the Microsoft Windows API public, and Apple releases its APIs Carbon and Cocoa, so that software can be written for their platforms.

A mix of the two behaviors can be used as well.

APIs and Copyrights[link]

In 2010 Oracle sued Google for having distributed a new implementation of Java embedded in the Android operating system.^[9] The litigation concerns also the fact that Google did not acquire any permission to reproduce the Java API. Instead a similar permission was given to the OpenJDK project.

API examples[link]

• ASPI for SCSI device interfacing
• Carbon and Cocoa for the Macintosh
• DirectX for Microsoft Windows
• EHLLAPI
• Java APIs
• ODBC for Microsoft Windows
• OpenAL cross-platform sound API
• OpenCL cross-platform API for general-purpose computing for CPUs & GPUs
• OpenGL cross-platform graphics API
• OpenMP API that supports multi-platform shared memory multiprocessing programming in C, C++ and Fortran on many architectures, including Unix and Microsoft Windows platforms.
• Simple DirectMedia Layer (SDL)
• Talend integrates its data management with BPM from Bonita Open Solution

Language bindings and interface generators[link]

APIs that are intended to be used by more than one high-level programming language often provide, or are augmented with, facilities to automatically map the API to features (syntactic or semantic) that are more natural in those languages. This is known as language binding, and is itself an API. The aim is to encapsulate most of the required functionality of the API, leaving a "thin" layer appropriate to each language.

Below are listed some interface generator tools which bind languages to APIs at compile time.

• SWIG open-source interfaces bindings generator from many languages to many languages (Typically Compiled->Scripted)
• F2PY:^[10] Fortran to Python interface generator.

See also[link]

• Calling convention
• Comparison of application virtual machines
• CORBA
• DOM
• Double-chance function
• Foreign function interface
• List of 3D graphics APIs
• Name mangling
• Open Service Interface Definitions
• Platform-enabled website
• Plugin
• Software Development Kit
• XPCOM

References[link]

External links[link]

• How to design a good API and why it matters
• How to Write an API
• LMAX Application Programming Interface (API) technology

This biographical article needs additional citations for verification. Please help by adding reliable sources. Contentious material about living persons that is unsourced or poorly sourced must be removed immediately, especially if potentially libelous or harmful. (August 2009)

Pat Metheny
Background information
Born	(1954-08-12) August 12, 1954 (age 57) Lee's Summit. Missouri, United States
Genres	Jazz, jazz fusion, folk jazz world fusion, post-bop, jazz-rock, crossover jazz
Occupations	Musician, songwriter
Instruments	Electric guitar, acoustic guitar, guitar synthesizer
Years active	1974–present
Labels	ECM, Geffen, Nonesuch
Associated acts	Pat Metheny Group, Noa, The Orb, Steve Reich
Website	www.patmetheny.com
Notable instruments
Gibson ES-175 Ibanez PM20 Signature Model Ibanez PM100 Signature Model Ibanez PM35 Roland GR-300 Pikasso guitar

Patrick Bruce "Pat" Metheny (/məˈθiːni/mə-THEE-nee; born August 12, 1954) is an American jazz guitarist and composer.

He is the leader of the Pat Metheny Group and is also involved in duets, solo works and other side projects. His style incorporates elements of progressive and contemporary jazz, post-bop, latin jazz and jazz fusion.^[1] Pat Metheny has three gold albums and 19 Grammy Awards.^[2] He is the brother of jazz flugelhornist and journalist Mike Metheny.

Biography[link]

Metheny was born and raised in Lee's Summit, Missouri, a suburb southeast of Kansas City. Following his graduation from Lee's Summit High School, he briefly attended the University of Miami in Coral Gables, Florida in 1972, where he was quickly offered a teaching position. He then moved to Boston to take a teaching assistantship at the Berklee College of Music with jazz vibraphonist Gary Burton.^[3] He first made his name as a teenage prodigy under the wing of Burton.^[4] In 1974 he made his recording debut on two sessions for pianist Paul Bley's and Carol Goss' Improvising Artists label, along with fretless electric bassist Jaco Pastorius.

Metheny entered the wider jazz scene in 1975 when he joined Gary Burton's band, where he played alongside resident jazz guitarist Mick Goodrick. Goodrick was a 1967 alumnus of Berklee, who had held a teaching post there in the early 1970s. The two guitarists were interviewed jointly by Guitar Player Magazine in 1975, bringing them to the attention of fellow guitar aficionados around the world. Metheny's musical momentum carried him rapidly to the point that he had soon written enough material to record his debut album Bright Size Life with Pastorius and drummer Bob Moses.

Metheny's next recording, 1977's Watercolors, was the first to feature pianist Lyle Mays, Metheny's most frequent collaborator. The other musicians on this session were Eberhard Weber on upright bass and Danny Gottlieb on drums. Metheny's next album formalized his partnership with Mays and began the Pat Metheny Group, featuring several songs they co-wrote; the album was released as the eponymous Pat Metheny Group on West German musician/producer Manfred Eicher's ECM record label. Pat Metheny also has released notable solo, trio, quartet and duet recordings with musicians such as Jim Hall, Dave Holland, Roy Haynes, Toninho Horta, Gary Burton, Chick Corea, Pedro Aznar, Jaco Pastorius, Charlie Haden, John Scofield, Jack DeJohnette, Herbie Hancock, Bill Stewart, Ornette Coleman, Brad Mehldau, Joni Mitchell and many others.

Pat Metheny has also joined projects such as Song X with Ornette Coleman; Parallel Realities; and Jazz Baltica, with Ulf Wakenius and other Nordic jazz players like E.S.T., Nils Landgren and has played with unique singers from all over the world, such as Silje Nergaard on Tell Me Where You're Going (1990), Bruce Hornsby on Harbor Lights (1993) and Hot House (1995), Noa on Noa (1994), Abbey Lincoln on A Turtle's Dream (1994) and Anna Maria Jopek on Upojenie (2002). His collaboration with other great musicians also contains works with Milton Nascimento, Santana, Dominic Miller, Michael Brecker, Trilok Gurtu etc.

Pat Metheny has been touring for more than 30 years, playing between 120 and 240 concerts a year.

Pat Metheny Group[link]

The Pat Metheny Group is a fusion band founded in 1977. The first Pat Metheny Group release, 1978's Pat Metheny Group, featured the writing duo of Pat Metheny and pianist Lyle Mays, a collaboration which has spanned over 25 years and 15 albums. The recording featured the electric bass playing of Jaco Pastorius's protégé Mark Egan. The second group album, American Garage (1980), was a breakout hit, reaching #1 on the Billboard Jazz chart and crossing over onto the pop charts as well, largely on the strength of the up-tempo opening track "(Cross the) Heartland" which would become a signature tune for the group. This early incarnation of the group included Mark Egan on electric bass and Dan Gottlieb on drums.

The group built upon its success through constant touring across the USA and Europe. The early group featured a unique sound, particularly due to Metheny's Gibson ES-175 guitar coupled to two Eventide Clockworks' Harmonizer digital delay units and Mays' Oberheim and Sequential Circuits Prophet 5 synthesizers and Steinway piano. Even in this early state the band played in a wide range of styles from folk to rock to experimental. Metheny later started working with the Roland GR-300 guitar synthesizer and the Synclavier guitar system made by New England Digital. Mays expanded his setup with the Synclavier keyboard and later with various other synthesizers.

Left to right: Steve Rodby and Pat Metheny.

From 1982 to 1985 the Pat Metheny Group released Offramp (1982), a live set Travels (1983), and First Circle (1984), as well as The Falcon and the Snowman (1985), a soundtrack album for the movie of the same name in which they collaborated with David Bowie. A single from the soundtrack, 'This Is Not America', reached number 14 in the British Top 40 in early 1985 as well as number 32 in the USA.

Offramp marked the first appearance of bassist Steve Rodby (replacing Mark Egan) and Brazilian "guest artist" Nana Vasconcelos whose work on percussion and wordless vocals marked the first addition of Latin music shadings to the Group's sound, a trend which would continue and intensify on First Circle with the addition of Argentinian multi-instrumentalist Pedro Aznar, which also marked the group debut of drummer Paul Wertico (replacing Dan Gottlieb) - both Rodby and Wertico were members of the Fred Simon Group at the time, and had played in Simon-Bard as well, in Chicago, before joining Metheny.

This period became a peak of commercial popularity of the band, especially for the live recording Travels. First Circle would also be Metheny's last project with ECM Records; Metheny had been a key artist for ECM but left following conceptual disagreements with label founder Manfred Eicher. The next Pat Metheny Group releases would be based around a further intensification of the Brazilian rhythms first heard in the early 1980s. Additional Latin musicians appear as guests, notably Brazilian percussion player Armando Marçal. Still Life (Talking) (1987) was the Group's first release on new label Geffen Records, and featured several popular tracks, followed by Letter from Home (1989) which also featured Aznar and Marçal. During this period The Steppenwolf Theater Company of Chicago featured an assortment of compositions by Pat Metheny and Lyle Mays for their production of Lyle Kessler's play Orphans where it has remained special optional music for all productions of the play around the world since.

Metheny then again delved into adventurous solo and band projects, and four years went by before the release of the next record for the next Pat Metheny Group, a live set entitled The Road to You, which featured tracks from the two Geffen studio albums amongst new tunes. The group integrated new instrumentation and technologies into its work, notably Mays' unique playing technique accomplished by adding midi-controlled synth sounds at command during acoustic solos via a pedal on the piano.

Mays and Metheny themselves refer to the following three Pat Metheny Group releases as the triptych: We Live Here (1995), Quartet (1996), and Imaginary Day (1997). Moving away from the Latin style which had dominated the releases of the previous 10 years, these albums were the most wide-ranging and least commercial Group releases, including experimentations with sequenced synthetic drums on one track, free-form improvisation on acoustic instruments, and symphonic signatures, blues and sonata schemes.

After another hiatus, the Pat Metheny Group re-emerged in 2002 with the release Speaking of Now, another change in direction adding musicians to the band who are one generation younger and thus grew up with the Pat Metheny Group. The new members on the bandstand are the drummer Antonio Sanchez from Mexico City, trumpet player Cuong Vu, and bassist, vocalist, guitarist, and percussionist Richard Bona from Cameroon.

Metheny touring in 2003
Courtesy: Tyrone Lancaster

The latest release, 2005's The Way Up, is another large concept record which consists of one 68 minute-long piece (although split into four sections solely for CD navigation), a tightly organized, but not through-composed piece based on a pair of three-note kernels: The opening B, A#, F# and the derived B, A, F#. The reception of The Way Up was consistent, with standing ovations in each of the almost 90 concerts during the world tour 2005. On The Way Up, harmonica player Grégoire Maret from Switzerland was introduced as a new group member, while Richard Bona contributed only as a guest musician.

During the world tour Brazilian multi-instrumentalist Nando Lauria completed the line-up of the Pat Metheny Group. The Way Up was released through Nonesuch Records and all of Metheny's Geffen and Warner Brothers back catalogue is to be released on the label. Core members of the group are leader and founder, guitarist Pat Metheny, Lyle Mays (piano, keyboards) and Steve Rodby (double and electric bass) who joined in 1980. Drummer Paul Wertico replaced Dan Gottlieb in 1983 and continued to play with the group for more than 18 years, until he was replaced by Antonio Sanchez, currently also a member of The Pat Metheny Trio.

The current Pat Metheny Group members are Pat Metheny (guitars), Lyle Mays (piano and keyboards), Steve Rodby (double bass, electric bass), Antonio Sanchez (drums), Cuong Vu (trumpet). Other musicians that have been hired regularly for Metheny Group tours are: the late Mark Ledford (vocals, trumpet, guitar); David Blamires (vocals, miscellaneous instruments); Armando Marçal (percussion); Pedro Aznar (vocals, guitar, percussion); Richard Bona (vocals, guitar, bass, and percussion). On the most recent tour to promote the record "The Way Up", Grégoire Maret (harmonica, percussion, vocals) and Nando Lauria (guitar, percussion, vocals) joined the Group. Pat Metheny has collected 19 Grammy Awards, and of them, as part of The Pat Metheny Group, 10 of those awards were consecutive.

Side projects[link]

When working outside of the confines of the PMG, Metheny has shown different sides to his musical personality. On Secret Story (1992) and Orchestrion (2009), he has ventured into forms of orchestrating his music not covered by the PMG. In the late '80s Metheny began collaborating more with established jazz figures such as Ornette Coleman, Chick Corea, Michael Brecker, Joshua Redman, Charlie Haden, Jim Hall, Dave Holland, Christian McBride, David Sanchez and Roy Haynes. Despite his conversion from Brazilian and Latin jazz into more traditional jazz, Metheny still pushed the envelope in the mid-90s with avante garde albums in Zero Tolerance for Silence and The Sign of Four (with Derek Bailey). Metheny's latest side projects teams him with Brad Mehldau and his Trio. In 2006, Metheny appeared as a sideman on Brecker's last album, Pilgrimage.

Guitar contributions[link]

Pat Metheny and his guitar.

Continuing the tradition of jazz guitarists borrowing tones and techniques from their rock counterparts, Metheny has made alterations to the jazz guitar tone palette.

Twelve-string electric[link]

Prior to Metheny, Pat Martino had used the electric twelve-string guitar on a studio album, Desperado, and John McLaughlin had used a double-neck electric guitar with the Mahavishnu Orchestra. (Lenny Breau had introduced the acoustic twelve-string to jazz.^{[citation needed]}) Metheny introduced alternate 12-string tunings to jazz^{[citation needed]}; these can be heard on tunes such as "Sirabhorn" (from Bright Size Life) and San Lorenzo (from Pat Metheny Group and Travels).

Six-string electric[link]

Metheny's tone, which has evolved over the years, involves using the natural full-frequency response of his hollow-body guitar, combined with high-midrange settings on his amplifier to create a smooth, sustaining lead sound that is virtually devoid of piercing treble yet is able to cut through a dense mix. By using digital signal processing that involves digital delay/chorus and reverb, he has created a big, rich, and resonant instrumental voice.

Guitar synthesizer[link]

Metheny was also one of the first jazz guitarists to make heavy use of the Roland GR-300 Guitar Synthesizer. While John Abercrombie and Bill Frisell also used it heavily in the 1980s, Metheny is the only one of the three who still uses the instrument on a regular basis. Unlike many guitar synth users, Metheny limits himself to a very small number of sounds. In interviews, he has argued that each of the timbres achievable through guitar synthesis should be treated as a separate instrument, and that he has tried to master each of these "instruments" instead of using it for incidental color. One of the "patches" that Pat used often is on Roland's JV-80 "Vintage Synth" expansion card titled "Pat's GR-300".

42-string Pikasso guitar[link]

Metheny plays a custom-made Pikasso I created by Canadian luthier Linda Manzer on "Into the Dream" and on the albums Quartet, Imaginary Day, Jim Hall & Pat Metheny, Trio→Live, and the Speaking of Now Live and Imaginary Day DVDs. Metheny has also used the guitar in his guest appearances on other artist's albums.

Manzer has also made many acoustic guitars for Metheny, including a mini guitar, an acoustic sitar guitar, and also the baritone guitar, which Metheny used for the recording of One Quiet Night. His latest use of the Pikasso is found on the album Metheny Mehldau Quartet, his second collaboration with pianist Brad Mehldau and his trio sidemen Larry Grenadier and Jeff Ballard; the Pikasso is featured in Metheny's impressionistic composition "The Sound of Water."

Influences[link]

Metheny playing the guitar controller for the Roland GR300 Guitar Synthesizer.

As a young musician, Pat Metheny did everything he could to sound like Wes Montgomery, but when he was 14 or 15, he decided that he felt that it was disrespectful to imitate him.^[5] In the liner notes on the 2-disc Montgomery compilation Impressions: the Verve Jazz Sides, Metheny is quoted as saying, "(Smokin' at the Half Note) is the absolute greatest jazz-guitar album ever made. It is also the record that taught me how to play."

The angular compositions, asymmetrical lines, relentless rhythmic drive, and deep blues feeling of Ornette Coleman's New York is Now (Blue Note) inspired Metheny to find his own direction.^[6] He has recorded Coleman compositions on a number of his records (starting with a medley of "Round Trip" and "Broadway Blues" on his debut Bright Size Life); worked extensively with Coleman collaborators such as Charlie Haden, Dewey Redman, and Billy Higgins; and has even made a record, Song X, with Coleman.

Metheny's playing (as well as his tone) also show significant influence by Jim Hall, Joe Diorio, Kenny Burrell, Joe Pass, John McLaughlin and other classic jazz players^{[citation needed]}. Metheny has often been quoted saying that he is as likely to name non-guitarists as significant stylistic influences as fellow guitar players, giving as examples players like Clifford Brown and John Coltrane^{[citation needed]}. He has stated that Miles Davis' live album Four & More was hugely influential on his pursuit into jazz music. He has also admitted to being heavily influenced by The Beatles, going so far as to say that everything by The Beatles has impacted him as a musician. He has paid significant attention to the evolution of guitar playing across genres, however, and is familiar with the playing of notables from the likes of rocker Eddie Van Halen to Leo Kottke.^{[citation needed]}

In particular, he has been influenced by Brazilian music--both the European-influenced jazz sound of the bossa nova and the intensely polyrhythmic Afro-Brazilian sounds of the country's northeast.^{[citation needed]} Metheny made 3 albums on ECM with the Brazilian vocalist and percussionist Naná Vasconcelos in the early 1980s. He also lived in Brazil from the late 1980s to the early 1990s and performed with several local musicians such as Milton Nascimento and Toninho Horta. He also played with Antonio Carlos Jobim as a tribute, in a live performance in Carnegie Hall Salutes The Jazz Masters: Verve 50th Anniversary before Jobim’s passing away.

He is also a fan of several pop music artists, especially singer/songwriters including The Beatles; James Taylor (after whom he named the song "James" on Offramp); Bruce Hornsby, Cheap Trick, Joni Mitchell, with whom he performed on her Shadows and Light (1980, Asylum/ Elektra) live tour. Metheny is also fond of Buckethead's music. He also worked with, sponsored or helped to make attractive recordings of unique singer/songwriters from all over the world such as Pedro Aznar (Argentina), David Bowie (UK), Silje Nergaard (Norway), Noa (Israel), and Anna Maria Jopek (Poland).^[7]

Two of Metheny's recordings, The Way Up and Orchestrion, evidence the influence of American minimalist composer Steve Reich and utilize similar rhythmic figures structured around pulse. Reich's composition Electric Counterpoint was first recorded by Metheny and appears on the Different Trains CD released by Nonesuch Records in 1987.

Metheny Brothers[link]

Pat took part in recording some of the CDs by his older brother, trumpeter Mike Metheny, a jazz musician and a trumpet player based in Kansas City, Missouri, among them Day In - Night Out (1986) and more recently Close Enough for Love (2001).^[8][9]

Bibliography[link]

• Goins, Wayne E. (2001). Emotional Response to Music: Pat Metheny's Secret Story. Edwin Mellen Press. 

Discography[link]

Early recognition[link]

Chuck Lorre (producer of Two and a Half Men and The Big Bang Theory) mentions Pat Metheny in his weekly 'vanity card'^[10] (shown briefly after the credits of the Season 1 Episode 12 episode of The Big Bang Theory entitled "The Jerusalem Duality"). To summarize, Chuck Lorre was a professional guitarist at the age of 22. He was invited to audit a jazz guitar class at the University of Miami, and his ego was crushed when Pat Metheny began to play. Chuck says that this experience played a part in shifting his focus toward television.

Awards & Recognition[link]

In 2011, Pat Metheny was voted "Guitarist of the Year" in the DownBeat Magazine's Readers Poll.

In 2010, Pat Metheny was voted "Guitarist of the Year" in the DownBeat Magazine's Readers Poll.

In 2009, Pat Metheny was voted "Guitarist of the Year" in the DownBeat Magazine Readers Poll.

In 1995, Pat Metheny was granted the Miles Davis Award by the Montreal International Jazz Festival.

List of Grammy Awards received by Pat Metheny:^[11]

References[link]

External links[link]

Wikimedia Commons has media related to: Pat Metheny

• The Pat Metheny homepage - biographies, discographies, discussion and songbook forums, tour dates, etc.
• The most complete Pat Metheny discography with radio shows, promos a. o.
• Pat Metheny entry at AllMusic.com
• Pat Metheny profile, NNDB
• Pat Metheny's guitar rig
• Pat Metheny at the Internet Movie Database
• Pat Metheny discography at MusicBrainz
• Pat Metheny's artist file on the Montreal International Jazz Festival's website