Jython What is Jython? As previously mentioned, Jython is an implementation of Python written in the Java

Jython

What is Jython?

• As previously mentioned, Jython is an implementation of Python written in the Java

• language and integrated with the Java platform. Python is a scripting language often

• used in UNIX-based systems, including Linux. Python was invented by Guido van

• Rossum and introduced to the developer community in 1991. Jython currently supports

• the Python syntax at level 2.1.

What is a scripting language?

• · Very easy to learn and code

• · Expressive and concise, yet powerful

• · Has minimal required structure to create a running "program"

• · Supports interactive (command-at-a-time) execution

• · Does not require a compile step

• · Supports reflective programming

• · Supports functional programming

• · Supports dynamic execution of source (that is, an eval function)

• · Runs external programs

• Clean, easy-to-read syntax

• Python was designed from the ground up to be as readable as possible--it's been described as "executable pseudocode." Python's use of indentation to denote block boundaries makes for consistent and clear code. Unlike some other scripting languages, Python syntax tends to be in words rather than typographical syntax--it's very unlikely you'll be writing lines of code that look like comic book curse words. As a result, when you have to come back to your code six months later, odds are you will still be able to understand it.

• Interactive interpreter

• Jython has a command-line interpreter where you can enter any Jython expression (including function definitions, class definitions, and module imports) and evaluate it interactively. The interactive session makes it easy to test and debug Jython code and also to explore existing Java libraries by trial and error

• Module-based organization

• Unlike Java, where every line of code has to be inside a class definition, Jython separates the package organization from the class system. A Jython module can contain any valid statement, including class and function definitions as well as normal program code. The lack of insistence on structure is particularly nice in short scripts, but also helpful for distributing a number of related classes together.

• High-level, built-in types

• Jython's list of basic types includes a few that go beyond Java's basic data types. These include sequence types similar to Java collection classes and dictionaries similar to Java's map classes. Having these types built into the language makes them easier to work with--you can enter an entire dictionary as a literal expression, for example. Jython also includes a built-in file type which is far easier to use than Java's I/O classes.

• Simple object-oriented semantics

• Classes, instances, and modules are all implemented using the same simple concept of a namespace or mapping between variable names and values. Syntax and behavior of all three are similar, and are only a short step from the behavior of any Python dictionary. This consistency makes the behavior of Python programs extremely easy to predict, with nearly no special cases or exceptions to be memorized.

• Operator overloading

• Python allows you to easily overload all operators and many built-in functions to work as desired on user-defined classes. This allows your classes to interoperate cleanly with built-in types, and can also result in clearer code.

• Dynamic dispatch and polymorphism

• Both Python and Java have dynamic dispatch, meaning that the class whose code is evaluated from a line such as instance.method( ) is determined at runtime based on the class to which that instance belongs. Unlike Java, Python does not test for the existence of method( ) in any particular class at compile time. This is a corollary of dynamic typing, and has many of the same strengths and weaknesses. However, the flexibility it gives you over Java is significant, removing the need for Java-style interfaces and more generally promoting code reuse by making it easier for new code to interact with existing code.

• No compile phase

• The Jython development cycle does not have a separate compilation phase. Files are compiled if needed during execution, speeding up development.