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))))

Tuesday, December 15, 2009

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

Getting started

Future evolution

Friday, August 07, 2009

The content of the java module

Outstanding issues

java for other Python implementations

Integration from the Java perspective

What do you think?

Friday, July 31, 2009

Wednesday, July 15, 2009

The benchmarks

Where we started

Getting better

The current state of performance of Jython synchronization primitives

Where do we proceed from here?

Monday, July 06, 2009

Sunday, June 28, 2009

The effect of the implementation

The incredible benefit of closures

Friday, June 26, 2009

Thursday, June 25, 2009

Thursday, June 18, 2009

Language Interoperability on the JVM Made Simple

Exploiting Concurrency with Dynamic Languages

Thursday, May 14, 2009

Wednesday, April 22, 2009

Stuff worth reading

Twitter Updates

Stuff I read

Lijit Search

Blog Archive

Post categories

The content of the `java` module

`java` for other Python implementations