[Jifty-commit] r4550 - in Jifty-Book: .

[jifty-commit at lists.jifty.org]

Author: sterling
Date: Tue Nov 27 22:34:09 2007
New Revision: 4550

Modified:
   Jifty-Book/   (props changed)
   Jifty-Book/doc/Jifty/Book/Part-A/01-Introduction.pod

Log:
 r14252 at dynpc145:  andrew | 2007-11-27 21:33:53 -0600
 First draft for most of the introduction is complete. Please proofread me.


Modified: Jifty-Book/doc/Jifty/Book/Part-A/01-Introduction.pod
==============================================================================
--- Jifty-Book/doc/Jifty/Book/Part-A/01-Introduction.pod	(original)
+++ Jifty-Book/doc/Jifty/Book/Part-A/01-Introduction.pod	Tue Nov 27 22:34:09 2007
@@ -22,18 +22,110 @@
 
 =head1 Web 2.0
 
+M<Web 2.0> is a term coined by Tim O'Reilly and basically means a second-generation web application. Many, including Tim O'Reilly, mark the "dot-com bust" of 2001 as the turning point from the failure of first-generation to the success second-generation of web applications. 
+
+There's no specific factor that marks a web application as Web 2.0, but there are a few hallmarks. However, the largest single marker of a Web 2.0 application is advanced end-user participation. Such an application gives creative control over the use of the application to the end-users rather than more rigid control by the application's developers. The users help determine what the application is good for and, in a sense, help develop it.
+
 =head1 What is Jifty?
 
+A Jifty application does not actually have to be a Web 2.0 application. However, the framework is constructed with such applications in mind. The goal of Jifty is to provide tools to the developer that make it easier for her to grant greater control to the end user.
+
+=head2 Features
+
+Jifty does this by providing many tools to the programmers kit:
+
+=over
+
+=item * Schema management tools so the developers can focus on the structure of the data rather than maintaining the structure.
+
+=item * Security features to allow the developers some control over who can view and modify the data.
+
+=item * Helpers for building different views of the data.
+
+=item * JavaScript tools so the developers can enhance the UI with advanced tools that fail gracefully when faced with diverse web clients and accessbility needs.
+
+=item * Localization helps so that your application can be easily tailored to meet the needs of those speaking other languages and dialects and formats regarding dates and currency.
+
+=item * Email tools to help you send out notices and other information in a push fashion.
+
+=item * API interfaces that allow external applications and automatic agents to leverage your program.
+
+=back
+
+All of these can be used to build a Web 2.0 application that is focused on providing a rich experience for your end-users.
+
 =head2 History
 
-=head2 Purpose
+TODO Jesse should write something here about how Jifty was started, why, etc...
 
 =head2 Philosophy
 
