The KISS Framework is an application development framework for developing web-based business applications. 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, 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 simply 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 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 accomplished 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 re-writes 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.
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; //... }
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’s 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).
Largely, the Kiss system, in the form of running applications, has been used in production environments for a few years. The effort to tease away the generic parts and generalize them is recent (2018). Moving forward, as time permits, the priorities are as follows:
Source code for all of Kiss and its dependencies is freely
available. The builder program located at
builder/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
Although Kiss supports the Oracle DBMS out-of-the-box, the Kiss build system does not automatically load the Oracle JDBC JAR files. This is because Oracle JDBC is not downloadable without a login, password, and accepting their license – all of which must be done manually.
Once the Oracle JDBC libraries are manually installed, Kiss will support the Oracle database as-is.
The Kiss main web site is at http://kissweb.org
Source code is at https://github.com/blakemcbride/Kiss
Public discussion and support is available at
https://groups.google.com/forum/#!forum/kissweb
Issue tracking is at https://github.com/blakemcbride/Kiss/issues
Commercial support is available. Contact us via email at<EMAIL_ADDRESS>Copyright (c) 2018 Blake McBride<EMAIL_ADDRESS>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.

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 http://groovy-lang.org
ABCL project located at https://common-lisp.net/project/armedbear
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
Melaine Sarbey<EMAIL_ADDRESS>for creating the Kiss logo.
The Kiss system comes with its own build system, so it doesn’t use build systems such as ant, maven, or gradle. It works under Linux, Mac, Windows, etc. This included build system will make things such as downloading remote libraries, installing and configuring a web server, building Kiss, and running Kiss for development purposes easy, intelligent, and automatic. This new build system can be used in conjunction with your favorite IDE.
The build system (called it bld) is small and written in Java. Its source code is included with the Kiss source code. So, a Java compiler will be needed before anything will work. At this point, Java version 8 is primarily used. Java 11 has also been tested. Later Java versions should work as well.
When building the system for the first time, BLD will automatically download and cache required libraries (jar files), install and configure the development server (tomcat), build the system, and it can even be used to launch the development-mode server. After building the system the first time, application development proceeds without any need for re-compiles or re-builds.
The program that runs BLD is “bld” under Unix-like systems and “bld.cmd” under Windows. In this manual, “bld” will be shown as “./bld”. The “./” is required under Linux and Mac but not under Windows. When running on Windows, use “bld” rather than “./bld” and the same for all the other commands shown.
This is the simplest and shortest path to a running system. It assumes:
After doing a git clone
, all that is needed is the following:
./bld develop [Linux, Mac, BSD, etc.] -or- build-builder [Windows] bld develop [Windows]
This will build the system, install tomcat, deploy the app, and run the server. At this point you will be able to go your browser at the following URL:
http://localhost:8000
Be sure not to use port 8080. Although port 8080 will appear to work, you will not be able to do front-end development while the system is running. Port 8000 will allow front-end development while the system is running.
At this point, you can do all development without any build procedures. You can add or change anything on the front-end or back-end while the system is running.
All application back-end code is located under the src/main/application
directory.
All application front-end code is located under the src/main/webapp
directory.
If you change anything in either place, the system will notice the change and deliver it with the next request.
This is a more detailed and expanded description of the same super-quick-start.
The following enumerates the steps necessary to get the system up and running:
./bld develop
http://localhost:8000
You can also debug the back-end by
attaching to the process at port 9000.
Alternatively, your IDE can be configured to run the development process entirely through it.
Once the development server is running under bld, you can stop it by hitting any key.
As shipped, there are two different environments that Kiss may run in as follows:
The Production scenario is created with a single command
(./bld war
) and produces a single war
file (located in
the build.work
directory) that can be deployed to your production
environment.
Before doing anything with the Development environment, it is important that you have the JAVA_HOME environment variable set correctly to the root of your JDK (Java Developer Kit). Doing this varies according to the OS you are using and various other Java installation possibilities. There are plenty of instructions on the Internet for this.
The Development environment consists of two servers. One serves the back-end REST services, and the second serves the front-end HTML, CSS, and JavaScript files. By using this method, both front-end and back-end source files can be changed on a running system and take effect immediately without any builds, compiles, server reboots, re-deploys, or file copies. (This is also true of a production environment – with a single server – when the new files are put in place.)
Back-end REST services are debugged, and edited through the IDE. Saving a source file is all that is needed to have it take effect.
The front-end (HTML, CSS, and JavaScript files) are served by a simple server supplied with the Kiss system. See Front-end Development. (Source code to this server is available at https://github.com/blakemcbride/SimpleWebServer) Debugging the front-end is done through the browser debugger. There is no setup, and the front-end server runs by executing a single command.
You should download and install the following pre-requisites.
Correctly setting the JAVA_HOME environment variable to the root of your JDK is necessary. Setting this varies from OS to OS and also depends on where it gets installed. Instructions for setting this variable are all over the Internet.
The system was built and tested with JDK 8 and 11, PostgreSQL, IntelliJ, and tomcat. Other environments such as IIS, Glassfish, eclipse, should work fine but may require some configuration.
Kiss comes with its own build system. See Important
Install the above according to their instructions.
The Kiss reporting facilities are dependent on the full groff system and the ability to convert Postscript files to PDF files. This is generally true on Linux, however, the full groff package may need to be installed. Mac’s are fine. These packages are not on Windows and must be installed.
Correctly installing groff and ghostscript will allow the reporting facilities to work under Windows. They may be obtained from:
https://sourceforge.net/projects/ezwinports
Kiss is located at https://github.com/blakemcbride/Kiss
It can be downloaded via the following command:
git clone https://github.com/blakemcbride/Kiss.git
The Kiss documentation consists of three parts; this manual, the detailed back-end API documentation contained in the JavaDocs, and the detailed front-end API documentation. The JavaDocs do not come with the system, but you can generate them yourself with what is provided. See Creating JavaDocs.
This manual may be created in two forms. The first is in an HTML form. The system comes with this. You can also generate a nicely formatted PDF file with the following commands (if you have all of the formatting tools installed):
cd manual make Kiss.pdf
Updates to the HTML file are achieved with the following commands:
cd manual make
All of the documentation can be accessed with your browser. For
example, if the root of Kiss is located at
/my/home/path/kiss
then you will be able to access the three
manuals at the following URL’s:
file:///my/home/path/kiss/manual/man/index.html file:///my/home/path/kiss/build.work/javadoc/index.html file:///my/home/path/kiss/manual/jsdoc/index.html
The system is configured by the contents of a single file
src/main/application/KissInit.groovy
A reboot of the web server
is required if any of the parameters in this file are changed.
Given that Kiss is for business applications, it authenticates its users. In order for this to work, there is usually a database of valid users. This information is persisted in an SQL database. Therefore a database is normally required. However, for testing purposes, if no database is configured, the system will still run and allow any username and password to succeed.
As shipped, the system comes configured as follows:
| Database type | SQLite |
| Host | localhost |
| Database | DB.sqlite |
| Database user | [empty] |
| Database user password | [empty] |
Valid options for the Database type are as follows:
Support for other databases is easy to add.
setMaxWorkerThreads defines how many REST services may be processed in parallel. Service requests beyond this are placed in a FIFO queue and processed as worker threads become available. This capability drastically improves the system’s ability to handle a large number of simultaneous users.
The remaining parameters should be self-explanatory. Use the format shown in the example.
Although Kiss comes with a default demo database, another one
should be configured in live or more substantial development
environemnts. An SQL script file, named init.sql
, is included
with the system to initialize said database. Application specific tables
may be added to this database.
The default username is kiss, and the default password is password
Although the system may be built with the included build system (called bld) or your favorite IDE, the bld system should be used for the initial step which downloads the external dependencies (jar files).
The build system included with Kiss (called bld) has been tested on Linux, Mac, and Windows. The system also includes an Ant build file (named build.xml) that is only used for IDE integration with the included bld system.
The build system included with Kiss is written in Java and located under the builder directory. This build system also includes two driver batch files / shell scripts used to build and run the build system. All that is needed to use this system is a Java compiler. (As a side note - this build system is generic and can be used to build other types of projects.)
The build process is run from the command-line. No IDE is necessary. There is no specific IDE integration. None is needed because the system is rarely built. After the first build, application development is done without any build process.
The build system, which comes in source form, must be built before it can be used to build Kiss. Under Linux, Mac, BSD, etc., the build system gets built automatically. However, under Windows, the following command is needed once to build the build system:
build-builder [Windows]
Once the build system has been built, you can see what operations it can perform by typing:
./bld listTasks [Linux, Mac, BSD, etc.] -or- bld listTasks [Windows]
Those tasks that require prior tasks will evoke the dependent tasks automatically. The system is smart enough not to repeat tasks that are unneeded.
The main tasks that will be of interest to you are as follows:
libs
This task is only required if you intend to use your IDE to build the remainder of the system. It installs the required dependencies.
develop
This will cause the entire system to build (not repeating unnecessary
steps) and start up a tomcat instance to run the system in a
development mode. The system will be available from your local
browser at http://localhost:8000
. You may debug the
application by attaching to the running tomcat server at port
9000.
war
This will cause the system to generate the single file needed by a production system. It will end up in build.work/Kiss.war
Other tasks which may be useful are as follows:
clean
This task removes all files built but retains files that were downloaded from repositories (although bld caches those files anyway.)
realclean
This removes all built and downloaded files so the system should be everything you need to build it without any extraneous files
all
This performs all of the steps necessary to setup and build the system but doesn’t start up the tomcat server.
javadoc
This task creates the javadoc files that end up in build.work/javadoc
kisscmd
This task creates a command-line JAR that can be used in a non-web, command-line application.
This is useful when creating applications that perform various utility functions. This
JAR cannot be used in any web environment. See src/main/java/org/kissweb/Main.java
See Important and See Quick-Start Checklist.
Most IDE’s can be used to develop and debug the application. There are two way to do this as follows:
Using bld to build and run the development environment is the easiest to start off with but is somewhat klunky on an ongoing basis. Its main advantage is that it is portable and doesn’t require a lot of IDE configuration. The back-end development server is configured and started by bld by simply running ./bld develop After that, the IDE can be used to debug it by attaching to port 9000.
Using your IDE to run the entire process is a bit tedious to initially setup but makes the entire process simpler from that point forward. Unfortunately, configuring your IDE is completely different for each IDE. Instructions for setting up the Ultimate (commercial) version of IntelliJ and NetBeans are included as follows. Other IDE’s may be configured according to the instructions that are typically associated with the IDE.
Also, bear this in mind, the build process used by bld and that of the IDE are not the same. Use one or the other.
Although the Ultimate (commercial) version of IntelliJ costs money, it is probably the most powerful, reliable, and best supported IDE. Kiss works well with it. On the other hand, like other IDE’s, IntelliJ can be a bit tedious to configure properly. The following steps can be used to configure IntelliJ.
If bld is used, it will setup tomcat in a directory named tomcat under the root of the Kiss installation.
After this configuration is performed, you can use the IDE’s native build and debug processes for development. However, bld should still be used to produce the production WAR file.
NetBeans is currently under significant transition since it joined the Apache organization. NetBeans 11.2 did not work correctly with tomcat, however, the nightly build as of February 28, 2020 did. So, we expect that any version after 11.2 should work. This is how we configured the IDE. In all cases, when not specified otherwise. leave the defaults.
If bld is used, it will setup tomcat in a directory named tomcat under the root of the Kiss installation.
src/main/webapp
directory.
src/main/java
directory.
libs
folder
under the Kiss root.
After this configuration is performed, you can use the IDE’s native build and debug processes for development. However, bld should still be used to produce the production WAR file.
What you have at this point is the beginnings of your new application. Kiss is provided as a running and deployable system. It is expected that you would modify what’s there to suit your application needs.
Besides this narrative, you would need the JavaDocs located under the
build.work/javadoc
directory for back-end API specific documentation and
front-end API reference located in the manual/jsdoc directory.
The entire source code comes with the system and is convenient when debugging, however, only a few areas in the system would normally be of concern when building an application as follows.
src/main/application/KissInit.groovy
This file is used to configure the system. See Setup And Configuration
src/main/application
All other files under this directory represent the application back-end. All the files are used and distributed in source form. The Kiss system compiles them at runtime but does not save the compiled form. Updates to files under this directory take affect immediately on a running system.
Files under the src/main/webapp
directory represent the
front-end of the application.
All files under the src/main/webapp/kiss
directory are part of
the Kiss system and would normally not need to be touched.
index.html
and index.js
are also part of the Kiss
system and aren’t normally modified.
login.html
and login.js
represent the user login page
and would be modified to suit your needs.
Other directories such as page1
represent other user pages and
would be the application specific screens you create. The included
page1
directory is only an example page.
Kiss supports Microsoft SQL Server, Oracle, PostgreSQL, MySQL, and SQLite.
As shipped, Kiss comes configured with an embedded SQLite
server and database. While this is fine for a demo or small
application, a real database should be configured for real use.
The included database is located in the application
directory
and is named DB.sqlite
Although Kiss has no preferred database, PostgreSQL is strongly recommended because it is free, full featured, fast, rock solid, and portable on all major platforms.
Kiss applications are single page applications in the sense
that there is a single <body>
tag and all other pages
essentially get placed into that tag on a single page. However,
Kiss is not a single page application in the sense that the
entire application gets loaded with a single GET
request. This
doesn’t make sense for a large business application in which many
hundreds of pages may exist. Kiss lazy-loads pages as they are
used, and except for browser cache, eliminates them once another page
is loaded.
The user’s browser cache can be controlled from the file
src/main/webapp/index.html
In that file you will see two lines
that look as follows:
var softwareVersion = "1"; // version of the entire system var controlCache = false; // normally true but use false during // debugging
If controlCache
is set to true
, each time softwareVersion
is incremented all users starting the application will be forced to
load new code from the server and not use their browser’s cache. Once
they download the new version, normal browser cache activity will
occur.
JavaDocs for the Kiss system will need to be created. It is created from the command line by issuing the following command:
./bld javadoc [Linux, Mac, BSD, etc.] -or- bld javadoc [Windows]
The JavaDoc files end up in the build.work/javadoc
directory.
The only file needed to deply the application is Kiss.war
It
can be built by typing ./bld war
at a command prompt.
Kiss.war
ends up in the build.work
directory. If you
have your IDE create the Kiss.war
file, it will likely not
work. The Kiss system requires a special build process because
application files are distributed in source form. Therefore, bld
should be used to create the production WAR file.
If using tomcat, Kiss.war
should be placed in the
webapps
directory. When tomcat starts, it will see the
file, unpack it, and run it. The application will be available at
[HOST]/Kiss
Renaming Kiss.war
to ABC.war
, for example, will cause
the application path to change to [HOST]/ABC
In order to start getting a feel for how Kiss
applications
function, in terms of the back-end, look at files in the
src/main/application/services
directory. With Kiss
you can
develop applications in several different languages. The services
example shows the same code in all of the supported languages.
In terms of the front-end, see the example files under src/main/webapp/page1
This section details the development process with Kiss. The details provided will be for intelliJ but can be adapted to other IDE’s. The use of an IDE is tremendously beneficial because of the graphical debugging and intelligent code completion capabilities.
A good development environment includes two separate servers running on two different ports. One serves the back-end REST services, and the other serves the front-end HTML, JavaScript, and CSS files. This arrangement allows both front-end and back-end development without any compiles, server reboots, file copies, or deployments. Back-end and front-end files can be edited and saved. Their changes take effect immediately.
Of course, in a production environment, only a single server would be utilized and front-end and back-end changes take effect immediately there too.
The back-end works differently in development and production environments. Although in both environments back-end and front-end changes take effect immediately, setup of the production environment copies all files into the production environment, whereas in a development environment the source and production code are split. In order to facilitate rapid and easy development, it is important that source files be used rather than the production copies during the development process.
The system automatically detects the location of the application
source in most configurations. However, this may be explicitly
set via a system environment variable (KISS_ROOT
). The
value of this environment variable should be the absolute path of the
root of the application source code. The directory it indicates
should have a sub-directory named src/main/application
.
There are two different methods of running the back-end REST server as follows.
Running of the IDE back-end requires the following:
Typically, the IDE manages a tomcat instance and serves up the core back-end code serving the REST services. That code detects that it is running under an IDE and re-routes all back-end application files back to the source directories.
Although back-end files are edited in source form and run in compiled form, back-end code can be debugged (including break-points) as if they were compiled before the system was booted.
Once the back-end server is up, application files changed under the
src/main/application
directory will take effect immediately.
Utilizing the included Kiss build system (bld) the many steps required to install and configure tomcat and the IDE are unnecessary. The whole process (for the back-end portion) can be done as follows:
./bld develop
Note 1. You may have to first perform the one-time task of building
the bld system by typing: ./build-builder
Note 2. Remember that all commands that start with ./
would drop
the ./
under Windows.
At this point, the back-end will be running. From within your IDE you can attach to the process at port 9000 to debug the back-end (including breakpoints, etc.)
Remember, however, that you won’t be able to use or debug the application until the front-end server is started too.
All communications between the front-end and back-end occur over REST services you define. Each REST service exists in its own file or class. Web methods are methods within those classes.
As architected, directories under src/main/application
represent the application’s REST services. Each class / file under that
directory represents a web service. The name of the class is the name
of the web service.
Instance methods within the web service class represent REST methods for that web service. Each web method is passed four arguments as follows:
JSONObject injson
This represents the data that came from the front-end.
JSONObject outjson
This represents the data being returned to the front-end. It is pre-initialized with an empty JSONObject
.
Connection db
This is a pre-opened connection to the defined database (defined in application/KissInit.groovy
)
MainServlet servlet
This is a rarely used servlet context argument.
Basically what happens is:
Kiss
back-end receives the request.
outjson
object that is filled in by the web service that is to be returned to the front-end.
outjson
to the front-end.
Additional class and instance methods, that are not web methods, may be defined and used within web service classes.
Of course during this process, Kiss
handles many possible error conditions.
At this point, Kiss supports the development of back-end REST services in the Java, Groovy, or Common Lisp languages. Groovy was added first because it was easy, worked with the IDE well, and did all that was needed. Java was added simply due to its natural integration with the rest of the system.
With Kiss, different web services can be written in different languages. You are not forced to use one or the other.
Common Lisp (ABCL) was added due to this author’s love of that
language. Unlike Groovy and Java, Lisp has an impedance mismatch with
the core Kiss system that is written in Java. For example, in
Java, one can have two methods with the same name in the same class
that differ only by their argument types. This is not part of the
Common Lisp language. Also, the foreign function interface in Lisp
requires some Lisp code to make the connection clear. Due to this
connection code having to run, the Lisp interface is very slow on the
first call. It is, however, reasonably fast on all subsequent calls.
The code that interfaces Java to Lisp is under the
src/main/java/org/kissweb/lisp
directory.
Do to the easy and natural connection between Java and many other JVM languages, interfaces to those languages is very easy. It is anticipated that support for many of these other languages (such as Scala, Clojure, JRuby, Jython, and Kotlin) will likely follow, especially if there are requests.
A separate server is used so that development files will be served rather than the front-end that was present when the back-end server was started. This is the same whether your are using the IDE or bld back-end server modes.
Once the back-end and front-end servers are running, the front-end can be debugged through your browser debugger (F12 on Chrome).
In order to make this work, there are two steps that need to be followed.
src/main/webapp/index.js
. That file
contains a line that looks as follows:
Server.setURL('http://localhost:8080');
As shipped, that setting should be good in most cases. Adjust as needed.
SimpleWebServer.jar
on the
root of the Kiss system. From the root of the Kiss
system, run the following command to run the front-end server:
./serve
or on Windows:
serve.cmd
(Source code to this simple server is available at https://github.com/blakemcbride/SimpleWebServer)
Once the front-end and back-end servers are up, you can access the development
environment through your browser at http://localhost:8000
If you disable the browser cache through the browser developer console
settings, changes you make to the front-end will appear by just
reloading the page. On Chrome, for example, the browser cache can be
turned off by going into the page debugger (F12), then
settings
, and then select Disable cache (while DevTools
is open)
You can now develop the front-end portion of your application by
editing files under the src/main/webapp
directory.
Creating reports and exports requires both front-end and back-end components. The back-end usually creates the file to be sent to the front-end. It then returns a path that the front-end can use to download the file.
Kiss provides the infrastructure needed to support this facility. Kiss also manages and cleans up report files that are no longer needed.
In terms of producing reports, Kiss leverages the facilities provided by the common groff/tbl/mm utilities publicly available. These facilities automatically handle paging, titles, page numbering, tables, and overall formatting of your reports. See https://www.gnu.org/software/groff
In terms of producing CSV export files, see the back-end
DelimitedFileWriter
class.
When files are produced by the back-end, they are sent to the
front-end by just providing the URL to the file. At that point, the
front-end Utils.showReport
takes the URL returned by the back-end
and downloads the file.
The front-end API are all the facilities that run on the browser.
This includes HTML, CSS, JavaScript, image files, etc. The Kiss
back-end does not produce or modify HTML or JavaScript code. These
files are served, unaltered, by the server as they are on the back-end
disk. The Kiss
model is that the browser receives these files
from the server, and that they include all the code that the browser
needs to perform its function. Besides these static files, all data
is communicated between the back-end and front-end via REST services.
Having all of the display logic running on the front-end or user’s browser makes a lot of sense for the following reasons:
All of this leads to the following:
The front-end API is documented in the file manual/jsdoc/index.html
.
On the front-end, the class Server
is what deals with the REST
communications between the front-end and back-end. In it, there are a
handful of methods that deal with the environment such as the back-end
URL. All communications between the back-end and front-end are done
with JSON.
The way it works is the login service requires a user name and password, and it returns a login token (uuid). That token is used in all future calls, and it gets automatically invalidated after a certain amount of non-use time. There is no state kept on the back-end. Each REST call must login to the back-end with the provided token in order to be authenticated to communicate.
The method used to communicate is named Server.call()
. It is passed the
path to the REST service, the REST service method name, and a JSON
object that is send to the back-end method. A Promise
is
returned that is used to obtain the result of the call. This
can also be used with async/await
.
There is also a logout
method that simply erases the
login token so that future communications cannot occur.
The Server
class also includes a method (fileUploadSend
)
that makes it easy to upload files.
Although HTML provides what is needed for real applications, it provides those facilities in too low a level to be useful without a lot of custom code. Custom components (tags) allow you to encapsulate that advanced behavior into what is used as and appears as native functionality.
Kiss provides the ability to create your own custom HTML tags
or elements as well as use those provided by Kiss. There are
two principal user methods that make this work.
Utils.useComponent
is used to load either a Kiss defined
component or one you define yourself (there is no difference). This
loads the JavaScript file that defines the new tag. All of the
components that come with the Kiss system are under the
src/main/webapp/kiss/component
directory. You can see those
files for examples of how custom tags are defined.
New application pages are loaded with the Utils.loadPage
method. In addition to loading the HTML and JavaScript code
associated with that page, this method performs the processing
necessary to make the components work. It does this intelligently so
that, for example, one component can use another component without any
special loading order requirement.
Briefly, the code that describes the custom tag must describe what the tag is replaced with. Ultimately, it must boil down to straight HTML, CSS, and JavaScript code.
Let’s say you have a pop-up window that allows a user to search for employees, or product, or whatever. The user gets a variety of search capabilities and the selected item is returned. Let’s further say that you need this functionality in several places within your application. These are tagless components. They aren’t placed with a custom tag. They are a response to an event like a button push. Tagless components allow you to encapsulate a block of functionality (including pop-up windows) into a neat package that can be re-used in any number of places.
The method used to load tagless components is
Utils.useTaglessComponent
. Later, when the tagless component
is needed, one would execute Kiss.MyComponent.run(in_data, on_exit)
(where
MyComponent
is the name of your tagless component.
in_data
represents possible data passed to the component on entry.
on_exit
is a function that gets executed when the component exits.
Arguments passed to on_exit
are determined by the component.
Kiss supports dragable, modal popup windows. HTML is used to describe the layout of the popup, and JavaScript is used to control the appearance of the popup.
The HTML portion is represented as a top-level popup
tag
that represents the entire popup. Withing the top-level popup
there most be two child tags named popup-title
and
popup-body
. The first represents the single line header, and
the second represents the body of the popup window.
The top-level popup
tag’s attribute section must contain the following:
id="my-popup"
an ID is needed to reference the popup
width="600px" height="300px"
Set the height and width of the popup
An examples is as follows:
<popup id="my-popup" width="600px" height="300px"> <popup-title>The title</popup-title> <popup-body> The content <div style="display: inline-block; position: absolute; bottom: 20px; right: 20px;"> <push-button id="cancel" style="margin-left: 15px;">Cancel</push-button> <push-button id="ok" style="margin-left: 15px;">Ok</push-button> </div> </popup-body> </popup>
There are only two JavaScript functions used to control the popup.
Utils.popup_open(id [, focus-id])
open the popup indicated by the id
, and if focus-id
is present, set initial focus to that control
Utils.popup_close()
close the most recent popup
Your defined responses to the buttons on the popup determines your dealing with the data on the popup and when to close it.
Kiss includes facilities that make it easy to upload a file or multiple files. The way to use it is as follows:
The HTML would contain two controls; a file input and a button. The file input looks as follows:
<file-upload id="myUpload">Upload File</file-upload>
The file input control allows the user to select the file or files to
be uploaded. If multiple files are to be allowed the multiple
attribute should be added to the HTML.
The button is used to activate the upload process. Your code that sends the file(s) to the server should be attached to this button.
The file-upload
control contains the helper functions
numberOfUploadedFiles
and getFormData
, and the main
function used to send the files is fileUploadSend
in the
Server
class. The code would look like the following:
$$('upload').onclick(async () => { if ($$('the-file').numberOfUploadFiles() < 1) { Utils.showMessage('Error', 'You must first select a file to upload.'); return; } const fd = $$('the-file').getFormData(); let data = { var1: 22, // just some random data we want to sent to the back-end var2: 33 } const r = await Server.fileUploadSend('theService, 'theMethod', fd, data); });
Back-end code would look like this:
public void theMethod(JSONObject inJson, JSONObject outJson, MainServlet servlet) throws Exception { String var1 = inJson.getString("var1"); String var2 = inJson.getString("var2"); if (servlet.getUploadFileCount() == 0) throw new Exception("No file specified."); String originalFileName = servlet.getUploadFileName(0); BufferedInputStream bis = servlet.getUploadBufferedInputStream(0); // do something with the file stream bis.close(); -or- String localFileName = servlet.saveUploadFile(0); }
Kiss includes an ever-growing set of utilities to help deal with common tasks.
These utilities are located under the src/main/webapp/kiss
directory and have names such as
DateTimeUtils.js
, DateUtils
, TimeUtils
, Utils
, etc. These utilities
are documented in the front-end API documentation.
Browser’s have a mind of their own in term of deciding when to use their cache for a file and when to download a new one. This can cause no end of trouble when code gets changed. Some user files end up being old from the browser cache, and others are freshly downloaded. The old and new files don’t agree with each other and all sorts of errors occur.
Kiss includes a facility to assure that all files are
downloaded afresh whenever the application changes while still taking
maximal advantage of the browser cache when the files have not
changed. The only cost for this capability is the requirement
that the index.html
file always gets loaded afresh.
To that end, Kiss has code to ignore browser cache and always load
index.html
afresh.
index.html
contains two variables names softwareVersion
and controlCache
.
Assuming controlCache
is true
, Kiss has code that forces the browser
to re-load all files whenever softwareVersion
changes. After the code is re-loaded,
the browser cache will work as normal to maximally cache the files until the next
softwareVersion
change.
Although not a part of the Kiss system, there are some very valuable technologies and libraries that have been used with Kiss in order to create some very powerful solutions.
The first is the Lovefield library that adds SQL capabilities on the browser side. Data is persisted on the user’s browser and remains through browser or machine re-boots. The library is located at https://github.com/google/lovefield
A recent technology that has been used to enable browser application that run when there is no Internet connection is called Service Workers.
In addition to the full API provided by the Java system, and any additional JAR files you add, Kiss comes with an API that assists with the development of business application with Kiss. These API’s may be broadly grouped as follows:
An overview of these API’s is contained in this chapter. Detailed documentation is contained in the JavaDocs. See Creating JavaDocs.
Kiss comes with a powerful library for accessing SQL databases.
Code for this is located under org.kissweb.database
It is
currently being used in production environments. This API provides
the following benefits:
As shipped, this library supports PostgreSQL, Microsoft Server, Oracle, MySQL, and SQLite.
The detailed documentation for the database utilities are in the JavaDocs which you must generate. (See Creating JavaDocs.) This section provides an overview.
The Kiss database routines revolve around four main classes as follows:
Connection
This represents a connection to an SQL database.
Command
This represents a single action or command against the database.
Cursor
If the action is a select
, the Cursor
represents a
pointer into the result set.
Record
This class represents a single row within a table or result set.
The Connection
class contains several convenience methods that
are used in simple cases where only a single action is being
performed. These methods should not be used when multiple
simultaneous actions are taking place at once (by that single thread).
This issue is not a problem in multi-user or multi-threaded
situations. It is only a problem when a single thread is doing one
action while another action is still open.
You will notice that your REST services are passed a Connection argument. Kiss automatically forms a unique connection for each REST service call and closes it when the call is done. Therefore, you will not normally need to create your own connection. Additionally, Kiss automatically starts a new transaction with each REST service and commits it when the service is done. However, if the service throws any exception, the transaction is rolled back instead.
You would not normally write SQL for single record adds, updates, and
deletes. Using the Record API, Kiss
automatically
generates these statements for you.
In addition to the above, these utilities provide full support for transactions and parameters.
The first two arguments to all REST methods is injson
and
outjson
. injson
is a JSONObject
that contains
the data passed in from the front-end. outjson
is a
pre-initialized, empty JSONObject
that will be returned
to the front-end. The rest service should read the data passed in
from injson
, perform any needed processes, and put the result
into outjson
to be returned to the front-end.
A modified version of a publicly available JSON Java package is included and used to access JSON from the front-end and create JSON to return to the front-end. This package has many methods but only a few are commonly used.
There are two main data type of interest. They are JSONObject
and
JSONArray
. They hold the JSON types indicated by their names.
Command useful for getting data out of injson
:
Again, outjson
is supplied as a pre-initialized, but empty,
JSONObject
. It is up to the REST service code to populate it
with the return data. Useful JSON utilities include the following:
Kiss includes an ever-growing set of utilities to help deal with common tasks.
These utilities are located under the src/main/java/org/kissweb
directory and have names such as
DateTime.java
, NumberFormat
, etc. These utilities
are documented in the JavaDocs.


- –––, 2009, Self-Constitution: Agency, Identity, and Integrity, Oxford: Oxford University Press.
- Kriegel, Uriah, 2003, “Consciousness as Intransitive Self-Consciousness: Two Views and an Argument”, Canadian Journal of Philosophy, 33(1): 103–132.
- –––, 2009, Subjective Consciousness: A Self-Representational Theory, Oxford: Oxford University Press.
- –––, 2012, “Self-Representationalism and the Explanatory Gap”, in Lui & Perry 2012: 51–75.
- Kriegel, Uriah and Kenneth Williford (eds.), 2006, Self-Representational Approaches to Consciousness, Cambridge, MA: MIT Press.
- Kripke, Saul A., 1982, Wittgenstein on Rules and Private Language, Oxford: Blackwell.
- Lane, Timothy and Caleb Liang, 2011, “Self-Consciousness and Immunity”, Journal of Philosophy, 108(2): 78–99.
- Langland-Hassan, Peter, 2015, “Introspective Misidentification”, Philosophical Studies, 172(7): 1737–1758.
- Legerstee, Maria, 2005, Infants’ Sense of People: Precursors to a Theory of Mind, Cambridge: Cambridge University Press.
- Legrand, Dorothée, 2006, “The Bodily Self: The Sensori-Motor Roots of Pre-Reflective Self-Consciousness”, Phenomenology and the Cognitive Sciences, 5(1): 89–118.
- Levine, Joseph, 2006, “Conscious Awareness and (Self-)Representation”, in Uriah Kriegel and Kenneth Williford (eds.), Self-Representational Approaches to Consciousness, Cambridge, MA: MIT Press, pp. 173–197.
- Lewis, David, 1979, “Attitudes De Dicto and De Se”, The Philosophical Review, 88(4): 513–543. Reprinted with Postscripts in David Lewis, 1983, Philosophical Papers: Volume 1, New York: Oxford University Press, pp. 133–159.
- Lewis, Michael, 2011, “The Origins and Uses of Self-Awareness or the Mental Representation of Me”, Consciousness and Cognition, 20(1): 120–129.
- Lewis, Michael and Jeanne Brooks-Gunn, 1979, Social Cognition and the Acquisition of Self, New York: Plenum Press.
- Locke, John, 1700, An Essay Concerning Human Understanding, 4th Edition, edited by Peter H. Nidditch. Oxford: Clarendon Press, 1975.
- Longworth, Guy, 2013, “Sharing Thoughts About Oneself”, Proceedings of the Aristotelian Society, 113: 57–81.
- Ludwig, Kirk, 2011, “Triangulation Triangulated”, in Cristina Amoretti and Gerhard Preyer (eds.), Triangulation: From an Epistemological Point of View, Heusenstamm: Ontos Verlag, pp. 69–95.
- Lui, JeeLoo and John Perry (eds.), 2012, Consciousness and the Self: New Essays, Cambridge: Cambridge University Press.
- Lycan, William, 1996, Consciousness and Experience, Cambridge, MA: MIT Press.
- –––, 2004, “The Superiority of HOP to HOT”, in Gennaro 2004: 93–114.
- Macdonald, Cynthia, 1999, “Shoemaker on Self-Knowledge and Inner Sense”, Philosophy and Phenomenological Research, 59(3): 711–738.
- Magidor, Ofra, 2015, “The Myth of the De Se”, Philosophical Perspectives, 29(1): 249–283.
- Malcolm, Norman, 1979, “Whether ‘I’ is a Referring Expression”, in Diamond & Teichman 1979: 15–24.
- Marcel, Anthony J., 2003, “The Sense of Agency: Awareness and Ownership of Action”, in Roessler & Eilan 2003: 48–93.
- Marchetti, Clelia and Sergio Della Sala, 1998, “Disentangling the Alien and Anarchic Hand”, Cognitive Neuropsychiatry, 3(3): 191–207.
- Markie, Peter, 1992, “The Cogito and its Importance”, in John Cottingham (ed.), Cambridge Companion to Descartes, Cambridge: Cambridge University Press, pp. 140–173.
- Martin, M.G.F., 1995, “Bodily Awareness: A Sense of Ownership”, in Bermúdez, Marcel, & Eilan 1995: 267–289.
- –––, 1997, “Self-Observation”, European Journal of Philosophy, 5(2): 119–40.
- Matthews, Gareth B., 1992, Thought’s Ego in Augustine and Descartes, Ithaca: Cornell University Press.
- McDowell, John, 1977, “On the Sense and Reference of a Proper Name”, Mind, 86(342): 159–85.
- –––, 1997, “Reductionism and the First Person”, in Dancy 1997: 230–250. Reprinted in John McDowell, 1998, Mind, Value, & Reality, Cambridge, MA: Harvard University Press, pp. 359–382.
- –––, 1998, “Referring to Oneself”, in Lewis Edwin Hahn (ed.), The Philosophy of P.F. Strawson, Chicago: Open Court, pp. 129–145.
- McGinn, Colin, 1983, The Subjective View: Secondary Qualities and Indexical Thoughts, Oxford: Clarendon Press.
- –––, 1984, “What is the Problem of Other Minds?” Proceedings of the Aristotelian Society, Supplementary Volume, 58: 119–137.
- McGlynn, Aidan, 2016. “Immunity to Error Through Misidentification and the Epistemology of De Se Thought”, in García-Carpintero & Torre 2016: 25–55.
- Mead, George Herbert, 1934, Mind, Self, and Society: From the Standpoint of a Social Behaviourist, Chicago: University of Chicago Press, 2009.
- Mellor, D.H., 1989, “I and Now”, Proceedings of the Aristotelian Society, 89: 79–94.
- Meltzoff, Andrew N. and M. Kieth Moore, 1977, “Imitation of Facial and Manual Gestures by Human Neonates”, Science, 198(4312): 75–78.
- Menzel, Charles, 2005, “Progress in the Study of Chimpanzee Recall and Episodic Memory”, in Terrace & Metcalfe 2005: 188–224.
- Merleau-Ponty, Maurice, 1960, “The Child’s Relations With Others”, Translated by William Cobb in Maurice Merleau-Ponty, 1960, The Primacy of Perception, edited by Edie, J. Evanston, Illinois: Northwestern University Press, pp. 96–155.
- Metzinger, Thomas, 2003, Being No One: The Self-Model Theory of Subjectivity, Cambridge, MA: MIT Press.
- Michael, Michaelis, 2010, “Belief De Re, Knowing Who, and Singular Thought”, Journal of Philosophy, 107(6): 293–310.
- Michaelian, Kourken, 2016, Mental Time Travel, Cambridge MA: MIT Press.
- Michaelian, Kourken, Stanley B. Klein, and Karl K. Szpunar (eds.), 2016, Seeing the Future: Theoretical Perspectives on Future Oriented Mental Time Travel, Oxford: Oxford University Press.
- Michaelson, Eliot, 2014, “Shifty Characters”, Philosophical Studies, 167(3): 519–540.
- Miguens, Sofia, Gerhard Preyer, and Clara Bravo Morando (eds.), 2016, Pre-Reflective Consciousness: Sartre and Contemporary Philosophy of Mind, Abingdon: Routledge.
- Millikan, Ruth Garrett, 1990, “The Myth of the Essential Indexical”, Noûs, 24(5): 723–734.
- Mitchell, Robert W., 1993, “Mental Models of Mirror-Self-Recognition: Two Theories”, New Ideas in Psychology, 11(3): 295–325.
- Moran, Richard, 2001, Authority and Estrangement: An Essay on Self-Knowledge, Princeton, NJ: Princeton University Press.
- Morgan, Daniel, 2015, “The Demonstrative Model of First-Person Thought”, Philosophical Studies, 172(7): 1795–1811.
- Moro, Valentina, Massimiliano Zampini, and Salvatore M. Aglioti, 2004, “Changes in Spatial Position of Hands Modify Tactile Extinction but Not Disownership of Contralesional Hand in Two Right Brain-Damaged Patients”, Neurocase, 10(6): 437–443.
- Mullins, Simon, and Sean A. Spence, 2003, “Re-examining Thought Insertion: Semi-Structured Literature Review and Conceptual Analysis”, The British Journal of Psychiatry, 182(4): 293–298.
- Musholt, Kristina, 2015, Thinking about Oneself: From Nonconceptual Content to the Concept of a Self, Cambridge, MA: MIT Press.
- Nagel, Thomas, 1986, The View From Nowhere, New York: Oxford University Press.
- –––, 1996, “Universality and the Reflective Self”, in Korsgaard 1996: 200–209.
- Nichols, Shaun and Stephen P. Stich, 2003, Mindreading: An Integrated Account of Pretence, Self-Awareness, and Understanding Other Minds, Oxford: Clarendon Press.
- Nielsen, Mark, Thomas Suddendorf, and Virginia Slaughter, 2006, “Mirror Self-Recognition Beyond the Face”, Child Development, 77(1): 176–185.
- Ninan, Dilip, 2016, “What is the Problem of De Se Attitudes?” in García-Carpintero & Torre 2016: 86–120.
- Noë, Alva, 2002, “Is Perspectival Self-Consciousness Non-Conceptual”, The Philosophical Quartlery, 52(207): 185–194.
- Nozick, Robert, 1981, Philosophical Explanations, Cambridge, MA: Harvard University Press.
- Nunberg, Geoffrey, 1993, “Indexicality and Deixis”, Linguistics and Philosophy, 16(1): 1–43.
- –––, 1995, “Transfers of Meaning”, Journal of Semantics, 12(2): 109–132.
- O’Brien, Lucy, 1994, “Anscombe and the Self-Reference Rule”, Analysis, 54(4): 277–281.
- –––, 1995a, “The Problem of Self-Identification”, Proceedings of the Aristotelian Society, 95: 235–251.
- –––, 1995b, “Evans on Self-Identification”, Noûs, 29(2): 232–247.
- –––, 1996, “Solipsism and Self-Reference”, European Journal of Philosophy, 4(2): 175–194.
- –––, 2003, “Moran on Agency and Self-Knowledge”, European Journal of Philosophy, 11(3): 375–390.
- –––, 2007, Self-Knowing Agents, Oxford: Oxford University Press.
- –––, 2012, “Action and Immunity to Error Through Misidentification”, in Prosser & Recanati 2012: 124–143.
- O’Brien, Lucy and Matthew Soteriou (eds.), 2009, Mental Actions, Oxford: Oxford University Press.
- O’Rourke, Michael and Cory Washington (eds.), 2007, Situating Semantics: Essays on the Philosophy of John Perry, Cambridge, MA: MIT Press.
- O’Shaughnessy, Brian, 2002, Consciousness and the World, Oxford: Clarendon Press.
- Owens, Joseph, 1988, “The Self in Aristotle”, The Review of Metaphysics, 41(4): 707–722.
- Pacherie, Elisabeth and Jean-Remy Martin, 2013, “Out of Nowhere: Thought Insertion, Ownership and Context-Integration”, Consciousness and Cognition, 22(1): 111–122.
- Parfit, Derek, 1984, Reasons and Persons, Oxford: Clarendon Press.
- Parnas, Josef and Louis A. Sass, 2011, “The Structure of Self-Consciousness in Schizophrenia”, in Gallagher 2011: 521–546.
- Pasnau, Robert, 2002, Thomas Aquinas on Human Nature: A Philosophical Study of Summa Theologaie 1a 75–89, Cambridge: Cambridge University Press.
- Peacocke, Christopher, 1983, Sense and Content: Experience, Thought, and their Relations, Oxford: Clarendon Press.
- –––, 1996, “Entitlement, Self-Knowledge, and Conceptual Redeployment”, Proceedings of the Aristotelian Society, 96: 117–158.
- –––, 1999, Being Known, Oxford: Clarendon Press.
- –––, 2003, “Action: Awareness, Ownership, and Knowledge”, in Roessler & Eilan 2003: 94–110.
- –––, 2008, Truly Understood, Oxford: Oxford University Press.
- –––, 2014, The Mirror of the World: Subjects, Consciousness, & Self-Consciousness, Oxford: Oxford University Press.
- Penelhum, Terence, 2000, Themes in Hume. Oxford: Clarendon Press.
- Perry, John, 1977, “Frege on Demonstratives”, The Philosophical Review, 86(4): 474–97. Reprinted with Postscript in Perry 1993: 3–32.
- –––, 1979, “The Problem of the Essential Indexical”, Noûs, 13(1): 3–21. Reprinted with Postscript in Perry 1993: 33–52.
- –––, 1986, “Thought Without Representation”, Supplementary Proceedings of the Aristotelian Society, 60: 137–152. Reprinted with Postscript in Perry 1993: 205–255.
- –––, 1993, The Problem of the Essential Indexical and Other Essays, New York: Oxford University Press.
- –––, 2001, Reference and Reflexivity, Stanford: CSLI Publications.
- –––, 2012, “Thinking About the Self”, in Lui & Perry 2012: 76–100.
- Piaget, Jean, 1937, The Construction of Reality in the Child, translated by Margaret Cook, New York: Basic Books, 1954.
- Pippin, Robert, B., 2010, Hegel on Self-Consciousness: Desire and Death in the Phenomenology of Spirit, Princeton, NJ: Princeton University Press.
- Pitson, A.E., 2002, Hume’s Philosophy of the Self, London: Routledge.
- Plotnik, Joshua M., Richard Lair, Wirot Suphachoksahakun, and Frans B.M. de Waal, 2006, “Self-Recognition in an Asian Elephant”, Proceedings of the National Academy of Sciences of the United States of America, 103(12): 17053–17057.
- Powell, C. Thomas, 1990, Kant’s Theory of Self-Consciousness, Oxford: Oxford University Press.
- Predelli, Stefano, 1998a, “I Am Not Here Now”, Analysis, 58(2): 107–115.
- –––, 1998b, “Utterance, Interpretation and the Logic of Indexicals”, Mind and Language, 13(3): 400–414.
- –––, 2002, “Intentions, Indexicals and Communication”, Analysis, 62(4): 310–316.
- Priest, Stephen, 2000, The Subject in Question: Sartre’s Critique of Husserl in The Transcendence of the Ego, London: Routledge.
- Prinz, Jesse, 2012, “Waiting for the Self”, in Lui & Perry 2012: 123–149.
- Prosser, Simon, 2015, “Why are Indexicals Essential?” Proceedings of the Aristotelian Society, 115: 211–233.
- Prosser, Simon and François Recanati (eds.), 2012, Immunity to Error Through Misidentification, Cambridge: Cambridge University Press.
- Proust, Joëlle, 2013, The Philosophy of Metacognition: Mental Agency and Self-Awareness, Oxford: Oxford University Press.
- Pryor, James, 1999, “Immunity to Error Through Misidentification”, Philosophical Topics, 26(1&2): 271–304.
- Pust, Joel, 2014, “Critical Notice of Hilary Kornblith’s On Reflection”, Episteme, 11(1): 53–61.
- Ram-Prasad, Chakravarthi, 2013, “Situating the Elusive Self of Advaita Vedānta”, in Siderits, Thompson, & Zahavi 2013: 217–238.
- Recanati, François, 1993, Direct Reference: From Language to Thought, Oxford: Blackwell.
- –––, 2007, Perspectival Thought: A Plea for (Moderate) Relativism, Oxford: Oxford University Press.
- –––, 2012, “Immunity to Error Through Misidentification”, in Prosser & Recanati 2012: 180–201.
- Reddy, Vasudevi, 2008, How Infants Know Minds, Cambridge, MA: Harvard University Press.
- Reed, Baron, 2010, “Self-Knowledge and Rationality”, Philosophy and Phenomenological Research, 80(1): 164–181.
- Reiss, Diana and Lori Marino, 2001, “Mirror Self-Recognition in the Bottlenose Dolphin: A Case of Cognitive Convergence”, Proceedings of the National Academy of Sciences of the United States of America, 98(10): 5937–5942.
- Reynolds, Steven L., 1989, “Imagining Oneself To Be Another”, Noûs, 23(5): 615–633.
- Rochat, Philippe and Dan Zahavi, 2011, “The Uncanny Mirror: A Re-framing of Mirror Self-Experience”, Consciousness and Cognition, 20(2): 204–213.
- Rödl, Sebastian, 2007, Self-Consciousness, Cambridge, MA: Harvard University Press.
- Roessler, Johannes, and Naomi Eilan (eds.), 2003, Agency and Self-Awareness: Issues in Philosophy and Psychology, Oxford: Clarendon Press.
- Romdenh-Romluc, Komarine, 2002, “Now the French are Invading England!” Analysis, 62(1): 34–41. doi:10.1111/1467-8284.00326
- –––, 2008, “First-Person Thought and the Use of ‘I’”, Synthese, 163(2): 145–156.
- Rosenbaum, R. Shayna, Stefan Köhler, Daniel L. Schacter, Morris Moscovitch, Robyn Westmacott, Sandra E. Black, Fuqiang Gao, and Endel Tulving, 2005, “The Case of KC: Contributions of a Memory-Impaired Person to Memory Theory”, Neuropsychologia, 43(7): 989–1021.
- Rosenthal, David, 1986, “Two Concepts of Consciousness”, Philosophical Studies, 49(3): 329–359.
- –––, 2005, Consciousness and Mind, Oxford: Oxford University Press.
- –––, 2012, “Awareness and Identification of Self”, in Lui & Perry 2012: 22–50.
- Russell, Bertrand, 1910, “Knowledge by Acquaintance and Knowledge by Description”, Proceedings of the Aristotelian Society, 11: 108–128.
- –––, 1921, The Analysis of Mind, London: George Allen, & Unwin.
- Sainsbury, Mark, 2011, “English Speakers Should Use ”I“ to Refer to Themselves”, in Anthony Hatzimoysis, 2011, Self-Knowledge, Oxford: Oxford University Press, pp. 246–260.
- Sacks, Mark, 2000, Objectivity and Insight, Oxford: Clarendon Press.
- –––, 2005, “Sartre, Strawson, and Others”, Inquiry, 48(3): 275–299.
- Saks, Elyn R., 2007, The Centre Cannot Hold: A Memoir of My Schizophrenia, London: Virago.
- Sartre, Jean-Paul, 1937, The Transcendence of the Ego, translated by Andrew Brown, London: Routledge, 2004.
- –––, 1943, Being and Nothingness: An Essay on Phenomenological Ontology, translated by Hazel E. Barnes, London: Routledge, 1998.
- Schear, Joseph K., 2009, “Experience and Self-Consciousness”, Philosophical Studies, 144(1): 95–105.
- Schwartz, Bennett L., 2005, “Do Nonhuman Primates have Episodic Memory?” in Terrace & Metcalfe 2005: 225–241.
- Schwenkler, John, 2014, “Vision, Self‐Location, and the Phenomenology of the ‘Point of View’”, Noûs, 48(1): 137–155.
- Seeger, Max, 2015, “Immunity and Self-Awareness”, Philosophers’ Imprint, 15(17): 1–19.
- Shields, Wendy E., J. David Smith, and David A. Washburn, 1997, “Uncertain Responses by Humans and Rhesus Monkeys (Macaca Mulatta) in a psychophysical same-different task”, Journal of Experimental Psychology: General, 126(2): 147–164.
- Shoemaker, Sydney, 1968, “Self-Reference and Self-Awareness”, The Journal of Philosophy, 65(19): 555–567. Reprinted in Shoemaker 1984a: 6–18.
- –––, 1970, “Persons and their Pasts”, American Philosophical Quarterly, 7(4): 269–285. Reprinted in Shoemaker 1984a: 19–48.
- –––, 1984a, Identity, Cause, and Mind: Philosophical Essays, Cambridge: Cambridge University Press.
- –––, 1984b, “Personal Identity: A Materialist’s Account”, in Sydney Shoemaker and Richard Swinburne, Personal Identity, Oxford: Blackwell.
- –––, 1986, “Introspection and the Self”, Midwest Studies in Philosophy, 10: 101–120. Reprinted in Shoemaker 1996: 3–24.
- –––, 1988, “On Knowing One’s Own Mind”, in James E. Tomberlin (ed.), Philosophical Perspectives, 2, Epistemology, Atascadero, CA: Ridgeview Publishing, pp. 183–209. Reprinted in Shoemaker 1996: 25–49.
- –––, 1994, “Self-Knowledge and ‘Inner-Sense’”, Philosophy and Phenomenological Research, 68(2): 249–314. Reprinted in Shoemaker 1996: 201–268.
- –––, 1996, The First-Person Perspective and Other Essays, Cambridge: Cambridge University Press.
- –––, 2012, “Personhood and Consciousness”, in Lui & Perry 2012: 198–213.
- Sidelle, Alan, 1991, “The Answering Machine Paradox”, Canadian Journal of Philosophy, 21(4): 525–539.
- Siderits, Mark, 1997, “Buddhist Reductionism”, Philosophy East and West, 47(4): 455–478.
- Siderits, Mark, Evan Thompson, and Dan Zahavi (eds.), 2013, Self or No-Self? Perspectives from Analytical, Phenomenological, and Indian Traditions, Oxford: Oxford University Press.
- Siewert, Charles, 2003, “Self-Knowledge and Rationality: Shoemaker on Self-Blindness”, in Brie Gertler (ed.), Privileged Access: Philosophical Accounts of Self-Knowledge, Farnham: Ashgate, pp. 131–145.
- Slote, Michael A., 1970, Reason and Scepticism, London: Routledge.
- Smith, J. David, 2005, “Studies of Uncertainty Monitoring and Metacognition in Animals and Humans”, in Terrace & Metcalfe 2005: 242–271.
- –––, 2009, “The Study of Animal Metacognition”, Trends in Cognitive Science, 13(9): 389–396.
- Smith, J. David, Justin J. Couchman and Michael J. Beran, 2014, “The Highs and Lows of Theoretical Interpretation in Animal-Metacognition Research”, in Fleming & Frith 2014: 87–111.
- Smith, J. David, Jonathan Schull, Jared Strote, Kelli McGee, Roian Egnor, and Linda Erb, 1995, “The Uncertain Response in the Bottlenosed Dolphin (Terciops Truncatus)”, Journal of Experimental Psychology: General, 124(4): 391–408.
- Smith, Joel, 2006a, “Which Immunity to Error?” Philosophical Studies, 130(2): 273–83.
- –––, 2006b, “Bodily Awareness, Imagination, and the Self”, European Journal of Philosophy, 14(1): 49–68.
- –––, 2011, “Strawson on Other Minds”, in Smith & Sullivan 2011: 184–208.
- Smith, Joel and Peter Sullivan (eds.), 2011, Transcendental Philosophy and Naturalism, Oxford: Oxford University Press.
- Smith, Quentin, 1989, “The Multiple Uses of Indexicals”, Synthese, 78(2): 167–191.
- Smithies, Declan, 2016, “Reflection On: On Reflection”, Analysis, 76(1): 55–69.
- Snowdon, Paul F., 2014, Persons, Animals, Ourselves, Oxford: Oxford University Press.
- Sodian, Beate, Claudia Thoermer, Susanne Kristen and Hannah Perst, 2012, “Metacognition in Infants and Young Children”, in Beran et al. 2012: 119–133.
- Sorabji, Richard, 2006, Self: Ancient and Modern Insights about Individuality, Life, and Death, Oxford: Clarendon Press.
- Sosa, Ernest, 2003, “Knowledge of Self, Others, and World”, in Kirk Ludwig (ed.), Donald Davidson, Cambridge: Cambridge University Press.
- Soteriou, Matthew, 2013, The Mind’s Construction: The Ontology of Mind and Mental Action, Oxford: Oxford University Press.
- Spencer, Cara, 2007, “Is There a Problem of the Essential Indexical?” in O’Rourke & Washington 2007: 179–197.
- Stalnaker, Robert C., 2008, Our Knowledge of the Internal World, New York: Oxford University Press.
- Stephens, G. Lynn and George Graham, 2000, When Self-Consciousness Breaks: Alien Voices and Inserted Thoughts, Cambridge, MA: MIT Press.
- Stern, Daniel, 1985, The Interpersonal World of the Infant: A View from Psychoanalysis and Developmental Psychology, New York: Basic Books.
- Stern, Robert (ed.), 1999, Transcendental Arguments: Problems and Prospects, Oxford: Clarendon Press.
- –––, 2000, Transcendental Arguments and Scepticism: Answering the Question of Justification, Oxford: Clarendon Press.
- Stone, Jim, 1988, “Parfit and the Buddha: Why There Are No People”, Philosophy and Phenomenological Research, 48(3): 519–532.
- Stoneham, Tom, 2002, Berkeley’s World: An Examination of the Three Dialogues, Oxford: Oxford University Press.
- Strawson, Galen, 1999, “Self, Body, and Experience”, Proceedings of the Aristotelian Society, Supplementary Volume, 73: 307–332.
- –––, 2009, Selves: An Essay in Revisionary Metaphysics, Oxford: Clarendon Press.
- –––, 2011a, The Evident Connexion: Hume on Personal Identity, Oxford: Oxford University Press.
- –––, 2011b, Locke on Personal Identity: Consciousness and Concernment, Princeton, NJ: Princeton University Press.
- Strawson, P.F., 1959, Individuals, London: Methuen.
- –––, 1966, The Bounds of Sense, London: Methuen.
- Stroud, Barry, 1968, “Transcendental Arguments”, Journal of Philosophy, 65(9): 241–256.
- Suddendorf, Thomas and David L. Butler, 2013, “The Nature of Visual Self-Recognition”, Trends in Cognitive Sciences, 17(3): 121–127.
- Suddendorf, Thomas and Steven C. Corballis, 2007, “The Evolution of Foresight: What is Mental Time Travel and is it Unique to Humans?” Behavioural and Brain Sciences, 30: 299–351.
- Sullivan, Peter, 1996, “The ‘Truth’ in Solipsism, and Wittgenstein’s Rejection of the A Priori”, European Journal of Philosophy, 4(2): 195–219.
- Sutton Morris, Phyllis, 1982, “Some Patterns of Identification and Otherness, ” Journal of the British Society of Phenomenology, 13(3): 216–225.
- Terrace, Herbert S., and Janet Metcalfe (eds.), 2005, The Missing Link in Cognition: Origins of Self-Reflective Consciousness, New York: Oxford University Press.
- Thiel, Udo, 2011, The Early Modern Subject: Self-Consciousness and Personal Identity from Descartes to Hume, Oxford: Oxford University Press.
- Trevarthen, Colwyn, 1979, “Communication and Cooperation in Early Infancy: A Description of Primary Intersubjectivity”, in Margaret Bullowa (ed.), Before Speech: The Beginning of Interpersonal Communication, Cambridge: Cambridge University Press, pp. 321–347.
- Tsakiris, Manos, 2011, “The Sense of Body Ownership”, in Gallagher 2011: 180–203.
- Tugendhat, Ernst, 1979, Self-Consciousness and Self-Determination, translated by Paul Stern, Cambridge, MA: MIT Press, 1986.
- Tulving, Endel, 1972, “Episodic and Semantic Memory”, in Endel Tulving and Wayne Donaldson (eds.), Organization of Memory, New York: Academic Press, pp. 382–403.
- –––, 1983, Elements of Episodic Memory, Oxford: Clarendon Press.
- –––, 2005, “Episodic Memory and Autonoesis: Uniquely Human?” in Terrace & Metcalfe 2005: 3–56.
- Tye, Michael, 1995, Ten Problems of Consciousness, Cambridge, MA: MIT Press.
- Velleman, J. David, 1996, “Self to Self”, The Philosophical Review, 105(1): 39–76.
- Vision, Gerald, 1985, “I Am Here Now”, Analysis, 45(4): 198–199.
- Watson, Gary, 1975, “Free Agency”, The Journal of Philosophy, 73(8): 205–220.
- Weinberg, Shelley, 2011, “Locke on Personal Identity”, Philosophy Compass, 6(6): 398–407.
- White, Michael J., 1979, “The First Person Pronoun: A Reply to Anscombe and Clarke”, Analysis, 39(3): 120–3.
- Wider, Kathleen, 1997, The Bodily Nature of Consciousness: Sartre and Contemporary Philosophy of Mind, Ithaca: Cornell University Press.
- Williams, Bernard, 1978, Descartes: The Project of Pure Enquiry, London: Penguin.
- –––, 1973, “Imagination and the Self”, in Bernard Williams, Problems of the Self, Cambridge: Cambridge University Press, pp. 26–45.
- Williams, Michael, 2015, “What’s So Special About Human Knowledge?” Episteme, 12(2): 249–268.
- Wilson, Margaret Dualer, 1978, Descartes, London: Routledge.
- Wittgenstein, Ludwig, 1921, Tractatus Logico-Philosophicus, translated by D.F. Pears and B.F. McGuinness, London: Routledge & Kegan Paul, 1961.
- –––, 1953, Philosophical Investigations, translated by G.E.M. Anscombe, Oxford: Blackwell.
- –––, 1958, The Blue and Brown Books, Oxford: Blackwell.
- Wood, Allen W., 2006, “Fichte’s intersubjective I”, Inquiry, 49(1): 62–79.
- Wright, Crispin, 1998, “Self-Knowledge: The Wittgensteinian Legacy”, In Wright, Smith, & MacDonald 1998: 13–45.
- Wright, Crispin, Barry Smith, and Cynthia MacDonald (eds.), 1998, Knowing Our Own Minds, Oxford: Clarendon Press.
- Zahavi, Dan, 2005, Subjectivity and Selfhood: Investigating the First-Person Perspective, Cambridge, MA: MIT Press.
- –––, 2007, “The Heidelberg School and the Limits of Reflection”, in Heinämaa, Lähteenmäki, & Remes 2007: 267–285.
- –––, 2014, Self and Other: Exploring Subjectivity, Empathy, and Shame, Oxford: Oxford University Press.
- Zahavi, Dan and Uriah Kriegel, 2015, “For-Me-Ness: What It Is and What It Is Not”, in Daniel O. Dahlstrom, Andreas Elpidorou, and Walter Hopp (eds.), Philosophy of Mind and Phenomenology, Oxford: Routledge, pp. 36–53.
- Zahn, Roland, Jochen Talazko, and Dieter Ebert, 2008, “Loss of the Sense of Self-Ownership for Perceptions of Objects in a Case of Right Inferior Temporal, Parieto-Occipital and Precentral Hypometabolism”, Psychopathology, 41(6): 397–402.
- Zöller, Günther, 1992, “Lichtenberg and Kant on the Subject of Thinking”, Journal of the History of Philosophy, 30(3): 417–441.
Academic Tools
How to cite this entry. Preview the PDF version of this entry at the Friends of the SEP Society. Look up this entry topic at the Indiana Philosophy Ontology Project (InPhO). Enhanced bibliography for this entry at PhilPapers, with links to its database.
Other Internet Resources
- Bibliography for Self-Consciousness, at PhilPapers.org
- Entry on Self-Consciousness at Internet Encyclopedia of Philosophy


This blog is triggered by an email sent to me by Kobus Scheltema, a fellow ambassador at Global Impact Network. So Kobus has become the community manager of the network after Yoanna Koleva stepped down from that position earlier this year. And Kobus, like most other people in the network, is passionate about measuring the impact of the little things that the citizens of the world can do to extend the existence of life on this planet. The Global Impact Network (GIN) platform has been working on a social media application that can help citizens track their impact, and they base these measurements based on empirical data and proof of action, which is currently accepted as a photograph. And some of the ambassadors were concerned that there is no way to measure the impact of using more sustainable transportation on the app.
So Kobus wanted to get some input from my end regarding sustainable transportation, and I am summarizing my response in this blog because I believe that everyone should be aware of these facts.
I truly believe that this is not the case. I have seen these statistics from a lot of different, credible sources, and I will just add a link to one such source here. This image from the same article summarizes it well:
If you look at the bottom-most bar, it is clear that just the adoption of electric vehicles does nothing for the environment on its own (in fact, it makes things worse). And people mustn't stop using their ICE vehicles to adopt EVs because that will just cause more harm than good. EV should only be bought when you anyway would have bought a new vehicle.
I strongly support the use of public transport, and non-motor transport like walking and cycling, over the use of EVs. On a quick search of the web, I found this article. This is an image that summarizes the learnings from the same:
As you can see, walking and biking is a sure-shot method to reduce carbon footprint. With EVs, if you are 100% sure of the source to be green, then you still have a big initial manufacturing footprint (due to batteries) as mentioned in the previous section. And then, public transport, even if not running on green energy, is the next best thing you can do.
At least in India, a lot of the public transport, including the largest railway network in the world, and various major city metro-train networks and bus networks, run exclusively on electricity. So buying a private EV is clearly much worse than using these alternatives.
Have I missed out on any bit of information? Is my analysis faulty? I do change my own behaviour based on the information that I have shared above. And I would appreciate it if you can correct me wherever I am wrong. Additionally, I would also be glad to discuss this topic if you are interested in it. And maybe we can together start a ritual which helps us take better care of our planet.


Find a southwest Arizona drop-in campground with the best weather for the weekend.
{{ selected_data.fire_level }}


|
OptaPlanner distribution 6.2.0.Final | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface SolverEventListener<SolutionG extends Solution>
| Method Summary | |
|---|---|
void |
bestSolutionChanged(BestSolutionChangedEvent<SolutionG> event)
Called once every time when a better Solution is found. |
| Method Detail |
|---|
void bestSolutionChanged(BestSolutionChangedEvent<SolutionG> event)
Solution
is found.
The Solution
is guaranteed to be initialized.
Early in the solving process it's usually called more frequently than later on.
Called from the solver thread.
Should return fast, because it steals time from the Solver
.
In real-time planning
If Solver.addProblemFactChange(ProblemFactChange)
has been called once or more,
all ProblemFactChange
s in the queue will be processed and this method is called only once.
In that case, the former best Solution
is considered stale,
so it doesn't matter whether the new Score
is better than that or not.
event
- never null
|
OptaPlanner distribution 6.2.0.Final | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


--- layout: post permalink: carmoza.html Tags: Array NameOfCoupon: Carmoza Cash Back Summary: See our Carmoza Coupon Code, Carmoza Rebate, Carmoza Promo Code, Carmoza Discount, Carmoza Coupon Cash Back Rebate here. MetaKeywords: Carmoza Coupon Code, Carmoza Rebate, Carmoza Promo Code, Carmoza Cash Back Rebate, Carmoza Discount, Carmoza Coupon Image: images/27563.gif LinkURL: http://www.shareasale.com/r.cfm?b=234382&u=412002&m=27563 affiliate_url_link: http://www.icouponblog.com/jane.php?id=2953 thesis_readmore: See the Carmoza Coupon thesis_thumb: http://www.icouponblog.com/tn.php?merchantURL=carmoza.com Title: Save $30 - Carmoza Coupon Code for carmoza.com. Carmoza Rebate & Discount thesis_description: Our Carmoza Discount Coupon Code for carmoza.com. We have the best Carmoza Rebate anywhere. thesis_keywords: Carmoza, Carmoza Coupon Code, Carmoza Discount, Carmoza Rebate product_name: Carmoza hop_url: http://www.icouponblog.com/hop.php?id=2953 ---
Have you found a new job and need to relocate? Do you need to ship your daughter’s car to her college campus? Is the thought of transporting your Aston Martin, BMW or Toyota Yaris making you nervous? Put all your fears to rest with a company that is well known, well reputed and well trusted in the car transportation business. Check them out on www.carmoza.com. You will feel confident, happy and content with their efficiency and great transportation record. Use our discount coupons to save a bundle of money!
If you need to transport your car to Alaska even or Puerto Rico, Carmoza is the company you can trust. They will transport your car safely and on time. Whether it is a college move, a military move or just a seasonal move for your car, Carmoza has the best tools and the most professional set of personnel to do the job. Don’t leave your car transportation to amateurs or novices, go with Carmoza, a name you can trust and their years of experience you can count on. Visit www.carmoza.com and see for yourself and experience peace of mind.
If you need to transport a car to another state, trust www.carmoza.com. If you have a classic car that you are very nervous about transporting, feel at confident with carmoza.com. They have transported many classic cars safely and on time. Carmoza also provides $500, 000 in cargo insurance for your classic cars. It is a company that cares for you and your vehicle. You will be glad you used carmoza.com.


Before Change
num_missing = [
np.sum(missing.data[missing.indptr[i]:missing.indptr[i + 1]])
for i in range(missing.shape[0])]
elif scipy.sparse.isspmatrix_csc(missing):
num_missing = [np.sum(missing.data[missing.indices == i])
for i in range(missing.shape[0])]
return float(np.sum([1 if num > 0 else 0 for num in num_missing]))
After Change
def _calculate_sparse(self, X, y, categorical):
missing = helper_functions.get_value("MissingValues")
new_missing = missing.tocsr()
num_missing = [
np.sum(new_missing.data[new_missing.indptr[i]:new_missing.indptr[i + 1]])
for i in range(new_missing.shape[0])]


Lego Database Web App
Designed a t-sql database to store over 500k rows of data.
Built a react web app that connects to a Node/Express backend that connects to the database.
Hosted the web app on heroku and the t-sql databse on an AWS RDS instance.
view code
This Website!
Used HTML, CSS, and JavaScript to create this website's front-end from scratch,
along with Python's Django framework for the website's back-end, and Heroku for hosting.
view code
Threes! Ai
Created a Threes! clone game with react.js.
Currently working on an Ai that uses the expectimax algorithm to play the game
view code
Leidos Software Engineering Internship
Worked as a software engineering intern for Leidos, a govenment contractor,
in Summer 2020. Developed code in java, python, and bash scirpt, created and
managed technical documentaion, and worked with various software including Itential, CISCO NSO,
and MongoDB.
Education - Software Engineering Bachelor's
Currently enrolled at Rose-Hulman Institute of Technology in Terre Haute,
Indiana. Pursuing my Bachelors in Software Engineering with an expected graduation
date in December, 2022.


Frequently asked questions for readers and authors
For Readers
content
content-link
Please contact the Webmaster at<EMAIL_ADDRESS>content
(content) LINK
content
content
Content with links
link
link
link
Phone:
Fax:
E-mail: @.com
content link website.
See our subscription rates (PDF format)
content link.com.
Please contact<EMAIL_ADDRESS>Please contact<EMAIL_ADDRESS>Read our link info.


[§211F-15] Annual report. The corporation shall submit a complete and detailed report of the corporation's activities to the legislature. The report shall be submitted not later than twenty days before the convening of the regular session of 1991, and every year thereafter. [L 1990, c 110, pt of §3]


New Retro-Futuristic Renderings Take The Porsche 993 To Another Level
Looking better than the original?
by Anthony KarrEarlier this year, we shared a series of renderings depicting a modern interpretation of the Porsche 993 that was sold from 1995 to 1998 in the United States. The drawings were close to perfection and we really enjoyed their author’s, Mathew Parsons, work. Now, he’s back with a new version of the same project and it’s even better than before.
The vehicle carries the same basic idea but brings new and softer lines and surfaces to the execution. The obvious inspiration comes from the original 993, as well as from the Porsche 935 – the latest official special edition of the 911, revealed by the Stuttgart-based company in 2018.
Gallery: Porsche 993 modernized (version 2)
“Leading on from the initial ‘Project 993’, version 2 takes a different approach to a longtail/widebody 993. Smoother transitions between surfaces, larger radii, and an overall softer approach to the design. The wing is inspired by 993 race cars, with outlandish looking two-part designs, with mine being more suited to a longtail rear-end,” the designer explains in his post on Behance.
We have to admit that these new virtual drawings look almost as if they were done by the automaker itself. The quality of both the styling and the rendering work is amazing, and there are a few new touches compared to the previous version that make a huge difference.
Modernized Classics:
If you take a look at the front bumper, for example, it has a completely new layout, which now incorporates two large round air openings with O-shaped LED daytime running lights. In our eyes, this new shape better corresponds with the main headlights. At the back, in turn, the central exhaust system is replaced by two large pipes at both ends of the bumper.
Source: Mathew Parsons on Behance


Before DB2 9, CLOB columns were a common choice to store XML data.
A fundamental difference between CLOB storage and pureXML processing lies in
XML parsing and its significant impact on insert and query performance.
Refer to the example on the right to see how XML documents can be stored in CLOB.
Note that the CREATE TABLESPACE statements may fail if they already exist in the database. If that's the case, you may ignore those errors.


precipitation Holocene jet westerly China stream position pollen model summer Asian modern insolation [], reconstructions changes records results patterns using {border-style climate empirical maximum (Fig. East Rev. Sci. pollen-based px;} #ffffff;} circulation Quat. eastern grid.. spatial Sciences, Supplementary daily dataset minimal monsoon Asia annual ./j.quascirev... Tibetan used Chinese study Academy Fig. Institute function mid-Holocene northeastern northern simulated southern supported transfer trends EASM Plateau Summer correlation data early orientation past quantitative reconstructed relationship set temperature version Key Monsoon derived fossil late number pattern period record simulations spatiotemporal time-series Climate Environmental Science cluster indicated levels moisture north-central px; {font-family (see Clim. Mongolia Research University, Wang analog area band font-size interactions jet-stream major modeled modeling monsoonal reconstruction regional variability variations vegetation wind ./s--- Data ENSO Earth Laboratory Liu Pacific anomalies atmospheric available based broad-scale change days double; indicate insolation, likely mechanisms mesoscale obtain pollen–precipitation precipitation. processes proxy-based rain rainfall representation result seasonal selected simulation sites smoothed stream, temporal time Cao China, China. Herzschuh Holocene. Indian Table University Zhao areas associated border-color border-width climatological consistent decades distribution dynamics early-Holocene evidence functions gradient including increase latitude local maxima mean models observed obtained package present reanalysis relationships reliable solid; southeastern strong years zonal {font-style {font-weight (). (Supplementary (i.e., Change Chen College Commons Creative Dyn. ESMs However, Lake Methods Mongolia. National Nature Note Program Research, State Tian Zhang accordance account analyses analysis axis bold caused clustering code continental contrasting courier; cycle day different dry em; estimated example, explain future general high-resolution indicating inferred late-Holocene long-term middle package, pattern. proxy pt;} reconstructions. region resulting revealed shown similar space synthesis timing tropical values weak western ka


Slides from my talk "Testing the Multiverse" are up at https://speakerdeck.com/jasonrclark/testing-the-multiverse. Thanks #rubyonales for giving me the opportunity to share!
3/7/2015, 9:35:46 AM
Favs: 2
Retweets: 1
link--- layout: tweet ---
Slides from my talk "Testing the Multiverse" are up at https://speakerdeck.com/jasonrclark/testing-the-multiverse. Thanks #rubyonales for giving me the opportunity to share!
3/7/2015, 9:35:46 AM
Favs: 2
Retweets: 1
link


Exploring make and Makefiles
Prev Next
What is make?
Features
- Programming language interpreter
- Source in:
- Makefile
- makefile
- .mk files
- Non-imperative
- Declarative
- Graph based
GNU make
Version
GNU Make 4.1
Prev Next
copyright Ed Howland 2020 email: ed.howland@gmail.com


---
layout: post
esbma_id: 1428
date: 2001-12-07 12:00:00
keywords: cornsharp
title: Blog entry on 07 Dec 2001
---
So VA Linux has just taken the next step, changing their name to VA Software. I hate to say this, because I've met some cool people at VA, but this company looks like it has definitely jumped the shark. I firmly believe that SourceForge can be productized, but it won't support anything close to their current payroll. OSDN is not going to give them enough presence to pay for itself through indirect SourceForge sales. Their ROI calculator is just dying to be parodied, but I don't have time.


EDUCATION
- University of Ilorin (Unilorin) - Ilorin, Kwara, Nigeria Oct. 2016 - June. 2021
-Bachelor of Science in Zoology (Second Class Honours (Upper Division)
- Mozilla Web Development Online Cours-Web Development (HTML, CSS, JavaScript)
- Learn Python The Hard Way (Zed. A. Shaw) - Python Programming Language
Victory Gate College, Lagos, Nigeria
Senior Secondary School, SSCE
PROFESSIONAL EXPERIENCE
- CENTRAL RESEARCH LABORATORIES, UNIVERSITY OF ILORIN, Jul. - Nov. 2020 ILORIN, KWARA STATE
Laboratory Assistant (Intern)
Worked on Atomic Absorption Spectrophotometer (AAS) machine for running metal analysis, participated in the various procedures involved in Proximate and food analysis, engaged in the culturing of plants invitro in the plant tissue culture laboratory and was taught the ethical considerations regarding the use of laboratory animals. Also assisted during a PHD research on Type II Diabeties.
LEADERSHIP EXPERIENCE
Academic co-ordinator, Hephzibah Word Campus Fellowship, University of Ilorin, Ilorin Nov. 2019 - June. 2021
WORK EXPERIENCE
Sales Clerk, Jestok Pharmacy and Store Sept.2015 - Dec 2015
WAEC Tutor, Home Tutorials April.2020 - June 2020
WAEC Tutor, Todak Tutorial Center Dec. 2020 – March 2021
SKILLS AND INTEREST
- Digital skills: Python programming language, HTML, CSS, JavaScript, Basic Django framework. Confident usage of MS Word, MS Power Point. Proficient social media management ( Facebook, Instagram, Whatsapp )
- Personal skills: Self-motivated, persistent and diligent, tech obsessed, motivator, enjoys learning new things, loves teaching and making impact, aim driven. Loves driving computer equipments to their full potential. Avoids under-utilization of devices.
- Interest: Web design and development, Gaming, App development, Game engines, Computer Processors speed test, Full stack web development, Chess.
Languages: English (Fluent), Yoruba (Native), Pidgin English (Fluent).


Build Checklist
Files and directories to be removed
- .htaccess
- database.ini
- general.log
- error_log
- tests
- util
After removing the files, perform these steps
- The application environment has to be set to production
- The version has to be updated in installer and updater
- .svn directories must be moved
- The update process from previous version has to be thoroughly tested
- Tag the release version in Subversion
- Generate .tar.gz archive
- Upload release tarball to binaryvibes.co.in
- Create a news post at projects.binaryvibes.co.in
- Make a blog post at blog.binaryvibes.co.in. Mention changelog, highlights and plans for future releases.


{% extends 'base.html' %} {% block content %}
Math Contest Format
The contest consists of five rounds: the TCS round, team round, and three individual rounds (Algebra/NT, Geometry, Combo/CS).
In the Theoretical Computer Science (TCS) Round, you will come up an algorithm that represents your best possible solution. Here, "best" is defined differently for each problem - it could be the number of moves that your algorithm makes, or the number of points it earns.
This is a proof-based round, so you will also need to prove the correctness of your algorithm. This means proving that it always solves the given problem, as well as proving that it attains the claimed bound. You will get a higher score for proving a better bound, according to a pre-defined rubric.
You'll be working with your team to solve 3 problems in 90 minutes. You can see the sample problem for a good example of what you'll need to do. No coding experience is required, only algorithmic thinking!
The team round consists of 15 short-answer problems, which you have 60 minutes to solve. The problems will be taken from a variety of subjects, and you can collaborate with your entire team (in a Zoom breakout room) to solve them.
There will be 3 individual rounds, organized by subject: Algebra and Number Theory, Geometry, and Combinatorics and Computer Science. You'll have 60 minutes to solve 8 short-answer problems.
Each student will take all 3 individual rounds, and can choose between divisions 1 and 2 - see details below.
For each individual round, you can choose to take the Division 1 or Division 2 version of the test. Division 1 problems will be harder, but you will earn more points if you manage to solve them.
You can choose between Division 1 and 2 for each subject separately. For example, someone who is especially weak at Geometry but strong at the other subjects might choose to take Division 2 Geometry and Division 1 Algebra/NT and Combo/CS. To choose a division, go to the contests page and click on your team.
You can expect Division 1 to be around the same difficulty as previous CMIMC individual tests, while Division 2's difficulty range covers the easier half of each test (e.g. problems 1-5 on a 10-problem test). To account for this fact, Division 2 problem weights will be scaled down by a factor of 0.5


--- title: spending of the best part of one’s life earning money in order to enjoy a questionable liberty during the least valuable part of it reminds me of the Englishman who went to India to make a fortune first, in order that he might return to England and live the life of a poet. date: '2010-01-12T13:28:26+05:30' tags: [] tumblr_url: https://sureshshanmugam.com/post/330222363/spending-of-the-best-part-of-ones-life-earning ---
spending of the best part of one’s life earning money in order to enjoy a questionable liberty during the least valuable part of it reminds me of the Englishman who went to India to make a fortune first, in order that he might return to England and live the life of a poet.—Walden - Wikiquote


Our Logo
This is a page to elaborate on the history of Real Canadian Recreation and how we got here. The two images on the left are the logo for the Royal Canadian Regiment which inspired the name of the company as well as the logo, and underneath that is the logo for this company.
The owner of Real Canadian Recreation, Tyson Bowen, will be the one to write up the history on the official release of this website. However, because I can't speak to the history of the organization, for the purposes of showing off this website in it's current form, I guess I will speak to the history of this website and how it came to be.
Tyson and I met in the Spring of 2018. We decided to start working together as he had faith in my abilities and I had faith in his business plan. Over the course of the past year, I had worked on the plans for our website, and worked of drafts and logos. Initially, I thought the timeline for this website would be much shorter and I would outsource the coding to some friends that I work with, but in the end, I had more time to learn to code it myself, and so I did.


hero-builder works!
Idea for application:
- Take these tests to find your types
- Make up your own -> with references to what they all mean
- Put links by the appropriate question
- Open links In new window
- Put informational modal up to describe what is being asked
Sidenote
Neutral Good
Personality Test
Test 1
Personality Types
Second Test
second type of test -> probably not going to use this one but does provide more succinct explanations
Alignment Test
Test
Second Test
Alignment Info


{% extends "global/Base.html" %} {% load staticfiles otree %} {% block content %}
On a scale from 50 % = very uncertain to 99 % = very certain, how certain are you that your colleague has made the same choice as you?
{% include Constants.instructions_template %} {% endblock %}