<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en" >
	<head>
		<title>log4javascript 1.4 distribution</title>
		<meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
		<meta name="author" content="Tim Down - tim@log4javascript.org" />
		<meta name="description" content="log4javascript, a logging framework for JavaScript based on log4j" />
		<meta name="robots" content="all" />
		<link rel="stylesheet" type="text/css" media="screen,print" href="../main.css" title="Default" />
	</head>
	<body>
		<div id="container" class="nonav">
			<div id="header">
				<h1><a href="../index.html">log4javascript</a></h1>
			</div>
			<div id="content">
				<div id="nav">
					<a class="navitem" href="../index.html">home</a>
					| <a class="navitem" href="http://sourceforge.net/projects/log4javascript" target="_blank" title="Download (opens in new window)">download</a>
					| <a class="navitem" href="index.html">docs</a>
					| <a class="navitem" href="quickstart.html">quick start</a>
					| <a class="navitem" href="../demos/index.html">demos</a>
					| <a class="navitem" href="http://log4javascript.org" target="_blank">website</a>
					| <a class="navitem" href="http://www.timdown.co.uk" target="_blank">timdown.co.uk</a>
				</div>
				<h1>log4javascript 1.4 distribution</h1>
				<p>
					From version 1.4 the distribution includes three different editions of log4javascript:
				</p>
				<ul>
					<li>
						<div><strong>Standard Edition</strong></div>
						<p>
							Equivalent to log4javascript from earlier versions and suitable for general JavaScript
							debugging and logging (including via Ajax).
						</p>
					</li>
					<li>
						<div><strong>Production Edition</strong></div>
						<p>
							Designed for use in production systems where the focus is solely on logging JavaScript
							messages back to the server. Consequently this edition omits all appenders except
							<a href="manual.html#ajaxappender">AjaxAppender</a>, resulting in a drastically reduced
							file size compared to the standard edition.
						</p>
					</li>
					<li>
						<div><strong>Lite Edition</strong></div>
						<p>
							A lightweight version of log4javascript for quick page debugging. Included is a single logger
							using a basic pop-up window appender with a fixed layout.
						</p>
					</li>
				</ul>
				<p>
					Each edition comes in compressed and uncompressed versions. The compressed version is
					functionally identical to the uncompressed version but has had whitespace and comments removed
					and therefore downloads more quickly.
				</p>
				<p>
					Each edition also comes with a stub version. This contains dummy implementations of all
					log4javacript objects and methods in the public API, making it ideal for production environments
					where logging is not required. Replacing the main log4javascript script file with this file
					means that log calls may be left in production code. Compressed and uncompressed versions of
					each stub are included.
				</p>
				<p>
					Finally, each edition comes with a suite of unit tests, available as HTML pages in the
					<code>test/</code> directory. Note that these tests crash old versions (pre-3.1) of Safari. Sorry.
				</p>
			</div>
			<div id="footer">
				<span class="externallinkinfo">
					<strong>NB.</strong> All external links open in a new window.
				</span>
				Written by Tim Down. <a href="mailto:tim@log4javascript.org">tim@log4javascript.org</a>
				<br />
				log4javascript is distributed under the <a href="http://www.apache.org/licenses/LICENSE-2.0.html"
					title="Apache License, Version 2.0 (opens in new window)" target="_blank">Apache License,
					Version 2.0</a>

			</div>
		</div>

	</body>
</html>
