Wardrobe strength

very

$ unzip JPype-0.5.4.1.zip
$ cd JPype-0.5.4.1
$ python setup.py install

$ svn co https://svn.neo4j.org/components/neo4j.py/trunk neo4j-python
$ cd neo4j-python
$ python setup.py install

$ easy_install django

$ django-admin.py startproject neo4django

$ python neo4django/manage.py startapp business

NEO4J_RESOURCE_URI = '/var/neo4j/neo4django'
# NEO4J_RESOURCE_URI should be the path to where
#    you want to store the Neo4j database.

NEO4J_OPTIONS = {
    # this is optional and can be used to specify
    # extra startup parameters for Neo4j, such as
    # the classpath to load Neo4j from.
}

from neo4j.model import django_model as model

class Person(model.NodeModel):
    first_name = model.Property()
    last_name = model.Property()
    def __unicode__(self):
        return u"%s %s" % (self.first_name, self.last_name)

class Company(model.NodeModel):
    name = model.Property(indexed=True)
    owners = model.Relationship(Person,
        type=model.Outgoing.OWNED_BY,
        related_name="owns",
    )
    employees = model.Relationship(Person,
        type=model.Incoming.WORKS_AT,
        related_name="employer",
        related_single=True, # Only allow Persons to work at one Company
    )
    def __unicode__(self):
        return self.name

$ python neo4django/manage.py shell
>>> from neo4django.business import models
>>> seven_eleven = models.Company.objects.create(name="Seven Eleven")
>>> seven_eleven.employees.add(
...     models.Person.objects.create(
...         first_name="Sally", last_name="Getitdone"),
...     models.Person.objects.create(
...         first_name="John", last_name="Workerbee"))
>>> seven_eleven.save() # store the newly created relationships
>>> people = list(seven_eleven.employees.all())
>>> someone = people[0]
>>> print someone, "works at", someone.employer

@java.JavaClass
class WithAField:
    data = java.Field(java.lang.String)

@java.JavaClass
class WithOverloadedMethod:
    @java.Access.public
    def method(self, value:java.lang.String) -> java.util.List[java.lang.String]:
        ...
    @java.Overload(method)
    @java.Access.public
    def method(self, value:java.lang.Integer) -> java.lang.String:
        ...
    @java.Overload(method)
    @java.Access.public
    def method(self, value:java.lang.Iterable[java.lang.String]) -> java.Primitive.void:
        ...

@java.JavaClass
class WithInjectedDependency:
    @javax.inject.Inject # This is JSR 330 by the way
    @java.Access.private
    @java.Field
    dependency = JavaClassIDependOn
    # could expand to: dependency = javax.inject.Inject(
    #     "dependency", java.Access.private(
    #         "dependency", java.Field(
    #             "dependency", JavaClassIDependOn)))
    # or to the same thing as above, depending on how
    # assignment decorators were implemented...

@java.JavaClass
class MyEnum(java.lang.Enum):
    ONE = java.EnumInstance(1)
    TWO = java.EnumInstance(2, True)
    THREE = java.EnumInstance(3, True)
    FOUR = java.EnumInstance(4)
    def __init__(self, number, is_prime=False):
        self.number = number
        self.is_prime = is_prime
    def __str__(self):
        return self.name()
    class SEVENTEEN(java.EnumInstance):
        """This is an enum instance with specialized behavior.
        Will extend MyEnum, but there will only be one instance."""
        def __init__(self):
            """This class gets automatically instantiated
            by the __metaclass__ of Enum."""
            self.number = 17
            self.is_prime = True
        def __str__(self):
            return "The most random number there is."

@java.JavaClass
class GenericClass:
    T = java.TypeParameter() # default is "extends=java.lang.Object"
    C = java.TypeParameter(extends=java.util.concurrent.Callable)

class Something implements Comparable<? extends Something> {
    ...
}

@java.JavaInterface
class MyAnnotation(java.lang.annotation.Annotation):
    name = java.AnnotationParameter(java.lang.String)
    description = java.AnnotationParameter(java.lang.String, default="")

# -*- coding: utf-8 -*-
from __future__ import with_statement, division

from java.lang.System import nanoTime
from java.util.concurrent import Executors, Callable
from java.util.concurrent.atomic import AtomicInteger

