text:
US 20050160104 A1 Abstract The present invention is directed to systems and methods for providing a software developer's toolbox for generating and deploying a software application. While several preferred embodiments are directed toward a modular toolbox for generating and deploying web-based enterprise applications deployable onto J2EE-compliant servers, all embodiments are not so limited and can be directed toward the generation and deployment of software applications that are compatible with non-Internet networks such as private networks, local networks, and intranets and further are compatible with non-networked applications including Windows and non-Windows operating system applications. Further, exemplary embodiments can provide for the generation and deployment of software applications written in non-Java code.
Claims(64) 1. A computer-based method for generating a software application, comprising:
defining entities, including entity attributes and relationships, for access by the generated software application; defining database queries to be included in the generated software application for searching application data; defining application users, roles, and groups for controlling user access to software application generation and/or execution; defining business logic for directing the processing of the generated software application; and generating software application code in conformance with the defined business logic. 2. The method according to
3. The method according to
4. The method according to
5. The method according to
6. The method according to
7. The method according to
8. The method according to
9. The method according to
10. The method according to
11. The method according to
12. The method according to
13. The method according to
14. The method according to
15. The method according to
16. The method according to
17. The method according to
18. The method according to
19. The method according to
20. The method according to
21. The method according to
22. The method according to
23. The method according to
24. The method according to
25. The method according to
26. The method according to
27. The method according to
28. The method according to
29. A computer-based method for generating a software application, comprising:
providing an extensible user interface framework for generating a software application; and providing a computer to:
define entities, including entity attributes and relationships;
define database queries to be included in the generated software application for searching application data, including the attributes of the defined entities;
define application users, roles, and groups for controlling user access to application generation modules and generated application methods;
define business logic for directing the processing of the generated application; and
generate software application code in conformance with the defined business logic.
30. The computer-based method according to
define data lookup lists; and create formatted record identification strings. 31. The computer-based method according to
deploy the generated software application onto an application server. 32. The computer-based method according to
33. A computer-based system for generating a software application, comprising:
an entity builder module for defining entities, entity attributes, and entity relationships; a search builder module for defining database queries to be included in the generated software application for searching application data; a security manager module for defining application users, roles, and groups; a business logic builder module for defining business logic for directing the processing of the generated application and for generating software application code in conformance with the defined business logic; and a deployment module for deploying the generated software application code. 34. The system according to
35. The system according to
36. The system according to
37. The system according to
38. The system according to
39. The system according to
40. The system according to
41. The system according to
42. The system according to
43. The system according to
44. The system according to
a list builder module for defining table lookup lists; and an identification builder module for creating formatted record identification strings. 45. A computer-based system for generating a software application, comprising:
a graphical user interface for selecting software application generation options and for entering data; and a computer configured to:
define entities, including entity attributes and relationships;
define database queries to be included in the generated software application;
define application users, roles, and groups;
define business logic for directing the processing of a software application; and
generate software application code to perform the defined business logic.
46. The computer-based system according to
define data lookup lists; and create formatted record identification strings. 47. The computer-based system according to
48. The computer-based system according to
49. The computer-based system according to
50. A computer software application generation system, comprising a computer system, said computer system including at least one of a software application generation program, a memory, and a processor, wherein the processor is directed by the software application generation program to automatically generate software application code in conformance with a user-specified standard and user-supplied business logic.
51. A computer system having a networked server architecture, comprising:
a client server, said client server providing a graphical interface between an application user and a software application; an application server, said application server configured to receive one or more generated software applications and further configured to communicate with a client server; and a database server, said database server comprising at least an enterprise information system, said database server configured to communicate with the application server. 52. The computer system according to
53. A system for generating a software application, comprising:
means for defining entities, including entity attributes and relationships; means for defining database queries to be included in the software application; means for defining data lookup lists; means for creating formatted record identification strings; means for defining application users, roles, and groups; and means for defining business logic for directing the processing of the generated application. 54. The system according to
means for generating software application code in conformance with the defined business logic; and means for deploying the generated software application code onto an application server. 55. The system according to
56. A computer-readable medium encoded with software for generating a software application, wherein the software is provided for:
defining entities, including entity attributes and relationships; defining database queries to be included in the generated software application for searching application data; defining application users, roles, and groups; defining business logic for directing the processing of the generated application; generating software application code for performing the business logic on a computer; and deploying the generated software application code onto an application server. 57. The computer-readable medium according to
58. The computer-readable medium according to
59. The method according to
60. The computer-readable medium according to
61. The computer-readable medium of
defining data lookup lists; and creating formatted record identification strings. 62. A computer program product, which, when executed by a computer, implements a software application generator by performing the steps of:
presenting a graphical user interface for selecting application generation options and for entering data; defining entities, including entity attributes and relationships; defining database queries to be included in the software application; defining application users, roles, and groups; defining business logic for directing the processing of the generated application; generating software application code for performing the business logic on a computer; and deploying the generated software application code onto an application server. 63. A computer-based method for generating a software application, comprising:
defining entities, including entity attributes and relationships; defining database queries to be included in the software application for searching application data, including the attributes of the defined entities; defining application users, roles, and groups for controlling user access to application generation and/or application execution; defining business logic for directing the processing of the generated application; generating software application code in conformance with the defined business logic, wherein the generated code is written in Java and is deployable on a J2EE-compliant application server. 64. A computer-based method for generating a software application, comprising:
defining entities for access by the generated software application; defining search queries to be included in the generated software application for searching the defined entities, attributes, and/or relationships; defining data lookup lists, said lookup lists being available for populating the defined entities; creating formatted record identification strings for creating and assigning identifier values to the defined entities; defining application users, roles, and groups for controlling user access to software application generation and/or execution; defining business logic for directing the processing of the generated application; and generating software application code in conformance with the defined business logic. Description This application is based upon and claims priority from U.S. provisional patent application No. 60/536,991, filed Jan. 20, 2004, the contents of which being incorporated herein by reference. A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights, whatsoever. 1. Field of the Invention The present invention relates generally to software application tools and, more specifically, to systems and methods for generating and deploying enterprise applications compatible with the Java� 2 Platform, Enterprise Edition standard for Internet or intranet based applications. 2. Description of the Related Art The implementation and use of the Internet, intranets, and local networks has exploded in recent years, with a large number of diverse applications being written and deployed on these various networks for both public and private use, with a concurrent number and diversity of data, files, information systems, and databases being also available for both query and writing. In the interest of providing broad and easy access to the Internet and other large networks by a large numbers of users, a multitude of conventions, standards, and procedures have been adopted to permit both users and application developers more or less seamless access and use of the networks and their related applications and files. One such standard for the generation of software applications to run smoothly on the World Wide Web and the Internet is the Java� 2 Platform, Enterprise Edition (J2EE), developed by Sun Microsystems, Inc. J2EE is not a programming language, such as the Java� 2 Platform, Standard Edition, with which to write and deploy distributed network-compatible applications, including Web-based services. Instead, it is a standard, or specification, for ensuring that diverse J2EE-compliant applications and databases can operate successfully across a multitude of computers, networks, servers, and browsers. J2EE-compliant software (the �application server�) supplies the infrastructure required in enterprise software. For example, an application server may provide the infrastructure to communicate with clients over a network using the Hypertext Transfer Protocol (HTTP) made popular by its use in browser software; to persist data to databases over a network using proprietary communications protocols; to maintain data integrity throughout business processing and data persistence, even in the event of errors; to support asynchronous messaging for client convenience; to manage concurrent requests without data overlap, unwanted sharing, or corruption; and so forth. The J2EE specification dictates the services to be provided as well as the interfaces to these services, giving application developers a well-understood supply of services to use in the creation of their business and domain logic. While a consistent standard makes sense for access to and use of a diverse, international network, the standard itself is very complex, detailed, and interrelated, entailing more than fifteen separate specification documents. Accordingly, there exists a need for a J2EE developer's toolbox system that eases the process of creating applications using J2EE-specified service interfaces and thereby deployable on J2EE-compliant application servers. There is a particular need for a business solution toolbox to enable a user who is not conversant in Java or J2EE standards to generate and deploy web-based business enterprise solutions that can be deployed on a J2EE-compliant application server. The present invention is directed toward a computer-based system and method for generating a software application, including defining entities, including entity attributes and relationships, for access by the generated software application; defining database queries to be included in the generated software application for searching application data; defining application users, roles, and groups for controlling user access to software application generation and/or execution; defining business logic for directing the processing of the generated software application; and generating software application code in conformance with the defined business logic. In accordance with one aspect of the present invention, a computer-based method is directed toward generating a software application, including providing an extensible user interface framework for generating a software application; and providing a computer to define entities, including entity attributes and relationships; define database queries to be included in the generated software application for searching application data, including the attributes of the defined entities; define application users, roles, and groups for controlling user access to application generation modules and generated application methods; define business logic for directing the processing of the generated application; and generate software application code in conformance with the defined business logic. Exemplary embodiments of the invention are directed toward a computer-based system for generating a software application, including an entity builder module for defining entities, entity attributes, and entity relationships; a search builder module for defining database queries to be included in the generated software application for searching application data; a security manager module for defining application users, roles, and groups; a business logic builder module for defining business logic for directing the processing of the generated application and for generating software application code in conformance with the defined business logic; and a deployment module for deploying the generated software application code. Additional embodiments include a computer system having a networked server architecture, including a client server, said client server providing a graphical interface between an application user and a software application; an application server, said application server configured to receive one or more generated software applications and further configured to communicate with a client server; and a database server, said database server comprising at least an enterprise information system, said database server configured to communicate with the application server. These and other objects and advantages of the present invention will become more apparent and more readily appreciated from the following description of the preferred embodiments, taken in conjunction with the accompanying drawings, wherein like reference numerals have been used to designate like elements, and wherein: In the following description, for purposes of explanation and not limitation, specific details are set forth in order to provide a thorough understanding of the present invention. However, it will be apparent to one skilled in the art that the present invention may be practiced in other embodiments that depart from these specific details. In other instances, detailed descriptions of well-known methods, devices, and circuits are omitted so as not to obscure the description of the present invention. For instance, a high level familiarity with the basic components of the J2EE platform, e.g., Enterprise JavaBeans, is presumed. Exemplary embodiments are directed to systems and methods for providing a software developer's toolbox for generating and deploying software applications. While several preferred embodiments are directed toward a modular toolbox for generating and deploying web-based enterprise applications compatible with the J2EE standard, all embodiments are not so limited and can be directed toward the generation and deployment of software applications that are compatible with non-Internet networks such as private networks, local networks, and intranets and further are compatible with non-networked applications including Windows and non-Windows operating system applications. Further, exemplary embodiments can provide for the generation and deployment of software applications written in non-Java code. Details of exemplary embodiments, including embodiments directed toward generating software applications compatible with the J2EE standard, can be found in the publication Jetson� Toolbox, Version 1.0, Developers' Guide, �2004 DataSource, Inc., the contents of which are incorporated herein by reference. Exemplary embodiments for generating and deploying software applications can be viewed as a plurality or set of software tools or modules that are utilized to (1) describe, in high-level language, business requirements for the application to be generated; (2) generate the software code to actually execute or fulfill the aspects of the business or enterprise application; and (3) deploy the generated application to one or more computers or servers for ultimate execution. Each of the functional modules can be viewed as plug-in tools from the perspective that the modules need not always be executed in a particular sequence to generate and build the applications. In fact, one or more modules can be processed, and the user can defer processing of the remaining modules as the enterprise application concepts are further refined, as time becomes available, or any number of other reasons. Additional modules and plug-in tools not presented here are envisioned to be able to be added later, and the modular aspect of exemplary embodiments permits users to develop their own modules to add to those presented here to customize the generation of software applications according to the specific needs of each user. The modular tools discussed herein permit the user to generate and deploy an enterprise software application which follows targeted enterprise logic while divorcing the user from the typical skill set requirements associated with drafting and deploying a software application on an application server. Referring now to The process of application generation by exemplary embodiments is accomplished in part with the developer/user inputting descriptions of data elements, business logic, and output form elements into the application generation systems. Each description is stored in database tables 132, either as simple data values or in Extensible Markup Language (XML) format. The model built by exemplary embodiments from these descriptions becomes the basis for generation of application-specific code. Modules of exemplary embodiments generate, compile, and deploy the applications to designated servers 114 for ultimate use and execution. Each toolbox module of the application generation system presents a graphical user interface (GUI) 106 that simplifies the task of describing and selecting application requirements and options. XML files and database tables created and stored by each module in one or more databases 112 can be utilized during deployment and execution to fully describe a portion of the application architecture generated by a particular module. The exemplary modules permit the user to define multiple enterprise applications by designating for each application a dedicated database 112 and a group of middle-tier application servers 620 to be used for generating and ultimately executing the enterprise applications. The results of the application generation/deployment process can be displayed to the user on a GUI 106 and/or on a printer 108. The application development user can work with exemplary embodiments directly with the computer 100 or by means of an alternate computer 104 connected by known means to the computer 100. The generated application can be deployed over one or more networks 110 onto one or more remote servers 114 for ultimate usage by means of a remote computer 116, with application results being displayed on a GUI to the user and/or output to a printer 122. While the application generation/deployment system is envisioned herein to have separate and remote application developers and application users working on their respective computers 104 and 116 across one or more networks 110, the system is not limited to this configuration. In an alternate embodiment, the application developer and the application user can be the same person and/or can utilize the same resources with which to generate and to access or execute the application. In this alternate embodiment, both classes of users could utilize the Client Server 600 environment to first generate the application and second execute the generated and deployed application. In this manner, an enterprise could both develop an application and deploy it for usage within the enterprise. In such an embodiment, for example, the Runtime Services 608 could be equally available to both the developer and the application user. Exemplary embodiments provide application development and runtime features that utilize the Hypertext Transfer Protocol (HTTP) and Simple Object Access Protocol (SOAP) for communication between different application layers. By using standard Internet protocols in some of the embodiments, the application generation and deployment process can perform well across both local and wide area networks, such as the World Wide Web, and can perform well in many firewall environments without need for modification of existing firewall security settings. While the Report Server 680 is shown in A preferred embodiment of the present system and method for generating and deploying software applications is designed to target all layers of a typical J2EE application, which is shown in The application generation and deployment is accomplished with a software toolbox of modules, each designed to perform a finite portion of the generation and deployment process. Referring now to Through the various modules of the application generation/deployment system, the user can select and apply templates, accepting one or more filled-in fields of the templates and/or entering information in one or more templates and thereby building the targeted application with the user's desired logic. The user's computer 604, either directly or through a Client Server 600, communicates with the Application Server 620 to generate and compile the software code and objects for the user's application. A Database Server 640 can also be communicated with to access script, code, and objects with which to compile the code of the end application. Finally, a Deployment Server 660 and its deployment modules can be accessed to assist in deploying the objects, components, software modules, applications, and the like generated by the application generation modules 402-412 for ultimate use and/or execution by an application user. The generated application can be deployed onto the Application Server 620 for ultimate access and/ or execution by a user, but exemplary embodiments are not limited to the generated code residing on the Application Server 620. For example, the generated code can reside on the Client Server 600 and/or can reside on one or more databases for access and loading upon application execution. Generation and ultimate deployment of a user application often begins with the user planning and modeling the application by determining what input data is desired or needed, the business logic the application is to follow, and the desired output of the application. The graphical user interfaces, menus, prompts, and objects of exemplary embodiments guide the user from the planning and modeling stage through the steps of the generation and deployment of the finished application. In short, exemplary embodiments provide a bridge from the business logic of an enterprise application to a coded application for carrying out the enterprise logic. The present application generation/deployment system envisions that a targeted user application can be a fully functional enterprise application or merely an application module to be called by or to be an integral part of another application. The process of generating and deploying a software application can be seen in Application generation and deployment begins with the creation of a project, as accessed through the Tools Menu shown in An additional option available during application project creation is �Create JUnit Tests.� Selecting this option instructs the system to create and deploy a JUnit test for each of the following application components: Entities, Search Procedures, ID Numbers, Business Components, List Services, and Security Services. JUnit tests will automatically be generated when any of these components are deployed, and these tests can then be initiated by the user from a menu command to test the deployed components (see The Initial Login and Password create a user ID and password for this project to secure the building of the application. The Admin Login and Password are the existing administrative ID and password for the particular database instance to which the user intends to connect. The Toolbox Login and Password are the user login keys for communication with the generation/deployment system Toolbox database 643. Database Type denotes the structure of the meta-model database, such as MSSQL. The Database Server (640) Name is the name of the server on which the meta-model database is to be created. The Database Server Port defaults to 1433 and can be changed as necessary. The Database Name is the system database instance and defaults to the project name. The Data File Path on Server and the Log File Path on Server refer to existing paths on the Database Server 640. If MSSQL has been selected/defaulted as a database type, the normal values are entered by default. These values can be changed to match different paths as needed. The Toolbox Database Server (640) Name and Port entries define the connection from the Application Server 620 to the Database Server 640; normally they will be the same as specified for the connection used for the Toolbox modules 643. The Toolbox Server Database (643) Login and Password value are derived from the entries in the Toolbox Client Database Information fields but can be edited as needed, such as to accommodate firewall settings. Clicking OK results in the next menu page being presented to the user, displaying the information and options entered by the user and giving the user the opportunity to edit and/or accept the project definition data. Having created the application project, the user is ready to begin using the toolbox modules shown in Entities can also have relationships, which are the associations or interactions between and among two or more entities, such as a customer entity can be assigned a purchase order number, thereby having a purchase order relationship. Relationships are defined in terms of cardinality and direction. Each side of a relationship can involve one record or many records. Cardinality quantifies how many instances of one entity are related to a single instance of another entity. Possible cardinality are one-to-one (an employee is assigned one office cubicle only and a specific office cubicle is assigned to one employee only), one-to-many (a department can have many employees, but an employee can be a member of only one department), and many-to-many (a student can take many classes, and a class can have many students in it). The directionality of a relationship describes how the relationship can be traversed, either bi-directionally or uni-directionally. A bi-directional relationship can be traversed beginning from either the �To Entity� or the �From Entity.� In other words, given one entity, the other entity can be found. A uni-directional relationship can only be traversed beginning from the �From Entity.� For example, if the user has a table of cars and a table of drivers and the user wants to search for those cars a particular driver drives but is not interested in which drivers drive a particular car, the user will select a uni-directional relationship between the cars and drivers. If the user wants to conduct both queries, a bi-directional relationship should be selected for the entities. Each entity has one or more attributes and, optionally, relationships to other entities. As will be discussed in more detail below regarding the List Builder Module 406, entities can be associated together in lists by their common attributes and/or relationships. The Entity Builder Module 402 is responsible for capturing data requirements; generating database stored procedures and views; generating, compiling and deploying data objects in the Data Access Layer (DAL); and creating links to external databases 120. The Entity Builder Module 402 also allows the user to import and define relationships for tables in external databases 120. Accordingly, there is no need for the user to manually write, or even be familiar with, relational database code to save, delete, or retrieve entities. In this manner, the user can utilize a level of abstraction provided by the Entity Builder Module 402 and the List Builder Module 406 to define the characteristics of each class of entity and optionally, automatically import database tables 132 from external databases 120 defining the structure of the databases 120. The user can define entities to describe groupings of data attributes. For example, an application could have a Judge entity defined. Each Judge can have a name, employee number, office number, hair color, date of birth, social security number, and/or several additional attributes. The entity can also be derived from another entity already existing in the system (i.e., a Circuit Court Judge may be defined as a Judge entity having additional attributes, such as a Circuit Court number). Each attribute for an entity is given a unique name and has a data type associated with it. Data types define the possible characteristics of the data that can be stored for a particular attribute. Examples of data types include integer, decimal, boolean, fixed-length text, unlimited text, and binary. The Entity Builder Module 402 is further utilized to store data requirements in the database meta-tables 132 for an application project instance. It uses the stored data requirements to generate stored database procedures 126 and views 130 that depend upon the database architecture described below, which hides the actual database table structure used to store entity data values. In this manner, the Entity Builder Module 402, and not the user, determine and manage the structures and architecture of the databases and tables. The stored database procedures and views present a virtual interface to each database 120 that appears to provide a separate table 132 for each entity. Because of the distinction between the actual database table structure and the table structure implied by the interface, the actual database tables 132 are referred to as meta-tables. Data to be utilized by the generated application, whether to be read or written, can reside in one or more databases, including internal databases 118 and external databases 120. In addition to defining new entities and/or attributes, the Entity Builder Module 402 provides the ability to link to these external databases 120 (i.e., databases other than the database 112 containing the meta-tables 132 for the project application and databases 118 managed by the system-generated application). When linking to an external database 120, the system can automatically import each database table structure with which to build an entity in the application and with which to navigate the external database 120 in the generated application, thereby saving the user the task of determining, specifying, and coding the database structure. Alternately, some or all of the data for the application can reside on one or more internal databases 118 under a meta-model approach where newly-defined entities inherit one or more of the properties of a base entity, thereby simplifying the process of defining the entity and transferring the responsibility of managing the application data to the generation/deployment system. Exemplary embodiments permit applications to be built using either the external database model or the meta-data model approach, or a combination of both. Using the meta-module approach, the user can describe entities' attributes and relationships completely within the application generation system. Referring again to Once a new base entity has been created, the new base entity must be published to the generation system for the new base entity to be known, to appear as an entity definition in the Entity Builder menu (see Once a base entity has been published, indexes can be added to the base entity for one or more fields of the entity. Indexes allow rows to be located more quickly and efficiently in queries. While the indexes do not appear to a user executing the generated application, they are given names to facilitate the indexing process and are assigned either ascending or descending attributes based on how the respective field is to be treated in application queries. In those applications where application data resides on one or more external databases 120, the application developer accesses a database connection menu as shown in During actual application code generation by exemplary embodiments, the Entity Builder Module 402 uses the user-specified and default data requirements to generate a data access layer 208 of the application. The data access layer 208 is used to limit and enforce data access business logic for the project application. The system can generate Enterprise JavaBean (EJB) code that will properly execute on, for example and not limitation, an application server 620 conforming to the J2EE 1.3 specification (or later). The resulting Enterprise JavaBeans (EJB's) can use either bean-managed persistence (BMP) or container-managed persistence (CMP) as described in the J2EE specification to persist application data and relationships. The system compiles the generated code and deploys the compiled code to designated application servers. The J2EE specification requires that the Enterprise JavaBeans (EJB's) be accessible to external clients via Java Remote Method Invocation (RMI). EJB's generated by the Entity Builder Module 402 are designed to be accessible to application users via web services. One example of the code-generation procedure is schematically illustrated in the block diagram of In the second process, an XML document 804 containing stored object and/or component information is provided to a template-based code generation unit 806 in the application server 620. The XML document 804 containing the information is created in the toolbox 612. The code generation unit 806 transforms the data in this document into source code, in accordance with templates 808 that are resident at the application server. In essence, the code generation unit 806 functions to replace tokens in the templates with data from the XML document, or with the results of processing that data according to rules in, or accessible to, the template, to produce the source code. An example of a suitable technology that can be employed to implement the code generation unit 806 is the Velocity Template Engine, an open-source program provided by The Apache Software Foundation. Although a direct link from the database(s) 118/120 to the application server 620 is depicted in The determination as to which code generation unit to employ for any particular component of the application can be based upon any number of factors. For instance, in one embodiment of the invention, the code generation unit 806 in the application server 620 can be used to generate the code for imported entities representing external databases 120, and perhaps other specific components, such as those pertaining to user security and lists, discussed below. All other code can be generated by the unit 802 in the client toolbox 612. However, either process can be employed to generate any component of the application code. In an application which is deployable onto a J2EE-compliant server, each object and/or component can consist of multiple Java classes, each of which is represented in a separate Java source code file. For example, each Enterprise JavaBean (EJB) consists of at least 3 and as many as 6 or more such classes. It will be appreciated that the task of managing the large number of files that constitute an application can become overwhelming to the application developer. To reduce this task, therefore, the code generation units 802 and 806 can be configured to produce a single Java source code file, representing a single class, for each object and/or component. This approach also simplifies the deployment process, since the number of files to be deployed is greatly reduced. At code generation time, the source code files produced by each of the code generation units 802 and 806 are provided to another code generation engine 810. This code generation engine 810 utilizes tags and comments in each source code file to generate the other classes that are needed for the object and/or component. An example of a suitable technology that can be employed to implement the code generation engine 810 is XDoclet, an open-source program. The Search Builder Module 404 allows the user to create custom database queries in step 702, whether as standalone queries, or as queries incorporated into the business logic/rules of the application, or as queries to be used to generate reports by the application. Each query is built using a graphical user interface designer, such as shown in
The Search Builder Module 404 permits the user to define database queries to be included in the software application to return specific rows and columns of data from designated databases. By presenting several graphical user interface menus to the user, exemplary embodiments alleviate the need for an in-depth knowledge of system query language (SQL) and data structures and extensions which may be unique to each database. The user can easily construct a search using a visual designer presented by exemplary embodiments to guide the user through the search building process. Once the search has been built, the Search Builder Module 404 includes a facility for the user to test the search immediately. If the results are not satisfactory, the user can return to the search build menu, modify the search design, and retry the search. In this manner, modules of the software application can be easily and quickly tested during the application generation process. External databases can be imported into exemplary embodiments, and both the user and exemplary embodiments have full access to any stored procedures in each such database. Further, users can also write SQL code directly against external databases for inclusion in the software application being generated. The search queries can be defined against both meta model databases and external databases. Since database structures in the form of database tables have been stored in the system database 132 and existing database search procedures have also been imported and stored in the system database 126, the user can also be presented with existing database structures and search procedures from which to select and, optionally, modify to define a desired database query. In either situation, the user need not have detailed knowledge of SQL commands nor particular database formats to define search queries consistent with a desired enterprise logic. In one embodiment of the invention, the coded queries are built by the code generation unit 802 in the toolbox 612. As an example, the unit 802 can generate one object for all of the searches to be performed on the internal database 118, and another object for each external database 120 to be searched. While the user is building the search query by means of the Search Builder Module 404, an XML document is created in the background representing that query. The XML document is stored as an XML file in the application database 128 when the user finishes building or changing the query. This stored XML file is used to generate and deploy a stored procedure in the system database 126 and an associated data object in the Application Server 620. Search objects can also be created, following standard J2EE conventions and providing interfaces for discovery and execution that are used when building Business Components (BC) and Business Data Objects (BDO) as discussed below. These components and objects are implemented as Enterprise JavaBeans (EJB's) and data transfer objects (DTO's) in the generated code. While a user is defining a new search procedure or is editing an existing query, the search procedure is locked for that user's access only. Once work on the query is complete, the user unlocks the procedure, and it is available for public use. The lock feature prevents simultaneous changing of records in a multi-user application generation and utilization environment. Once a user is finished defining or editing the application search procedures, all added and changed search procedures are deployed for use by the Business Logic Builder Module 412. Many business enterprise applications utilize information and data elements that are inter-related or have one or more common attributes. Such data can be organized physically and/or virtually into lists of information and/or data objects, such as a customer list or a product list. For example, data can be associated into a list of states for use in addresses, a list of fonts to apply during text editing, or a list of data types to assign when creating attributes. Further, the lists of data can be used when populating forms and reports. Exemplary embodiments provide a feature of lookup lists to assist with accessing, manipulating, and viewing these lists. The List Builder Module 406 provides facilities for the user to define such lookup lists. With the List Builder Module 406, the user can create any number of lists, each with an unlimited number of list items, said lists being available for data population. Lists can be of two types: master lists and presentation lists. A master list is used for grouping data that is subsequently used to define presentation lists. Each element of a master list is logically related to every other member of that list, as for example, a list of U.S. states and territories might be one master list in an application. A presentation list is a grouping of list items or lists from one or more master lists for presentation to a user or as input to subsequent data processing. A software application developer might create a presentation list of contiguous states, which would be a subset of a master list of U.S. states and territories. Another exemplary presentation list might include border states and bordering Canadian provinces, which would include a different subset of the same master list with additional list items taken from another master list, a list of Canadian provinces. Exemplary embodiments provide that changes made to lists or list items in a master list are automatically reflected in the presentation lists that use that master list. List definitions, as developed by the user through a graphical user interface, such as shown in Once the list definitions have been entered via an interface such as those shown in The Identification Builder Module 408 permits the generated application to accommodate any ID format, such as needed for data identification. Business and enterprise applications often utilize one or more identification (ID) number schemes for quickly and easily categorizing, identifying, and finding specific records and data items within a large collection. When transitioning to an automated system, such as converting an existing local system to a networked application to be made available as a web service, there can be a mismatch between the identification scheme already in place and the identification scheme developed for the automated system. The Identification Builder Module 408 defines creational processes for item identification numbers by allowing the user to create a formatted record identification string that conforms to existing business logic/rules for creating and assigning identifier values to any entity. The resulting identification number can be used, for example, as an account number, a case number, a purchase order number, or any other form of identification. In this manner, the logic of the generated application is compatible with the existing logic and data of the enterprise. The identification string can be comprised of one or more elements or components, including static text, calculated dates, numeric sequences, and formats, for example. An example will show some of the flexibility that can be achieved by the Identification Builder Module 408 for creating ID strings. The generated string DSI-020766-028.206 can be created from the following components:
By defining multiple element and ID rules through a versatile graphical user interface such as shown in Once the appropriate data has been entered via the interface of The Security Manager Module 410 is used to define application users, roles, and groups in step 704 and is a tool that is intended for use in both the application generation and the application execution environments. This module manages all aspects of security within the generation and the application production environments, including system users, groups, roles, and permissions. The security settings allow the system administrator to determine at a very granular level which data and system features are accessible to any user. In one embodiment, permissions are grouped together as roles, and the roles are then assigned to users for granting individual users various permissions, or authority to access one or more features. By combining users into groups and assigning them to one or more roles, the administrator can manage very large groups of users easily. Additionally, permissions assigned by roles can be individually overridden, allowing complete control over each user's access. In one embodiment, application access rights are defined in terms of permissions to call methods on the objects generated by the system, thereby controlling user access by system or application feature. In another embodiment, roles are defined as sets of specific permissions that allow application users to work with defined entities. Each entity is created with four possible levels of permission, namely create, read, update (write), and/or delete. When a particular role is defined for an entity, each of the four permissions are either granted or denied for a user assigned that particular role as regards the entity. The system uses positive grant access permissions to allow access to resources. A resource not specifically granted to a user is denied to that user. The Security Manager Module 410 provides an interface which allows permissions to be granted or revoked individually, so that each user's access can be narrowly tailored. For example, a Judge can be granted permission to enter rulings within a system, but can be limited to entering rulings for the Judge's own court only. Security permissions can be modified without stopping or recompiling the generated application. In this embodiment, assigned roles applicable to users are maintained in a system database 112 and are not within the application itself. Further, the logic that maps the executable methods or features to roles is not retained within the application. Such security information is defined in a system database 112 and is cached within the application at the start of the application and is cleared upon a database change within the application or at the termination of the execution of the application. Therefore, roles and permissions can be changed and are automatically made effective upon the next start of the application or the access of the security information portion of the system database 112. Accordingly, any changes or additions to roles and permissions are automatically deployed when saved to the system database 112. The Business Logic Builder Module 412 is used to define the business logic, or rules, in step 706 for directing the running or processing of the generated application. In particular, this module provides for the creation, maintenance, and deployment of business objects and client-side scripts that perform the logic of the user's enterprise application. Business objects and client-side scripts are defined using a custom, XML-based scripting language. Business objects represent the business logic of an application. The Business Logic Builder Module 412 provides a framework for easily constructing these objects, ensuring that business objects generated and deployed adhere to the requirements of the user's intended enterprise application. It is through the Business Logic Builder Module 412 that the enterprise business rules, or logic, are translated into the software logic of the generated enterprise application. Through the performance of the Business Logic Builder Module 412, a level of abstraction is provided to the user so the resulting application can be server independent in that the resulting code need not be modified to be migrated from one server to another. The user interface presented by the Business Logic Builder Module 412 simplifies the creation of these objects by providing language tools, functions, and access to the other objects created and deployed by exemplary application generation modules (402-410), such as entities, lists, ID's and the like, including business objects that have already been deployed. Business objects can be divided into two types. First, Business Data Objects (BDO) represent entity components derived from one or more data transfer objects (DTO's) created using the Entity Builder Module 402 and can be viewed as containers or buckets of data to be moved, manipulated, transferred, and the like. Business Data Objects can also expose custom attributes related to the objects they encapsulate. Their purpose is to join various data transfer objects (DTO's) into a logical grouping. For example, a Judge Business Data Object might include data from several related entities:
The second type of business object, Business Components (BC), comprises the actual business logic for an application, encompassing all the methods intended for client interaction. These methods include those objects necessary for standard create, read, update, and delete (CRUD) operations on Entity Builder entities and Business Data Objects. Business Component objects can also include Boolean logic, branches, and conditions. Typically, an enterprise application is comprised of one or more business components, each of which can be comprised of one or more methods. For example, a Judge's Business Component might include the following methods:
Business Components can be implemented as generated Enterprise JavaBeans (EJB's) within a J2EE v1.3 (or later) application server 620. In one exemplary embodiment, the Business Logic Builder Module 412 can generate code to make methods of these EJB's accessible via web services 610 using Simple Object Access Protocol (SOAP). Creation and editing of business data objects and business components are performed within the Business Logic Editor (BLE) of the Business Logic Builder Module 412. For example, via the Code Generation Unit 802 within the client Toolbox 612, the Business Logic Editor presents to the user the script of the business data object or the business component along with a toolbox of action components that can be used within scripts as well as a properties grid for specifying the properties of a tool, method, or functionality added to the script. In this manner, the generation system creates the actual business logic code of the application at step 708 while the user stays at the logical level and need not be concerned nor involved in the specific conditional clauses or the coded program instructions to effect the business logic of the enterprise application into a coded and compiled application. The graphical user interface through which the available Editor tools and corresponding actions are presented for selection by the user is shown in The Business Logic Editor also has the flexibility of allowing the user/developer to create/import and install client-side, or user-drafted, scripts. These client-side scripts can, for example and not limitation, control application workflow, respond to client-side events, and determine which screens are displayed to the application user. The Business Logic Editor can store all such scripts as XML documents in the system database 128. Like forms, business objects and client scripts are assigned a version number; and all share locking mechanisms that allow multiple developers to work on an application without conflict. Referring now to The methods of each business component can be constructed in two ways. First, the method can be built manually by adding a new (empty) method and adding statements and commands to build the logic and instructions of the method. Second, the method can be built automatically by selecting an item from the Tools list and creating a Wrapper Method for that item. Under the first option, the Add New Method button (see Opening each node in the Tools list will reveal, and provide access to, the data objects and methods that have been developed and deployed during the application generation process so far. The Tools list includes a node for each of the five toolbox modules (402-410) discussed above, in addition to a node each for the Business Components and the Business Data Objects. Further, the Tools list includes four nodes not created by the application generation toolbox and not yet discussed. The Document Generation node includes a report builder for developing script statements for handling output reports for the generated application. External Components are logic modules in the form of, for example and not limitation, Enterprise JavaBeans (EJB's), functional code, and web services from external sources, including Java libraries. These external sources and libraries such as legacy systems and open source products, can be imported and then can be incorporated into scripts in the same manner as the Toolbox items to generate the functionality of the enterprise application. In this manner, existing third-party business logic can be utilized rather than having to recreate it. Actions/Statements are logic statements for use in building method scripts and can be a convenient technique for including common functionality to business components. For example and not limitation, entries in this node can provide for calculations, conversions, date operations, exception handling, file operations, flow control, and memory actions. These statements and blocks of statements can include Java code snippets for inserting hand-written Java code into the enterprise application. When the developer is ready to add the Java snippet code, the system automatically generates and displays on the developer's computer 104 the Java code corresponding to the business component so far developed, both before and after the location in the business logic where the developer wishes to insert his/her Java snippet. The generated code is for display only, to inform the developer of the context in which he/she will be writing Java code so the Java snippet can be written with full knowledge of the environment in which it will run. Comments are displayed on either side of the generated code to serve as markers to the developer for the beginning and ending of the code snippet to be added. The Java code itself can be inserted by the developer using the default text editor, or a text editor of the developer's preference can be opened for assisting with the creating and insertion of the Java code. Upon code generation, the Java snippet code is treated as a string literal that is placed in the position indicated for it in the business component. The concatenated result of the generated code and the inserted literal Java snippet code is output from the generation process for ultimate deployment. Local Methods are business components that have been previously defined in the generation process that can also be called as methods in any other business component. Referring now to Referring now to An additional feature of the Business Logic Module 412 is the creation of pseudo code on demand. The user can define various business rules with which to guide the generated application; and, upon the press of a button or clicking on this feature on his/her computer 104, the generation system will output a listing of pseudo code describing the function, logic, and/or system defined by the user. In one exemplary embodiment, the pseudo code is generated in compliance with the Java Remote Method Implementation (RMI) protocol. Exemplary embodiments provide a mechanism for designing and deploying graphical user interface screens for presenting information, menus, requests for information, and the like to the application user at run time. A form editor within the Business Logic Builder Module 412 provides a graphical user interface for creating application screens to be used in the generated application. The form editor allows the application developer to position screen components on the form and to set their properties. The form editor allows the developer to break screens into smaller constituent parts and reuse these parts, or sub-screens, in the final application. For example, a developer might create a simple address sub-screen. This address sub-screen could then be placed on any other screen needing to capture or display address data, such as with the Local Methods feature described above. Through the judicious use of sub-screens, the developer is able to significantly reduce the amount of work necessary to produce the project application. Additionally, the form editor allows the developer to lock a form while it is being edited to prevent other users from simultaneously modifying the form. This mechanism helps ensure that multiple developers are not overwriting each other's work. The created/edited form can then be saved to the database 112 in an XML format. Forms produced by the form editor are used by a rendering engine at runtime to produce the screens that are presented to and viewed by the application user. When a form is saved to the database 112, it is assigned a version number, which is incremented each time the form is modified. By comparing version numbers at runtime, the system can quickly determine whether or not the user's computer has the latest client version in their local cache. If the latest version is not in use, it is automatically and seamlessly transmitted to the client user for use. As discussed above regarding the Document Generation node/feature, exemplary embodiments can utilize one or more document/report generation engines optionally accessible through the Report Server 680, depending on the needs and requirements of the enterprise application to be generated and operated. For example, a current industry standard reporting engine, Crystal Reports, is accessible as a plug-in to the application generation Toolbox for allowing the developer to define reports and to identify associated data objects within the system for inclusion in application-generated documents and reports. Upon completion of the business component and business data object construction process, or alternately upon partial completion of the application generation process, all generated components and data objects are deployed in step 710 to be made available to non-local Business Components and application users. Accordingly, portions of, or a part of an entire software application, including specific modules, can be generated and deployed. A business component and/or a business data object can be undeployed to remove it from the available enterprise application environment. A color-coded icon or button next to each component and object displayed to the user indicates the deployment status, with, for example, green indicating a deployed status and red indicating an undeployed status. Yellow can indicate that the business component/object has been deployed and then changed, thereby visually indicating that the component/object needs to be re-deployed. The Business Logic Builder Module 412 deploys and undeploys the generated software code and objects, including Session Enterprise JavaBeans (EJB's) and methods (including remove, create, update, find by primary key, find all), to the target Application Server 620 environment for subsequent access by the application users/clients. Exemplary embodiments deploy the following application components for subsequent access and/or usage by the enterprise application:
Lists and security services can be deployed to the one or more targeted Application Servers 620 as soon as any one of the above components are deployed. Exemplary embodiments are application server platform-independent in that the enterprise application can be generated to be compatible with any number of operating system protocols, computer platforms, and networks. Exemplary embodiments provide for auto-deployment from one operating system platform to another. Referring again to The Database Tables 132 store three separate types of data: application component design data, component instance data, and security data. These three sets of tables provide all of the functionality required to model and store data for any logical entity-relationship data model. The component design tables are used by the client Toolbox and are never accessed directly by any developer or runtime application. They are used are used to store the definitions of any objects created by the development tools. They do not contain any component instance data. These tables contain the component structure, but no instance data records. The component instance tables store the actual business data entered or generated by the running application. For example, if the developer creates a Judge entity using the Entity Builder Module 402, the definition of that entity is stored in the component design tables, but specific records of Judge data are stored in the component instance tables. The instance data records can only be interpreted in terms of the structure stored in the component design tables. The security data tables store all of the security information required by exemplary embodiments during actual application operation. This security information includes user, group, role, and permission data. This data is stored by the Security Manager Module 410 plug-in and is utilized by the security services framework to permit or deny user access to each business object, data object, entity, and entity record in the system. The information stored in the Views database 130 is used to translate the physical model represented by the tables into a logical model which is used by the rest of the Toolbox suite and by the generated application. The database Views 130 presents a logical model of the application to the rest of the system. Access to the Views information is also available through the database Stored Procedures 126, which contains logic to process Views information before returning the results to the user. The generated code uses both generated Views and generated Stored Procedures to produce a logical entity view of the application at runtime. This ensures that data access to the entity record level is properly managed. There are several types of views, including application views and entity views. An application view provides a logical view of the application generation system tables including the lists created by the List Builder Module 406, while entity views provide a logical view of the entities defined in the Entity Builder Module 402. Application views are predefined, while entity views are automatically generated by the Entity Builder Module 402. Whenever a user changes an entity, the Entity Builder Module 402 re-generates and re-deploys an updated version of the view that represents the current logical entity definition. Note that the security tables do not have a corresponding set of views because the base security table's logical and physical data models are the same. The Stored Procedures 126 provide granular CRUD (create, read, update, and delete) access to the underlying tables and views stored in databases 132 and 130. These stored procedures are called directly by the generated entity, search, ID, list, and business component Enterprise JavaBeans (EJB's). They are also called from the application development tools. There are several types of stored procedures, including application procedures, business procedures, entity procedures and search procedures. Application procedures are the primary procedures used by the application development tools for accessing and maintaining application views and security tables. Only user accounts with development tool access permissions have permission to call these stored procedures. Business procedures are a set of runtime helpers that provide access to ID and list functions. These procedures are called by ID and list session Enterprise JavaBeans (EJB's). Entity procedures are the procedures used by meta-model entities to store and retrieve application data. These procedures are automatically generated by the Entity Builder Module 402 following creation or update of an entity. These procedures are not part of the application generation framework and are specific to each application generated by exemplary embodiments. Search procedures represent stored procedures generated and maintained by the Search Builder Module 404 plug-in. These procedures are called from search session EJB's. They also are not part of the application generation framework and are specific to each generated application. Exemplary embodiments provide a suite of Runtime Services 608 supplying database, data access layer, business layer, and presentation layer components in order to provide services that are needed during application execution. These services are utilized during application generation and/or by the generated portions of the application for runtime support. These Runtime Services 608 include a presentation service, a security service, an introspector service, a form service, and a script service. The presentation service is comprised of a Java-based thin client and a JavaServer Pages (JSP)-based web client, depending on the application user's computer configuration. These presentation layers provide similar functionality by converting application logic scripts and forms into an appropriate graphical user interface for presentation to the application user. As part of the presentation services, each client interacts with the security, form and script services. This interaction occurs via web-based Hypertext Transfer Protocol (HTTP) and Simple Object Access Protocol (SOAP). A Java-based thin client presents a graphical user interface as a standard desktop application to the application user. Since the interface is written in Java, it is equally compatible with Windows, UNIX, Linux, and Mac OS X environments. The Java client can be automatically downloaded and executed across the Internet, greatly simplifying application deployment while providing the power of a traditional desktop application. The runtime security service is responsible for ensuring that only trusted accounts have access to application resources. As discussed above, each application user account can be associated with roles and groups within the system, which are assigned permissions to access various resources, including business logic, data objects, database entities, business components, and methods. The security service is available to every layer of the application architecture, ensuring that any resource access, at any level, is authorized for the current user or account. The system employs a custom authentication service based upon the Java Authentication and Authorization Service (JAAS) specification for validating each service call from the client, whether through standard clients or web services. The introspector service is an Enterprise JavaBean (EJB) that is published as a web service available to application generation users. This service provides methods to discover and list information regarding services and components currently deployed in the project application. These services are used by the Business Logic Builder Module 412 and the Script Editor and Forms Editor to determine what functions have been deployed to the application. As business and data objects are deployed, they automatically become available to these editors. The form and script services, including editing, are used by both the application generation tools and by the runtime framework for storing and retrieving forms and scripts using the database. Each form or script is identified with a version number that is automatically incremented whenever the form or script is updated in the database 112. The form and script version numbers are used by the system to implement client-side caching services. For example, when an application user first logs in, the system downloads a list of forms and scripts along with their current version numbers. Whenever the user needs to access a form or script, the system first looks to its cache and compares the version in the cache with the version list downloaded during login and downloads the current form or script anew if needed, ensuring the most current form or script is used. Additionally, form and script services provide the ability to �lock� forms and scripts during editing to prevent other users from modifying a particular form or script until the lock is removed. When a form or script is locked, users and developers can download the current version but cannot check in any updates. This locking mechanism prevents developers from overwriting each other's changes. As discussed above, the application generation system provides documentation generation methods to get, print, and export reports in the generated application. The document generation services are used by the runtime framework to generate reports, letters, and other application runtime documents, based on the requirements entered using the report builder. The business layer processes each report request and passes that request, along with data retrieved from one or more data transfer objects (DTO's), to the document generation server, i.e. the Report Server 680. Each generated document can be queued for immediate printing, scheduled for batch printing, or returned to the business layer and thereby to the application user for viewing. Each document may be saved in a database and can be associated with another entity stored in the database. The document generation service supports outputting documents in a variety of formats, including Microsoft Word, Microsoft Excel, Adobe PDF, and Rich Text Format (RTF). Access to external documentation generation methods can be provided by means of the new project configuration, where a Document Generation URL is included. This URL is the address that can be used by business components to communication with the Report Server 680 during application execution. Although preferred embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that changes may be made in these embodiments without departing from the principle and spirit of the invention, the scope of which is defined in the appended claims and their equivalents. Referenced by
Legal Events
Rotate |


text:
Cottman Transmission and Total Auto Care
3192 West Broad Street,Columbus, OH 43204
Oh snap! "Cottman Transmission and Total Auto Care" doesn't have any current deals at the moment. Check back soon, or share a deal now?
Additional Business Information
main: 614.654.0006
business hours:
M-Su 8am-8pm
payment methods:
american express, cash, check, discover, mastercard, visa
audi, bmw, buick, cadillac, chevy, chrysler, dodge, ford, gm, honda, hyundai, jaguar, kia, land rover, lincoln, mazda, mercedes benz, mercury, mitsubishi, nissan, oldsmobile, porsche, suzuki, toyota, volkswagen, volvo
auto repair, transmission repair, maintenance, brakes, rotors, pads, disks, alignment, belts, hoses, tune ups, shocks, clutches, engine repair, tires, wiper blads, check engine light, catalytic converters, steering, oil service
bbb, atra
website: http://www.cottmanofcolumbus.comemails:
find us on:
year established:
video >>
click here to read more on google places
OTHER NEARBY DEALS IN COLUMBUS (change my city)
$25 Gift Certificate for $10.00
provided by
user reviews
rating 3.5 out of 5
Brent Chandler
I went in to see if they could fix my transmission. They said it would be $1,600 just to open it up to see what was wrong. No thanks. The owner was very pushy, and would not take no for an answer. I wanted to leave it on the street to make a decision to go look at cars. He said he had to have the ke.... Brent Chandler
Wendi Bush
I had a good experience at Cottman. They made me feel welcome, were accommodating, and communicated well. I would suggest this shop to anyone who has had transmission problems. Transmissions can be a pain, but Cottman can take care of it and put your mind at ease. Wendi Bush
Tom Brown
What a jerk, The Owner , Call to ask a question about our car and all he could tell me was have your car towed here and will look at it, I tried to ask questions but he was as rude as could be. I ask to speak to the owner and he said he was the owner when I told him he was being rude he said sorry y.... Tom Brown

subset: commoncrawl


text:
| Email | Full Article (TrendHunter.com/id/45521) |
To accept his Swarovski Womenswear Designer of the Year Award from the Council of Fashion Designers of America (CFDA), Alexander Wang opted to wear his suit with shorts rather than full pants.
While it may seem like a moment of fashion rebellion, no detail was spared in this outfit. The shorts were from Comme des Garcons and made of black sateen, his white shirt was from Band of Outsiders, and he finished the look with a vintage black Helmut Lang tuxedo jacket.


text:
Outstanding customer service. Jeff went above and beyond the call of duty to make me happy. He could have just blown me off, as other shops have done...Read More ->
Unbelieveable! The only real Magic that is taking place here is just how great these guys are .... Many, many thanks for being there. Best supplier...Read More ->


text:
David P. Jones, Ph.D., Vice President for Student Affairs
and Minnesota State University Mankato alumni and friends reception.
March 17, 2014
Chase-Hilton Room
Hilton Baltimore
401 W. Pratt Street
Baltimore, MD
The event is free of charge. RSVP by March 10.
For MSU events: individuals with a disability, who need reasonable accommodation to participate in this event, are asked to contact the Office of Disability Services at 507-389-2825 (V/TTD), 800-627-3529 or 711 (MRS/TTD) at least five days prior to the event.
Email this article | Permanent link | Alumni news | Alumni news archives


text:
The Terror Aboard The Speedwell: Interactive, Sci-Fi Fiction
Welcome to the future. The remnants of humanity, in the aftermath of a cataclysmic event known only as The Fall, have fled a dying homeworld to seek refuge among the colonies of the solar system.
A small reconnaissance team returns to survey the surface of Earth. What they find there not only puts their lives in peril, but also endangers all of humanity.
The Terror Aboard The Speedwell is a sci-fi horror game where victory means surviving a two month trip back to Mars as a deadly creature stalks your spaceship, picking your crew off one by one.
Maybe if you're smart–and a little lucky–you'll make it back home with all your limbs intact. Choose poorly and the Speedwell will be your tomb.
We're interested in interactive fiction at VODO. As in, very interested. As in, thinking about commissioning some new, Speedwell-style works that could bring together promising new writers with illustrators and musicians to create some fab cross-media, VODO-branded fiction.
Watch this space – but while you're watching it grab a copy of The Terror Aboard The Speedwell – at a smashing discount and bid-what-you-like for the next two weeks!
p.s., If you're a writer, illustrator or musician interested in making interactive fiction with us, drop us a line!
I Killed Adolf Hitler: Meet Your New Favourite Time Travelling Contract Killer
Welcome to a strange, violent world in which contract killers are routinely hired to rub out dysfunctional relatives, abusive co-workers, and even just loud neighbours. 'I Killed Adolf Hitler' opens on a note of perverse sexuality and ends with a touching ode to the permanence of true love. Sandwiched in between there's murder, time travel and alternate futures – all brought together with a perfectly logical and yet completely shocking, unexpected climax.
Rendered in Jason's trade crisp deadpan style, and augmented by lovely, understated colouring, I Killed Adolf Hitler is a truly marvellous, oddball gem from Fantagraphics – and worth winner of the Eisner award. It's available on VODO at a 35% discount on Buy-it-Now, or, of course, bid what you like!
Orborun: Become The Pinball, In This Feel-Good, Futuristic Racer-Puzzler
For the next 14 days we're bringing you a solid slice of fun – in the form of the fast-paced racing-puzzler, Orborun. This release comes with the original Android game as well as the adapted, upgraded and streamlined Windows, Mac AND Linux versions.
Oh and for you Steam hounds (we know you're out there) — yes! we have Steam keys.
One to dive into when you're in the mood for some straight-ahead, swift rolling, relaxing action – although there can be yelling when you don't nail a level, and groaning when you hurtle over the edge into the digital abyss. Still, a cool breakbeat soundtrack contributes to the good-time groove as you hurl your cute little Orbot through vertiginous, Portal-on-acid-style levels of increasing velocity and trickiness.
"Little running mech man. Ramps and boosts. High scores. Jumps. Get to the portal. Wrong portal. Start again. Fall off. Start again. Beat the level. Start the next one. Mindlessly. Happily." Twinfinite.
Tiny Lab Productions have done a fantastic job of producing an entertaining, light-but-challenging vibe as the game develops. You'll be constantly surprised at the new tricks they pull on you as you progress and you're forced to put your pinball through increasingly demanding moves.
"Bouncing that little rolled-up mech ball off a sick boost jump into a string of high scoring items only to smash through some blue glass as the finish line comes into sight is bizarrely satisfying." Twinfinite, again.
Beyond the various hazards strewn in your path and the general mechanic of fast-paced pinball manoeuvering plus regular power-ups for some pleasantly zippy sequences, many levels require you to navigate through puzzle-like warp portals and launch pads to get to the exit. Puzzle plus kinetics, in the end, creates more than enough interest to create a potential addiction problem across three levels of play.
Thanks to Nick over at Digerati Distribution for bringing us this one. Grab Orborun today and hurtle your way to freedom!
War Stories: Pay-What-You-Want For The Future Of War, Now
Fresh off the presses from our friends at Apex Books, and currently rocking a solid 4.5 stars on Goodreads, we're proud to present our first pay-what-you-want, One-Shot release: War Stories. (It's available for the next 10 days. If you haven't already, subscribe to the mailing list to hear first about our upcoming, most excellent deals and discoveries.)
- Front Cover: War Stories
Science fiction's been speculating about war from the earliest days of the genre. From George Tomkyns Chesney's The Battle of Dorking and H.G. Well's War of the Worlds & War In the Air to Robert Heinlein's Starship Troopers to Karin Traviss's Wess'har Wars series and Dan Abnett's Embedded, science fiction literature has long imagined and elaborated ideas of war.
In a 21st century characterised by permanent, weird, asymmetric war, a collection like this couldn't be more timely. Funded via a successful Kickstarter,the hefty 356pp, illustrated book presents some of today's most exciting short fiction authors, and a glimpse of the down and dirty future of war.
War Stories is divided into four sections: "Wartime Systems," "Combat," "Armored Force" and "Aftermath." Many of the stories, especially those in the "Aftermath" section, wrestle with such present-day realities of military life as posttraumatic stress and the moral implications of remote killing via drones.
With the book only out just a few days, great reviews are already pouring in from publications as well as readers. 'The stories in this anthology have a strong focus on the protagonists and the costs and consequences of war,' writes Paul Weimar at SF Signal. 'It's the people and their stories that make the stories in War Stories truly excellent.'
'The authors focus on what the future holds for soldiers' bodies,' explains BookishlyWitty, 'how they'll react to biological "upgrades," high-tech prosthetics, brain implants, and even teleportation. Others consider the role of militarized suits, advanced drones, and virtual reality. The anthology brings together talented authors imagining the same topic in diverse, unique ways.'
The collection is available as a VODO release for 14 days only at 35% discount on Buy-It-Now, or for pay-what-you-want, via our new Bid feature: simply make your bid and our friendly algorithm will let you know if you won. You only pay if you receive the content at the price you want!
p.s.. The collection's editors, Jaym Gates and Andrew Liptak, ran an AMA over at Reddit during their Kickstarter last year. Many of the authors in the collection jump in!
p.p.s If you enjoy War Stories, jump over to Apex (take a look at their free books!) and take advantage of their excellent bundle offer.)
Scare Yourself Stiff –– The Really Creepy Bundle
Join us for an adventure to the dark side!
Dare you prise open the creepiest bundle of them all – support our inspiring independent creators, help charity, and make off with some great, great content for yourself?
- 4 chilling games (Oknytt, Finding Teddy, The Path and Sang Froid)
- Lashings of frightening fiction (novel ) Stranger In Olondria
- 6 month subscription to Nightmare Magazine
- 4 spooky short films (Tales From The Creep'd)
- 8 track compilation from LA's Not Not Fun records, laden with doom
- 1 very disturbing and massively entertaining graphic novel (The Furry Trap)
The choice is yours: beat the average price, or choose exactly what to pay. Simply click the "That's too much for me!" button and tell us which tier you want and how much you want it for. Our mysterious (and possibly sentient) algorithm will select from the best bids. If selected, you'll automatically receive a bundle at your chosen price.
With VODO, everyone can afford some spine-tingling fun. Our creators want you to know they're super happy whatever your level of support.
70% of contributions are divided between content providers, 25% goes to VODO and 5% goes to our chosen charity for the bundle, Electronic Frontier Foundation. The EFF is the leading nonprofit organization defending civil liberties in the digital world. Founded in 1990, EFF champions user privacy, free expression, and innovation through impact litigation, policy analysis, grassroots activism, and technology development. EFF works to ensure that rights and freedoms are enhanced and protected as our use of technology grows.
So… your purchase guarantees fair recognition for the work of our fabulous contributors, helps pay VODO to find and share more great content in ways that make sense, and even helps cut a nice check for charity!
Indie: love it? Share it!
Cutting Edge Indie — The Cork Film Festival Bundle
Reeled and landed by Cork Film Festival, we're proud to present a special selection of gripping, innovative and inspiring movies from new, emerging and established filmmakers.
Now in its 59th year, Ireland's Cork Film Festival is an industry-leading institution for movie-making talent development with a fiercely independent programme that reflects the character of the rebel city.
Including shorts, features, dramas and documentaries, The Cork Film Festival Bundle boasts seven feature films and seven shorts, including award-winning works from the Grand Prix 2013 pick. With a recommended retail price of over $100, this lovingly assembled library of works is available on a Pay What You Want basis. So… what's it worth to you?
The bundle includes:
Bird on a Wire (feature doc)
Intimate portrait of singer and author Leonard Cohen's tour of the same name, hidden and unreleased until 2010.
Barbaric Genius (feature doc)
One man's rise from alcoholic street thief to chess master and award-winning author.
How to be Happy (feature comedy)
Intensity mounts as a relationship counsellor starts sleeping with his clients
Here One Day (feature doc)
A stunning and stark exploration of a mother's struggle with life, recomposed from a hidden box of audiotapes
The O'Briens (feature comedy)
Against the backdrop of beautiful Galway, a loveable, dysfunctional Irish family negotiates a chain of unfolding secrets
NCR: Not Criminally Responsible (feature doc)
A provocative examination of the criminalisation of mental illness
Nocturne (feature doc)
Controversial examination of the life of the great British composer, Benjamin Britten
Stolen (Short drama; Winner, Grand Prix Cork, Cork Film Festival 2013)
A young girl is held captive by a couple in strange house
Mechanic (Short drama; Special Mention, Grand Prix Irish, Cork Film Festival 2013)
A mechanic fixes up an old car for his last ever drive, but old age catches up with him
"It's like you're giving a donation to support independent filmmaking… and getting 14 amazing movies with it!"
James Mullighan, Creative Director, CFF
70% of contributions are divided between content providers, 25% goes to VODO and 5% goes to Cork Film Festival and the Spirit of the Festival Award––a new fund and accolade recognising bold ideas well told, and new, experimental and hybrid forms.
Indie: love it? Share it!
The Otherworlds Bundle––Indie Sci-Fi From The Edge!
Grab your ticket for a mind-rupturing ride through our interstellar collection of Sci-Fi and Speculative Fiction movies, games, ebooks and music (and meet the team in our craziest intro video to date!).
VODO's Otherworlds Bundle is jammed with far-out entertainment from the incredible, to the implausible to the downright strange, by inspiring independent creators from around the globe.
Pay What You Want while this offer lasts and get lifetime access to a constellation of crucial creativity including:
Ghosts With Shit Jobs
(Mockumentary satire by former Adbusters Editor, Jim Munroe)
"a brilliant, satirical indie flick about the future of dead-end jobs" io9;
AI Wars: Fleet Command
(Brilliant RTS from Arcen Games)
"Expertly crafted" Boomtown, 90; "close to perfect"Dark Zero;
"Excellent space strategy." PC Gamer
(Awesome indie feature by Amber Benson and Adam Busch of Buffy fame)
"The Office meets Close Encounters", "office politics take on cosmic dimensions" Eye For Film;
"a heightened reality that's just left-of-center…. It's hard not to root for a film that can translate intergalactic drama into water cooler talk." Notcoming.com
The Surrogates 1, 2 and Case Files
(Top-notch graphic novel collection from Top Shelf Productions)
A NEW YORK TIMES BESTSELLER! "The Best Indie Book of the year." IGN;
"An absolutely fascinating piece of work — heartfelt and thoughtful" Fantasy & Science Fiction;
As well as:
Future My Love, a documentary from Maja Borg:
Romance and politics in the ruins of economic collapse
Bientôt l'été, Tale of Tales games:
Existential gaming at it's most atmospheric
Clarkesworld magazine, 4-month subscription; Blink short-film compilation (Prospect (2013); The Naturalist (2012); In the Pines (2011); Jouet (2012)); The Apex Book of World SF:
Collected works of short-form Sci-Fi in movie and magazine form
Sabled Sun 5-part album suite; Not Not Fun records Out-There EP:
Soundtracks for your ride – file under deep-spaced
Jump aboard––It's a TRIP!
70% of contributions are divided between content providers, 25% goes to VODO and 5% goes to our chosen charity for the bundle, Electronic Frontier Foundation. The EFF is the leading nonprofit organization defending civil liberties in the digital world. Founded in 1990, EFF champions user privacy, free expression, and innovation through impact litigation, policy analysis, grassroots activism, and technology development. EFF works to ensure that rights and freedoms are enhanced and protected as our use of technology grows.
So… your purchase guarantees fair recognition for the work of our fabulous contributors, helps pay VODO to find and share more great content in ways that make sense, and even helps cut a nice check for charity!
Indie: love it? Share it!
The NSFW Bundle – Sizzling, Sleazy, Seductive Fun!
How hot is too hot? Undo those buttons, recline and take your time to explore a bursting bundle of edgy, fun, sex-positive sights and sounds.
BDSM star, activist and educator Madison Young presents this potent concoction of cult sleaze on celluloid, great games, hot music and enthralling ebooks that tickle, tease, stroke and smack their way around the subject of sex, or throb with unquenched desire and wild abandon.
Available for 15 days only, from 21 February to 07 March, VODO's NSFW Bundle is here to engorge your curiosity with: a digitally remastered sexploitation classic (Vampire Hookers) and bare-naked tale of sex on celluloid (A Labor Of Love); simmering tales of burlesque seduction in sumptuous HD (Cabaret Desire); three games of pleasure tactics, pent-up anticipation and libidinal lunacy (Seduce Me, Dinner Date and My Girlfriend is the President); two hot, too-cool EPs in hi-intensity, hi-def FLAC format and Mp3 (Animal Chuki, LA Vampires); and three tightly gripping reads and romps (Jess Fink's Chester 5000, Girlvert by Ashley Blue and Daddy by Madison Young). For the first thousand Premium sales, there's a one week entry ticket to Erika Lust's xconfessions message board, where you can share your deepest sexual secrets for a chance to have them brought to life in an erotic short film.
This brimming bottle of burning hot sauce combines over $120 worth of high-quality cross-media to entertain, educate, amuse and arouse.
Madison Young, Author of BDSM memoir, Daddy, commented:
Sex-positive means healthy sexual communication, authenticity, finding a sense of sexual wellness. All of the images that bombard us on a daily basis, on billboards and in commercials, are constantly telling us 'this is what you should look like', 'this is who you should be' and––when it comes to porn––that you'd better be squealing in this way, be able to get your legs over your shoulders, take it in all of your orifices at the same time and act like you like it. I try to undo all of that. Believe in whoever you are inside and amplify it! Thanks for taking a look at the Not Safe For Work bundle––I hope you find something you like!
70% of contributions are divided between our fabulous content providers, 25% goes to VODO and 5% goes to our chosen charity, The Center For Sex and Culture. Based in San Francisco, USA, this award-winning nonprofit offers judgment-free education and events to audiences across the sexual and gender spectrum, as well as framing and informing issues of public policy and public health.
VODO is proud to present an ongoing series of Artists' Moving Image works, curated in collaboration with Michael Cousin/Outcasting (Cardiff, UK) and supported by the Arts Council of Wales. The programme has previously shown work by Darren Banks and accompanying the NSFW Bundle are works by Cristine Brache and Miguel Maldonado.
The Big Brother Bundle, Curated By Daniel Domscheit-Berg (ex-Wikileaks)
The word is out: we're all being watched. It's never been more important to think about our privacy — and how governments and corporations are invading it.
VODO asked one of the original members of Wikileaks, Daniel Domscheit-Berg, to help curate the unique, one-off bundle of content around the theme of Big Brother. It brings together indie creators, authors and experts on one of the most important issues of the day and is available for 20 days only, starting October 30.
VODO's Big Brother Bundle contains two essential documentaries fresh from major film festivals (Shadows of Liberty, Secrecy), award-winning graphic novels (The Homeland Directive, Subatomic), highly rated Steam games (I Have No Mouth And I Must Scream, Hacker Evolution: Duality), original music from conscious hip-hop star Immortal Technique (Surveillance EP), a book from privacy guru Bruce Scheneier (Schneier on Security), and, for the first 10,000 "Beat The Average" customers, 3 months online privacy from well-respected VPN provider iPredator. The bundle also sees the launch of a partnership between VODO and Outcasting agency for artist's moving image, supported by the Arts Council of Wales, to include artist's film and video with VODO releases. The Big Brother Bundle will feature Removable Media, a short found-video work by UK-based artist Darren Banks.
We're proud to have brought together over $145 worth of content in the bundle – and a great combination of fun, information and creativity.
Daniel Domscheit-Berg, author of Wikileaks: My Years With Julian Assange, commented:
"I'm delighted to be involved in this exciting bundle. It's an important time for us all to be thinking about these issues – and this is a great way to get in touch with the issues, collect some great, fun content and support independent creators distributing their work in a truly innovative way."
Daniel's biography is the basis of the new film The 5th Estate. He lives and works in Berlin Germany.
70% of contributions are divided equally between the 7 content providers, 25% goes to VODO and 5% goes to our chosen charity, Fight For The Future. Fight for the Future is dedicated to protecting and expanding the Internet's transformative power in our lives by creating civic campaigns that are engaging for millions of people.
Indie: love it? Share it!
Lovecraft / Cthulhu Trans-Media Bundle Goes Live On VODO – 3 Week Special Offer
Grab this awesome Pay-What-You-Want collection of trans-media treats inspired by the writings and mythos of cult American horror writer H.P. Lovecraft, including film, indie games, ezines, ebooks, audio books and more, only on VODO!
For the as yet uninitiated, here is a good explanation of Lovecraft's style from Wikipedia: 'Lovecraftian horror is a sub-genre of horror fiction which emphasizes the psychological horror of the unknown (in some cases, unknowable) over gore or other elements of shock, though these may still be present… The hallmark of Lovecraft's work was the sense that ordinary life was a thin shell over a reality which was so alien and abstract in comparison that merely contemplating it would damage the sanity of the ordinary person.'
The bundle includes the following goodies:
Call of Cthulhu: The Wasted Land(Android & PC Game), courtesy of Red Wasp Design
Cthulhu Saves the World (PC Game), courtesy of Zeboyd Games
Die Farbe / The Colour Out Of Space (Film), courtesy of BrinkVision
Innsmouth Magazine, Collected Issues 1-4 / 5-7 (eBooks), courtesy of Innsmouth Free Press
Lovecraft Audio Books Packs 1 & 2 (mp3 audio), courtesy of The Atlanta Radio Theatre Company
Lovecraft eZine, 2 x Annual Megapacks, 2011/2012 (eBooks), courtesy of The Lovecraft eZine
Sherlock Holmes: The Awakening (PC Game), courtesy of Frogwares
Curated by Tomas Rawlings of Red Wasp Design, this special offer is available from VODO on a time-limited basis from August 1 to August 18 and can be tweeted about via the hashtag #CthulhuBundle.
Tomas remarked:
"This is a really exciting bundle that reflects the fact that fans like myself aren't only interested in one medium; we like games, films, books and audio and are happy to have Cthulhu on all of these and more! Each of the things selected here is something that personally I'm a huge fan of so am really pleased to see them all in one collection."
70% of contributions are divided equally between the 7 content providers, 25% goes to VODO and 5% goes to our chosen charity for this offer, Fight For The Future. Fight for the Future is dedicated to protecting and expanding the Internet's transformative power in our lives by creating civic campaigns that are engaging for millions of people.
Indie: love it? Share it!
Recent Posts
- The Terror Aboard The Speedwell: Interactive, Sci-Fi Fiction
- I Killed Adolf Hitler: Meet Your New Favourite Time Travelling Contract Killer
- Orborun: Become The Pinball, In This Feel-Good, Futuristic Racer-Puzzler
- War Stories: Pay-What-You-Want For The Future Of War, Now
- Scare Yourself Stiff –– The Really Creepy Bundle