The KISS Framework is an application development framework for developing web-based business applications, portable desktop applications, and command-line utilities. The main home for Kiss is https://github.com/blakemcbride/Kiss
Kiss’ focus is on simplicity and development speed. By being simple to develop in, the development and support of the application can occur more rapidly. Simplicity is achieved by abstracting away as much common functionality as possible so that developer lines of code are maximally applicable to the application solution rather than infrastructure and support of the framework. Throughout the framework, business-normal defaults have been employed in order to minimize commonly needed functionality.
Another goal of the Kiss framework is to be a complete web-based application development solution. Kiss isn’t a browser solution alone, nor is it a back-end solution. Kiss includes solutions for both ends – although the two sides may largely be used independently.
Kiss attempts to create a consistent interface. This can greatly simplify code even in simple cases. For example, in terms of an input text control, why would you disable/enable it with:
$('#id').prop('disable', false); $('#id').prop('disable', true);
and then hide/show it with:
$('#id').hide(); $('#id').show();
Kiss provides a consistent interface. With Kiss, you would do:
$$('id').disable(); $$('id').enable(); $$('id').hide(); $$('id').show();
Kiss is designed to be simple to get started with, simple to learn, and simple to use. Kiss does this while supporting important technologies such as micro-services, front-end components, and SQL.
The term single page application has several, subtly different meanings. One meaning is that the entire application code is bundled into a single file or HTTP GET request. In that sense, Kiss is not a single page application. This makes no sense for a business application that could have hundreds of screens.
Another meaning of the term single page application is that there is
only a single html
tag and all of the remaining pages are
modifications of the original html
tag contents. In this
sense, Kiss is a single page application. Kiss
applications lazy-load as needed. Browser cache is leveraged to
minimize Internet traffic.
Kiss is used in a production environment and built by someone with more than 30 years of experience as a framework designer and a business application software engineer. So Kiss is not a proof of concept.
Kiss was built as a solution to the challenges faced by the author when developing web-based business applications. As such, Kiss is more a solution for business application development than for the development of public facing company presentation web sites.
Another goal of Kiss is to keep the front-end and back-end as independent of each other as possible. To this end, communications between the front-end and back-end occur via REST services and JSON. This accomplishes two things. First, it allows your organization to be best prepared for the ever-evolving software environment. Pieces can be changed and enhanced without causing massive rewrites of the entire system. The second advantage is that by pushing as much processing to the front-end as possible (rendering the display on the front-end), the system can better scale.
Kiss comes as a very basic running application. Since the front-end and back-end can be changed while the system is running, it is intended that a developer would start with this basic application and build it into the desired application.
The basic application the system comes with does not represent the kind of application that can be built with Kiss. It is intentionally kept basic so that it is easy to see how it works. In a real application, all of the possibilities made available with HTML and CSS are at your disposal without limitation. In other words, the only limitations to the sophistication of the application are your imagination and the amount of work you’re willing to put into it.
Kiss comes with a complete front-end framework that includes most of the things needed for a modern business web application. In fact, it is currently being used as the sole framework in some very large production systems. It works well. However, there is nothing in Kiss that prevents you from using other front-end frameworks such as React, Angular, Vue, etc. In fact, except for dealing with web services and authentication, you could exclusively use your preferred front-end framework.
The Kiss back-end is a complete back-end. It is currently being used by large web applications involving many hundreds of screens and SQL tables and thousands of users. The Kiss back-end contains many built-in features to efficiently handle many, many simultaneous users. Like the front-end, the Kiss back-end is designed to be as simple as possible to build production-quality web applications. For example, a web service can be built with a single source file containing just a handful of lines of code. Everything in Kiss is designed to be simple to understand, simple to use, and yet be fully compiled and run at top speed.
Some highlights of the Kiss system include:
The following example depicts a complete back-end web service. The path to the file is its URL. The class name is the web method name.
The file is a text file, but compiled code gets executed.
Authentication occurs before main
is called.
Simply drop the file in place and the web service and method become immediately available on a running system. Changes to the service take effect immediately (no need to reboot the server app). There are no configuration files or other code that needs to be changed.
For example, the following file is located in the
services
directory.
class MyWebService { void myWebMethod(JSONObject injson, JSONObject outjson) { int num1 = injson.getInt("num1"); int num2 = injson.getInt("num2"); outjson.put("result", num1 + num2); } }
The following front-end example utilizes the web service defined in the previous sub-section.
let data = { num1: 22, num2: 11 }; let res = await Server.call("services/MyWebService", "myWebMethod", data); if (res._Success) { let result = res.result; //... }
The following development platforms are supported by the Kiss framework:
The following production platforms are supported by the Kiss framework:
The following database servers are supported by the Kiss framework:
The system is tested with Java versions 8, 11, 17, and 21. Any Java version above 8 is expected to work.
To use a component, add to HTML:
<my-component></my-component>
Add to JavaScript:
Utils.useComponent('MyComponent');
The component can put any HTML in the component location, have any functionality, have its own modal windows, and use other components. The component can have custom and non-custom attributes (like style). Non-custom attributes do what you’d expect them to do.
The system also supports tag-less components. This provides an easy way to package arbitrary blocks of code (that can have screens too).
The Kiss system has been used in production environments for several years. Additionally, several commercial applications utilize Kiss. In spite of this, however, Kiss is constantly being adjusted in response to additional needs, evolving environments, and bug fixes.
We use Kiss daily in a Linux and PostgreSQL environment. Therefore, it is best tested there. While we support all of the listed environments, they receive a bit less testing. If you encounter a problem, please reach out to us. It is probably easy for us to fix, and we are happy to do so.
Source code for all of Kiss and its dependencies is freely
available. The builder program located at
src/main/core/org/kissweb/builder/Tasks.java
contains the paths
to all of the external dependencies (those not included in the
Kiss distribution). The following lists the paths to the
internal dependencies (those included with Kiss):
abcl.jar
json.jar
SimpleWebServer.jar (only used during development)
The Kiss main website is at https://kissweb.org
Source code is at https://github.com/blakemcbride/Kiss
Public discussion and support are available at
https://github.com/blakemcbride/Kiss/discussions
Issue tracking is at https://github.com/blakemcbride/Kiss/issues
Commercial support is available. Contact us via email at blake@mcbridemail.com
Copyright (c) 2018 Blake McBride (blake@mcbridemail.com)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The Kiss design, code, documentation, and web site were written by Blake McBride. The author gratefully acknowledges and appreciates, among others, the following:
Apache Groovy located at https://groovy-lang.org
Dynamic Loader located at https://github.com/dvare/dynamic-loader
JSON-Java located at https://github.com/stleary/JSON-java (although I am using a modified version available at https://github.com/blakemcbride/JSON-java)
C3P0 located at https://www.mchange.com/projects/c3p0
Texinfo located at https://www.gnu.org/software/texinfo/
ABCL project located at https://common-lisp.net/project/armedbear
Melaine Sarbey (melswildart@gmail.com) for creating the Kiss logo.
The SQLite interface does not work on OpenIndiana due to reasons unrelated to OpenIndiana. However, Kiss works fine with the other supported databases on OpenIndiana. Also, the demo that Kiss comes with will not run completely on OpenIndiana because it depends on SQLite. Once another database is configured, all is well.
The SQLite interface does not work on Haiku due to reasons unrelated to Haiku. However, Kiss works fine with the other supported databases on Haiku. Also, the demo that Kiss comes with will not run completely on Haiku because it depends on SQLite. Once another database is configured, all is well.