from functools import wraps
from threading import Lock

def adder(a, b):
    return a+b

count = 0
def counting_adder(a, b):
    global count
    count += 1 # NOT SYNCHRONIZED!
    return a+b

lock = Lock()
sync_count = 0
def synchronized_counting_adder(a, b):
    global sync_count
    with lock:
        sync_count += 1
    return a+b

atomic_count = AtomicInteger()
def atomic_counting_adder(a,b):
    atomic_count.incrementAndGet()
    return a+b

class Task(Callable):
    def __init__(self, func):
        self.call = func

def callit(function):
    @Task
    @wraps(function)
    def callable():
        timings = []
        for x in xrange(5):
            start = nanoTime()
            for x in xrange(10000):
                function(5,10)
            timings.append((nanoTime() - start)/1000000.0)
        return min(timings)
    return callable

def timeit(function):
    futures = []
    for i in xrange(40):
        futures.append(pool.submit(function))
    sum = 0
    for future in futures:
        sum += future.get()
    print sum

all = (adder,counting_adder,synchronized_counting_adder,atomic_counting_adder)
all = [callit(f) for f in all]

WARMUP = 20000
print "<WARMUP>"
for function in all:
    function.call()
for function in all:
    for x in xrange(WARMUP):
        function.call()
print "</WARMUP>"

pool = Executors.newFixedThreadPool(3)

for function in all:
    print
    print function.call.__name__
    timeit(function)
pool.shutdown()

glob = list(globals())
for name in glob:
    if name.endswith('count'):
        print name, globals()[name]

require 'java'
import java.lang.System
import java.util.concurrent.Executors
require 'thread'

def adder(a,b)
  a+b
end

class Counting
  def initialize
    @count = 0
  end
  def count
    @count
  end
  def adder(a,b)
    @count = @count + 1
    a+b
  end
end

class Synchronized
  def initialize
    @mutex = Mutex.new
    @count = 0
  end
  def count
    @count
  end
  def adder(a,b)
    @mutex.synchronize {
      @count = @count + 1
    }
    a + b
  end
end

counting = Counting.new
synchronized = Synchronized.new

puts "<WARMUP>"
10.times do
  10000.times do
    adder 5, 10
    counting.adder 5, 10
    synchronized.adder 5, 10
  end
end
puts "</WARMUP>"

class Body
  def initialize
    @pool = Executors.newFixedThreadPool(3)
  end
  def timeit(name)
    puts
    puts name
    result = []
    40.times do
      result << @pool.submit do
        times = []
        5.times do
          t = System.nanoTime
          10000.times do
            yield
          end
          times << (System.nanoTime - t) / 1000000.0
        end
        times.min
      end
    end
    result.each {|future| puts future.get()}
  end
  def done
    @pool.shutdown
  end
end

body = Body.new

body.timeit("adder") {adder 5, 10}
body.timeit("counting adder") {counting.adder 5, 10}
body.timeit("synchronized adder") {synchronized.adder 5, 10}

body.done

with lock:
    counter += 1

lock()
invoke closure_body
    // do stuff...
unlock()
invoke __enter__
    Do Jython dispatch
        Do Jython to Java dispatch
            Do Java reflection dispatch
                lock()
// do stuff...
invoke __exit__
    Do Jython dispatch
        Do Jython to Java dispatch
            Do Java reflection dispatch
                unlock()
with neo.transaction:
    with_node = neo.node(language="Python", feature="with statement")
    example__node = neo.node(language="Python", example="Using the with statement")
    example_node.USES(with_node)

tx = neo.transaction.begin()
try:
    try:
        try_node = neo.node(language="Python", feature="try block")
        example__node = neo.node(language="Python", example="Not using the with statement")
        example_node.USES(try_node)
    except:
        tx.failure()
        raise
    else:
        tx.success()
finally:
    tx.finish()

(define-generator (iterate lst)
 (define (iter lst)
    (if (not (null? lst))
        (begin (yield (car lst))
               (iter (cdr lst)))))
 (iter lst))
