Application programming interface (API) engine

Systems and methods for an application programming interface (API) engine are disclosed. Some implementations include receiving, via a user interface, a selection of a first graphical element representing a first component of an API that is to be generated, where the first component is associated with a first set of one or more reusable programming actions, receiving, via the user interface, instructions to drag the selected first graphical element and another selected second graphical element to a graphical workspace associated with the user interface to connect the first and the second graphical element, combining the first set of reusable programming actions with a second set of reusable programming actions when the selected second graphical element is connected with the first graphical component on the graphical workspace and automatically displaying software code representing the API based on the combination.

BACKGROUND

In computer programming, an Application Programming Interface (API) can specify how some software components should interact with each other. In practice, many times an API comes in the form of a library that includes specifications for routines, data structures, object classes, and variables.

Mean time for creation of a traditional API has a level of effort that can be, for example, from twenty to thirty days of development hours. Complexity associated with scope of such work can increase or decrease a developer's level of effort and software development cycles can take weeks. Furthermore, a software development cycle rarely has reusable software code, which results in a software developer rewriting a derivative API of an existing API. However, given today's highly competitive markets, a software development often needs to be completed in just a few days. In addition, speed to market within a development cycle must have a high level of integrity to ensure a consistently good customer experience.

As the foregoing illustrates, a new approach for API development may be desirable.

DETAILED DESCRIPTION

The various implementations disclosed herein relate to an innovative API development framework. In some implementations, the API development framework provides drag and drop functionality via a user interface to systematically generate an API. For example, a user may select a first graphical element representing a first component of an API that is to be generated, where the first component is associated with a first set of one or more reusable programming actions. The user may then drag the selected first graphical element and another selected second graphical element to a graphical workspace associated with the user interface to connect the first and the second graphical element. The graphical connection combines the first set of reusable programming actions with a second set of reusable programming actions. Then software code representing the API based on the combination is automatically displayed at the user interface. The software code of the API may be selected and embedded by the user (e.g., software developer) into another software application that may need functionality provided by the API. In contrast to approaches that may provide “drag and drop” software code entry where software code may be generated after selecting visual interface modules, the disclosed implementations are able to combine different sets of reusable programming actions (e.g., the first set of reusable programming actions with the second set of reusable programming actions).

In this way, different programming actions that are represented by respective graphical elements can be easily combined together by a user to generate an API with desired functionality. This reduces time for generating an API, and allows inclusion of a complete API into a software development cycle in a short period of time (e.g., a few hours or days) with a high level of integrity. The disclosed implementations improve speed to market (or customer use) and ensure business rule consistency and coding consistency for API clients.

FIG. 1illustrates a system10in which the disclosed implementations may be implemented. The example shows simply two mobile stations (MSs)13aand13bas well as a mobile communication network15. The network15provides mobile wireless communications services to those stations as well as to other mobile stations (not shown), for example, via a number of base stations (BSs)17. The present techniques may be implemented in any of a variety of available mobile networks15and/or on any type of mobile station compatible with such a network15, and the drawing shows only a very simplified example of a few relevant elements of the network15for purposes of discussion here.

The wireless mobile communication network15might be implemented as a network conforming to the code division multiple access (CDMA) IS-95 standard, the 3rd Generation Partnership Project 2 (3GPP2) wireless IP network standard or the Evolution Data Optimized (EVDO) standard, the Long Term Evolution (LTE) standard, the Global System for Mobile (GSM) communication standard, a time division multiple access (TDMA) standard or other standards used for public mobile wireless communications. The mobile stations13aand13bmay are capable of voice telephone communications through the network15and data communications through the particular type of network15(and the users thereof typically will have subscribed to data service through the network).

The network15allows users of the mobile stations such as13aand13b(and other mobile stations not shown) to initiate and receive telephone calls to each other as well as through the public switched telephone network or “PSTN”19and telephone stations21connected to the PSTN. The network15typically offers a variety of data services via the Internet23, such as downloads, web browsing, email, etc. By way of example, the drawing shows a computing device27as well as a server25connected to the Internet23; and the data services for the mobile stations13aand13bvia the Internet23may be with devices like those shown at25and27as well as with a variety of other types of devices or systems capable of data communications through various interconnected networks. The mobile stations13aand13(or any other mobile or non-mobile computing devices) of users of the API development framework also can receive and execute applications written in various programming languages, as discussed more later. In some implementations, the computing device27provides a graphical user interface that allows a user to interact with functions provided by API engine25. The API engine25is discussed further below.

