No announcement yet.

Comprehensive PB Web Development Platform (Free!)

  • Filter
  • Time
  • Show
Clear All
new posts

  • Comprehensive PB Web Development Platform (Free!)

    The Cnawlece Platform v3.00 is one tight package that includes a Web Server, Database Management System, Queries, Templates, and E-Commerce.

    The platform can be freely distributed, and includes lots of free open source modles that you can use as a good starting point.

    Read more here:

    This platform is currently in use by our own customers and we are looking to do a very soft release of it so that our growth does not get the best of us. If you are interested in using this platform, please contact us for a private assessment and introduction.

    Although we will have a more public release of this platform in the future, that will be geared more for non-PB programmers.
    Last edited by Colin Schmidt; 22 Aug 2009, 05:37 PM. Reason: Added note about it beging free

  • #2
    More info...

    The Cnawlece Platform has the following components:
    • Server (runs as a service)
    • Database Object
    • Query Objects
    • Request Objects
    • Template Objects
    • Template Tools
    • eCommerce Objects
    • Custom Objects, designed as independent Modules
    The Server is responsible for the Windows Service, the basic web server functions, and to tie everything together. Each connection to the web server runs in it's own thread.

    A single Database Object is created and loaded by the Server when the service is first started. This object is then passed around to other objects whenever database access is needed. The Database Object is responsible for managing the raw data. It is of course thread safe, and is highly optimized for the variable length string data that is most commonly needed in web based systems.

    Query Objects are dynamically created and destroyed as needed. You can have as many of them existing at one time as you require. Their current states can also easily be copied, moved, and serialized. Capable of a wide variety of data manipulation tasks, they are very powerful and more elegant than SQL once the complexity of the task increases.

    Request Objects contain easy access to all of the information the web server received from the client. All of the parameters passed on the URL are already parsed out for you and readily accessible. You can easily access the data provided to you with an HTTP POST, and simply have this object parse that out for you into parameters as well. By creating your own Request Objects, you can populate data to be used in dynamically created web forms using the Template Tools.

    Template Objects are used to load a set of template files and then populate their insertion points. The syntax used makes it easy to create your own custom elegant templates. It is also flexible enough to work with most third party templates, such as Joomla templates without any hassle. The Template Object makes it easy to build your output and keep a consistent look across your system, and even a consistent look between your main website in another CMS and your Cnawlece Platform data system. Your system can make use of as many different templates as need be.

    Template Tools are a set of flat functions that help you build your output. With CSS names that match those used by Joomla and Mambo you will find it easy to build pages with good looking headers, tables, and forms. With items such as the easy to use Query to Table function, and the dynamic form creation functions, this package provides you with simple and fast design-to-build throughput.

    The eCommerce Objects are created for you by request of the server, and then fully managed throughout their life span. All you have to do is provide the transaction details, and then monitor for the results.

    The Custom Object, along with your own collection of independent Module classes is what makes your system uniquely yours. With the provided open source MemTab, Private, GMaps, and Admin modules, you are well on your way to completing your first online application.


    • #3
      Example of a Simple Database Driven Web Form

      METHOD ExampleForm(poTmpl AS iTemplate, poReq AS iRequest, poDB AS iDatabase, psItem AS STRING)
          LOCAL lsErr, lsForm AS STRING
          LOCAL loR AS iRequest
          LOCAL loQ AS iQuery
          REM Init
              mNewQ(loQ) : mIsNot2poTmplGTForm(loQ)
              mNewR(loR) : mIsNot2poTmplGTForm(loR)
          REM Update
              IF poReq.Mode = "GET" THEN GOTO ShowForm:
              IF LCASE$(psItem) = "new" THEN
                  loQ.NewFields("Example.", "Alias Name Reference Street City Province Postal Country Notes")
                  loQ.f("Example.Alias") = "*"
                  loQ.LoadRecord(poDB, "Example", psItem)                                       : mQErr2poTmplExit("Loading Record for Update")
              END IF
              loQ.f("Example.Name")          =              poReq.Param("Name")
              loQ.f("Example.Reference")     =              poReq.Param("Reference")
              loQ.f("Example.Street")        =              poReq.Param("Street")
              loQ.f("Example.City")          =              poReq.Param("City")
              loQ.f("Example.Province")      =              poReq.Param("Province")
              loQ.f("Example.Postal")        =              poReq.Param("Postal")
              loQ.f("Example.Country")       =              poReq.Param("Country")
              loQ.f("Example.Notes")         =              poReq.Param("Notes")
              IF LCASE$(psItem) = "new" THEN
                  loQ.New(poDB, "Example.Alias",    "")                                          : mQErr2poTmplGTForm("New Example")
                  psItem = loQ.f("Example.Alias")
                  loQ.Update(poDB, "Example.Alias", "")                                          : mQErr2poTmplGTForm("Update")
              END IF
              REM Load or Create our record
                  IF LCASE$(psItem) = "new" THEN
                      loR.ParamCreate("Alias")        = "New"
                      loQ.LoadRecord(poDB, "Example", psItem)                                   : mQErr2poTmplExit("Loading Record")
                  END IF
                  loR.ParamCreate("Alias")        =               loQ.f("Example.Alias")
                  loR.ParamCreate("Name")         =               loQ.f("Example.Name")
                  loR.ParamCreate("Reference")    =               loQ.f("Example.Reference")
                  loR.ParamCreate("Street")       =               loQ.f("Example.Street")
                  loR.ParamCreate("City")         =               loQ.f("Example.City")
                  loR.ParamCreate("Province")     =               loQ.f("Example.Province")
                  loR.ParamCreate("Postal")       =               loQ.f("Example.Postal")
                  loR.ParamCreate("Country")      =               loQ.f("Example.Country")
                  loR.ParamCreate("Notes")        =               loQ.f("Example.Notes")
              REM Build the Form
                  ttFromInit          lsForm
                      ttFormAdd3Head1 lsForm, "Example Details"
                      ttFormAdd3Col   lsForm, "READONLY",     "Alias",            "", "Alias:",               ""
                      ttFormAdd3Col   lsForm, "TEXT",         "Name",             "", "Name:",                "first last"
                      ttFormAdd3Col   lsForm, "TEXT",         "Reference",        "", "Reference Number:",    "from other file"
                      ttFormAdd3Col   lsForm, "TEXT",         "Street",           "", "Street:",              ""
                      ttFormAdd3Col   lsForm, "TEXT",         "City",             "", "City:",                ""
                      ttFormAdd3Col   lsForm, "SELECT",       "Province",         "", "Province:",            "", "", "BC|AB|SK|MA|ON|QC"
                      ttFormAdd3Col   lsForm, "TEXT",         "Postal",           "", "Postal:",              ""
                      ttFormAdd3Col   lsForm, "SELECT",       "Country",          "", "Country:",             "", "", "Canada|USA"
                      ttFormAdd3Col   lsForm, "TEXTAREA",     "Notes",            "", "Notes:",               "Private Notes to Remember"
                  ttFormEnd           lsForm, "/Example/" + psItem, "Save"
                  lsErr = ttForm(loR, lsForm, lsForm)
                  mlsErr2poTmpl("Error creating form")
                  poTmpl.Module("MainBody",  %TMReplace) = lsForm
                  poTmpl.Module("MainTitle", %TMReplace) = "Example Form"


      • #4
        Key points worth your time to read:

        Key points worth your time to read:

        - Why waste time trying to bridge a web server, a database server, a query language, and an ecommerce gateway with your own code when you can get all of this as a single tightly integrated package?

        - The database works exclusively with variable length string data which is of course ideal for web systems. (Why would anyone convert integers to strings over and over and over again every time a page is requested?)

        - The database speed is second to none. It's primary advantage is that it can do lighting fast binary searches, inserts, updates, deletions, attachments, and detachments on variable length string data without the use of any indexes or wasted memory/disk space. The inner core of the database is 100% hand coded assembler. The design of the data layout in RAM is optimized for modern CPUs and Intel assembler for the tasks at hand.

        - The database is optimized for case-insensitive global keywords searching without the need for indexes. Give your users the simple one-box-one-button search power they expect from the internet.

        - The database file format greatly reduces the risks of data corruption. If data corruption should happen somehow, it is all stored in human readable text. The lack of indexes entirely removes the possibility of the most common form of database corruption.

        - Without all those otherwise necessary indexes, this database keeps things small and fast: A membership organization with 45,000 people in their system with six years of memberships, extras, and financial information amounts to 1 million records that take up less than 100MB on disk or in RAM. Hourly backups become fast and cheap.

        - The query system gives you a powerful and optimized toolbox of data manipulation methods. No more loop code, as all of the logic is applied to the dataset as a whole.

        - With the use of database callbacks, your data management logic remains separate from your user interface.

        - You focus on the design and the architecture of your system, while 10+ years of DB design research does the grunt work for you.

        - If you need to do something really bizarre and different, Cnawlece will not stop you. For extreme cases you can request direct memory access to a data set. User defined query functions and a thread management system let you take the wheel if it ever becomes necessary.

        - The template system, and the provided default template, make it overly easy to create attractive systems that can be fully customized via simple well structured CSS.

        - The average total CPU time used on a single processor core to compose a complex dynamically generated, database driven, web page on a production system with over 1 million records is: 0.016 seconds.

        - Because the entire system from the ground up uses dynamic length strings, the possibility of a buffer overrun attack are greatly reduced.

        - Because the system uses binary query objects to manipulate the data instead of parsing SQL, SQL injection attacks and their would be equivalents are not possible.

        - Managed session control with HTTPS and no cookies makes it easy to secure your system with the least possible attack surface.

        - If your Windows Desktop business clientele are not already demanding a web interface to their systems, whether it is exclusively web based or a mix of Windows Desktop in the office and Web for the outside world, they will probably want it from you sooner than you can build it. Get started today.

        - Did I mention that it is free and comes with lots (say 20,000 lines worth) of open source example code that is already proven in large production systems? In case the 20,000 lines idea scared you, a skeleton system starts at only 30 lines and an entire Google Maps database module is less than 1,000 lines. One of the open source modules is a very nice database admin system.

        Thank you for your time, I trust that it was worth it!

        If you see Cnawlece fitting into your current or future projects, contact me today for a personal introduction and demonstration. Full professional support is available to help you get started.


        • #5
          Originally posted by Colin Schmidt View Post
          If you see Cnawlece fitting into your current or future projects, contact me today for a personal introduction and demonstration. Full professional support is available to help you get started.
          Hi Colin, I am interested in having a look at your system. sslater1 (at) summitcn (dot) com
          Scott Slater
          Summit Computer Networks, Inc.