C++ Server Pages
C++ Server Pages (CSP) is a Web Engine for advanced Web Application Development, that uses blended Markup Language / C++ scripts ( such as HTML/C++, XML/C++, WML/C++ etc.)
Similar to ASP and JSP, it provides a great easiness in creating web pages with dynamic content, as well as complex business applications.
However, instead of Java, Javascript or VBscript, it uses C++.
- Incredibly high processing efficiency. Benchmarks have shown a range of 80 to 250 times higher processing speed than ASP.
- The use of pure C++ allows the use of tons of libraries that are currently available. It is important to notice that the libraries written in C++ are tens or hundreds of times more than in any other language.
- It is widely accepted that the most skilled programmers in the IT market are the C++ ones. However, CGI, ISAPI and other frameworks where C++ applies, do not provide the web developer with facilities for efficient application development. As a result, until now, Web Development could not take advantage of the best programmers.
- The processing efficiency of CSP allows the use of affordable systems even for complex Web Applications with heavy algorithms.
- The ability of making direct system calls, allows the development of advanced web applications that are impossible with ASP and JSP. For example, it is possible for a CSP page to use multiple threads and do blocking tasks (credit card check, database queries etc.) simultaneously and hence faster, whereas such an accomplishment is only a dream for other technologies.
Achievements and Characteristics:
- The CSP engine for MS IIS and Apache for Windows is based on ISAPI Extension technology and Apache module API, which provide the CSP Engine with great efficiency through IIS's or Apache's thread pooling.
- An automatic pre-compiler has been developed that interprets the CSP blended code to pure C++. A great weight was given to the pre-compiler robustness so that it can assure error free C++ outputs.
- The compilation of the C++ outputs, currently, is carried out by Microsoft C++ Compiler, by Borland C++ Compiler or by GNU C++ Compiler. This fact, in combination with the pre-compiler robustness, can assure the quality of the final executable modules (.dll outputs).
- The pre-compilation and compilation take place automatically with error information, when a change on the CSP files occurs. In contrary to ISAPI and CGI applications, there is no waste of time for manual compilation of the CSP code, substantially increasing the speed of development and deployment.
- The fact that in CSP the content of pages is produced from execution of a binary (.dll output) and not from interpretation of a script, as in ASP, is the main reason for the incredibly higher processing speed of CSP (100+ times faster than ASP).
- The core of the engine supports configurable module pooling and sub-engine pooling. These features provide less per request overhead, smart use of system resources, and high robustness.
- Intrinsic Objects (Response, Request, Session etc) have been developed in order to provide the basic functionality that a dynamic content Web Page needs. The design of the objects is as compatible as possible with the ASP objects, so that existing ASP developers will be familiar and existing ASP applications can be easily migrated to CSP. Also, the prototyping of these objects has a cross platform design.
- Besides the intrinsic objects, the CSP framework provides many other highly optimized classes, such as high performance string class, thread class, thread safe object pool class, transaction classes, e-mail class, content template class and more.
- The CSP Framework has been designed in such a way so that the developer can build applications without using pointers at all, making the code clearer and eliminating pointer related bugs.
- The CSP engine is designed with multiple levels of Exception Handling. This is a very important feature that increases the robustness of the CSP engine and the Web Server, since unhandled exceptions may cause the web server to malfunction.
- The CSP engine can run under COM+ or MTS. This provides the ability of working in a transactional environment, increasing the ability of creating large scale and robust business applications. Also, a couple of easy to use classes help the developer in using transactional objects or designing transactional classes by just inheriting.
- Regarding the rules of the code blending, the syntax of the HTML/C++ code, is identical to the ASP's HTML/JScript or HTML/VBScript scripting.
- An important limitation of the syntax above is eliminated, by the introduction of a "global scope section". Within this section, the developer, can include files, define additional functions, classes, and global variables, or insert compiler and linker directives as well, using pure C++ code (and not any other weird and unfamiliar syntax). Additionally, since the .dll modules are pooled, "start-up" and "clean-up" sections are introduced so that specific tasks can be performed when a module is loaded and unloaded.
- CSP gives you the ability of separating HTML from C++ code, by using content template files and a special Template classe. This feature provides a) the ability of maintaining very long scripts, which could be very confusing when HTML, client side javascript and server side C++ is blended, and b) the ability of creating automated content by other tools (for example visual development tools).
- The CSP Engine comes with a Management Console which provides easy configuration of the engine and supports optimization choices.
- A new performance feature is supported by CSP. Existing CSP pages can automatically be converted to static pages. This feature reduces the use of resources and increases the performance. This feature is very useful for pages like "Tickers" and "Catalogues" that are heavily used but rarely updated, reducing the database workload.
- After exhaustive performance tests of many millions of HTTP requests, the engine has proven absolute stability.
» C++ Server Pages Web Site (@ SourceForge with free download links)
Comments