Mobile stations13aand13band computing device27can take the form of portable handsets, smart-phones or personal digital assistants, although they may be implemented in other form factors. For example, a mobile station application can be written to execute on a binary runtime environment for mobile (BREW-based) mobile station, a Windows Mobile based mobile station, Android, I-Phone, Java Mobile, or RIM based mobile station such as a BlackBerry or the like. Some of these types of devices can employ a multi-tasking operating system.

The mobile communication network10can be implemented by a number of interconnected networks. Hence, the overall network10may include a number of radio access networks (RANs), as well as regional ground networks interconnecting a number of RANs and a wide area network (WAN) interconnecting the regional ground networks to core network elements. A regional portion of the network10, such as that serves mobile stations13aand13b, can include one or more RANs and a regional circuit and/or packet switched network and associated signaling network facilities.

Physical elements of a RAN operated by one of the mobile service providers or carriers, include a number of base stations represented in the example by the base stations (BSs)17. Although not separately shown, such a base station17can include a base transceiver system (BTS), which can communicate via an antennae system at the site of base station and over the airlink with one or more of the mobile stations13aand13b, when the mobile stations13aand13bare within range. Each base station can include a BTS coupled to several antennae mounted on a radio tower within a coverage area often referred to as a “cell.” The BTS is the part of the radio network that sends and receives RF signals to/from the mobile stations13aand13bthat are served by the base station17.

The radio access networks can also include a traffic network represented generally by the cloud at15, which carries the user communications and data for the mobile stations13aand13bbetween the base stations17and other elements with or through which the mobile stations13aand13bcommunicate. The network can also include other elements that support functionality other than device-to-device media transfer services such as messaging service messages and voice communications. Specific elements of the network15for carrying the voice and data traffic and for controlling various aspects of the calls or sessions through the network15are omitted here for simplicity. It will be understood that the various network elements can communicate with each other and other aspects of the mobile communications network10and other networks (e.g., the public switched telephone network (PSTN) and the Internet) either directly or indirectly.

The carrier will also operate a number of systems that provide ancillary functions in support of the communications services and/or application services provided through the network10, and those elements communicate with other nodes or elements of the network10via one or more private IP type packet data networks37(sometimes referred to as an Intranet), i.e., a private networks. Generally, such systems are part of or connected for communication via the private network37. A person skilled in the art, however, would recognize that systems outside of the private network could serve the same functions as well. Examples of such systems, in this case operated by the network service provider as part of the overall network10, which communicate through the intranet type network37, include one or more application servers31and a related authentication server33for the application service of server31. A mobile station13communicates over the air with a base station17and through the traffic network15for various voice and data communications, e.g. through the Internet23with a server25and/or with application servers31.

Servers such as25and31may provide any of a variety of common application or service functions in support of or in addition to an application program running on the mobile station13. However, for purposes of further discussion, we will focus on functions thereof in support of the API development framework. For a given service, including the API development framework, an application program within the mobile station may be considered as a ‘client’ and the programming at25or31may be considered as the ‘server’ application for the particular service.

As shown by the above discussion, functions relating to the API development framework, via a graphical user interface of computing device27(or mobile stations13aor13b), may be implemented on computers connected for data communication via the components of a packet data network, operating as an API engine25as shown inFIG. 1. Although special purpose devices may be used, such devices also may be implemented using one or more hardware platforms intended to represent a general class of data processing device commonly used to run “server” programming so as to implement the API development framework discussed above, albeit with an appropriate network connection for data communication.

As known in the data processing and communications arts, a general-purpose computer typically comprises a central processor or other processing device, an internal communication bus, various types of memory or storage media (RAM, ROM, EEPROM, cache memory, disk drives etc.) for code and data storage, and one or more network interface cards or ports for communication purposes. The software functionalities involve programming, including executable code as well as associated stored data, e.g. files used for the API development framework that includes the API engine25. The software code is executable by the general-purpose computer that functions as the API engine25and/or that functions as computing device27and/or mobile station13aor13b. In operation, the code is stored within the general-purpose computer platform. At other times, however, the software may be stored at other locations and/or transported for loading into the appropriate general-purpose computer system. Execution of such code by a processor of the computer platform enables the platform to implement the methodology for the API development framework, in essentially the manner performed in the implementations discussed and illustrated herein.