(for (element (iterate '(a b c))
  (print element))
(define-syntax explicit-generator-definition
 (syntax-rules (yield)
  ((explicit-generator-definition (yield exit) params . body)
   (lambda params
     (lambda (done loop)
       (define (exit . values)
         (call/cc (lambda (next) (apply loop (cons next values)))))
       . body)))))

(define-syntax for
 (syntax-rules (break continue)
  ; multiple valued generator version
  ((for (break breaker) (continue continuation)
        ((variables ...) generator) . body)
   (call/cc
    (lambda (breaker) (generator breaker
                                 (lambda (continuation variables ...)
                                   . body)))))
  ; single valued generator version
  ((for (break breaker) (continue continuation)
        (variable generator) . body)
   (call/cc
    (lambda (breaker) (generator breaker
                                 (lambda (continuation variable)
                                   . body)))))
  ; enable ignoring break and continue
  ((for (continue continuation) (break breaker) (target ...) . body)
   (for (break breaker) (continue continuation) (target ...) . body))
  ((for (break breaker) (targets ...) . body)
   (for (break breaker) (continue ignored) (targets ...) . body))
  ((for (continue continuation) (targets ...) . body)
   (for (break ignored) (continue continuation) (targets ...) . body))
  ((for (targets ...) . body)
   (for (break _break) (continue _continue) (targets ...) . body))))
(for (break break) (continue continue) (element (iterate '(a b c))
  (print element))
(define-macro (generator arguments . body)
 `(explicit-generator-definition (yield yield) ,arguments ,@body))

(define-macro (define-generator signature . body)
 `(define ,(car signature)
   (explicit-generator-definition (yield yield) ,(cdr signature) ,@body)))
(define-generator (range . params)
(define (range start stop step)
  (if (and (> start stop) (> step 0))
      (values start (lambda (current) (<= current stop)) (- step))
      (values start (lambda (current) (>= current stop)) step)))
(call-with-values
 ; parse the variables based on the number of them
 (lambda () (cond
              ; 0 arguments ->
              ((null? params)
               ; infinite generator from 0
               (values 0 (lambda (current) #f) 1))
              ; 1 argument: count ->
              ((null? (cdr params))
               ; generator with count elements, starting at 0
               (range 0 (car params) 1))
              ; 2 arguments: start and stop ->
              ((null? (cddr params))
               ; generator over [start, stop[
               (range (car params) (cadr params) 1))
              ; 3 arguments: start, stop and step ->
              ((null? (cdddr params))
               ; generator over [start, stop[ with a given step length
               (range (car params) (cadr params) (caddr params)))
              ; more arguments - error (by passing too few arguments to internal range
              (#t (values))))
 (lambda (start stop? step)
   (do ((current start (+ current step)))
       ((stop? current))
     (yield current)))))
(define-syntax for*
(syntax-rules (break continue)
  ; base case - one generator - expands to single for
  ((for* (((break breaker) (continue continuation) targets ...)) . body)
   (for (break breaker) (continue continuation) (targets ...) . body))
  ((for* (((continue continuation) (break breaker) targets ...)) . body)
   (for (break breaker) (continue continuation) (targets ...) . body))
  ((for* (((break breaker) targets ...)) . body)
   (for (break breaker) (targets ...) . body))
  ((for* (((continue continuation) targets ...)) . body)
   (for (continue continuation) (targets ...) . body))
  ((for* ((targets ...)) . body)
   (for (targets ...) . body))
  ; recursive case - more than one generator - expands to nested for*
  ; for* is used instead of for to avoid repeating break and continue cases
  ((for* (first more ...) . body)
   (for* (first) (for* (more ...) . body)))))
; A generator expands to a function that accepts the defined parameters
(lambda params
  ; The generator function, when called, returns a function to which
  ; the for-construct passes the break continuation and a closure
  ; representing the body of the loop
  (lambda (done loop)
    ; yield is defined as a function that takes arbitrary parameters
    (define (exit . values)
      ; when invoked it retrieves the current continuation to be
      ; able to resume then calls the loop body with the continuation
      ; and the passed in parameters as arguments
      (call/cc (lambda (next) (apply loop (cons next values)))))
    ; The actual body of the generator is defined by the user,
    ; this executes arbitrary code and calls yield.
    . body))

; The for-construct starts by retrieving the current conitunuation
; this is used for breaking the loop
(call/cc
  ; It then calls the generator with two arguments:
  ; the break continuation and the body of the loop.
  (lambda (breaker) (generator breaker
  ; The body of the loop accepts two arguments:
  ; the continue continuation and the argument that was passed to yield.
                               (lambda (continuation variable)
                                 ; All it does is execute the body
                                 . body))))
package java.util;

import java.util.iter.*;

public final class Iterators {
    public <E> Iterable<E> empty() { ... }
    public <S,T> Iterable<T> convert(Iterable<S> iterable, Converter<S,T> converter) { ... }
    public <T> Iterable<T> upCast(Iterable<? extends T> iterable) { ... }
    public <T> Iterable<T> downCast(Class<T> target, Iterable<?> iterable) { ... }
    public <T> Iterable<T> append(Iterable<T>... iterables) { ... }
}

// These classes should preferably be reused from somewhere.
package java.util.iter;

public interface Converter<S,T> {
    T convert(S source);
}

public interface Filter<E> {
    boolean accept(E element);
}
package org.thobe.example;

import java.util.Iterators;
import java.util.iter.*;

class UsesIteratorComposition {
    private class Something {}
    private class Source extends Something {}
    private class Target { Target(Source s) {} }

    Iterable<Source> source = Iterators.empty();

    void conversions() {
        Iterable<Target> target = Iterators.convert(source, new Converter<Source,Target>() {
            Target convert(Source source) {
                return new Target(source);
            }
        });
    }

    void casts() {
        Iterable<Something> something = Iterators.upCast(source);
        Iterable<Source> back = Iterators.downCast(Source.class, something);
    }

    void append() {
        Iterable<Source> source = Iterators.append(source, new ArrayList<Source>(){
            {
                add(new Source());
                add(new Source());
            }
        });
    }
}
package java.util.concurrent;

public abstract class LazyLoaded<T> {
    private volatile T value;
    // Get the value, guard the loading by double checked locking
    public final T getValue() {
        T result = value;
        if (result == null)   { // First check
            synchronized (this) { // Lock
                result = value;
                if (result == null) { // Second check
                    result = loadValue();
                    value = result;
                }
            }
        }
        return result;
    }
    protected abstract T loadValue();
}
package org.thobe.example;

import java.util.concurrent.LazyLoaded;

class UsesDoubleCheckedLocking {
    // The generics even makes it read well:
    private final LazyLoaded<Something>() {
        @Override protected Something loadValue() {
            return new Something();
        }
    };
    // ... your code will probably do something useful here ...
}
import sys

class Restriction(object):
    __forbidden = set()
    @classmethod
    def add(cls, module_name):
       cls.__forbidden.add(module_name)
    def find_module(self, module_name, package_path):
       if package_path: return
       if module_name in self.__forbidden:
       return self
    def load_module(self, module_name):
       raise ImportError("Restricted")

sys.meta_path.append(Restriction())
add = Restriction.add
del Restriction

Wardrobe strength

Seamless Neo4j integration in Django

Why the **** has this taken a year to finish?

Getting started

Future evolution

Java integration in future Jython

The content of the java module

Outstanding issues

java for other Python implementations

Integration from the Java perspective

What do you think?

"Social networking" killed productivity

Improving performance in Jython

The benchmarks

Where we started

Getting better

The current state of performance of Jython synchronization primitives

Where do we proceed from here?

My view of EuroPython 2009

Performance of Synchronization primitives in Jython

The effect of the implementation

The incredible benefit of closures

Five years later

Jython 2.5 - Why you should upgrade

JavaOne 2009 from my perspective

Language Interoperability on the JVM Made Simple

Exploiting Concurrency with Dynamic Languages

Twitter: #dontfixreplies

Python-style generators in Scheme

On Iterator composition in Java

On Double Checked Locking in Java

About types in Neo4j

Call frame introspection on the JVM

Meta post: Querying languages versus APIs

Meta post: Introducing the concept of meta posts

My JVM wishlist, pt. 1 - Interface injection

The state of the advanced compiler

EuroPython 2008

Simple stuff with import hooks in Python

Jython call frames and Dynamic Languages Symposium

Jython thesis project

The next step to increase Python compatability in Jython

Den moderna människans (mitt) förfall

The content of the `java` module

`java` for other Python implementations