Anonymous committed dd1b66e

Adding Chapter 10 Final Draft, Updating chapter headers to indicate draft or final version

  • Participants
  • Parent commits fdf9d35

Comments (0)

Files changed (22)

File DataTypes.rst

-Chapter 2:  Data Types and Referencing
+Chapter 2:  Data Types and Referencing - *Final v1.0*
 Programming languages and applications need data. We define applications to work with
 data, and we need to have containers that can be used to hold it. This chapter is all

File DefiningFunctionsandUsingBuilt-Ins.rst

-Chapter 4:  Defining Functions and Using Built-ins
+Chapter 4:  Defining Functions and Using Built-ins - *Final v1.0*
 Functions are the fundamental unit of work in Python. A function in Python
 performs a task and returns a result. In this chapter, we will start with the

File ExceptionHandlingDebug.rst

-Chapter 7:  Exception Handling and Debugging
+Chapter 7:  Exception Handling and Debugging - *Final v1.0*
 Any good program makes use of a language’s exception handling mechanisms. There
 is no better way to frustrate an end-user then by having them run into an issue

File InputOutput.rst

-Chapter 5:  Input and Output
+Chapter 5:  Input and Output - *Final v1.0*
 A program means very little if it does not take input of some kind from the
 program user. Likewise, if there is no form of output from a program then one

File LangSyntax.rst

-Chapter 1:  Language and Syntax
+Chapter 1:  Language and Syntax - *Final v1.0*
 *Elegant* is an adjective that is often used to describe the Python language.
 The word elegant is defined as “pleasingly graceful and stylish in appearance or manner.” *Uncomplicated* and *powerful* could also be great words to assist in the description of this language.

File ModulesPackages.rst

-Chapter 8:  Modules and Packages for Code Reuse
+Chapter 8:  Modules and Packages for Code Reuse - *Final v1.0*
 Up until this chapter, we have been looking at code at the level of
 the interactive console and simple scripts. This works well for

File ObjectOrientedJython.rst

-Chapter 6:  Object-Oriented Jython
+Chapter 6:  Object-Oriented Jython - *Final v1.0*
 This chapter is going to cover the basics of object-oriented programming. We’ll start with covering the basic reasons why you would want to write object-oriented code in the first place, and then cover all the basic syntax, and finally we’ll show you a non-trivial example.
 Object-oriented programming is a method of programming where you package your code up into bundles of data and behavior. In Jython, you can define a template for this bundle with a class definition. With this first class written, you can then create instances of that class that include instance-specific data, as well as bits of code called methods that you can call to do things based on that data. This helps you organize your code into smaller, more manageable bundles.

File OpsExpressPF.rst

-Chapter 3:  Operators, Expressions, and Program Flow
+Chapter 3:  Operators, Expressions, and Program Flow -  - *Final v1.0*
 The focus of this chapter is an in-depth look at each of the ways that we can
 evaluate code, and write meaningful blocks of conditional logic. We’ll cover

File Scripting.rst

-Chapter 9:  Scripting With Jython
+Chapter 9:  Scripting With Jython - *Final v1.0*
 In this chapter, we will look at scripting with Jython. For our
 purposes, we will define 'scripting' as the writing of small

File appendixA.rst

-Appendix A:  Using Other Tools with Jython
+Appendix A:  Using Other Tools with Jython - *Draft*
 The primary focus of this appendix is to provide information on using some external
 python packages with Jython.  In some circumstances, the tools must be used or installed

File appendixB.rst

-Appendix B:  Jython Cookbook - A compilation of community submitted code examples
+Appendix B:  Jython Cookbook - A compilation of community submitted code examples - *Draft*
 There are a plethora of examples for using Jython that can be found on the web.  This
 appendix is a compilation of some of the most useful examples that we have found.  There

File appendixC.rst

-Appendix C: Built-in Functions
+Appendix C: Built-in Functions - *Draft*
 Constructor Functions

File chapter11.rst