In some implementations, a user interface29displayed at the computing device27receives a selection of a first graphical element representing a first component of an API that is to be generated. The first component can be associated with a first set of one or more reusable programming actions.FIG. 2illustrates example graphical elements that may be used as the first (or other components) of the API that is to be generated. Different programming action types represented as graphical user elements include, but are not limited to, adapter, business rule, validator, data access, data calculator, public action, private action, etc. Each graphical action element can represent a first component of an API that is to be generated.

In some implementations, the adapter action element extracts data from entities and outputs the data to the API engine25. The business rule action element can introduce conditions based on previously retrieved information. The validator action element can generate exceptions based on previously retrieved information. The data access action element can retrieve information from one or more data sources. The data calculator action element can compute values based on retrieved information. The public action can be an action element that is publicly available (or not private). The private action element can be an action that is private and is specific to a particular API (e.g., government APIs). As shown inFIG. 2, these action elements can be represented as graphical elements.

The user interface29allows a user (e.g., API developer) to drag the selected first graphical element to a graphical workspace associated with the user interface29. For example, with reference toFIG. 2, a user may select the adapter, “Get Customer and Default Account” from a toolbar and drag it to the graphical workspace on the user interface29.

The user may then select a second graphical element representing a second component of the API, where the second component is associated with a second set of one or more reusable programming actions. For example, a user may select data access action element, “Populate Account from Data Grid” from a toolbar and drag the data access action element to connect with the adapter, “Get Customer and Default Account” on the graphical workspace. The user may then select a third graphical element representing a third component of the API, where the third component is associated with a third set of one or more reusable programming actions. For example, a user may select data access action element, “Populate Contacts At Customer Level From Data Grid” from a toolbar and drag the data access action element to connect with the adapter, “Get Customer and Default Account” on the graphical workspace. The user may connect the dragged elements onto the graphical workspace by using one or more connectors (e.g., lines with arrows). In this way, connections between the different graphical workspace components may be established. In some implementations, the shape and color of the elements may differ based on functions associated with the elements. The shape (e.g., square, rectangle, circle, etc.) and color (e.g., a color from a color palette) of the elements may also be changed by the user in accordance with the user's preference. Connections may be setup by connecting the action elements using “arrow” connectors. The arrows may be directional and may specify a direction of dataflow between the elements. Connections may also be established by highlighting one or more elements and selecting a connect action button that automatically may generate connections between the selected elements. Connectors may connect elements in parallel or in any sequence.

As shown inFIG. 2, the action elements “Populate Account from Data Grid” and “Populate Contacts At Customer Level From Data Grid” are connected in parallel with the “Get Customer and Default Account” action element. In this way, the second set of one or more reusable programming actions can be performed in parallel with the third set of one or more reusable programming actions. In a manner similar to that has been discussed above, the user may drag and connect other action elements such as “Check Attributes For Accounts” and “Populate Customer Code Descriptors” and connect them to the parent action elements “Populate Account from Data Grid” and “Populate Contacts At Customer Level From Data Grid.” The user may then place a validator action “Validate Client ID For Non-Wireless Customers” and connect the validator action to the action element “Check Attributes For Accounts.” The user may add other action elements, such as, a private action element “Get XML Out of Customer.”

As the user drags and connects the different graphical action elements, the API engine25combines respective reusable programming actions associated with the action elements. For example, the API engine25combines the first set of reusable programming actions with the second set of reusable programming actions when the selected second graphical element is connected with the first graphical component on the graphical workspace. Upon the combining, the API engine automatically displays software code representing the API. The software code can be embedded in the other software applications to perform the reusable programming actions as a single API. An example of the graphical workspace is illustrated inFIG. 4. In some implementations, the graphical workspace is included within the user interface29and can be represented as a “Design Tab” that includes the connected graphical elements ofFIG. 2. In some implementations, as shown inFIG. 5, the graphical workspace is included within the user interface29and can be represented as a “XML Tab.” The XML Tab can display software code generated by the API engine25.