+The framework has been designed according to some specific principles. These principles have guided many of the design decisions made and are much of the reason the developers who use Jifty have chosen it.
+
+=over
+
+=item DRY (Don't Repeat Yourself)
+
+A M<DRY> application is one that does not contain copied-and-pasted code. A M<DRY> application framework is one that allows applications on a specific platform to focus on the big picture rather than the nuts-and-bolts of the workspace.
+
+It is counter-productive, frustrating, and even less robust to create an application that contains the same pieces over and over again. Good developers work hard to make sure that they do everything one time and do that thing well by breaking everything up into pieces that can be reused within the program as well as possible. Copy-and-paste is evil! We don't do it! (Well, okay, we try really hard not to...)
+
+If we then expand our consideration to classes of applications, we find the same principle applies. It doesn't make sense to copy and paste the request-handling code from application to application, making small modifications along the way. Instead, we believe it is much more efficient to abstract aspects of request handling so that you don't have to deal with all the details over and over again.
+
+Jifty attempts to provide all the basic tools needed by every web application so that the application developer can focus on what is unique to her application. Nice, huh? Not only this, but Jifty provides the tools so that as the Jifty framework gets better, you don't (usually) have to make major changes to your application to take advantage of the new features and bug fixes.
+
+Now, you don't have to worry about handling requests, you can start by worrying about how you're going to use the information in the request. You don't have to worry about storing your data. Instead, you can worry about what data to store and how best to present that data to the user.
+
+=item Full-stack
+
+By being a M<full-stack> framework, Jifty provides all the tools you need in one magic box. To build a data-centric web application you need things like templating tools, database schema tools, request-handling tools, session-handling tools, etc. Jifty provides a solution to every area.
+
+The alternative would be to use a framework like the Catalyst Framework, which provides some structure and principles for design, but doesn't make many policy decisions for your application. Catalyst itself doesn't provide all the tools you need, but many different tools can be plugged together to provide a complete framework.N<Actually, this isn't precisely correct since there is a full-stack distribution of Catalyst designed to help new developers get started with the framework.>
+
+Jifty does provide some flexibility, in fact, more and more all the time, but the goal is to provide all the tools together in one kit. Jifty does provide alternatives for some tools, but, in general, Jifty applications all use a very similar selection of tools.
+
+=item Continuations
+
+The concept of M<continuations> is not new, but using them to build web applications is somewhat new. The idea of a continuation is to freeze the state of your application at a certain point so that the state of your application can be resumed later. 
+
+Since the Perl programming language doesn't actually provide continuations (yet), Jifty has fudged a little and created its own concept of continuations that freeze the most vital aspects of a Jifty web application. These, then, become very useful for performing tasks like being able to take "tangential" actions that return to home.
+
+For example, you can use Jifty continuations to easily construct a login screen that pops up when a user tries to access a restricted screen. When the user finishes login, the user can be sent back to whichever screen they started on with all the information of the original request intact---even if they submitted a complicated form.
+
+=item Form-based dispatch
+
+The intent of M<form-based dispatch> is to make forms just go without the application developer having to put a lot of thought into the process. HTML forms are really weak tools. Until all browsers implement some of the new form and widget stanards, we're stuck with them.
+
+Jifty takes these weaknesses and applies several techniques to make HTML forms that are more powerful and require less involvement from you to make them work. You can focus on what information you need users to send you and Jifty will take care of the rest. You can even present multiple "sub-forms" with a single form submission with no more complexity than a handling a single submission at a time.
+
+=item Perl
+
+Jifty is written by developers that love Perl. We know what Perl is good at and we know what Perl is weak at, particularly since many of the same developers that built Jifty, help build Perl.
+
+Perl provides a great deal of flexibility in how different logic can be expressed. There's More Than One Way To Do It. Jifty is built on Perl in both the language it has been expressed in and in the philosophy with which it has been developed.
+
+=item CPAN
+
+One of the reasons Perl is great is CPAN. CPAN provides a vast repository of libraries to do everything from checking email, to calculating pie, to writing programs in DNA sequences. Jifty attempts to use CPAN to its full advantage by not reinventing the wheel when a robust solution already exists on CPAN to perform a task.
+
+Jifty has a large number of CPAN requirements. For example, this means that the developers of Jifty can focus on providing convenient charting tools rather than worrying about the best way to draw a pie.N<Mmmm... pie...> 
+
+However, it also means that installing Jifty can be a chore because installing all those dependencies and all the dependencies of those dependencies and so one can be time consuming and frustrating task. This book tries to make that task less difficult.
+
+=item A Pony
+
+What other framework comes with a Pony? They're short. They're cuddly and we love ponies. Whenever you build a Jifty application, you too will enjoy the pony.
+
+=back
+
 =head1 Audience for this Book
 
+TODO Add some information about the audience.
+
 =head1 Conventions in this Book
 
+TODO What are the conventions in this book. We don't know yet, do we? DO WE!?
+
 =head2 Chapter Structure
 
 The basic structure of each chapter will be as follows:
@@ -58,8 +150,6 @@
 
 The final major section of each chapter will cover testing strategies. The key to developing good applications is to build solid tests that will verify that your code works as expected. The major difficulty is how to do that. For each topic covered, we've tried to provide some examples related to the tutorial and guidelines on how to apply test strategies in your applications.
 
-=head2 Other Conventions
-
 =head1 Getting More Help
 
 This book is only one help available to you. You should also consider these additional resources: