Understanding CODE:NEO

Understanding CODE:NEO
-1-
EXECUTIVE SUMMARY ....................................................................................................... 4
THE FOLLOWING ARE SOME KEY BENEFITS CODE:NEO PROVIDES; ................................ 4
WITH CODE:NEO .......................................................................................................... 4
THE CODE:NEO SOLUTION CAN BE BROKEN INTO SEVERAL MAIN AREAS; ..................... 4
GENERAL OVERVIEW ......................................................................................................... 6
BENEFITS ............................................................................................................................ 7
REDUCES SOFTWARE DEVELOPMENT AND RECONFIGURATION AND COSTS AND SPEEDS
TIME-TO-MARKET ........................................................................................................... 7
IMPROVES SITE PERFORMANCE, ENHANCING REVENUE GENERATION AND CUSTOMER
SATISFACTION.................................................................................................................. 8
LOWERS INFRASTRUCTURE COSTS ................................................................................... 8
EASILY INTEGRATES WITH EXISTING DEVELOPMENT TOOLS ........................................... 9
LEVERAGES THE POWER OF C/C++.................................................................................. 9
CODE:NEO’S INTEGRATION WITH OTHER TECHNOLOGIES ........................................... 10
SERVER SIDE RESOURCES .............................................................................................. 10
PROVIDES EASY, ONLINE DEVELOPMENT ...................................................................... 11
PROTECTS INTELLECTUAL PROPERTY THROUGH ENHANCED SECURITY ........................ 11
BUSINESS OPPORTUNITY .................................................................................................. 13
BUSINESS CHALLENGES AND OPPORTUNITIES ............................................................... 13
INTERNET CHALLENGES AND OPPORTUNITIES ............................................................... 14
INTELLECTUAL PROPERTY CHALLENGES AND OPPORTUNITIES...................................... 15
CODE:NEO COMPETITIVE ADVANTAGE ...................................................................... 15
TECHNOLOGY ................................................................................................................... 17
OVERVIEW ..................................................................................................................... 17
HOW POWERFUL IS CODE:NEO? THIS POWERFUL;....................................................... 18
HOW SIMPLE IS CODE:NEO? ........................................................................................ 18
CODE:NEO FRAME WORK ........................................................................................... 19
THE CODE:NEO APPLICATION PROGRAMMERS INTERFACE (API)............................... 21
THE CODE:NEO SYSTEM ............................................................................................. 24
SELECTING C++ AS CODE:NEO’S CORE TECHNOLOGY .............................................. 25
CODE:NEO SHARED MEMORY .................................................................................... 26
THE CODE:NEO PROCESS ............................................................................................ 28
CODE:NEO – AN EFFICIENT DEVELOPMENT PROCESS ................................................ 30
WEB-BASED DEVELOPMENT.......................................................................................... 31
THE ADVANTAGE FOR DEVELOPERS .............................................................................. 32
WHAT IS UNIQUE ABOUT CODE:NEO?........................................................................ 32
THE SYSTEM ENVIRONMENT.......................................................................................... 33
THE CODE:NEO LANGUAGE ........................................................................................ 34
FREQUENTLY ASKED QUESTIONS .................................................................................... 36
ARE THEIR ANY SEVERE SHORTCOMINGS OF CODE:NEO?............................................ 36
CAN A NON-PROGRAMMER SCALE FROM BEGINNER TO ENTERPRISE LEVEL USING
CODE:NEO?................................................................................................................. 36
DOES JAVA OR ANY OTHER LANGUAGE HAVE A BROADER USAGE BASE THAN C++?...... 36
IS CODE:NEO HARDER TO PROGRAM BECAUSE IT’S BASED ON C++?........................... 37
-2-
HOW DO C++ POINTERS ENHANCE SOFTWARE AND HOW DOES IT AFFECT RELIABILITY
AND COMPLEXITY?......................................................................................................... 38
IS CODE:NEO A ‘TAG BASED’ LANGUAGE?.................................................................. 40
HOW DOES CODE:NEO EFFECT PROJECT COST COMPARED TO PROGRAMMING IN COLD
FUSION, JAVA OR ASP................................................................................................... 40
HOW DOES CODE:NEO PROTECT YOUR INTELLECTUAL PROPERTY? ............................ 41
HOW DOES CODE:NEO’S NEED FOR COMPILATION HELP DEVELOPERS? ....................... 41
CAN CODE:NEO SUPPORT ALL PLATFORMS, DEVICES AND BROWSERS? ...................... 42
DOES CODE:NEO COME WITH AN IDE (INTEGRATED DEVELOPMENT ENVIRONMENT)?
....................................................................................................................................... 42
DOESN’T THE FACT THAT SERVERS ARE LESS EXPENSIVE THAN PROGRAMMERS MEAN
THAT WEB EXECUTION SPEED CAN ACHIEVED CHEAPER WITH BUYING MORE SERVERS
THAN UTILIZING CODE:NEO? ...................................................................................... 43
HOW DEOS CODE:NEO COMPARE IN NUMBER OF SOURCE CODE LINES OR FILES TO
ACCOMPLISH THE SAME TASKS AS JAVA, COLD FUSION OR ASP?.................................. 43
CODE:NEO APPLICATIONS ARE EASY TO DEBUG.......................................................... 44
HOW DOES CODE:NEO HANDLE COMMON INTEGRATION TECHNOLOGIES SUCH AS COM,
CORBA, RMI, AND MQ SERIES ETC.? ........................................................................... 45
HOW DOES CODE:NEO HANDLE DATABASE SUPPORT? ................................................ 45
CODE:NEO IS A MATURE DEVELOPMENT ENVIRONMENT. ............................................ 45
BENCHMARKS ................................................................................................................... 47
PARTNERS ......................................................................................................................... 60
SOLUTIONS........................................................................................................................ 63
CODE:NEO CART OVERVIEW ...................................................................................... 63
HOME SEEKERS MTA CALCULATOR ............................................................................. 68
OPTICAL OUTLETS E-COMMERCE SYSTEM WALK THRU ............................................... 71
OPTICAL OUTLETS INTRANET REPORT AND UTILITIES SYSTEM WHITE PAPER ............. 77
BEST SECUIRTY INDUSTRIES CONTACT SYSTEM ............................................................ 96
EMPSTAT ONLINE PROCESSING APPLICATION ............................................................ 98
PENSACOLA REALESTATE PREMEIR LISTING SYSTEM .................................................... 99
MANAGEMENT & ADVISORY TEAM ............................................................................... 100
CONCLUSIONS ................................................................................................................. 102
CONTACT INFORMATION .............................................................................................. 102
-3-
Executive Summary
CODE:NEO is a system for creating powerful applications. It allows developers
to program in the most powerful programming language available, C++, rapidly
and efficiently. This allows companies utilizing CODE:NEO to save money, time,
and increase revenue. This white paper’s intent is to introduce the reader to
CODE:NEO technology, show the benefits CODE:NEO has and to allow a
technology professional to have a solid understanding of what CODE:NEO can
offer his or her business.
The information in this document ranges from very technical to completely
business oriented. It also varies in complexity from simple to extremely complex.
And is generalized into two main areas, technological overview and business
overview. If a specific topic is either to technical or not technical enough it’s
likely expressed differently elsewhere.
The following are some key benefits CODE:NEO provides;
•
•
•
•
•
•
•
•
Allows C++ programming within HTML
Brings C++ Applications to the Web Quickly
Provides Libraries For Rapid Web Development
Improves Site Performance, Enhancing Revenue Generation and Customer
Satisfaction
Lowers Infrastructure Costs
Provides Easy, Online Development
Protects Intellectual Property Through Enhanced Security
Easily Integrates with Existing Development Tools
With CODE:NEO
•
•
•
•
Internet applications can run ten times faster than current applications.
A company’s existing software is converted to Internet based applications.
Potential customers save substantial conversion costs.
Availability of programmers for Internet development projects increases.
The CODE:NEO solution can be broken into several main areas;
Application Server, the CODE:NEO application server is a web server add-on
for Apache, IIS or other ISAPI / module compliant web server a shared memory
-4-
server and set of libraries for executing CODE:NEO applications. This currently
runs on Win32 platforms such as 9x,NT, W2K as well as Linux, Solaris and soon
FreeBSD/OpenBSD.
The Development Tool is software, which assists a developer in creating a
CODE:NEO application. These tools include a generator to turn pages, which
include HTML and C++ into a specified format C++ file for compilation. These
tools include the header files and API documentation as well as tutorials and
examples to get the programmer started.
The Application is actually the end result product of the development tool. This
is the binary code that will actually be executed by the server’s processor natively
instead of abstractly as is true of JAVA, ASP, .NET, J2EE, Etc. The benefits over
these technologies are speed and power. As CODE:NEO allows programming to
be done in C++ you do not have the limits of web languages like ASP, .NET and
JAVA. From within a web page you have the power of C++. The application
result files are assembled binary protecting the developer’s intellectual property
rights.
-5-
General Overview
The C programming language was created in 1971, over thirty years ago. C++, its
object-oriented sibling, was released in 1983, and has since become the most
powerful programming language available. Despite its prevalence of C++ in highend application development, the C++ language has not been associated with the
development of web-based applications.
CODE:NEO is a system for creating sophisticated web-enabled applications using
both C and C++. Using the patent-pending Rivar CODE:NEO™ Application
Server, both C and C++ based applications can be rapidly and efficiently
deployed on the Internet. Once built, these applications frequently run over an
order of magnitude faster than similar applications built using JSP or ASP.
By creating an easy path for C/C++ developers to web-enable their code under
both Windows and UNIX, CODE:NEO delivers the following key benefits:
•
•
•
•
•
•
•
•
•
Allows C++ programs to be embedded within HTML
Allows companies to leverage existing capital investments in C/C++
development resources
Brings C++ Applications to the Web quickly
Provides libraries for rapid Web development
Improves site performance, enhancing revenue generation and customer
satisfaction
Lowers infrastructure costs
Provides easy online development environment
Protects intellectual property through enhanced security
Easily integrates with existing development tools
-6-
Benefits
Reduces Software Development and Reconfiguration and Costs
and Speeds Time-to-Market
Many existing backend systems, databases and software applications are written
in C++. CODE:NEO, reduces the complexity of programming C++ software
applications for the web. CODE:NEO achieves this by seamlessly merging C++
with HTML, minimizing complex conversion processes for porting software
applications to the web. Now, businesses can reduce software development costs
by using existing C++ programmers to convert, rather than rewrite existing
programs, eliminating the need for hiring specialized programmers. Businesses
benefit from substantial savings for developing an integrated web presence by
reusing existing code, reducing integration costs and increasing the source code
longevity. Businesses also reap the rewards of a faster time-to-market. In addition,
they can tap the huge, readily available base software written in C++ to easily
develop new Internet applications without requiring staff to learn new
programming languages for web development.
C/C++ developers make up the largest pool of programmers available. C++ is a
standard college courses for computer science majors and is recognized as the
most common programming language used today. CODE:NEO allows using these
existing programmers for web development through CODE:NEO’s ability to
combine the power of the C++ programming language within HTML.
Software development costs are greatly reduced when companies with
CODE:NEO reuse existing code instead of redeveloping. This reused code can
come in the form of software already written by the business, or from the
thousands of existing libraries already available to the C++ programming
language. CODE:NEO can reduce integration costs by allowing software
applications already written in C++ to be used directly for web development.
Other solutions such as Microsoft .NET, Java or ColdFusion require development
budget be spent on both recreation of the user interface and development budget
for encapsulation or redevelopment of existing systems. CODE:NEO reduces
those development budgets by large margins.
The value and longevity of code written for CODE:NEO is much greater than
competing technologies because it based on the ISO/ANSI standardized language
C++. Other technologies are proprietary and often obsolesced and ultimately
unsupported such as Microsoft is doing today. Microsoft’s .NET is resulting in
large redevelopment budgets as companies struggle to keep up with the latest
change at Redmond. Alternatively developers can choose because of CODE:NEO
-7-
developing in the C++ programming language which is standardized and
supported by many companies and organizations such as Sun Microsystems,
Borland, KAI, GNU and others.
Because existing backend software applications are not directly compatible with
new web application languages, it typically takes a great deal of time and money
to rewrite these applications for the Internet. CODE:NEO reduces the costs for
bringing applications to the web because its foundation is in C++.
Improves Site Performance, Enhancing Revenue Generation and
Customer Satisfaction
Many users leave a site before a transaction is completed due to performance
bottlenecks. CODE:NEO solves this problem of poor site performance and
recovers lost revenue by enabling a site to run at least 10 times faster than Cold
Fusion, Microsoft .NET or Java. These speed gains improve performance for
demanding applications such as transaction processing, interactive form
generation, security and authentication procedures, and access to complex
databases. CODE:NEO therefore helps eliminate bottlenecks, reduces the chance
of overload and site crashes, resulting in a more satisfying user experience for
customers when ordering products, filling out a form or querying a database.
Lowers Infrastructure Costs
CODE:NEO’s fast processing speeds allow a single server to handle many more
customers than other solutions. With CODE:NEO, businesses can leverage
existing equipment investments and reduce their total cost of ownership for
deploying and supporting a web solution. CODE:NEO decreases overhead by
reducing the number of servers a company must run to create a web presence with
the necessary performance to insure customer satisfaction. Consider a business,
which required ten web servers to run their corporate site; with CODE:NEO that
site could be reduced to a couple of web server. By reducing the number of web
servers, a company reduces hardware costs as well as the labor and material cost
for maintaining each web server. This opportunity is inviting to hosting providers,
which typically run many servers.
This opportunity extends into large application service providers like, AOL,
Yahoo, CNET, Ticket Master, etc. Who are faced with the challenges of
maintaining massive costly data centers to operate their sites. CODE:NEO
increases performance and allows for the addition of new features.
-8-
Easily Integrates with Existing Development Tools
Many developers have tools that they prefer to use. CODE:NEO integrates easily
with existing tools and enables developers to program by using their favorite
design tool or inserting C/C++ code within Web page content.
CODE:NEO can enhance existing Java, Perl, or ASP programs to execute and run
at least ten times faster on a web server. This dramatic speed increase translates
to a more satisfying end user experience.
The client does not have to worry about costly staff retraining, or rewriting tested
and stable applications because CODE:NEO can integrate smoothly.
Leverages the Power of C/C++
CODE:NEO provides a classical approach to programming, which allows
backend and front end systems to be developed and integrated together instead of
the time consuming, common front-end to backend approach that web developers
use. This classical approach to programming yields higher quality applications,
longer source code longevity and thereby increases the value of the developer’s
product.
Operating systems are written in the C++ programming language; therefore, a
software layer does not need to exist between the web application and the
operating system. As a result, CODE:NEO can directly call any operating system
instead of relying on the application server developer to support the feature that is
needed.
C++ allows object-oriented design, which decreases development cost, increases
code reusability and software quality. C++ is a polymorphism software system. In
object oriented software design polymorphism signifying that a single object can
behave in many different but related ways, enabling a programmer to program the
object once and the reuse it for many purposes.
C++ allows pointers, which are objects used to access specific locations in
memory. This enables CODE:NEO applications to directly access the computer’s
memory, allowing communication with both hardware and software, which is not
available in other web development solutions.
Because existing backend software applications, systems and databases are
written in C++, they are not directly compatible with new web application
languages, it typically takes a great deal of time and money to rewrite these
-9-
applications for the Internet. CODE:NEO reduces the costs for bringing
applications to the web because its foundation is in C++.
Furthermore, businesses can reduce software development costs by using existing
C++ programmers to convert, rather than rewrite existing programs, eliminating
the need for hiring specialized programmers. Businesses benefit from substantial
savings for developing an integrated web presence by reusing existing code,
reducing integration costs and increasing the source code longevity. Businesses
also reap the rewards of a faster time-to-market. In addition, they can tap the
huge, readily available base software written in C++ to easily develop new
Internet applications without requiring staff to learn new programming languages
for web development.
Other solutions such as Microsoft .NET, Java or ColdFusion require development
budget be spent on both recreation of the user interface and development budget
for encapsulation or redevelopment of existing systems.
C/C++ developers make up the largest pool of programmers available. C++ is a
standard college course for computer science majors and is recognized as the most
common programming language used today. CODE:NEO allows using these
existing programmers for web development through CODE:NEO’s ability to
combine the power of the C++ programming language within HTML.
CODE:NEO’s Integration with other Technologies
CODE:NEO integrates tightly with many other languages and technologies
because many options exist for integrating C++. Developers can directly use MQ
Series, COM, CORBA, SQL, ODBC and many other technologies.
This ability to integrate with other technologies stems from C/C++’s ability to
abstract them through object oriented programming, and C/C++’s long
programming history which has gained it a large support base in the computing
world.
Server Side Resources
CODE:NEO’s technology enables complex sites to run at least ten times faster
than current Internet languages such as Java. This speed increase allows more
users per server, and limits the need for expensive, capital-intensive solutions,
thereby lessening ownership costs for companies while providing greater
functionality to users.
CODE:NEO is designed so companies, web developers and programmers can
easily and cost-effectively eliminate bottlenecks – both with existing sites and
new sites – using software rather than expensive hardware. CODE:NEO’s
-10-
application server framework reduces site development time and cost, while
allowing dramatic performance improvement of existing languages Java, Perl or
application service provider websites. CODE:NEO improves interactive sites that
cannot benefit from caching technologies.
Many users leave a site before a transaction is completed due to performance
bottlenecks. CODE:NEO solves this problem of poor site performance and
recovers lost revenue by enabling a site to run significantly faster than Cold
Fusion, Microsoft .NET or Java. These speed gains improve performance for
demanding applications such as transaction processing, interactive form
generation, security and authentication procedures, and access to complex
databases. CODE:NEO therefore helps eliminate bottlenecks, reduces the chance
of overload and site crashes, resulting in a more satisfying user experience for
customers when ordering products, filling out a form or querying a database.
Rivar’s CODE:NEO can capitalize on the need for need for efficient web
solutions by enabling an increase in revenues, a decrease in overhead and on
software costs as well as intellectual property protection.
This opportunity extends into large application service providers like AOL,
Yahoo, CNET, Ticket Master, etc., who are faced with the challenges of
maintaining massive costly data centers to operate their sites. CODE:NEO
increases performance and allows for the addition of new features.
Provides Easy, Online Development
Currently, web developers do not have an efficient online mechanism to create
web solutions. They must develop the solution on a local machine, outside of the
web environment and later migrate the programs to a web server. This dilemma
restricts developers from obtaining the advantages of anytime, anywhere access,
collaboration, real-time interaction with the web server and reliability when
launching a new application or modifying an existing one. CODE:NEO is the
only solution to offer online development. This feature minimizes programming
problems, time, and costs by providing early diagnostic capabilities. In addition,
CODE:NEO provides easier updates and minimizes ongoing support and
maintenance requirements.
Protects Intellectual Property Through Enhanced Security
Software component developers that create programs for the web risk intellectual
property theft because they cannot secure their products from reverse engineering
before shipping them. With CODE:NEO, companies can distribute their products
in a more secure fashion.
-11-
Software developers program in human readable code called source code.
Different technologies take the human readable and understandable code and use
it as instructions to run the computer in different ways. With technologies such as
Java, ASP and Cold Fusion that source code is left in a state that can be easily
read and understood by a software developer’s competitor. As a result, it is
difficult for a company to protect its intellectual property (source code) because it
is forced to “give it away”.
When companies bundle their product with CODE:NEO, the compilation process
helps protect the software product from intellectual property theft because
CODE:NEO executables are pure binary code. This code is much harder to
reverse engineer, and therefore provides better intellectual property security for
Web software developers and development companies, insuring that clients return
for updates and improvements to their website. By bundling their products with
CODE:NEO, software component developers can release development libraries
without being afraid of giving away trade secrets because overall site security is
enhanced.
-12-
Business Opportunity
Business Challenges and Opportunities
As many established businesses move to a multi-channel strategy, the Internet
becomes an important source for generating revenue and communicating with
customers. Business sites have experienced challenges regarding performance
issues, resulting in a frustrated customer base. Typically, web servers are designed
to accept a set number of simultaneous users. Exceeding that number can prevent
users from accessing all or a portion of a site. This is what occurs, for example,
when many users arrive at a website to buy just-released concert tickets. As more
customers attempt to access data-rich, dynamic content sites – to order products,
fill out a form or query a database – the potential for bottlenecks increases.
In the past, businesses have been forced to continuously expand their
infrastructure by adding expensive additional hardware (servers) to overcome
these performance problems. According to a May 2001 report from the market
analysis firm Zona Research, Internet delays represent a lost opportunity of more
than $25 billion in potential business, including over $21 billion per year lost
when users abandon a Web site because of excessive delays in page downloads
and about $4 billion due to transmission errors caused by Internet infrastructure.
Businesses are also moving non-commerce related software programs for sales
force automation, customer relationship management and other applications to the
Internet. Because many existing backend software applications are written in
C/C++, they are incompatible with the new web application platforms. It takes a
great deal of time and money to rewrite these applications for the Internet, as
“web enabling” the software often includes porting the entire code base from
C/C++ to another language. For example, to build an e-commerce solution, a
website must be integrated existing inventory software and an accounting system.
This level of integration is very time consuming, requires expensive highly
specialized human capital and extensive software reconfiguration.
CODE:NEO quickly integrates with a company's existing hardware and software
systems where key applications and data reside, including databases, directories
and messaging servers. This allows the reuse of existing application code, leading
to more stable web applications at lower development costs.
Rivar’s CODE:NEO can capitalize on the need for need for efficient web
solutions by enabling an increase in revenues, a decrease overhead and on
software costs as well as, intellectual property protection.
-13-
Internet Challenges and Opportunities
As many established business move to a multi-channel strategy, the Internet
becomes an important source for generating revenue and communicating with
customers. Business sites have experienced challenges regarding performance
issues, resulting in a frustrated customer base. Typically, web servers are designed
to accept a set number of simultaneous users. Exceeding that number can prevent
users from accessing all or a portion of a site. This is what occurs, for example,
when many users arrive at a website to buy just-released concert tickets. As more
customers attempt to access data-rich, dynamic content sites - to order products,
fill out a form or query a database - the potential for bottlenecks increase. In the
past, businesses have been forced to continuously expand their infrastructure by
adding expensive additional hardware (servers) to overcome these performance
problems. According to a May 2001 report from the market analysis firm Zona
Research, Internet delays represent a lost opportunity of more than $25 billion in
potential business, including over $21 billion per year lost when users abandon a
Web site because of excessive delays in page downloads and about $4 billion due
to transmission errors caused by Internet infrastructure.
Businesses are also moving non-commerce related software programs for sales
force automation, customer relationship management and other applications to the
Internet. Because many existing backend software applications are written in
C/C++, they are incompatible with the new web application platforms. It takes a
great deal of time and money to rewrite these applications for the Internet, as
“web enabling” the software often includes porting the entire code base from
C/C++ to another language. For example, to build an e-commerce solution, a
website must be integrated existing inventory software and an accounting system.
This level of integration is very time consuming, requires expensive highly
specialized human capital and extensive software reconfiguration.
Rivar’s CODE:NEO offers business an ideal solution to these costly problems. By
speeding up websites without requiring costly reconfiguration, new hardware or
specialized personnel, CODE:NEO enables companies to increase revenues,
reduce overhead and reduce software development costs. With its foundation
based in C++, CODE:NEO providing at least a 10 times speed gains in dynamic
web site performance. CODE:NEO quickly integrates with a company's existing
hardware and software systems where key applications and data reside, including
databases, directories and messaging servers. CODE:NEO allows the reuse of
existing application code, leading to more stable web applications at lower
development costs.
-14-
Intellectual Property Challenges and Opportunities
Theft of computer code and database information is becoming an increasingly
global phenomenon, often pitting large software companies in North America and
Europe against slick crime rings and sophisticated hackers in Russia, China,
Southeast Asia, Israel and elsewhere.
Source code is the basic building block of software--a jealously guarded secret at
technology companies, where key assets are intellectual property.
According to a study by the American Society for Industrial Security (ASIS) and
consulting firm PricewaterhouseCoopers, Fortune 1000 companies sustained
losses of more than $45 billion in 1999 from the theft of proprietary information-up from mid-'90s estimates from the FBI that pegged the cost at roughly $24
billion a year. Tech companies reported the majority of those incidents. The
average tech firm reported nearly 67 individual attacks. The average theft was
pegged at $15 million in lost business.
However, software pirates don't need access to source code similar to that stolen
from Microsoft; they usually copy the software directly from off-the-shelf
products (CNET report Oct. 29, 2000).
Rivar’s product, CODE:NEO, helps companies to protect their intellectual
property when distributing their products by enhancing security. (See Intellectual
property section under benefits).
CODE:NEO Competitive Advantage
CODE:NEO’s technology enables sites to run at least 10 times faster than current
Internet languages such as Java. This speed increase will allow more users per
server, and limit the need for expensive, capital-intensive solutions, thereby
lessening ownership costs for companies while providing greater functionality to
users.
CODE: NEO gives a single web server the processing power of ten. It is designed
so companies, web developers and programmers can easily and cost-effectively
eliminate bottlenecks  both with existing sites and new sites –– using software
rather than expensive hardware. CODE:NEO’s application server framework
reduces site development time and cost, while allowing dramatic performance
improvement of existing languages Java, Perl or application service provider
websites. CODE:NEO improves interactive sites that cannot benefit from caching
technologies.
Rivar’s patent pending product, CODE:NEO is a programming environment
consisting of a development tool and application server software. C++ or web
-15-
developers can use the development tool to create dynamic websites for
businesses. After the sites are created, CODE:NEO application sever software
must be loaded on a web server in order run the site on the Internet. Customers
receive the CODE:NEO web development software for free. However, businesses
must pay a fee for the application server software, required to run a CODE:NEO
enabled website on a web server for Internet access.
-16-
Technology
Overview
CODE:NEO represents a significant step forward for the C/C++ developer in
terms of ease of use and speed of deployment in the Web services arena.
Currently, C/C++ is very rarely the language of choice for developing dynamic
web sites, even though the underlying operating system, Web server, and libraries
are all themselves usually written in C/C++. This is because it has traditionally
been very difficult to write scaleable applications in C/C++ that take advantage of
the Web’s inherent distributed nature. Any programmer who developed such an
application would typically be forced to develop large libraries of frequently used
routines – that is, they would spend as much (or more) time developing the webrelated routines as they would actually developing the application they were
building. Additionally, most web servers and applications are not C/C++ friendly
– they do not provide the programmer with the support services needed to quickly
and efficiently develop in C/C++. However, most companies have a large
investment made in C/C++; thus, web enabling applications is difficult and costly,
as companies frequently have to port software to another platform, costing time,
additional resources, and money.
CODE:NEO provides a solution to this problem. By allowing the programmer to
directly embed traditional C/C++ code (including library calls and object
instantiation) directly into HTML pages, web-enabling an application in C/C++
becomes a very quick and easy task, with a cleaner separation of the presentation
layer and the business logic.
The CODE:NEO system operates in an analogous way to JSP and Java in that the
pages are preprocessed and converted into a machine-readable format before
execution. However, unlike JSP and Java, the code is written entirely in C/C++,
allowing companies to leverage their existing code bases, saving both time and
money. Additionally, as code is often reused from existing and tested libraries,
CODE:NEO can allow application development with fewer errors, because less
recoding is required in order to web-enable an application. Finally, code can
execute over ten times more quickly under CODE:NEO as the code is compiled,
not interpreted.
To create a CODE:NEO-based web solution, a programmer needs to create
instructions for the processor to handle an incoming request. This is accomplished
by directly embedding C/C++ code into an HTML page. Once this HTML/C++
page (which we call a Rivet) is translated into pure C++, it may be compiled and
linked against developer libraries, third party libraries, system libraries and the
CODE:NEO library. Through this linkage CODE:NEO can accomplish
significant cost savings by reusing existing software for web development.
-17-
After this CODE:NEO binary object is created, it can be placed on a CODE:NEOenabled web server. When such a file is requested (for example, by an HTTP
GET statement) the web server passes control to CODE:NEO Application Server,
which performs the function of interfacing CODE:NEO applications to the web
server. This server is offered in two basic forms: as an ISAPI extension for
Microsoft IIS (or any other ISAPI compliant server) and as a module for Apache
web server. The application server also provides other service functionality, such
as logging and debugs systems, in order to aid development and increase product
quality.
The call to the application server occurs very quickly within the web server. Once
execution is within the binary file (known as the “Joint”) the programmer is free
to call any C++ or inline assembler instructions they wish, even printf, which will
have the effect or printing to the console. If the programmer wishes, he can output
data back to the web browser with the simple interface swritef, which uses the
familiar ANSI C format string specification.
How powerful is CODE:NEO? This powerful;
<html><body><%Cn>
__asm__ ("pushl %eax");
</Cn%></body></html>
That code controls the processor with a single push instruction from the middle of
a web page. This means that the programmer can program the execution of his
processor an instruction at a time, the most powerful way of all.
How simple is CODE:NEO?
<html><body><%Cn>
for(int x=1;x<11;x++)
swritef("%d<br>\n",x);
</Cn%></body></html>
Counts to ten. If you want to count up to a specific number, replace x<11 with
x<atoi(getArgument("count").c_str())+1
standard
template
library style.
If you understand simple C++ you can begin creating powerful interactive C++
websites. With Microsoft Visual Studio you can create projects with our project
wizard in seconds. On Linux you can even use tools like KDebug. Or work in
familiar VI and makefiles.
-18-
With CODE:NEO you have the power to create because we have created our tool
to supplement existing technology instead of reinventing it. CODE:NEO is a tool
that you adds the power of C++ application servers to your arsenal.
CODE:NEO Frame Work
To program a CODE:NEO web solution, a program needs to create instructions
for processor to handle an incoming request. Just like starting a car a list of steps
are translated into a language the processor can understand. The developer writes
these instructions in the programming language C++ for CODE:NEO. Other
techniques exist such as JSP ASP and Java, but with C++ these instructions can
be much more exact and are ultimately assembled into processor instructions,
whereas those other language require software to read and execute the list of
instructions the programmer provides.
CODE:NEO accomplishes this through a process called generation which
translates HTML pages mixed with C++ as seen above into an assemble program.
See the binary object creation flowchart below.
-19-
Create
Start
Developers
Libraries
Source
Code
.CnSrc
Third Party
Libraries
CODE:NEO
Generator
System
Libaries
Developers Native
Compiler
The Joint is a specification
for a DLL or DSO which
matches the application
server.
Joint (C++ File)
Visual C++
GNU GCC
Borland C++
CODE:NEO
Libraries
Object CODE
Developers
Native Linker
CODE:NEO
Binary
Application
Object
(.CnBin)
Goto
Exec
CODE:NEO Binary Object Creation Flowchart
Once the HTML/C++ page, which we call a rivet, is translated into pure C++ it
may be compiled and linked against developer libraries, third party libraries,
system libraries and the CODE:NEO library. Through this linkage CODE:NEO
can accomplish cost savings by reusing existing software for web development.
The C programming language was created in 1971, thirty-one years ago. Code
written over thirty years ago can still be utilized in CODE:NEO. C++ was
released in 1983, twelve years ago and has since taken the role of the most
powerful programming language available.
So certainly it is clear that C++ can provide a huge base of technology to pull
from. One of which is now web technology.
After this CODE:NEO binary object is created, it can be placed as a document
named. CnBin in the path of a web server. When the file xxxx. CnBin is
requested, say with a HTTP GET statement, the web server begins executing code
-20-
within either a ISAPI extension for Internet Information Server or another ISAPI
compatible web server or and Apache Module for Apache.
This change in point of execution occurs very quickly within the web server.
CODE:NEO creates a request object for this get request. For optimization the
request object’s members are lazily initialized to the web server data structures
(Lazy initialization is a programming pattern that saves time by only initializing
data structures which are requested.). CODE:NEO then maps the xxxxx. CnBin
file to a list of cached. CnBins and jumps point of execution into the. CnBins
entry point.
The CnBin entry point is actually a C++ class called CnJoint. The CnJoint is a
C++ specification for a dynamic link library or a dynamic shared object
depending on your platform. See the “Application Execution Flowchart”.
CODE:NEO
Binary
Application
Object
(.CnBin)
Apache
IIS
Orielly
Etc..
if
.CnBin
Web Server
Yes
CODE:NEO
Application Server
Web Browser
No
Do Standard
Processing
CODE:NEO Application Execution Flowchart
Once execution is within the CnJoint the programmer is free to call any C++ or
inline assembler instructions they wish, even printf which will have the effect or
printing to the console. If the programmer wished he can output data back to the
web browser with the simple interface swritef, which uses the familiar ANSI C
format string specification.
The CODE:NEO Application Programmers Interface (API)
The CODE:NEO API is a C++ Object Oriented interface used to access the
application server, application requests and responses. The concept underlying the
-21-
API is to allow a programmer to rapidly carry out actions, which are common to
most web applications. Its use can be as simple as the “getArgument” function
call used in the previous section to retrieve a URL argument value passed in from
a form submission.
The CODE:NEO API is designed to enable the rapid deployment of C/C++-based
SOAP services and other customized services, which rely on the HTTP transport
mechanism to function. Thus, the web-specific code is already developed,
allowing the programmer to concentrate on building the particular application at
hand.
The structure and architecture for CODE:NEO has been built upon of structure of
creating an application server framework for new application server to be built.
Look at the UML diagram of CnHttpServer and it’s parent objects, you can see
the CnServer -> CnHttpServer relationship. In a CODE:NEO joint you will have
access to the CnHttpRequest and will be executing as a subclass of CnHttpServer.
Implementation of a SOAP, XML-RPC or other HTTP application server
implementation would be a new subclass to CnHttpServer. You would name it
MySoapImplementation and could create your own requests and responses from
executing binary objects written in C++. CODE:NEO is able to execute any
CnServer type objects given the correct request and response object pointers.
CODE:NEO has an extensive development interface for supporting developers
when creating web applications for communicating with the web browser,
maintaining cookies and URL arguments, thereby simplifying programmers’ tasks
and decreasing development costs.
CODE:NEO’s development tools include interfacing to the developers existing
C++ compiler, linker and tools. This automates development tasks and allows
developers to continue using familiar and functioning tools so that they do not
lose development time or have to port or convert existing code to a new system.
-22-
Example CODE:NEO API Hierarchy
-23-
The CODE:NEO System
RIVET
Source
Code
Web Server
Plugin
CODE:NEO
Application Server
Engine
1
6
Binary Joint Executor
And Util Services
5
Joint
Source
Code
CODE:NEO
Application
Technology
2
3
Binary
Joint
4
CODE:NEO
Developmet
Tool
Development
Interfaces
Joint
Generator
CODE:NEO System Diagram
The CODE:NEO product can be logically divided into three different areas:
•
CODE:NEO Application Server which when installed on a server allows that server to
run CODE:NEO applications.
•
CODE:NEO Application Technology, which is an actual application, developed by a
developer using the CODE:NEO system. It is through that application technology being
compiled into executable binary objects that CODE:NEO gains it speed and power.
-24-
•
CODE:NEO Development Tool, which assists developers in creating the application
technology that the CODE:NEO application server executes.
CODE:NEO applications can consist of joints or rivets. CODE:NEO rivets are
source code files that integrate C++ and HTML or other markup language. They
use tags to denote where the boundary lies between C++ and HTML and the
CODE:NEO development tool called the generator converts this file into a
CODE:NEO joint. A CODE:NEO joint is a source code file which fits a
specification that when compiled it can be executed by the application server.
Alternatively, a developer may opt to write joints manually. This system is similar
to the relationship Java JSP pages and Java servlets share.
The CODE:NEO Application Server performs the function of interfacing the
CODE:NEO Applications to the web server. It is offered in two varieties, an
ISAPI extension for Microsoft IIS in addition to a module for Apache web server.
The application server also provides service functionality such as logging and
debug systems, in order to aid development and increase product quality.
CODE:NEO has an extensive development interface for supporting developers
creating web applications for communicating with the web browser, maintaining
cookies, URL arguments, thereby simplifying programmers’ tasks and decreasing
development costs.
CODE:NEO’s development tools include interfacing to the developers existing
C++ compiler, linker and tools. This automates development tasks and allows the
developer to continue to use his familiar and functioning tools so that he does not
loose development time or have to port or convert his existing code to a new
system.
Selecting C++ As CODE:NEO’s Core Technology
Rivar Technologies selected C++ as CODE:NEO’s core language because it is the
most powerful programming language available to developers today.
C++ is the fastest language available for several reasons. It compiles into highly
optimized native binary code, which requires no interpretation or software
abstraction layer to be executed, thereby providing the fastest code that a
processor can execute. C++ also creates fast solutions because the syntax of the
language allows the developer to be extremely granular with in areas of the
program which are highly speed sensitive; this flexible syntax allows both fast
execution as well as, flexible utility.
Another reason for selecting C++ is that it is commonly used for applications and
back end systems. C++ is widely known by programmers and is a prerequisite
-25-
requirement for most computer engineering courses. Thus, there are a much
higher number of developers skilled in these languages than in Java.
C++ offers the largest base of pre existing source code available. The C
programming language was first available in the 1970s; C++, an object-oriented
offshoot of C, became available in 1985. As a result, the platform is both proven
and readily supported by a large number of tools.
Rivar also selected C++ because of its portability and it standardized syntax. This
means that C++ is not a proprietary product and is supported on many platforms.
C++’s standardized nature yields higher quality and longer longevity for
businesses, very important factors in a rapidly changing world.
CODE:NEO Shared Memory
In a web server environment http connections themselves are session less. In
order to save programming costs CODE:NEO can establish a session and link it to
the sessions data stored directly in memory, instead of indirectly through a
database.
This functionality works cross platform on Windows 2000 and Linux and gives
server authors the power to store data structures in memory across many web
server connections and processes.
CODE:NEO implements and offers developers the use of shared memory. Shared
memory refers to sections of memory, which may be shared between processes.
This means that one process can write data to a place in memory, and another
process, either concurrent or subsequent, can read that data. This functionality
offers means by which processes can communicate with one another (IPC: InterProcess Communication), as well as fast, persistent storage of data for a process
or thread, which may come in and out of existence. An example of such a process
is an HTTP server connected to a particular client. Each time the client makes a
request of the server; it is associated with a new server process, which handles the
request. In order to establish a 'session' between the client and the server, there
must be some persistence of data between the server processes handling the
client's requests. This requirement is fulfilled by the use of shared memory.
In Code:Neo, a section of shared memory is referred to as a segment. Each
segment may consist of one or more blocks, which are simply allocation units that
comprise a segment. Blocks are used to define pieces of a segment and determine
whether or not they are in use. For example, if a shared memory segment is being
used like a heap, some blocks may contain data, while others do not. Mechanisms
are provided to track this status, so the developer can acquire, or 'allocate' an
unused block within a named segment. Likewise, a block that is no longer needed
may be 'freed'. Another use of the block structure of a segment is for sharing.
Blocks may be marked as shared or exclusive to allow or prevent read and write
-26-
operations on them. Shared blocks allow multiple threads and processes to read
their data. On the other hand, when a thread requests an exclusive mode on a
block, only that thread may read and write to the block until it is released back to
shared mode. This prevents simultaneous write operations to the same block of
data, while permitting reading on the rest of the segment.
Web Server
CODE:NEO
Application
Server
Shared Memory
CnBin
( Windows or Linux )
CnBin
CnBin
CnShmSrv
Other Executable
Using CODE:NEO
Shared Memory
CnShmMan
Shared memory blocks may be virtually any size. The granularity to use is up to
the developer. Finer granularity (i.e. - smaller blocks) offers greater control over
which parts of the segment data are available, but at a performance cost. At the
other end of the spectrum, a segment can consist entirely of one block, which
offers no control at all, but requires fewer system resources. Generally speaking,
though, the blocks in a multiple-block segment should be sized to align with the
data they will contain. For example, if the developer is storing 32-bit integers in a
segment, the block size should definitely be a multiple of 4 bytes (32 bits). As
there is not likely any need to lock individual integers, something like 16 or 32
byte blocks (4 or 8 integers each) might be suitable in this example.
-27-
Segment
Segment
Segment
Segment
Segment
Segment
Segment
Segment
Segment
Block
Block
Block
Block
Block
Block
Block
Block
Block
Block
Block
Block
Block
Block
Block
CnShmSrv is a server process that handles allocation, persistence, and freeing of
shared memory segments. Allocate and free requests are received by CnShmSrv
via named pipes. CnShmMan, the Code:Neo Shared Memory Manager, acts as the
client end in the program thread or process. Allocated segments are tracked by the
server in the CnShmIndex
The CODE:NEO Process
C/C++ is the most widely popular programming language being used today, with
over 69% more projects currently being worked on than its closest competitor,
Java.
The CODE:NEO Application Server provides a framework for C/C++ programs
to be executed as Web applications. Written using the APIs specifications
provided with Apache Server and Microsoft IIS, CODE:NEO directly handles the
execution of .CnBin (CODE:NEO Binary) files, which are requested via. HTTP.
These binary files are written in C/C++, and have a common interface for
execution from the Application Server as DLLs.
-28-
The following diagram outlines the process by which a CODE:NEO binary file is
requested, executed, and then how a response is sent back to the user.
-29-
CODE:NEO – An Efficient Development Process
Rivar Technologies conducted internal proof of concept studies that verified at
least a 10:1 or greater performance increase over competing technologies. The
Company believes this speed allows more users per server, lessening equipment
costs for companies while providing greater functionality to client users. Rivar is
in the process of selecting an independent research organization to verify the
performance studies.
Rivar’s long-term goal is to develop, market and support Internet software
products for companies building their businesses on the Web. Rivar anticipates a
suite of products that enable customers to rapidly build, deploy, and manage
sophisticated e-business Web sites that provide dynamic content, personalized
interaction, and secure transactions. Based on open Internet technologies, the
Rivar product provides a robust, secure, scalable foundation for building online
applications that support online commerce, strengthen customer and partner
relationships, publish and personalize content, and automate key business
processes.
With CODE:NEO:
Internet applications run at least ten times faster than current applications.
Developers can write Internet applications with C/C++.
-30-
Existing software can be converted to Internet based applications.
Internet development resources increase due to availability of C/C++
programmers.
Web-Based Development
The Web Development Environment (WDE) is a web application that enables
developers to create, modify, and build their own CODE:NEO web applications.
Once the WDE is installed on a server, a developer may access it through a webbrowser. The developer can browse, open, and edit files. The developer can also
create a WDE project, which is a combination of source files, compile settings,
link settings, and so on.
If the developer has created a project, the WDE can be used to compile and build
the application. The WDE builds CODE:NEO binary executables (CnBins) from
C/C++ source files as well as CODE:NEO rivets, which are HTML files with
elements that contain C/C++ code.
-31-
The Advantage for Developers
Developers benefit from CODE:NEO due to its added value, its simplicity, and its
extensibility.
Value is added to developing C/C++ applications for the web by using the
CODE:NEO libraries. An application framework has been built so that
development efforts are not begun “from the ground up”, but rather with a
collection of C++ objects which provide the required facilities of every web
application. These would include session handling and cookies, request and
response structures, and buffer handling and parsing for GET and POST methods.
The simplicity of using CODE:NEO can be understood by looking at its
architecture.
A main () is provided as the beginning point of execution for their application.
This is a standard and is intuitive to C/C++ application developers as a whole.
The Standard Template Library (STL) for C++ has been used within the
CODE:NEO libraries to add an element of familiarity for programmers
accustomed to using STL. Where appropriate, CODE:NEO’s classes either
incorporate or inherit from classes provided in the STL.
The extensibility of CODE:NEO has no limitations. The current Application
Server is being touted as being an HTTP “add-on”, however the capability lies
within the core libraries of CODE:NEO to support other application protocols
such as XML-RPC or SOAP and middleware like CORBA or COM. CODE:NEO
also works as a standalone, native application server for backend processing or
fat, client applications. Future releases of CODE:NEO libraries will contain
additional functionalities specific to these technologies.
What Is Unique About CODE:NEO?
The uniqueness of CODE:NEO is that it provides a framework for C/C++
applications to be written for the web. No other existing technology provides the
value of C++ libraries that simplify this task. Standards such as ISAPI and CGI
fall short of this by only providing a limited interface for further development of
framework and support. This leaves the developer to not only build their specific
solution, but also with the responsibility of developing additional code to manage
HTTP applications. CODE:NEO has taken that requirement and fulfilled it for
every C++ developer needing to write his or her code for the web.
Rivar Technologies, through its Patent Counsel, Foley & Lardner of Tampa,
Florida filed a provisional patent application with the United States Patent Office.
Additional filings are expected.
-32-
The System Environment
The following diagrams attempt to illustrate the overall system that CODE:NEO
operates within. The web client (y.1), aka web browser (surfer) uses web browser
software on his home machine to access web content just as he always has.
HTTP encapsulates a request for information and TCP/IP protocol assists with
providing transport of the requests to the CODE:NEO application server.
The application server (y.2) uses a web server to receive these requests. The web
server passes control to the CODE:NEO Application Server engine (x.1), which
in turn passes control to the appropriate CODE:NEO ‘RIVET’ (x.2).
CODE:NEO Application Server
Hardware Archetecture
CODE:NEO Application Server
Software Archetecture
y.1
Web Browser
Client
Web Client
Modem
HTTP Protocol
TCP/IP
Internet
HTTP Protocol
Web Server
Web Server
Plugin Method
CSU/DSU
Router
CODE:NEO
Application Server
Engine
x.1
y.2
Web / Application Server
CODE:NEO
Application Server
Rivet
x.2
diagram y
diagram x
-33-
Patent for CODE:NEO
Application Server
Applies To These
Block Items
The CODE:NEO language
As discussed above, CODE:NEO Rivets are source code files that integrate C++
and HTML or some other markup language. They use simple tags to denote where
the boundary lies between the C++ and the HTML. When the programmer is
ready, the CODE:NEO development tool called the generator converts this file
into a CODE:NEO Joint. A CODE:NEO Joint is a source code file which fits a
specification that when compiled it can be executed by the application server.
Alternatively, a developer may opt to write Joints manually. This system is
analogous to the relationship JSP pages and Java servlets share.
The basic premise of the CODE:NEO language is that it enables the server side
execution of embedded C and C++ calls from within standard HTML pages. For
example, the following text is a fully working CODE:NEO page:
<html><body><%Cn>
for(int x=1;x<11;x++)
swritef("%d<br>\n",x);
</Cn%></body></html>
This sample application simply counts to ten, outputting each integer to the
screen. Should you want to count up to a specific number, the program can be
easily
modified
by
replacing
x<11
with
x<atoi(getArgument("count").c_str())+1.
Another example is:
<html><body><%Cn>
__asm__ ("pushl %eax");
</Cn%></body></html>
In this example, the code controls the processor with a single push instruction
from the middle of a web page. This means that the programmer can program the
execution of his processor an instruction at a time, ultimately, the most powerful
way of all. This type of granularity is not found in other languages, and represents
a powerful and understandable method for leveraging C/C++ development
resources in a web environment.
If a programmer understands simple C++, with CODE:NEO he can begin creating
powerful interactive C++ websites. With Microsoft Visual Studio one can create
projects with the CODE:NEO project wizard in seconds. On Linux, programmers
can use tools like Kdebug, or use VI and makefiles.
In a web server environment HTTP connections themselves are sessionless. In
order to save programming costs, CODE:NEO can establish a session and link it
to the session’s data stored directly in memory, instead of indirectly through a
database. This functionality works cross platform on Windows 2000 and Linux
-34-
and gives programmers the power to store data structures in memory across many
web server connections and processes.
-35-
Frequently Asked Questions
Are their any severe shortcomings of CODE:NEO?
There are no barriers to creating the fastest most powerful websites with
CODE:NEO. Any perceived shortcomings come from a developers lack of
understanding of computer languages or the CODE:NEO product itself. Anyone
of any skill level can download and install the CODE:NEO application server and
development tools and begin programming web solutions with immediately.
Can a non-programmer scale from beginner to enterprise level
using CODE:NEO?
Individuals who either doesn’t know C++ or HTML will of course have a learning
curve to begin to use the CODE:NEO technology. For example books boast being
able to teach either C++ or Java in 21 days.
In fact the book “Learn C in Three Days ISBN: 155622298X” coupled with the
CODE:NEO getting started manual can get you programming CODE:NEO very
fast because those things learned can be used directly in a web page very easily.
CODE:NEO is a development tool, intended for use by programmers. In general it
is anticipated that most CODE:NEO developers will already be C++ programmers
as C++ is standard prerequisite for computer science degrees.
CODE:NEO can scale easily to enterprise levels because of the inherent power of
the C++ programming language. C++ is the most powerful programming
language available and has constituted as the backbone of all current common
operating systems since it creation in 1983 at Bell Labs.
Does Java or any other language have a broader usage base than
C++?
Consider the fact that the C language was invented in 1969 and enhanced into
C++ in 1983 giving C/C++ 33 years worth of development, improvement and
experience.
-36-
All other ‘internet’ languages are far younger and far less developed. In fact any
C code developed since the ANSI C standard in 1989 is directly usable in modern
C++ compilers.
Every common and most uncommon operating system has a C++ compiler for it
as well as a host of embedded microcomputers used in everything from washing
machines to wristwatches.
At this time no data represents any programming language as having a larger base
of programmers than C/C++. C/C++ has been chosen at least 2:1 against any
other programming language.
In fact sourceforge.com statistics as of October 31, 2002 show project language
selections as follows;
C
C++
Java
PHP
Perl
Python
Visual Basic
Assembly
9199
8615
6799
5157
3957
1938
1044
975
In fact you’ll notice that ASP, Cold Fusion do not even make the top ten in this
list.
Secondarily C++’s market dominance can easily been seen by search for jobs on
dice.com or monster.com and comparing the results of number of jobs specifying
C/C++ as a requirement as compared to another language.
As of October 2002 at least a 2:1 margin existed compared to any other language
requirement for offered positions.
Is CODE:NEO harder to program because it’s based on C++?
It is true that C++ is a more complicated programming language than some other
simpler languages, however the learning curve is similar between the C++
language and other languages such as Java.
Even the semantic syntax of Java and C++ are extremely similar. Java syntax is so
similar that source code looks almost identical.
/*
A Java Hello World Console Application */
-37-
public class Hello {
public static void main (String args[]) {
System.out.println ("Hello World!");
}
}
/* A C++ Hello World Console Application */
int main(int argc, char* argv[]){
printf("Hello World!\n");
}
Thou in fact the C code in this example is more simple than the Java code, C++
can be taken by an advanced programmer to extremely complex levels using
object oriented features such as templates which are not available within Java.
It is this power of C++ which allows programmers at a beginner level to advance
to an expert level as knowledge increases is one factor that will allow
CODE:NEO programmers to excel over their peers using other technologies.
Consider the fact that C++ is based on the simpler language C that does not have
an object-oriented paradigm. To learn and use Java even at the simplest (see the
‘class’ definition in the hello world java example) level you must understand
Object Oriented Programming whereas we have done our best with CODE:NEO
to allow programmers to program CODE:NEO with only a basic knowledge of
accessing object oriented objects and no knowledge of object oriented
programming architecture.
This ‘two layer’ C to C++ architecture makes CODE:NEO even easier to learn
and program in some respects as compared to Java.
How do C++ pointers enhance software and how does it affect
reliability and complexity?
Technology does not make software more or less reliable, people do. This basic
aspect of C and C++ changes the facilities available to a programmer. Pointers are
a common but not required aspect to programming C and C++. The majority of
the time pointers are handled invisibly and safely by the compiler, but from time
to time a programmer may choose to use pointers for several reasons.
•
To enhance the execution speed of the program. Having direct access to
memory means that the CPU does not have to fix figure out where the data
is stored.
-38-
•
To reduce the memory usage of an application by dynamically and
deliberately managing and linking memory.
•
To simplify algorithms by using advanced data structures which most
closely link the data at hand.
•
To integrate to software and hardware, which may only by accessed by
memory address and not by the CPU stack or internal registers.
In terms of reliability C++ pointers operate your entire operating system day in
and day out without fail. By using good C++ programming practice bugs related
to pointers are entirely eliminated. However a sloppy programmer is likely to
introduce more bugs into a C application when they use pointers than one written
in other languages such as Java or Visual Basic which does not allow pointer use
at all.
However not being able to use pointers completely cripples a language for being
able to be as efficient, elegant and simple as one written by a programmer skilled
in the use of this extremely powerful tool.
When a programmer chooses to use a pointer he/she must consider whether the
usage is overall beneficial to the execution of the programmer. Most C++
programmers use pointers almost everyday because the advantages greatly
outweigh any complexity.
Java removes entirely the pointer paradigm from the programmer therefore
removing the need for ‘good programming practices’ related to using pointers.
However even a Java programmers can encounter errors in memory access
because the virtual machine ultimately has to access memory directly and certain
situations can be reached where the virtual machine calculates the wrong memory
address to access, thou this situation is extremely uncommon.
A pointer is simply an address in memory, or more simply it’s like a street address
where the computer remembers information on a short-term basis. The CPU is
responsible for insuring that only certain process are able to access these pointer
addresses protecting the security of the system.
In Java a programmer is not programming directly for the processor they are
programming for a ‘virtual’ machine therefore the programmer is given no direct
access to memory.
The virtual machine is responsible to manage memory in such a way that the real
address of storage is masked and protected from the programmer.
-39-
This is similar to C where you allocate variables from the heap. The programmer
has the option to begin to use more complex algorithms such as pointers my
allocating memory manually.
Where the complexity comes in is that being able to access memory directly
means that a programmer could request access to ‘any’ area of memory. If the
programmer has programmed the software incorrectly than if he attempted to
access memory outside of his permissible process space than a error will be
generated or more dangerous is the incorrect memory access within the processes
memory space which may lead to undetermined program behavior.
Is CODE:NEO a ‘tag based’ language?
CODE:NEO is not a tag-based language because tag based programming is
restrictive and doesn’t allow for common programming practices.
CODE:NEO utilizes tags only to denote the difference between HTML and C++
programming code.
Tag based languages produce code, which is hard to maintain, redundant and
quite often sloppy or completely un-maintainable.
While tag based web languages can be understood simply by amateurs they are
frustrating and inefficient to even beginner programmers not to mention they hold
back intermediate and expert programmers.
How does CODE:NEO effect project cost compared to
programming in Cold Fusion, Java or ASP.
CODE:NEO development in most cases can reduce or even eliminate
development costs.
In general C++ is not considered a rapid development language, however the
lower long-term costs associated with software maintenance and longevity can
easily be seen with the C++ programming language.
In addition the ability to use existing C++ code for new web development projects
further enhances the overall CODE:NEO value.
-40-
How does CODE:NEO protect your intellectual property?
CODE:NEO not only allows you to use a wider variety of development tools, but
it ensures that your code will be able to be run without the need for any single
source vendor.
In fact CODE:NEO allows application developers to bundle CODE:NEO with
their products royalty free so that the end user does not even have to purchase or
individually install or configure the application server itself. Whereas
technologies such as Cold Fusion, Java and ASP and .Net where the individual
end user must purchase a license for the application server individually adding
cost and complexity to a developers product.
In addition developers can choose from a number of different compilers such as
Microsoft Visual C++, Borland C++ or EGCS known as GCC by GNU thereby
increasing the longevity of your source code and lowering the
By choosing to develop with a product such as .NET or Cold Fusion you lock
yourself and your customers into supporting those companies and application
servers.
How does CODE:NEO’s need for compilation help developers?
The need for compilation is one of the driving factors that helped the CODE:NEO
development team choose a language and technology such as C++ to base it’s
application server on.
Compilation protects developers intellectual property because the source code
does not have to appear on the web server for execution. Only a single binary file
is needed to run a complete web application.
Compilation can also help developers maintain customers because the source code
is required to make changes to web applications delivered in binary form. This
can greatly increase customer retention rate.
Compilation also makes it possible for web component development because a
developer can deliver binary components and include files, which allow
programmers to utilize these binary files for inclusion in their own software
without the component developer having to ship source code.
Compilation also increases execution speed because at no time does the process
have additional processing necessary to execute the binary CODE:NEO object.
-41-
Can CODE:NEO support all platforms, devices and browsers?
Because CODE:NEO applications run from a server, a CODE:NEO application
must never be ported to support a new device or browser. It also means that
CODE:NEO supports 100% of web browsers immediately, whereas technologies
like Macromedia Flash only support browsers who have special software installed
such as the Macromedia Flash plugin.
In the event that you want to change server platforms C++ has you covered
because it is the most widely accepted programming language. C++ compilers
exist for more platforms and devices than any other language, again from PC’s to
refrigerators to palmtop PC’s.
After having completed CODE:NEO for the windows platform the entire
application server, development tools, shared memory manager, utility and server
libraries where ported to the Linux operating system in less than 40 hours by a
single developer. This was possible because C/C++ is extremely standardized and
supported on such a huge number of systems and platforms.
CODE:NEO current ships for Windows, Linux and Solaris and should work on
your BSD derivate with native Linux support.
Rivar Technologies, Inc. is eager to port our application server to many other
platforms upon request. CODE:NEO was able to be ported to Solaris from Linux
in only a few days after being requested by one of our customers.
Because of the ease and speed of porting the product to other platforms it is likely
that any single port request accompanied with a single license purchased will
result in us porting to your platform of choice.
Does CODE:NEO come with an IDE (Integrated Development
Environment)?
Yes, CODE:NEO comes with an IDE called the WDE (web development
environment). This environment allows programmers to program CODE:NEO
applications without installing any software by using their web browser to log into
the server to develop.
Unlike Java Servlets, CODE:NEO can also be developed using common IDE’s
such as Microsoft Visual Studio, Allaire Dreamweaver, Etc.
This ability to develop in many different modes makes CODE:NEO development
versatile and powerful. Allowing web developers and graphic artists and C++
coders to all cooperate on programming projects.
-42-
Doesn’t the fact that servers are less expensive than programmers
mean that web execution speed can achieved cheaper with buying
more servers than utilizing CODE:NEO?
Servers are not less expensive than programmers for several reasons.
Servers require people to maintain, run, monitor and repair. Often computers need
to be replaced every three years and cost valuable data center space with
sophisticated air conditioning, fire suppression, battery backup and power
generation.
Programmers only need to be paid once to develop an application whereas servers
are a very costly reoccurring expense. When was the last time you had to call a
programmer at Microsoft to repair your software compared to calling your local
hardware technician?
Generally speaking servers running web applications cannot be enhanced enough
to yield ten times execution speed as microprocessor speeds only increase
incrementally.
In addition C++ programs have been running for 33 years showing a tremendous
longevity as compared to longevity of the hardware systems that it runs on.
How deos CODE:NEO compare in number of source code lines or
files to accomplish the same tasks as Java, Cold Fusion or ASP?
CODE:NEO source code is comparable in number of lines to accomplish the
same effort in ASP, Cold Fusion or Java. However CODE:NEO utilizes C++,
which inherently generates through the compilation multiple files.
This is of great advantage to programmers because this multi file approach is
what allows the linking process to integrate programming for which you have the
source code to programming for which you do not have the source code.
In addition C++ allows for a high level of architectural separation between
portions of programming so that a large pool of developers can collaborate on
different portions of a project simultaneously without having to share the entire
code base.
C++ in its entirety is designed to be powerful and flexible. All CODE:NEO
applications can either be a single file that the developers maintain or separated
-43-
into multiple files. Any files, which are required beyond the CODE:NEO .CnSrc
file, are automatically generated and can be ignored completely by the developer.
Should the developer design enhanced control over the project all files are
available for them to alter for complete power over their projects.
An excellent example of CODE:NEO programming lines comparison is the
CODE:NEO benchmark applications. This benchmark does math, database
access, logic, etc. making it a good point of comparison.
Platform
CODE:NEO
Java Servlet
ASP
Cold Fusion
Number Of Lines To Accomplish Benchmark
191*
188
171
148
From this you can see that the lines of code are comparable between all these
languages. The variations are mostly layout and comment differences rather than
for actually coding reasons.
The benchmark codes where not optimized for number of lines or speed, they
where programmed to produce output in a similar parallel fashion to make it a fair
and comparable test. *In addition the CODE:NEO version of the benchmark
implements some additional error handling not implemented in the other
languages.
Cold Fusion and ASP have fewer lines of code because those solutions have no
procedural or object oriented framework, which are the major contributing factors
why those languages are harder and more costly to maintain.
CODE:NEO applications are easy to debug.
CODE:NEO and C++ are easier to debug than Java, ASP or Cold Fusion because
so many excellent debugging options exist!
•
•
•
Debugging with trace window
Debugging with real-time debugger
Debugging with logging
Each of these options have specific advantages and disadvantages which are
outlined in the getting started manual.
In addition CODE:NEO’s ability to be debugged is enhanced by the availability
of a number of excellent third party products which not only can help to diagnose
-44-
known bugs but also analyze the code to intercept bugs which have not been
detected yet. These types of tools are available for C++ because of the long-term
investment that the computer industry has made to C++ overall.
How does CODE:NEO handle common integration technologies
such as COM, Corba, RMI, and MQ Series Etc.?
Attempting to include these technologies would be a waste of time because they
all, as well as many others already support C++ and therefore are already
supported within CODE:NEO.
A third a third party such as Orbix, IBM, Oracle, Sun Microsystems and many
others certainly can provide any integration need with C++ compatibility. In fact
the majority of software products natively support C++ integration because they
are written in C++ already and require no integration layer to be interfaced to
within CODE:NEO for the web.
How does CODE:NEO handle database support?
To many great methods for database connectivity already come with C++
compilers. On the Windows platform ADO, DAO, ODBC are all extremely
powerful!
On UNIX ODBC and proprietary integration layers already support C/C++
database connectivity.
In addition to database connectivity solutions which are based on standards and
come already with database products and tremendous number of third party
developers provide database connectivity solutions with specific intents such as
ease of use, cross platform connectivity and high performance.
It is beyond the scope of CODE:NEO to compete with these already successful
and powerful connectivity solutions and we recommend to purchase or download
the solutions that most closely meets your needs thereby increasing the value of
the CODE:NEO solution overall.
CODE:NEO is a mature development environment.
In terms of the CODE:NEO product itself the product was released three years
ago November 12, 2001 making the CODE:NEO, its first release won a Best Of
Comdex and adopters have the opportunity to outpace their competitors.
-45-
CODE:NEO’s popularity is growing and gaining momentum, while Rivar
Technologies developers are extending and expanding the products capabilities so
that it can be coupled with C++ and whatever future C++ development will have
over the next 33 years.
However CODE:NEO’s value really stems from the larger user base of millions
upon millions of C++ developers and consumers.
-46-
Benchmarks
CODE:NEO is the fastest web application server available today. It derives its
speed from the powerful C++ programming language that operating systems are
written in. This C++ compiles down to efficient binary objects that execute at
least ten times faster that Microsoft Active Server Pages, Microsoft .Net, Java or
JSP, ColdFusion and BEA.
CODE:NEO also speeds development by allowing C++ developers to reuse
existing code for web solutions. According to Wired magazine ‘Internet C++’ is
going forward and CODE:NEO can merge C++ and HTML for very rapid
development.
CODE:NEO developers also can reap the rewards of programming in an objectoriented way, further increasing development speed and reducing the costs of
software maintenance.
Because the execution speed of a application is so vital to web applications, the
following simple benchmark tests where created to verify the academic theory
that CODE:NEO was at least ten times faster than other competing technologies.
-47-
As this figure and the following figures show, the performance gain of using
CODE:NEO is quite substantial. The results where verified and tested several
ways including the use of Microsoft’s Web Application stress tool.
CODE:NEO Benchmark Source Example
<%Cn scope="global">
#include <math.h>
#include <sqlext.h>
// Determine if SQL API call was successful
bool
SqlFail(short Result) {
if (Result == SQL_SUCCESS || Result == SQL_SUCCESS_WITH_INFO)
return false;
else return true;
}
</Cn%>
<HTML>
<HEAD>
<TITLE>CODE:NEO Benchmark Test</TITLE>
</HEAD>
<BODY>
<P ALIGN="center">
CODE:NEO Benchmark Test
</P>
<%Cn>
CnString Test;
double r, Reps, Stress;
LARGE_INTEGER StartTm, EndTm, Res;
Test = getArgument("test");
if (Test == "") Test = "all";
Stress = atof(getArgument("stress").c_str());
if (Stress == 0) Stress = 1;
QueryPerformanceFrequency(&Res);
QueryPerformanceCounter(&StartTm);
</Cn%>
<P ALIGN="center">
<%Cn>
swritef("Test = %s<BR>\n", Test.c_str());
swritef("Stress = %.0f\n", Stress);
</Cn%>
</P>
<%Cn>
// MATH TEST
if (Test == "all" || Test == "math") {
double Result = 0;
Reps = 500000 * Stress;
for (r=1; r<=Reps; r++) {
Result = Result + 1;
Result = Result - 2;
Result = Result * 3;
Result = Result / 4;
Result = pow(Result, 2);
Result = pow(Result, .33);
Result = (int)Result % 10;
Result = Result - sin(r);
Result = Result + cos(r);
Result = Result - tan(r);
}
</Cn%>
<P ALIGN="center">
<B>MATH TEST</B><BR>
-48-
The server started with a value of zero<BR>
and performed the following mathematical computations on that value
<%Cn>swritef("%.0f", Reps);</Cn%>
times:<BR>
((((Value + 1 - 2) * 3 / 4) ^ 2 ^ .33) % 10) - Sin(i) + Cos(i) - Tan(i)
</P>
<P ALIGN="center">
The final result was
<%Cn>swritef("%f", Result);</Cn%>
</P>
<%Cn>
}
// End Math Test
// FILE TEST
if (Test == "all" || Test == "file") {
Reps = 20000 * Stress;
CnString String = "The quick red fox jumps over the lazy brown dog.
";
String
String
String
String
+=
+=
+=
+=
"The
"The
"The
"The
lazy brown dog barks at the sly orange cat. ";
sly orange cat chases the little gray mouse. ";
little gray mouse eats the round yellow cheese. ";
round yellow cheese frightens the quick red
fox.\r\n";
FILE* TestFile = fopen("C:\\CnBinTest.txt", "w");
for (r=0; r<=Reps; r++)
fputs(String.c_str(), TestFile);
fclose(TestFile);
TestFile = fopen("C:\\CnBinTest.txt", "r");
for(r=1; r<=Reps*Stress; r++)
fgets((char*)String.c_str(), String.length()+1, TestFile);
fclose(TestFile);
</Cn%>
<P ALIGN="center">
<B>FILE TEST</B><BR>
The server wrote the following string,<BR>
"<I><%Cn scope="inline">swritef("%s", String.c_str());</Cn%></I>"<BR>
to a file
<%Cn>swritef("%.0f", Reps);</Cn%>
times and then read the entire file
</P>
<%Cn>
}
// End File Test
// DATABASE TEST
if (Test == "all" || Test == "db") {
Reps = 300 * Stress;
long Length;
char Buff[16];
void *EnvHnd, *ConHnd, *SqlHnd;
CnString SqlStr, ZipCode, Plus4, FrLat, FrLon, ToLat, ToLon;
// Connect to database
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &EnvHnd);
SQLSetEnvAttr(EnvHnd, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3,
0);
SQLAllocHandle(SQL_HANDLE_DBC, EnvHnd, &ConHnd);
SQLConnect(ConHnd, (unsigned char*)"HiZip", SQL_NTS, (unsigned
char*)"", SQL_NTS,
(unsigned char*)"", SQL_NTS);
SQLAllocHandle(SQL_HANDLE_STMT, ConHnd, &SqlHnd);
for (r=1; r<=Reps; r++) {
// Prep query string
SqlStr = "SELECT ZIP_CODE, PLUS_4, FROM_LAT, FROM_LONG,
TO_LAT, TO_LONG FROM HI WHERE ID=";
SqlStr += formatStr("%d", (((int)r - 1) % 96918) + 1);
// Run query
SQLExecDirect(SqlHnd, (unsigned char*)SqlStr.c_str(),
SqlStr.length());
-49-
SQLFetch(SqlHnd);
SQLGetData(SqlHnd,
ZipCode = Buff;
SQLGetData(SqlHnd,
Plus4 = Buff;
SQLGetData(SqlHnd,
FrLat = Buff;
SQLGetData(SqlHnd,
FrLon = Buff;
SQLGetData(SqlHnd,
ToLat = Buff;
SQLGetData(SqlHnd,
ToLon = Buff;
1, SQL_C_CHAR, Buff, 16, &Length);
2, SQL_C_CHAR, Buff, 16, &Length);
3, SQL_C_CHAR, Buff, 16, &Length);
4, SQL_C_CHAR, Buff, 16, &Length);
5, SQL_C_CHAR, Buff, 16, &Length);
6, SQL_C_CHAR, Buff, 16, &Length);
// Free statement
SQLFreeStmt(SqlHnd, SQL_CLOSE);
}
// Close connection
SQLFreeHandle(SQL_HANDLE_STMT, SqlHnd);
SQLDisconnect(ConHnd);
SQLFreeHandle(SQL_HANDLE_DBC, ConHnd);
SQLFreeHandle(SQL_HANDLE_ENV, EnvHnd);
</Cn%>
<P ALIGN="center">
<B>DATABASE TEST</B><BR>
The server retrieved a record from a database of Hawaiian Zip Codes
<%Cn>swritef("%.0f", Reps);</Cn%>
times
</P>
<P ALIGN="center">
The final record retrieved was:<BR>
<TABLE BORDER="1">
<TR>
<TH ROWSPAN="2" ALIGN="center" VALIGN="middle">Zip Code</TH>
<TH COLSPAN="2" ALIGN="center">Latitude</TH>
<TH COLSPAN="2" ALIGN="center">Longitude</TH>
</TR>
<TR>
<TH ALIGN="center">From</TH>
<TH ALIGN="center">To</TH>
<TH ALIGN="center">From</TH>
<TH ALIGN="center">To</TH>
</TR>
<TR>
<TD><%Cn scope="inline">swritef("%s-%s", ZipCode.c_str(),
Plus4.c_str());</Cn%></TD>
<TD><%Cn scope="inline">swritef("%s", FrLat.c_str());</Cn%></TD>
<TD><%Cn scope="inline">swritef("%s", ToLat.c_str());</Cn%></TD>
<TD><%Cn scope="inline">swritef("%s", FrLon.c_str());</Cn%></TD>
<TD><%Cn scope="inline">swritef("%s", ToLon.c_str());</Cn%></TD>
</TR>
</TABLE>
</P>
<%Cn>
}
// End Database Test
QueryPerformanceCounter(&EndTm);
</Cn%>
<P ALIGN="center">
The test took
<%Cn>swritef("%.3f", (EndTm.QuadPart - StartTm.QuadPart) /
(double)Res.QuadPart);</Cn%>
seconds to process.
</P>
</BODY>
</HTML>
-50-
<HTML>
<HEAD>
<TITLE>ASP Benchmark Test</TITLE>
</HEAD>
<BODY>
<P ALIGN="center">
Active Server Page Benchmark Test
</P>
<%
Dim r, Reps, Stress, Test
Dim StartTm, EndTm
Test = Request.QueryString("test")
If Test = "" Then Test = "all"
Stress = Request.QueryString("stress")
If Stress = "" Then Stress = 1
StartTm = Timer
%>
<P ALIGN="center">
Test = <%=Test%><BR>
Stress = <%=Stress%>
</P>
<%
' MATH TEST
If Test = "all" Or Test = "math" Then
Reps = 500000 * Stress
Dim Result
Result = 0
For r = 1 To Reps
Result = Result + 1
Result = Result - 2
Result = Result * 3
Result = Result / 4
Result = Result ^ 2
Result = Result ^ .33
Result = fix(Result) Mod 10
Result = Result - Sin(r)
Result = Result + Cos(r)
Result = Result - Tan(r)
Next
%>
<P ALIGN="center">
<B>MATH TEST</B><BR>
The server started with a value of zero<BR>
and performed the following mathematical computations on that value
<%=Reps%>
times:<BR>
((((Value + 1 - 2) * 3 / 4) ^ 2 ^ .33) % 10) - Sin(i) + Cos(i) - Tan(i)
-51-
</P>
<P ALIGN="center">
The final result was
<%=Result%>
</P>
<%
End If ' Math Test
' FILE TEST
If Test = "all" Or Test = "file" Then
Reps = 20000 * Stress
Dim String, FsObj, TestFile
String = "The quick red fox jumps over the lazy brown dog. " & _
"The lazy brown dog barks at the sly orange cat. " & _
"The sly orange cat chases the little gray mouse. " & _
"The little gray mouse eats the round yellow cheese. " & _
"The round yellow cheese frightens the quick red fox."
Set FsObj = CreateObject("Scripting.FileSystemObject")
Set TestFile = FsObj.CreateTextFile("C:\AspTest.txt", True)
For r = 1 To Reps
TestFile.WriteLine(String)
Next
TestFile.Close()
Set TestFile = Nothing
Set TestFile = FsObj.OpenTextFile("C:\AspTest.txt", 1)
For r = 1 To (Reps * Stress)
String = TestFile.ReadLine()
Next
TestFile.Close()
Set TestFile = Nothing
%>
<P ALIGN="center">
<B>FILE TEST</B><BR>
The server wrote the following string,<BR>
"<I><%=String%></I>"<BR>
to a file
<%=Reps%>
times and then read the entire file
</P>
<%
End If ' File Test
' DATABASE TEST
If Test = "all" Or Test = "db" Then
Reps = 300 * Stress
Dim Conn, Rs
Dim SqlStr, ZipCode, Plus4, FrLat, FrLon, ToLat, ToLon
' Connect to database
Set Conn = Server.CreateObject("ADODB.Connection")
Conn.Open("DSN=HiZip")
For r = 1 To Reps
' Prep query string
SqlStr = "SELECT ZIP_CODE, PLUS_4, FROM_LAT, FROM_LONG,
TO_LAT, TO_LONG FROM HI " & _
"WHERE ID=" & (((r - 1) Mod 96918) + 1)
' Run query
Set Rs = Conn.Execute(SqlStr)
ZipCode = Rs(0)
Plus4 = Rs(1)
FrLat = Rs(2)
FrLon = Rs(3)
ToLat = Rs(4)
ToLon = Rs(5)
' Close recordset
-52-
Rs.close
Set Rs = Nothing
Next
' Close connection
Conn.close
Set Conn = Nothing
%>
<P ALIGN="center">
<B>DATABASE TEST</B><BR>
The server retrieved a record from a database of Hawaiian Zip Codes
<%=Reps%>
times
</P>
<P ALIGN="center">
The final record retrieved was:<BR>
<TABLE BORDER="1">
<TR>
<TH ROWSPAN="2" ALIGN="center" VALIGN="middle">Zip Code</TH>
<TH COLSPAN="2" ALIGN="center">Latitude</TH>
<TH COLSPAN="2" ALIGN="center">Longitude</TH>
</TR>
<TR>
<TH ALIGN="center">From</TH>
<TH ALIGN="center">To</TH>
<TH ALIGN="center">From</TH>
<TH ALIGN="center">To</TH>
</TR>
<TR>
<TD><%=ZipCode%>-<%=Plus4%></TD>
<TD><%=FrLat%></TD>
<TD><%=ToLat%></TD>
<TD><%=FrLon%></TD>
<TD><%=ToLon%></TD>
</TR>
</TABLE>
</P>
<%
End If ' Database Test
EndTm = Timer
%>
<P ALIGN="center">
The test took
<%=FormatNumber(EndTm - StartTm, 3)%>
seconds to process.
</P>
</BODY>
</HTML>
-53-
//benchmark.java
import
import
import
import
import
java.io.*;
java.sql.*;
java.text.*;
javax.servlet.*;
javax.servlet.http.*;
public class Benchmark extends HttpServlet
{
public void service(HttpServletRequest request, HttpServletResponse
response)
throws ServletException, java.io.IOException {
PrintWriter output = response.getWriter();
output.print("<HTML>\n");
output.print("<HEAD>\n");
output.print("<TITLE>Java Benchmark Test</TITLE>\n");
output.print("</HEAD>\n\n");
output.print("<BODY>\n");
output.print("<P ALIGN=\"center\">\n");
output.print("Java Benchmark Test\n");
output.print("</P>\n");
double r, Reps, Stress;
String Test;
long StartTm, EndTm;
DecimalFormat MilliFmt = new DecimalFormat();
if (request.getParameter("test") != null)
Test = request.getParameter("test");
else Test = "all";
if (request.getParameter("stress") != null)
Stress =
Double.parseDouble(request.getParameter("stress"));
else Stress = 1;
MilliFmt.setMinimumFractionDigits(3);
MilliFmt.setMaximumFractionDigits(3);
StartTm = System.currentTimeMillis();
output.print("<P ALIGN=\"center\">\n");
output.print("Test = " + Test + "<BR>\n");
output.print("Stress = " + Integer.toString((int)Stress) + "\n");
output.print("</P>\n");
// MATH TEST
-54-
if (Test.equals("all") || Test.equals("math")) {
Reps = 100000;
double Result;
Result = 0;
for (r=1; r<=Reps*Stress; r++) {
Result = Result + 1;
Result = Result - 2;
Result = Result * 3;
Result = Result / 4;
Result = Math.abs(Result);
Result = Math.sqrt(Result);
Result = Math.pow(Result, 3);
Result = (int)Result % 10;
Result = Result - Math.sin(r);
Result = Result + Math.cos(r);
Result = Result - Math.tan(r);
}
output.print("<P ALIGN=\"center\">\n");
output.print("<B>MATH TEST</B><BR>\n");
output.print("The server started with a value of
zero.<BR>\n");
output.print("and performed the following mathematical
computations on that value\n");
output.print(Integer.toString((int)Reps * (int)Stress) +
"\n");
output.print("times:<BR>\n");
output.print("((((Value + 1 - 2) * 3 / 4) ^ .5 ^ 3) % 10) Sin(i) + Cos(i) - Tan(i)\n");
output.print("</P>\n");
output.print("<P ALIGN=\"center\">\n");
output.print("The final result was\n");
output.print(Result);
output.print("</P>\n");
}
// End Math Test
// FILE TEST
if (Test.equals("all") || Test.equals("file")) {
Reps = 10000;
String Fstring;
Object TestFile;
Fstring = new String("The quick red fox jumps over the lazy
brown dog. ");
Fstring = Fstring + "The lazy brown dog barks at the sly
orange cat. ";
Fstring = Fstring + "The sly orange cat chases the little
gray mouse. ";
Fstring = Fstring + "The little gray mouse eats the round
yellow cheese. ";
Fstring = Fstring + "The round yellow cheese frightens the
quick red fox.\r\n";
TestFile = new FileWriter("C:\\ClassTest.txt");
((FileWriter)TestFile).flush();
for (r=1; r<=Reps*Stress; r++)
((FileWriter)TestFile).write(Fstring.toCharArray());
((FileWriter)TestFile).close();
TestFile = null;
TestFile = new FileReader("C:\\ClassTest.txt");
for (r=1; r<=Reps*Stress; r++)
((FileReader)TestFile).read(Fstring.toCharArray(),
0, Fstring.length());
((FileReader)TestFile).close();
TestFile = null;
output.print("<P ALIGN=\"center\">\n");
output.print("<B>FILE TEST</B><BR>\n");
output.print("The server wrote the following
string,<BR>\n");
-55-
output.print("\"<I>" + Fstring + "</I>\"<BR>\n");
output.print("to a file\n");
output.print(Integer.toString((int)Reps * (int)Stress) +
"\n");
}
output.print("times and then read the entire file\n");
output.print("</P>\n");
// End File Test
// DATABASE TEST
if (Test.equals("all") || Test.equals("db")) {
Reps = 20;
Connection Conn;
Statement Stmt;
ResultSet Result;
String SqlStr, ZipCode="", Plus4="", FrLat="", FrLon="",
ToLat="", ToLon="";
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
for (r=1; r<=Reps*Stress; r++) {
// Prep query string
SqlStr = "SELECT ZIP_CODE, PLUS_4, FROM_LAT,
FROM_LONG, TO_LAT, TO_LONG FROM HI WHERE ID=";
SqlStr = SqlStr + Integer.toString((((int)r
- 1) % 96918) + 1);
// Connect to database and run query
Conn =
DriverManager.getConnection("jdbc:odbc:HiZip");
Stmt = Conn.createStatement();
Result = Stmt.executeQuery(SqlStr);
Result.next();
ZipCode = Result.getString("ZIP_CODE");
Plus4 = Result.getString("PLUS_4");
FrLat = Result.getString("FROM_LAT");
FrLon = Result.getString("FROM_LONG");
ToLat = Result.getString("TO_LAT");
ToLon = Result.getString("TO_LONG");
// Close connection
Result.close();
Result = null;
Stmt.close();
Stmt = null;
Conn.close();
Conn = null;
// End for (r)
}
}
catch (ClassNotFoundException CnfEx) {}
catch (SQLException SqlEx) {}
output.print("<P ALIGN=\"center\">\n");
output.print("<B>DATABASE TEST</B><BR>\n");
output.print("The server retrieved a record from a database
of Hawaiian Zip Codes\n");
output.print(Integer.toString((int)Reps * (int)Stress) +
"\n");
output.print("times\n");
output.print("</P>\n");
output.print("<P ALIGN=\"center\">\n");
output.print("The final record retrieved was:<BR>\n");
output.print("<TABLE BORDER=\"1\">\n");
output.print("\t<TR>\n");
output.print("\t\t<TH ROWSPAN=\"2\" ALIGN=\"center\"
VALIGN=\"middle\">Zip Code</TH>\n");
output.print("\t\t<TH COLSPAN=\"2\"
ALIGN=\"center\">Latitude</TH>\n");
output.print("\t\t<TH COLSPAN=\"2\"
ALIGN=\"center\">Longitude</TH>\n");
output.print("\t</TR>\n");
output.print("\t<TR>\n");
-56-
output.print("\t\t<TH ALIGN=\"center\">From</TH>\n");
output.print("\t\t<TH ALIGN=\"center\">To</TH>\n");
output.print("\t\t<TH ALIGN=\"center\">From</TH>\n");
output.print("\t\t<TH ALIGN=\"center\">To</TH>\n");
output.print("\t</TR>\n");
output.print("\t<TR>\n");
output.print("\t\t<TD>" + ZipCode + "-" + Plus4 +
"</TD>\n");
}
output.print("\t\t<TD>" + FrLat
output.print("\t\t<TD>" + ToLat
output.print("\t\t<TD>" + FrLon
output.print("\t\t<TD>" + ToLon
output.print("\t</TR>\n");
output.print("</TABLE>\n");
output.print("</P>\n");
// End Database Test
+
+
+
+
"</TD>\n");
"</TD>\n");
"</TD>\n");
"</TD>\n");
EndTm = System.currentTimeMillis();
output.print("<P ALIGN=\"center\">\n");
output.print("The test took\n");
output.print(MilliFmt.format((EndTm - StartTm) / (double)1000.000)
+ "\n");
output.print("seconds to process.\n");
output.print("</P>\n");
output.print("</BODY>\n");
output.print("</HTML>\n");
}
}
<HTML>
<HEAD>
<TITLE>Cold Fusion Benchmark Test</TITLE>
</HEAD>
<BODY>
<P ALIGN="center">
Cold Fusion Benchmark Test
</P>
<CFSILENT>
<CFIF IsDefined("URL.stress")>
<CFSET Stress = URL.stress>
<CFELSE>
<CFSET Stress = 1>
</CFIF>
<CFIF IsDefined("URL.test")>
<CFSET Test = URL.test>
<CFELSE>
-57-
<CFSET Test = "all">
</CFIF>
<CFSET StartTm = Now()>
</CFSILENT>
<P ALIGN="center">
Test = <CFOUTPUT>#Test#</CFOUTPUT><BR>
Stress = <CFOUTPUT>#Stress#</CFOUTPUT>
</P>
<CFIF Test is "all" OR Test is "math">
<CFSILENT>
<CFSET Reps = 500000 * #Stress#>
<CFSET Result = 0>
<CFLOOP INDEX="r" FROM="1" TO="#Reps#">
<CFSET Result = Result + 1>
<CFSET Result = Result - 2>
<CFSET Result = Result * 3>
<CFSET Result = Result / 4>
<CFSET Result = Result ^ 2>
<CFSET Result = Result ^ 0.33>
<CFSET Result = Result MOD 10>
<CFSET Result = Result - Sin(r)>
<CFSET Result = Result + Cos(r)>
<CFSET Result = Result - Tan(r)>
</CFLOOP>
</CFSILENT>
<P ALIGN="center">
<B>MATH TEST</B><BR>
The server started with a value of zero.<BR>
and performed the following mathematical computations on that value
<CFOUTPUT>#Reps#</CFOUTPUT>
times:<BR>
((((Value + 1 - 2) * 3 / 4) ^ .5 ^ 3) % 10) - Sin(i) + Cos(i) - Tan(i)
</P>
<P ALIGN="center">
The final result was
<CFOUTPUT>#Result#</CFOUTPUT>
</P>
</CFIF>
<CFIF Test is "all" OR Test is "file">
<CFSILENT>
<CFSET Reps = 20000 * #Stress#>
<CFSET String = "The quick red fox jumps over the lazy brown dog. ">
<CFSET String = #String# & "The lazy brown dog barks at the sly orange
cat. ">
<CFSET String = #String# & "The sly orange cat chases the little gray
mouse. ">
<CFSET String = #String# & "The little gray mouse eats the round yellow
cheese. ">
<CFSET String = #String# & "The round yellow cheese frightens the quick
red fox.">
<CFFILE ACTION="delete" FILE="C:\CfmTest.txt">
<CFLOOP INDEX="r" FROM="1" TO="#Reps#">
<CFFILE ACTION="append" FILE="C:\CfmTest.txt" OUTPUT="#String#">
</CFLOOP>
<CFFILE ACTION="read" FILE="C:\CfmTest.txt" VARIABLE="String2">
</CFSILENT>
<P ALIGN="center">
<B>FILE TEST</B><BR>
The server wrote the following string,<BR>
"<I><CFOUTPUT>#String#</CFOUTPUT></I>"<BR>
to a file
<CFOUTPUT>#Reps#</CFOUTPUT>
times and then read the entire file
</P>
</CFIF>
-58-
<CFIF Test is "all" OR Test is "db">
<CFSILENT>
<CFSET Reps = 300 * #Stress#>
<CFLOOP INDEX="r" FROM="1" TO="#Reps#">
<CFSET Id = ((r - 1) MOD 96918) + 1>
<CFQUERY NAME="HiZip" DBTYPE="dynamic" CONNECTSTRING="DSN=HiZip">
SELECT ZIP_CODE, PLUS_4, FROM_LAT, FROM_LONG, TO_LAT,
TO_LONG
FROM HI WHERE ID=#Id#
</CFQUERY>
<CFOUTPUT QUERY="HiZip">
<CFSET ZipCode = ZIP_CODE>
<CFSET Plus4 = PLUS_4>
<CFSET FrLat = FROM_LAT>
<CFSET FrLon = FROM_LONG>
<CFSET ToLat = TO_LAT>
<CFSET ToLon = TO_LONG>
</CFOUTPUT>
</CFLOOP>
</CFSILENT>
<P ALIGN="center">
<B>DATABASE TEST</B><BR>
The server retrieved a record from a database of Hawaiian Zip Codes
<CFOUTPUT>#Reps#</CFOUTPUT>
times
</P>
<P ALIGN="center">
The final record retrieved was:<BR>
<TABLE BORDER="1">
<TR>
<TH ROWSPAN="2" ALIGN="center" VALIGN="middle">Zip Code</TH>
<TH COLSPAN="2" ALIGN="center">Latitude</TH>
<TH COLSPAN="2" ALIGN="center">Longitude</TH>
</TR>
<TR>
<TH ALIGN="center">From</TH>
<TH ALIGN="center">To</TH>
<TH ALIGN="center">From</TH>
<TH ALIGN="center">To</TH>
</TR>
<TR>
<CFOUTPUT>
<TD>#ZipCode#-#Plus4#</TD>
<TD>#FrLat#</TD>
<TD>#ToLat#</TD>
<TD>#FrLon#</TD>
<TD>#ToLon#</TD>
</CFOUTPUT>
</TR>
</TABLE>
</P>
</CFIF>
<CFSET EndTm = Now()>
<P ALIGN="center">
The test took
<CFOUTPUT>#NumberFormat(DateDiff("s", StartTm, EndTm), '0.000')#</CFOUTPUT>
seconds to process.
</P>
</BODY>
</HTML>
-59-
Partners
21C DIGITAL
On the web; www.21cdigital.com
21CDigital is a new media developer who adopted the CODE:NEO technology to
gain an edge on the competition.
Atavia
On the web; www.atavia.com
Atavia is a CODE:NEO’s hosting provider. They focus on providing premier
hosted solutions to optimize the value to the client.
Cenetec
On the web; www.cenetec.com
Cenetec is a technology incubator in Boca Raton Florida.
Deerfield
On the web; www.deerfield.com
Deerfield acquired the O’Reilly web site server software and is has enhanced it to
make it more powerful and dependable. It represents a great alternative
commercial web server to the Microsoft IIS web server.
-60-
Clients
Aquamed
On the web; www.aquamed.com
Vescent
On the web; vescent.com
Optical Outlets
On the web; opticaloutlets.com
On the web; www.practas.com
21C DIGITAL
On the web; www.21cdigital.com
Home Seekers
The Mostoller Group
-61-
Empstat
Best Security Industries
-62-
Solutions
CODE:NEO Cart Overview
Rivar Contact;
Vincent Risalvato, 813-368-1704, [email protected]
-63-
Executive Summary
Purpose
The CODE:NEO cart implements a shopping cart for politics products through a
direct C++ link to Verisign Credit Card Processing.
This cart also supports partner product sales and two levels of integration, direct
product integration and online link product integration.
It features online product administration and a complete ability to be customized
to meet customer needs.
It also feature online accounting and automated invoice emails to partners, clients
and server administrator.
-64-
-65-
-66-
-67-
Home Seekers MTA Calculator
Rivar Contact;
Vincent Risalvato, 813-368-1704, [email protected]
-68-
Executive Summary
Purpose
To create a versatile mortgage calculator.
-69-
-70-
Optical Outlets E-Commerce System Walk Thru
R1
December 28, 2002
Rivar Contact;
Vincent Risalvato, 813-368-1704, [email protected]
-71-
E-Commerce System Walk Thru
New home page now has prominent “Order Contact Button” which now allows
existing customers into the E-Commerce system to reorder contacts.
Generally clients will reach out to the website to reorder contacts after they have
received a postcard in the mail generated by the CODE:NEO recall generator.
Optical Outlets will also introduce clients to the website during fitting so that they
know they can reorder and in the future an system for new clients will be added to
that a prescription can be added then the prescribing doctor called for verification
for new clients not seen by and Optical Outlets doctor.
-72-
After clicking on order contacts user is placed within an information-gathering
screen, which asks for a name and phone number to authenticate user.
-73-
In the event that the customer’s last eye exam has expired an error screen appears.
-74-
After the patients prescription is verified they are offered the products they have
purchased in the past and the system automatically looks up discounts for the
products they are offered.
-75-
The credit card information is then obtained from the user, verified charged and
the user and Optical Outlets are sent confirmation emails.
-76-
Optical Outlets Intranet Report And Utilities System White Paper
November 7, 2002
Rivar Contact;
Vincent Risalvato, 813-368-1704, [email protected]
-77-
Reporting System Infrastructure Requirements
Optical Outlets is faced with having a computer system, which does not meet its
current needs. Those needs included accessibility, accountability and interactivity
of enterprise data. They rely upon several software packages based on the FoxPro
Database Technology by Microsoft.
Optical Outlets had to choose between developing our purchasing a new system
or integrating to the current system. It was felt that by integrating to the existing
system we could maximize positive effort by not having to retrain or expend the
budget to do a complete systems change.
We would accomplish the requirements through a phased approach that would
eventually obsolete the old FoxPro technology.
In general some main requirements where;
•
•
•
•
•
•
Web based intranet approach
Build using solid foundation of C++
Allows moving directly to extranet
Allows integration of many systems
Provides rapid development of further systems
Ability to relate home office and lab system data
-78-
Patient History Lookup
•
•
•
•
•
•
•
•
•
•
•
Ability to look up a patient’s record and see it
Specify ‘Like’ search which searches first name last name and full name fields
plus ability to choose a criteria to narrow by if name is similar to other clients,
I.E. phone number, address, SS#, these criteria are to be determined.
Displays the patient history and retail history sorted by date (newest entry
first) across stores grouped by procedure, with store they visited indicated
Ability to look up a patient’s record and obtain rx from the intranet
Specify ‘Like’ search which searches first name last name and full name fields
Search by patient ID and Store Number (because ID are duplicated between
stores)
Displays the RX in the system
Use algorithm to pull last exam date instead of pulling from database, which is
wrong.
Group purchases by left and right eyes
Add store id to patient header
Add right and left to OS / OD (do we need to switch?)
Main Screen
-79-
Intermediate Screen
Result Screen
-80-
Recall Generator
•
•
•
•
1. Report runs in a way that you specify which recall to do
a. eyeglass exam recalls,
b. contact exam recalls,
c. contact refills
2. The onscreen results has check boxes for sending recalls, a button
to 'check all', the results will not be paginated for print and viewing
purposes.
3. Specifiable date range to run this report.
a. the amount of time, which has passed since last
exam/visit/purchase whatever from a specifiable date which
defaults to today...
4. Generation of letters and envelopes. (not required at this time)
5. Ability to modify text used in verbiage.
a. Recall process
i. click on print postcards and they choose printer....
retrieves file contents of the blurb for that category
which is then editable they submit that as is or with
changes, if it's changed its saved back to the text
file.... and then used for the printing.... the will use
tags for dynamic fields.. we will define a small set
of these fields for the first run, which can be
extended later.
b. Options Tags
i. salutation
ii. date of last doctor visit
iii. date of last eye glasses exam
iv. date of last contact exam
v. date of last contacts purchase
vi. store address last seen at
vii. store name last seen at
viii. store phone number last seen at.
6. Ability to mark that a recall letter has been sent.
7. Ability to resend recall letters that have already been sent. (Check
box to override a run on a range already run)
8. Ability to print postcard
a. Postcard print button, opens print dialog to print postcards
and updated the tracking table...
Print functionality to produce recall call list
Algorithm to calculate when client runs out of product
By vendor and by partial text criteria for description field
Add patient history popup
-81-
Main Screen
CODE:NEO Sales Comparison Report
CODE:NEO offers incredible power and flexibility in producing web-based
programming solutions. This capacity extends to database report generation
scenarios. In the example of a Sales Comparison report, CODE:NEO allows the
developer to create a database driven report, the output of which the user can sort
“on the fly” at the client end of the application. Furthermore, the report will run
considerably faster, and with more capability than in any other development
technology.
In the Sales Comparison report scenario, the client requires sales, receipts, and
quantities data from two variable date ranges for all store locations, with percent
increase/decrease calculations on each field. The user must be able to sort this
-82-
data on all fields, without having to re-run the report. In addition, the user must be
able to print a business grade copy of the report from the server. The data source
is a directory of free tables produced by a FoxPro application on a Win32
platform.
The first thing the application must do is gather user input for the variable date
ranges. A simple form such as the following satisfies this requirement:
The next step in producing this solution is connecting to the data source. ODBC
provides a low-overhead method of connecting to FoxPro .DBF files from C++,
so this is the method of choice.
In Win32 ODBC, a database connection requires an environment handle, and a
connection handle. Once these are allocated, the simplest way to connect is via a
DSN established with the Data Source Manager. Finally, a statement handle is
allocated to support querying the data source. The code to achieve these tasks
looks like the following:
if (SqlFail(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
&EnvHnd)) ||
SqlFail(SQLSetEnvAttr(EnvHnd, SQL_ATTR_ODBC_VERSION,
(void*)SQL_OV_ODBC3, 0)) ||
SqlFail(SQLAllocHandle(SQL_HANDLE_DBC, EnvHnd, &ConHnd)) ||
SqlFail(SQLConnect(ConHnd, (unsigned char*)"OOdata",
SQL_NTS, (unsigned char*)"",
SQL_NTS, (unsigned char*)"", SQL_NTS)) ||
SqlFail(SQLAllocHandle(SQL_HANDLE_STMT, ConHnd, &SqlHnd)))
{
Errors += "Unable to establish database
connection<BR>\n";
}
In the above example, the ODBC environment has also been set to use ODBC
version 3. In addition, a simple function called SqlFail is used to test the return
value of each call for success or failure, since a successful call can return either
-83-
SQL_SUCCESS or SQL_SUCCESS_WITH_INFO, and SQL_NO_DATA can be
either a success or a failure, depending on the developer’s definition.
As the data resides in multiple tables that do not support inner-joins, the
application will have to collate the data internally in order to produce the result.
The query is driven by the list of store locations, so the first logical step is to
retrieve the number of locations and store details from the stores data file. The
number of locations is retrieved with an SQL COUNT function:
// Get record count
SqlStr = "SELECT COUNT(SID) FROM STORES";
if (SqlFail(SQLExecDirect(SqlHnd, (unsigned
char*)SqlStr.c_str(), SqlStr.length())) ||
SqlFail(SQLFetch(SqlHnd)) || SqlFail(SQLGetData(SqlHnd, 1,
SQL_C_SLONG, &Count, 0, &Length))) {
Errors += "Failed to retrieve count from STORES
table<BR>\n";
GetSqlErr(Errors, SqlHnd);
}
The application has to manipulate the retrieved data and output it in several ways,
which will be explained later, so the data is organized in an array of records. The
store data is saved in this array in ascending order by store id. Thus, the store with
the lowest id number is at index 0, the next store at index 1, and so on. In order to
support client-end sorting, indexes of the data must also be built, so all of the
fields are indexed while the report detail data is being collected. The indexes
consist of arrays containing the field value to sort by, and the array index of the
record. As each new value is added, it is sorted into the array in ascending order,
along with the index of the corresponding record from the Records array. Thus, if
the fifth record has the lowest Sales Range 1 figure, its index of 4 is stored in the
Index array (along with the figure, for continued sorting). Here’s how this is done:
// Function to sort a name into an index
void
IndexName(int Id, CnString& Name, NamIdx* Index, int Total)
{
for (int i=0; i<Total; i++) {
// Find index where new value belongs
if (Name.compare(Index[i].Name) < 0) break;
}
// Bump remaining values down
for (int j=Id; j>i; j--) Index[j] = Index[j-1];
// Default to first unused position if value is last
if (i == Total) i = Id;
}
// Add value to array
Index[i].Id = Id;
Index[i].Name = Name;
-84-
// Build data storage/index arrays
Records = new Record[Count];
NameIdx = new NamIdx[Count];
// Get STORES data
SqlStr = "SELECT SID, DMNAME FROM STORES ORDER BY SID";
if (SqlFail(SQLExecDirect(SqlHnd, (unsigned
char*)SqlStr.c_str(), SqlStr.length()))) {
Errors += "Failed to query STORES table<BR>\n";
GetSqlErr(Errors, SqlHnd);
}
else {
// Bind columns to variables for data retrieval
if (SqlFail(SQLBindCol(SqlHnd, 1, SQL_C_SLONG, &Sid,
0, &Length)) ||
SqlFail(SQLBindCol(SqlHnd, 2, SQL_C_CHAR, &Buff,
BuffSz, &Length))) {
Errors += "Failed to bind columns on STORES
table<BR>\n";
GetSqlErr(Errors, SqlHnd);
}
}
// Iterate through stores, fetching detail data
for (i=0; i<Count; i++) {
if (SqlFail(SQLFetch(SqlHnd))) break;
Records[i].Sid = Sid;
Records[i].Name = Buff;
IndexName(i, Records[i].Name, NameIdx, Count);
}
SQLCloseCursor(SqlHnd);
SQLFreeStmt(SqlHnd, SQL_UNBIND);
// End if (exec STORES data)
Next, the application iterates through the array, querying other tables to retrieve
detail data in both user-specified date ranges for each store. This is carried out in
the same manner as the retrieval of store data, shown above. The required percent
changes are calculated, and all the data is stored in the Records array by store id.
With this indexing method, presenting the records in ascending order by any
particular field only requires iterating through the Index, and retrieving each
record from the Records array with the index specified in the Index array.
Likewise, iterating backwards through the Index array produces a descending sort
on that column. For example, if the Records array looked like this:
Array
Index
Id
0
1
2
3
4
001
002
003
004
005
Store
Name
Downtown
Uptown
East Side
Smallville
Suburbia
Range
1
$217.42
$307.70
$266.80
$144.92
$251.73
Sales
Range
2
$272.61
$488.75
$297.48
$175.05
$215.24
%
Diff
25.38
58.84
3.72
20.79
14.50
-85-
Range
1
$154.49
$229.17
$220.88
$118.09
$215.49
Receipts
Range
2
$204.28
$359.59
$224.60
$149.70
$174.97
%
Diff
32.23
56.91
1.68
26.76
18.80
Range
1
12
16
15
5
9
Qty.
Range
2
17
27
15
6
9
%
Diff
41.66
68.75
0.00
20.00
0.00
Then the Index of the Sales Range 1 data would look like this:
Value
$144.92
$217.42
$251.73
$266.80
$307.70
Index
3
0
4
2
1
So, an ascending order sort on Sales Range 1 would present the store records in
this order: Smallville, Downtown, Suburbia, East Side, Uptown.
At the client end, the values stored in the indices are no longer necessary, as they
have already been sorted. This supports making one comprehensive Index for the
entire table. In other words, the rows of the Index represent ascending sort order,
and the columns represent the columns of the table to sort on. Such an Index for
the example table above would look like this:
Id
0
1
2
3
4
Store
Name
0
4
1
2
3
Range
1
3
0
4
2
1
Sales
Range
2
3
4
0
2
1
%
Diff
4
2
3
0
1
Range
1
3
0
4
2
1
Receipts
Range
2
3
4
0
2
1
%
Diff
4
2
3
0
1
Range
1
3
4
0
2
1
Qty.
Range
2
3
4
2
0
1
%
Diff
4
2
3
0
1
Reading down the column representing the sort field produces an ascending sort,
and reading up the column produces a descending sort.
Once the data has been retrieved, organized, and indexed, it is saved on the server
and sent to the client. The copy on the server is referenced if the client sends back
a request for a printed copy. The client receives the Recordset and the
comprehensive Index in the form of multidimensional JavaScript arrays, written
by the server application. The application also writes a call to a JavaScript
function, which will sort and write the output data when the page loads in the
client browser. At this point, the processing is handed off to the client, but this
client-side part of the solution is only viable because CODE:NEO has performed
all of the background work on the server. This is especially true of the indexing
process, which would take unacceptable amounts of time to process on the client
machine.
The client JavaScript function’s job is to generate the HTML output that displays
the data passed to it. Each time it runs, it must re-write the page header, which
contains the Records and Index arrays, as well as write the table of sorted data in
the body. The column headers are written as hyperlinks, each of which call the
function again when clicked, passing their column index as a parameter. Inside
the function, the Index array is iterated, either forward for an ascending sort, or
backwards for a descending sort, with the column index as the array’s second
-86-
dimension. In programming terms, referencing the example Index above, this
would mean SortTable(2), which would be called by clicking the Sales Range 1
column header, would execute the following code:
SortTable(ColIndex) {
…
for (r=0; r<RowCount; r++) {
// Iterate
through table rows
RowIndex = Index[r][ColIndex];
//
Get Records index from Index array
Document.writeln(“<TR>”);
// Start
table row
for (c=0; c<ColCount; c++) {
// Iterate
through table columns
Document.writeln(“<TD>” +
Records[RowIndex][c] + “</TD>”);
}
// Get column
data from Records array, write cell
Document.writeln(“</TR>”);
// End
table row
}
…
}
After this function runs, the output might look like this:
-87-
And clicking on the Sales Range 1 column header would produce this:
At the bottom of the displayed table is a “Print” button. When this button is
clicked, a custom print dialog box appears in a chromeless browser window, like
below.
This dialog allows the user to select a printer available to the server, and specify
the sort criteria for the printed report. The selected printer is then passed back to
the server, along with the index of the column and the sort order (ascending or
descending). The server print application begins its process by connecting to the
specified printer and establishing a GDI Device Context as follows:
// Connect to printer
-88-
if (OpenPrinter((char*)PrintNm.c_str(), &Printer, 0)) {
// Allocate buffer for printer context data
GetPrinter(Printer, 2, 0, 0, &NeedSz);
Pdata = (PRINTER_INFO_2*)new char[NeedSz];
PdatSz = NeedSz;
// Get printer context
if (GetPrinter(Printer, 2, (unsigned char*)Pdata,
PdatSz, &NeedSz)) {
// Set printer mode and job name
Pdata->pDevMode->dmOrientation =
DMORIENT_LANDSCAPE;
Pdata->pDevMode->dmPaperSize = DMPAPER_LETTER;
SetPrinter(Printer, 2, (unsigned char*)Pdata,
0);
DocInfo.cbSize = sizeof(DocInfo);
DocInfo.lpszDocName = ReptId.c_str();
// Get GDI Device Context and begin job
PrintDC = CreateDC(Pdata->pDriverName,
PrintNm.c_str(), 0, 0);
StartDoc(PrintDC, &DocInfo);
}
}
The application then iterates through the saved Index, much the same way the
client did. For each record retrieved by its sorted index, the data is printed in a
table row, formatted as per the client’s requirements:
// Select GDI pen & font
SelectObject(PrintDC, ThinPen);
SelectObject(PrintDC, Arial);
// Get font height & establish rectangle to print in
GetTextExtentPoint32(PrintDC, " ", 1, &Size);
Rect1.left = Bounds.left;
Rect1.top = Rect1.bottom;
Rect1.bottom = Rect1.top + (long)(Size.cy * 1.5);
// Draw table rows
for (i=0; i<Rows; i++) {
// Get record index by sort order & column
if (Ascend) IdxNum = Index[i][Sort];
else IdxNum = Index[Rows - i - 1][Sort];
// Draw table columns
for (n=0; n<Cols; n++) {
// Establish justification
switch (Fields[n].Just) {
case 'L':
Format = " " + Records[IdxNum][n];
Position = DT_LEFT | DT_VCENTER |
DT_SINGLELINE;
break;
case 'C':
Format = Records[IdxNum][n];
-89-
DT_SINGLELINE;
Position = DT_CENTER | DT_VCENTER |
break;
case 'R':
Format = Records[IdxNum][n] + " ";
Position = DT_RIGHT | DT_VCENTER |
DT_SINGLELINE;
}
// Adjust right edge of bounding rectangle
Rect1.right = Rect1.left + ((Bounds.right Bounds.left) * Fields[n].Size / 100);
// Draw formatted text and bounding rectangle
DrawText(PrintDC, Format.c_str(),
Format.length(), &Rect1, Position);
Rectangle(PrintDC, Rect1.left, Rect1.top,
Rect1.right, Rect1.bottom);
}
}
// Set left edge of rectangle for next field
Rect1.left = Rect1.right;
// Prep bounding rectangle for next row
Rect1.left = Bounds.left;
Rect1.top = Rect1.bottom;
Rect1.bottom = Rect1.top + (long)(Size.cy * 1.5);
This method of printing gives the application complete control of the printed
output, including scaling, page breaks, and footer information like page
numbering. This is a significant advantage over printing from the client, where the
web browser controls these parameters.
This solution exemplifies how the power of CODE:NEO can be applied to real
world scenarios, and provides unprecedented functionality in an HTTP
client/server environment. The server application, written in C++, retrieves and
indexes the data many times faster than any other technology could, and
CODE:NEO API calls make it easy and convenient for the developer to embed
the data in the server response. All together, this solution makes a seamless
interface for the user to retrieve data from it’s source, visually sort it, and print a
hard copy as if sitting at the server in person using a stand alone application.
-90-
Vendor Sales Lookup System
The vendor sales lookup system implements a very elegant group by system by
which we have combined the ability to choose three different levels of grouping
which are supported by all criteria.
The following example code demonstrates how simple complex tasks can be
accomplished using CODE:NEO and C++.
Notice our use of the CnString CODE:NEO string template used to simplify the
complex usage of strings in CODE:NEO. Being able to use CnString allow rapid
development of string manipulation.
while (ByClerk || ByStore || ByPrice || ByProd) {
// Build query string
Select = "SELECT COUNT(*), T.VID, V.VENDOR, P.PRONAME";
Group = " GROUP BY T.VID";
Order = " ORDER BY T.VID";
if (ByClerk) {
Select += ", T.TCLERK, E.FIRST, E.LAST";
Group += ", T.TCLERK";
Order += ", T.TCLERK";
}
if (ByClerk || ByStore) {
Select += ", T.SID";
Group += ", T.SID";
Order += ", T.SID";
}
else if (ByPrice) {
Group += ", M.PPRICE1";
Order += ", M.PPRICE1 DESC";
}
Group += ", P.PRONAME";
Order += ", P.PRONAME";
if (ColorDetail) {
Select += ", M.COLOR";
Group += ", M.COLOR";
Order += ", M.COLOR";
}
if (SizeDetail) {
Select += ", M.SIZE";
Group += ", M.SIZE";
Order += ", M.SIZE";
}
if (BaseDetail) {
Select += ", M.BCURVE";
Group += ", M.BCURVE";
Order += ", M.BCURVE";
}
if (PowerDetail) {
Select += ", M.PWR";
Group += ", M.PWR";
Order += ", M.PWR";
-91-
}
if (PriceDetail || (ByPrice && !ByClerk && !ByStore))
Select += ", M.PPRICE1";
From = " FROM TREAT AS T LEFT OUTER JOIN VENDORS AS V ON
T.VID = V.VENDORID";
From += " LEFT OUTER JOIN MPRODUCT AS M ON T.TCODENUM =
M.CODENUM";
From += " LEFT OUTER JOIN PRODNAME AS P ON T.TCODENUM =
P.CODENUM";
if (ByClerk) From += " LEFT OUTER JOIN EMPLOYEE AS E ON
T.TCLERK = E.NUM";
Where = " WHERE T.TCAT ";
if (CatFilter == "") Where += "IN (\"F\", \"L\", \"C\",
\"M\", \"U\", \"S\", \"P\")";
else Where += formatStr("= \"%s\"", CatFilter.c_str());
if (VidFilter == "") Where += " AND T.VID != \" \"";
else Where += formatStr(" AND T.VID IN ( %s )",
VidFilter.c_str());
if (Pdesc != "" && Pdesc != " Partial Matches OK")
Where += formatStr(" AND P.PRONAME LIKE \"%%%s%%\"",
Pdesc.c_str());
if (SidFilter != "000") Where += formatStr(" AND T.SID =
\"%s\"", SidFilter.c_str());
if (FrPrice != "") Where += formatStr(" AND M.PPRICE1 >= %s",
FrPrice.c_str());
if (ToPrice != "") Where += formatStr(" AND M.PPRICE1 <= %s",
ToPrice.c_str());
Where += formatStr(" AND T.TDATE >= { d '%s' } AND T.TDATE <=
{ d '%s' }",
FrDate.c_str(), ToDate.c_str());
SqlStr = Select + From + Where + Group + Order;
...
// Run query
...
}
-92-
•
•
•
Vendor sales report grouped by clerkid with date range,
Vendor description like clause and vendor drop down(like recall report)
storeid selection with all stores option(again like recall report).
-93-
•
•
•
Excludes credits and refunds and voids.
Browser screen output is used for printing and look like the following.
Sort products by high quantity
Category Selection Criteria Drop Down
This option will allow users to select which product category will be processed by
the report. The categories are Lens, Misc, Frames, Contact and all categories.
Add Price Range Criteria
The user will be able to supply the price range for which the report selects. It will
consist of two number fields, which specify a value greater than, less than and
equal to.
Add Group By Price Option
This should group the results of the report by prices just like the other three
current group criteria store, clerk and product.
Enhance the Vendor Selection Criteria
To benefit running reports this feature allows the user to select multiple vendors.
This is accomplished by presenting a list box with the vendors in it, which allows
‘ctrl’, and ‘shift’ multi select.
Frame Description Synchronization
Because Optical Outlet imports the frame descriptions on a regular basis,
maintaining the description table is problematic. Product table updating was
initially discussed but mistakenly answered wrongly.
Checkboxes for each;
Group By Clerk _X_
Group By Store _X_
Group By Product _X_
Summarize
X
X
X
X
Detail
O
O
O
O
Color
Size
BaseC
Power
if the user selects to detail any of these then those columns appear in the group by
lists
---------------------------------------------------------
-94-
VENDOR: VISTACON
TOTAL: 50
CLERK: 111
STORE
1
2
DESC
Acuvue2
Acuvue2
Color? Size?
B
1
R
2
TOTAL
QTY
6
6
12
CLERK: 112
STORE
1
2
DESC
Acuvue2
Acuvue2
Color? Size?
B
1
R
2
TOTAL
QTY
6
6
12
CLERK: 113
STORE
1
2
DESC
Acuvue2
Acuvue2
Color? Size?
B
1
R
2
TOTAL
QTY
6
6
12
TOTAL
QTY
2
5
7
TOTAL
QTY
2
5
7
STORE: 1
DESC
COLOR
Acuvue2 B
Acuvue B
STORE: 2
DESC
COLOR
Acuvue2 B
Acuvue B
Product:
Acuvue2
Acuvue
SIZE
1
1
SIZE
1
1
Color? Size?
Qty:
xx
xx
--------------------------------------------------------VENDOR: Boesch & L
TOTAL: xx
CLERK: 111
STORE
1
2
DESC
OPTIMA FW
OPTIMA 38
STORE: 2
DESC
OPTIMA
OPTIMAFW
Product:
Optima
OptimaFW
COLOR
B
B
Color? Size?
B
1
R
2
TOTAL
QTY
6
6
12
SIZE
1
1
QTY
2
5
Color? Size?
Qty:
xx
xx
-95-
Best Secuirty Industries Contact System
Best Secuirties receives numerous contact submission on the website due to the success
of their marketing program. To maintain this and manage those contacts, they wanted an
online database management system to handle these contacts.
They also knew that this contact management system could be most effectily used by
exporting the data to a CSV format for use with the marketing campaign.
Features
- Login Security –
single password
- Delete Entry
- Edit Entry
- Add Entry
- View results
o Sorting
columns by
ascending or
descending
order
o Column
names
included in
columns
- Output CSV with
provided link
o Include CSV
header row
- Auto response and
admin response
o Admin email
contains
submission
information
o Personalized
auto
response
- Capture date upon
form submission
-96-
-97-
EMPSTAT Online Processing Application
Online background check application.
-98-
Pensacola Realestate Premeir Listing System
-99-
Management & Advisory team
Vincent Risalvato, CTO, Acting CEO
Mr. Risalvato has a strong background in software development and Internet technologies
and is the creator of CODE:NEO. Vincent Risalvato is acting CEO and Executive
Vice President of the Company as well as Chief Technology Officer.
While CIO at Digital Chainsaw he brought their RND Internet hosting
environment into full production complete with automation and creating a Web
development team. DigitalChainsaw was subsequently sold to a Paul Allen,
Vulcan Ventures company.
While at Price Waterhouse he created a redirection server that integrated their
corporate and subsidiary worldwide Internet web servers and sites in over 50
countries in a seamless and instantaneous manner for their merger with Coopers
and Lybrand, July 1st 1998 at GMT 0.
Mr. Risalvato's technical expertise was utilized at Vision Twenty-One by building
an enterprise health care claims processing center prior to their IPO. Mr. Risalvato
has a strong background in software development and Internet technologies and is
the inventor of CODE:NEO.
He also was co-founder of NetConnect on of the first Intra Tampa Bay internet service
providers in the Tampa/Florida area, 1995-1996.
Joel E. Rodgers, CFO.
Mr. Rodgers served as Vice President and General Manager of Engineered
Solvents Systems of Allied Signal and previously was the President of Baron
Blakeslee Inc, a $75 MM solvent distribution business.
Scott Adams - Advisor
The information superhighway intrigues many of us, however, few people have
traveled that road as successfully as Cenetec Ventures President and Chief
Strategist, Scott H. Adams, an Internet industry icon. In 1995, Mr. Adams
founded Hiway Technologies, Inc., and in three short years, as its President and
-100-
CEO, he built Boca Raton-based Hiway into the world's largest web hosting
company with 240 employees and 150,000 accounts in 135 countries. Adams is a
participant in the birth of the Internet Coast, whose goal is to unite South Florida's
high-tech companies and organizations for recognition as a worldwide Internet
industry hub. A firm believer in the promotion of education, Adams launched the
Internet Institute at Florida Atlantic University's College of Business which is an
initiative aimed at spurring the growth of South Florida's Internet-based
industries. Due to his remarkable achievements, the Greater Boca Raton Chamber
of Commerce named Mr. Adams their 1997 Small Business Person of the Year
and in 1998 Mr. Adams won the prestigious Ernst & Young Florida Entrepreneur
of the Year Award.
Richard Ford, Ph.D., - Advisor
Cenetec Ventures's Chief Technology Officer Dr. Richard Ford is one of the
nation's top Internet architecture experts and an internationally acknowledged
computer security expert. Ford has lectured worldwide on the subject of computer
security, and holds editorial positions for several virus and security related
journals. He holds one patent and is widely published in the areas of both
computer security and physics. Dr. Ford has served as Director of Research for
the National Computer Security Association. He also spent a year at IBM
Research's prestigious T.J. Watson Research Center, working in the Massively
Distributed Systems group. Before being appointed Chief Technology Officer for
Cenetec Ventures, Dr. Ford was the Director of Technology at Verio in Boca
Raton. There he served as senior architect for the world's largest web hosting
platform and was also responsible for the security of more than 200,000 web sites.
Bruce M. Rodgers, Corporate Attorney
Mr. Rodgers is corporate attorney practicing with Foley & Lardner. He represents
a wide variety of developing companies primarily in technology-based industries.
-101-
Conclusions
CODE:NEO solves many of the problems faced by companies who have a large
investment in the C/C++ programming languages. By offering a robust and costeffective C/C++ platform for web-enabled applications, CODE:NEO addresses
many of the key constraints in developing a successful web-enablement strategy.
Not only does CODE:NEO facilitate the use of C/C++ on the web, but also
security (though source code protection), interoperability (through the widespread
availability of C/C++ libraries), speed and memory footprint are all improved
dramatically. Thus, CODE:NEO has much to offer any company developing webenabled applications.
CODE:NEO is available for evaluation online at www.rivar.com. During your
evaluation period feel free to call us at 727-461-4555 during business hours. Or
via email at [email protected] any time. Customers may choose to obtain 24x7
voice support with their purchase.
CODE:NEO is available for evaluation online at www.rivar.com. During your
evaluation period feel free to call us at 727-461-4555 during business hours.
Or via email at [email protected] any time. Customers may choose to obtain
24x7 voice support with their purchase.
Contact Information
RIVAR Technologies, Inc.
Telephone (727) 461-4555
Technology and Services - [email protected]
Careers - [email protected]
Investor Relations - [email protected]
-102-
-103-