In some implementations, the API engine25generates an action dependency graph representing the combined first set of reusable programming actions and the second set of reusable programming actions. The API engine25then transforms extensible markup language (XML) of the action dependency graph into an action graph object and iterates through each action in the action graph object to build dependencies (or pre-requisites). As an illustrative example, an action graph or object graph can be a view of API objects at a particular point in time. Action graph objects may be linked to each other by one object either owning or containing another object or holding a reference to another object. This web of objects can be called an action graph.

Dependencies may include, but are not limited to, a fully qualified action class name from a particular action's name, the particular action's children and the particular action's parents. In some implementations, a dependency graph listing all dependencies may be built at startup. In some implementations, the API engine25may reject the action dependency graph at startup when it is determined that the graph is invalid (e.g., a syntax error in Extensible Markup Language (XML) source code. Any action graphs that are not written in accordance with a predetermined syntax (or semantics) or contain ambiguities may be determined to be invalid. The ambiguities may include, but are not limited to, one or more of inability to locate a class matching a fully qualified class name assembled from the action dependency graph, inclusion of identifiers in the action dependency graph that deviate from configured naming conventions or a parentless action in the action dependency graph.

In some implementations, the API engine25parses graphical components (e.g., select data access action element, “Populate Account from Data Grid”) representing respective sets of reusable programming actions as a dependency graph of actions. The API engine25then executes the actions starting with actions that have no dependencies, until all actions are complete or a fatal error occurs. A dependency graph is a directed graph representing dependencies of several objects towards each other. It is possible to derive an evaluation order or the absence of an evaluation order that respects the given dependencies from the dependency graph.

In some implementations, the API engine25can store information about the status and data shared between different sets of reusable programming actions. For example, the API engine25can store status and data shared between data access action element, “Populate Account from Data Grid” from a toolbar and the adapter, “Get Customer and Default Account” that is connected to the data access action element. In some implementations, the API engine25can allow a graphical component representing a set of reusable programming actions to reference another graphical component representing another of reusable programming actions.

In some implementations, the API engine25can introduce one or more conditions via the first set of reusable programming actions or the second set of reusable programming actions, wherein the conditions include flags that can be used at runtime to determine if an action is eligible for execution. The flags may be checked by the API action engine25while traversing API action graphs to determine whether to further traverse an action graph. In some aspects, a flag may act as a conditional check to determine whether a condition at a point in the graph is satisfied. If the condition is satisfied, the graph may be further traversed. However, if the condition is not satisfied, the graph may not be further traversed. For example, while traversing the action graph if a flag indicates that the action graph should not be traversed further, the traversal of the action graph by the API action engine25may be suspended. This can save computing resources of the API action engine25.

In some implementations, the API engine25can add the first graphical element and the second graphical element to the graphical workspace with a service name as a key. The key can be a name or any identifier of an API. The key may be a part of an XML file associated with the API. In some implementations, the name of the XML file associated with the API is identical to the name of the API or key.

The API engine25can provide a copy of a parent connection map to each action in the combined first set of reusable programming actions and the second set of reusable programming actions. In some implementations, when n actions have the same parent, the API engine25can create n−1 copies of connections to the parent so that each action can have a separate parent connection map. In some implementations, the API engine25can, when an action has multiple parents, combine connection maps from the multiple parents into one map.

FIG. 3displays an exemplary software code300that is displayed by the API engine25at the user interface29based on the action element connection ofFIG. 2. As shown inFIG. 3, lines2-4of the code are associated with the “Get Customer and Default Account” action element. Similarly, lines5-10of the code are associated with the “Populate Account from Data Grid” action element. As described above, the API engine25combines respective reusable programming actions associated with these (and other) action elements and automatically displays software code300representing the API. In some implementations, displayed color of software code300may automatically update with the displayed color or shape of the action object. As the shape or color of the action object changes, the displayed color of its respective software code is automatically updated in real-time. This improves user experience of a person writing the software code300.

Referring toFIGS. 10 and 11, the software code can be embedded in the other software applications to perform the reusable programming actions as a single API. Thus, a software developer need not manually type the software code300. Instead, the software developer can easily develop an API by connecting reusable graphical action elements on a graphical workspace. This reduces time for generating an API, and allows placing of an API into production from weeks to days with a high level of integrity. The disclosed implementations provide speed to market and ensure business rule consistency and coding consistency for API clients.