-Chapter 11: Using Jython in an IDE
+Chapter 11: Using Jython in an IDE - *Chapter Draft*
 In this chapter, we will discuss developing Jython applications using two of the most popular integrated development environments, Eclipse and Netbeans.  There are many other development environments available for Python and Jython today, however, these two are perhaps the most popular and contain the most Jython-specific tools.  Eclipse has had a plugin known as PyDev for a number of years, and this plugin provides rich support for developing and maintaining Python and Jython applications alike. Netbeans began to include Python and Jython support with version 6.5 and beyond.  The Netbeans IDE also provides rich support for development and maintenance of Python and Jython applications. 

File chapter12.rst

-Chapter 12- Databases and Jython: Object Relational Mapping and Using JDBC
+Chapter 12- Databases and Jython: Object Relational Mapping and Using JDBC - *Chapter Draft*
 First, we will look at zxJDBC package, which is a standard part of

File chapter13.rst

-Chapter 13: Simple Web Applications
+Chapter 13: Simple Web Applications - *Chapter Draft*
 One of the major benefits of using Jython is the ability to make use of Java platform capabilities programming in the Python programming language instead of Java.  In the Java world today, the most widely used web development technique is the Java servlet.  Now, in JavaEE there are techniques and frameworks used so that we can essentially code HTML or other markup languges as opposed to writing Pure Java servlets.  However, sometimes writing a pure Java servlet still has it's advantages.  We can use Jython to write servlets and this adds many more advantages above and beyond what Java has to offer because now we can make use of the Python language features as well.  Similarly, we can code web start applications using Jython instead of pure Java to make our lives easier.  Coding these applicatons in pure Java has proven sometimes to be a difficult and sometimes grueling task.  We can use some of the techiques available in Jython to make our lives easier.  We can even code WSGI applications with Jython making use of the *modjy* integration in the Jython project.

File chapter14.rst

-Chapter 14:  Web Applications with Django
+Chapter 14:  Web Applications with Django - *Chapter Draft*
 Django is one of the modern Python web frameworks which redefined the web niche
 in the Python world. A full stack approach, pragmatic design and superb

File chapter15.rst

-Chapter 15: Introduction to Pylons
+Chapter 15: Introduction to Pylons - *Chapter Draft*
 While Django is currently the most popular webframework for Python, it
 is by no means your only choice.  Where Django grew out of the needs

File chapter16.rst

-Chapter 16:  GUI Applications
+Chapter 16:  GUI Applications - *Chapter Draft*
 The C implementation of Python comes with Tcl/TK for writing Graphical User
 Interfaces (GUIs).  On Jython, the GUI toolkit that you get automatically is

File chapter17.rst

-Chapter 17: Deployment Targets
+Chapter 17: Deployment Targets - *Chapter Draft*
 Deployment of Jython applications varies from container to container.  However, they are all very similar and usually allow deployment of WAR file or exploded directory web applications.  Deploying to "the cloud" is a different scenario all together.  Some cloud environments have typical Java application servers available for hosting, while others such as the Google App Engine, and moble run a bit differently.  In this chapter, we'll discuss how to deploy web based Jython applications to a few of the more widely used Java application servers.  We will also cover deployment of Jython web applicaitons to the Google App Engine and mobile devices.  While many of the deployment scenarios are quite similar, this chapter will walk through some of the differences from container to container.

File chapter18.rst

-Chapter 18:  Testing and Continuous Integration
+Chapter 18:  Testing and Continuous Integration - *Chapter Draft*
 Nowadays, automated testing is a fundamental activity in software
 development. In this chapter you will see a survey of the tools available for

File chapter19.rst

-Chapter 19:  Concurrency
+Chapter 19:  Concurrency - *Chapter Draft*
 Supporting concurrency is increasingly important. In the past,
 mainstream concurrent programming generally meant ensuring that the
     Leo Soto,
     Frank Wierzbicki
-:Version: .99 of 02/02/2010
+:Version: .99 of 02/07/2010
 **Please note that only Part I contains FINAL versions for this book.  The rest
    :maxdepth: 2
-   chapter10.rst
+   JythonAndJavaIntegration.rst