FIG. 6illustrates an exemplary deployment of an API engine.FIG. 6illustrates a front end602, the API engine25and infrastructure604. The front end may be computing device27and/or mobile station13aor13b. In some implementations, the API engine25may include a global router and an XML mapping component. The global router may route API calls from front end602to the a new or modified API via the XML mapping component. Calls based on the new API may be provided to the infrastructure604. The new API may be configured to interface with the components of infrastructure604. The components may include, but are not limited to, one or more servers, computing devices and databases.

FIG. 7illustrates exemplary relationships between the API engine25and other components in the API development framework in accordance with the implementations described above. For example, API engine25may include one or more of data access rules, business rules and data adapters. API engine25may consume or interface with API action metadata. The API action metadata may be stored as a data structure. The API action metadata may include one or more attributes or values associated with APIs. The API engine25may also manipulate a common data model. The common data model standardizes the format and content of API related data, so that standardized applications, tools and methods can be applied to the data.

FIG. 8illustrates an exemplary operation to open an API project. An API project may be a software project in which an API that is being created may be saved (e.g., saved to storage or memory). A user may select this menu to open an existing API project (e.g., “getLine.xml”) via the user interface19. Once opened, the user may graphically edit the API project using the graphical workspace illustrated inFIG. 4.

FIG. 9illustrates an exemplary operation to import an API into an API project. A user may select this menu to import an API (e.g., “getCustomer.xml”) into an existing API project via the user interface19. Once imported, the user may graphically edit the API project using the graphical workspace illustrated inFIG. 4.

FIG. 10illustrates an exemplary operation to import an action into an API project. A user may select this menu to import a particular programming action (e.g., “CheckAttributesForAccount”) into an existing API project via the user interface19. Once imported, the user may graphically edit the API project using the graphical workspace illustrated inFIG. 4.

FIG. 11illustrates an exemplary operation to add an action into an API project. A user may select this menu to add a particular programming action (e.g., “Adapter, Business Rule, etc.”) into an existing API project via the user interface19. Once opened, the user may graphically edit the API project using the graphical workspace illustrated inFIG. 4.

FIGS. 12 and 13provide functional block diagram illustrations of general purpose computer hardware platforms.FIG. 12illustrates a network or host computer platform, as may typically be used to implement a server.FIG. 13depicts a computer with user interface elements, as may be used to implement a personal computer or other type of work station or terminal device, although the computer ofFIG. 13may also act as a server if appropriately programmed. For example, the computer and platforms illustrated inFIG. 12andFIG. 13may be implemented as the API action engine25. It is believed that those skilled in the art are familiar with the structure, programming and general operation of such computer equipment and as a result the drawings should be self-explanatory.

A server, for example, includes a data communication interface for packet data communication. The server also includes a central processing unit (CPU), in the form of one or more processors, for executing program instructions. The server platform typically includes an internal communication bus, program storage and data storage for various data files to be processed and/or communicated by the server, although the server often receives programming and data via network communications. The hardware elements, operating systems and programming languages of such servers are conventional in nature, and it is presumed that those skilled in the art are adequately familiar therewith. Of course, the server functions may be implemented in a distributed fashion on a number of similar platforms, to distribute the processing load.

A computer type user terminal device, such as a PC or tablet computer, similarly includes a data communication interface CPU, main memory and one or more mass storage devices for storing user data and the various executable programs (seeFIG. 13). A mobile device type user terminal may include similar elements, but will typically use smaller components that also require less power, to facilitate implementation in a portable form factor. The various types of user terminal devices will also include various user input and output elements. A computer, for example, may include a keyboard and a cursor control/selection device such as a mouse, trackball, joystick or touchpad; and a display for visual outputs. A microphone and speaker enable audio input and output. Some smartphones include similar but smaller input and output elements. Tablets and other types of smartphones utilize touch sensitive display screens, instead of separate keyboard and cursor control elements. The hardware elements, operating systems and programming languages of such user terminal devices also are conventional in nature, and it is presumed that those skilled in the art are adequately familiar therewith.