Finally it’s released, http://blog.leosoto.com/2009/11/django-jython-100-released.html

Most importantly, the oracle support has been added…

Even before I actually study it in detail, Clojure becomes my latest fixation. A Lisp-based functional, general-purpose language, which produces JVM bytecode and has access to Java libraries? Sounds like a dream come true. I never liked Java, and as a matter of fact, I consider myself a Java-dyslexic. No matter how much I tried in the past, I never got around learning enough of it to use further than “Hello, world”s. Its syntactic resemblance to C, with which I am (was?) quite proficient, didn’t help much. Nevertheless, the breadth and depth of libraries that exist in Java are mind-boggling, and the ability to use them with a different language is just great. I know there are other JVM-based languages, e.g. Scala, but somehow after reading introductory material they never enticed me enough. Also, I really don’t know how come, although a big fan of Python I never tried Jython. I assume I just preferred the real thing — Python also has an extensive and compelling set of libraries.

In any case, I’ll try to get a closer look at Clojure and come back with a more complete opinion.

Qt Designer is an important tool for designing and building graphical user interface from Qt components. However, if you are a Java programmer and want to use Qt Designer with Qt Jambi in Mac, you can’t simply double-click the Designer app bundle shipped with Qt Jambi SDK. If you do so, you can still invoke the Designer, but… with the C++ environments, it’s useless for Java programmers. Instead, if you want to use Qt Designer with Qt Jambi. You have to start the program from a `designer.sh` script placed in your Qt directory. It’s pretty annoying because you’ll need a Terminal to run this script until you turn it off. Also, it’s not intuitive.

So, I checked the script code and found what it does is simply to set some environment variables and then execute the Designer binary within the Designer app bundle. Therefore, I decided to make a “real” app bundle for the Qt Designer with Qt Jambi. It’s pretty easy to do this job by using Jump, one of my open source projects. Here’s the instructions.

1. Go to the `QTDIR/bin` directory in Finder.
2. Right-click the `Designer` app bundle, select `Show Package Contents`, and it will open a new Finder window.
3. In the new opened Finder window, go to the `Contents/MacOS` directory, then copy the `Designer` binary back to `QTDIR/bin`.
4. Now pick a location to start writing our wrapper. I simply make a directory called `designer` in my home directory, then open a Terminal and switch to it.
5. Back to the new opened Finder window, copy the `Contents/Resources/designer.icns` file to our new created `designer` directory.
6. Create a Python module named `designer.py` in `designer` directory, and its content looks like this:

   import os
   # Replace this path to your QTDIR
   qt_home = '/Users/olliwang/workspace/qtjambi-mac-lgpl-4.5.2_01'
   
   def main():
       os.environ['QTDIR'] = qt_home
       os.environ['DYLD_LIBRARY_PATH'] = os.path.join(qt_home, 'lib')
       os.environ['QT_PLUGIN_PATH'] = os.path.join(qt_home, 'plugins')
       os.environ['PATH'] = os.path.join(qt_home, 'bin')
   
       classpaths = []
       for filename in os.listdir(qt_home):
           if filename.endswith('.jar'):
               classpath = os.path.join(qt_home, filename)
               classpaths.append(classpath)
       os.environ['CLASSPATH'] = ':'.join(classpaths)
       os.system(os.path.join(qt_home, 'bin/Designer'))

7. Create a `config.jp` file with following content:

   dist_name = Designer
   main_entry_point = designer:main
   icns = designer.icns

8. Run `jump app` in your Terminal, and you’ll see a new created directory called `dist`, our new app bundle is in there.
9. Copy the created app bundle back to the `QTDIR/bin` directory, now double-click the `Designer` app bundle and everything should work fine. Cheers!

I use Python to write this wrapper for easy, you can of course do the same thing in Java. Just remember to modify the `main_entry_point` to the `Main Class` in config file.

I am proud to announce that Jump 0.9.5.1 is released!
You can find the Jump project and its documentation at http://opensource.ollix.com/jump.

Jump is a build tool for distributing Jython applications in a really easy step.

Features:

• Distributing Jython applications into a single, independent JAR file. [New in v0.9.5]
• Distributing Jython libraries into a single JAR file.
• Distributing native Mac OS X application bundles, Windows .exe executables, WAR files for Python WSGI applications. [New in v0.9.5]
• Supporting Java source code and third-party JAR files.
• Supporting Java Native Interface files for distributing JAR files. [New in v0.9.5]
• Starting the created distribution from either Jython or Java code.
• Packaging **only required** Python modules into the final distribution **automatically**, which means you don’t have to worry about using Python third-party libraries as long as they can be found in your `sys.path`.
• Importing specified Python packages explicitly. [New in v0.9.5]
• All Python modules (except Python’s standard library) packaged into the final distribution are compiled to `$py.class` files, which means your source code is not public.

If you have any question or bug report, please post it to our mailing list at http://groups.google.com/group/ollix-jump, contributions are welcome as well.

I am proud to announce that Jump 0.9.0 is released!
You can find the Jump project and its documentation at http://opensource.ollix.com/jump.

This version is the Jump’s first release. The goal of Jump is to make a distribution for Jython applications in a really simple step.

Features:

• Distributing Jython applications into a single, independent JAR file.
• Supporting Java source code and third-party JAR files.
• Starting the distribution from either Jython or Java code.
• Packaging `only required` Python modules into the final distribution `automatically`, which means you don’t have to worry about using Python third-party libraries as long as they can be found in your `sys.path`.
• All Python modules packaged into the final distribution are compiled to $py.class files, which means your source code is not public.

The Future:

• Creating native applications for Mac, Windows and Linux.
• Creating web application archive (WAR) files for Python WSGI applications.

If you have any question or bug report, please post it to our mailing list at http://groups.google.com/group/ollix-jump, contributions are welcome as well.

In my previous post, Hello World! Qt Jambi, I showed you my brief experience with GUI toolkits for Python, and my idea to integrate Qt Jambi with Jython. Thus, we can take advantage of both Java and Python to use Qt library in Python. This is possible because Jython is an implementation of Python written in Java.

I’ve heard about Jython about over one year ago, but at that time, Jython only supported Python 2.2 features while Python 2.4 was already released for a long time, and because there is a big difference between Python 2.2 and Python 2.4, I never thought Jython is my option. But something is different, the Jython development team has released Jython 2.5 about two months ago and it seems that Jython is extremely useful for me now, to integrate with Qt Jambi.

To illustrate my idea of using Qt Jambi library in Jython, I firstly wrote the Jython equivalent code to the “Hello World” example written in Java in my previous post. Here is the original Java source code:

import com.trolltech.qt.gui.*;

public class HelloWorld
{
    public static void main(String[] args) {

        QApplication.initialize(args);
        QPushButton hello = new QPushButton("Hello World!");
        hello.resize(120, 40);
        hello.setWindowTitle("Hello World");
        hello.show();
        QApplication.exec();
    }
}

And here is the Jython equivalent to Java:

import sys

from com.trolltech.qt.gui import *

def main():
    QApplication.initialize(sys.argv)
    hello = QPushButton("Hello World!")
    hello.resize(120, 40)
    hello.setWindowTitle("Hello World")
    hello.show()
    QApplication.exec()

if __name__ == '__main__':
    main()

To execute this script, I just simply run the following instruction, and the result should be nothing different.

jython -J-d32 -J-XstartOnFirstThread helloworld.py

To further demonstrate if signals are working correctly in Jython, I borrowed the source code from tutorial 2 in Qt Jambi official documentation. Here’s the original Java source code:

import com.trolltech.qt.gui.*;

public class Quit
{
    public static void main(String args[])
    {
        QApplication.initialize(args);
        QPushButton quit = new QPushButton("Quit");
        quit.resize(80, 40);
        quit.setFont(new QFont("Times", 18, QFont.Weight.Bold.value()));
        quit.clicked.connect(QApplication.instance(), "quit()");
        quit.setWindowTitle("Calling It Quits");
        quit.show();
        QApplication.exec();
    }
}

And here’s the Jython equivalent I rewrote:

import sys

from com.trolltech.qt.gui import *

def main():
	QApplication.initialize(sys.argv)
	quit = QPushButton("Quit")
	quit.resize(80, 40)
	quit.setFont(QFont("Times", 18, QFont.Weight.Bold.value()))
	quit.clicked.connect(QApplication.instance(), "quit()")
	quit.setWindowTitle("Calling It Quits")
	quit.show()
	QApplication.exec()

if __name__ == '__main__':
	main()

As usual, I executed the script by running instruction like this:

jython -J-d32 -J-XstartOnFirstThread quit.py 

As you can see the result above, everything is just working fine. As long as I click the Quit button in the window, it quits normally, nothing wrong happened. Perfect!

Note that I add `-J-XstartOnFirstThread` parameter because I use Mac OS X operating system and I add `-J-d32` parameter because I use “Snow Leopard”. You don’t need these parameters if you are not a Mac user.

Following on from our “The Fastest Ruby Profiler is a Java Profiler” I am pleased to announce that our upcoming probes based resource metering extension for Jython is the fastest function call profiling solution for Python applications executed within a Java runtime. With our dynamic hotspot resource metering strategy the overhead of our probes instrumentation can drop down to approximately 8 nanoseconds for non-hotspot function calls.

Here is the Python micro-benchmark I have used in determining this.

Here is a chart showing the average time (secs) reported by multiple executions of the run method without (baseline) and with our probes based instrumentation. JXInsight’s instrumentation overhead is just over 2% but that is 2% on a method, call, that effectively does nothing.

The overhead incurred in the instrumentation and measurement of fine grain method executions, which dominate the execution (frequency) profile of most web applications, is a key performance indicator (KPI) for any enterprise application performance management and monitoring solution.

Below is a screenshot of the resulting resource metering in our application management console. Note the strike-through on the call:12 function indicating the associated instrumentation has been disabled following the execution of 1000 probe firings and the determination by the hotspot metering strategy that the named probe, benchmark.call.12, is not a hotspot.

Note: Line numbers can be excluded from the probe name assigned to a function marking all same named functions within a module as hot or cold spots depending on the combined resource metering behavior for all implementations.

The following chart shows the performance of the same benchmark executed by the native c-based Python engine along with the standard cProfile. The overhead is significant.

Here is a chart comparing the overhead (%) of JXInsight with that of the Python cProfile.

I attempted to run the benchmark with the Python based profile solution but a single run() call took over 200 seconds compared to 2-4 seconds for all other reported test runs. Surprisingly the Jython version of the Python profile solution executed in just under 120 seconds.

If you are interested in seeing more of what will be possible with the upcoming extension then check out the following images showing contextual labeling as well as multi-language metering (profiling).

www.jinspired.com/images/jxinsight.5.7.32.jython.to.python.p.1.gif
www.jinspired.com/images/jxinsight.5.7.32.jython.to.python.p.2.gif

Several months ago I wrote a post related to creating a recursive directory walker in Python. We did not make use of os.walk. While playing with Jython I thought it would be nice to write an equivalent. Here’s what I have :

from java.io import File
import sys

class FileWalker(object):
	def walk(dir,cbf):
	    files = dir.listFiles()
	    for file in files:
	        cbf(file)
	        if file.isDirectory():
	            FileWalker.walk(file,cbf)
	walk = staticmethod(walk)

def list_file(file):
    print "saw %s" % file

if __name__ == "__main__":
    FileWalker.walk(File(sys.argv[1]),list_file)

I think the code is pretty straight-forward. If you’re familiar with Java even a little bit, I’m sure you can understand what’ s going on in here. You should know that the callback function isn’t receiving a string as it’s parameter ( as the first version of the walker did ) . This one receives a Java File object, which means you have access to all the methods present in the File class.

Estou estudando Jython e um dos exercícios do curso (EAD) era fazer essa interface, coisa simples, resolvi disponibilizar:

O código segue a seguir, para executar é necessário ter o Jython instalado (apt-get install jython) e invoca-lo da seguinte forma:
$ jython Desenho.py

Código copiavel (atenção!!organize a identação pois é Python ;] ):

#!/usr/bin/env python
from java.awt import *
from java.lang import *

#Classe do exercicio
class Desenho(Panel):
clicked = None
dots = []
def __init__(self):
Panel.__init__(self, mouseDragged=self.Pressionado)
dim = Dimension()
dim.size=400,240
self.preferredSize = dim
self.background = Color.BLACK;
g = self.graphics
#self.addMouseListener(Click())
def Limpar(self, event): # Botao que limpa
g = self.graphics
g.clearRect(0, 0, 400, 300);
def Pressionado(self, event):
g = self.graphics
g.setColor(Color.white)
g.fillRect(event.x, event.y, 2, 2);
self.paint(g);

#Metodo para o botao “X”
def exit(event):
System.exit(0)

#Janela
frame = Frame(“Desenho”,windowClosing=exit)
frame.size = 400, 300;
desenho = Desenho()
frame.add(desenho)
frame.layout = FlowLayout()

#Botao limpar
button = Button ( “Limpar”, actionPerformed = desenho.Limpar)
dim = Dimension()
dim.size=400,25
button.preferredSize = dim
frame.add(button)
frame.visible = 1;

No cabe duda que los lenguajes de código abierto como Perl, PHP, Python, Ruby y otros más han popularizado enormemente el uso de los lenguajes dinámicos. Esto ah captado la atención de los gigantes del software como Microsoft y Sun Microsystems quienes ya se están preparando para la siguiente generación de máquinas virtuales.

Sun esta trabajando en un proyecto llamado the Da Vinci Machine Project que busca mejorar el desempeño y soporte para lenguajes externos no-java como: Jruby, Jython, Groovy y otros. Gran parte de este trabajo será integrado en Java7 que se espera para el 2010.

Microsoft por su parte esta trabajando en una extensión del CLR(Common Language Runtime) llamada DLR (Dynamic Language Runtime) que también será integrada con .NET 4.0. DLR permitirá un soporte completo para los lenguajes IronPython, IronRuby y otros.

Por su parte la comunidad de software libre también esta trabajando en su propia máquina virtual para lenguajes dinámicos, llamada Parrot VM que busca dar soporte a una gran variedad de lenguajes incluyendo: C, Forth, Java, PHP, Python, Perl, Scheme y muchos otros más.

Todas las máquinas virtuales vendrán con mejoras y optimizaciones para el desarrollo de aplicaciones multi-threading.

Jython Console is a Jython Interactive Interpreter that adds Code Completion.

This release fixes works with Jython 2.5.

See the project page for more info.

No ano passado eu tive a excelente oportunidade de participar do JavaOne 2008, foi uma experiência muito enriquecedora e apesar de este ano não poder estar lá presente, eu não poderia deixar de fazer um levantamento dos principais acontecimentos e novidades apresentadas no evento para ficar por dentro de tudo, e claro, deixar vocês, queridos leitores, em dia também.

O Slogan do evento no passado foi Java +You ou Java + Você, neste ano houveram três: Java  = Everywhere ou Java = Em toda a parte, Java + Community = Powerful ou Java + Comunidade = Poder e Java = Innovation ou Java = Inovação. Um outro acontecimento especial deste ano é o aniversário de 14 anos do Java, o vídeo abaixo, que foi exibido na abertura do evento, apresenta rapidamente alguns pontos fortes da evolução que a tecnologia sofreu ao longos dos anos:

O presidente da Oracle Corporation, Larry Elisson afirmou que a Oracle sempre investiu na plataforma Java e que agora investirá mais do que nunca. Veja alguns momentos no KeyNote no vídeo abaixo:

James Gosling apresentou a Java Store, um site que catalogará aplicações Java que poderão ser instaladas facilmente em seu computador, algumas delas simplesmente através de drag-and-drop no desktop (arrastar e soltar).

No segundo dia, houve uma General Session chamada Your Lifestyle: Mobile, TV and Beyond em foi demonstrado o uso de Java nos mais diversos dispositivos como celulares, televisores, Blu-ray, etc e destacou-se como o JavaFX poderá ampliar ainda mais este mercado em expansão.

The Gospel of Java

Esse divertido vídeo foi apresentado em uma General Session e conta a história do Java.

JavaFX

Falou-se bastante sobre as novas tecnologias Java SE 7 SDK, Java EE 6  e Jaxa FX 1.2, mas principalmente sobre Java FX, essa tecnologia recebeu grandes investimento da Sun e promete transformar a forma com que se desenvolve aplicações de alta qualidade de ambiente gráfico com Java. Os dois vídeos abaixo publicados por Augusto Sellhorn do Blog Sellmic.com exibem parte de uma demonstração de JavaFx em que é possível ver ferramentas de animação JavaFX muito semelhante com que se conhece com Adobe Flash e Microsoft Silverlight.

O pessoal do JavaPosse entrevistou Octavian Tanase e Jacob Lehrbaum sobre o JavaFX, vale a pena conferir (em inglês).

Brasileiros no JavaOne

Mais uma vez o Brasil foi muito bem representado por congressistase palestrantes que marcaram o evento. Magno Cavalcante e Clayton Chages apresentaram a Technnical Session: “Java™ in the Brazilian Digital TV: Interactivity and Digital Inclusion on TV“.  Ainda sobre TV Digital, David Campelo apresentou a “TS-4453: New Java Digital TV Standard Goes Brazil“. A Dupla Marlon Luz e Bruno Oliveira, também deixaram suas contribuições brasileiras com a palestra Java ME Myth Busters, confira a entrevista (em português) realizada pelo Sérgio do JavaBahia.

O brasileiro Felipe Gaucho que atualmente trabalha na Suiça esteve no evento e postou em seu blog suas impressões. O Baiano, Serge Rehem doJavaBahia também participou do evento registrou sua impressões.

O Classpath está morto!

Mark Reinhold, Chief Engineer do Java SE, disse isso durante a demonstração da forma com que o Java 7 gerenciará módulos. Vale a pena dar uma olhada no projeto Jigsaw que tem como objetivo resolver de forma eficiente as questões da modularização no JDK, esse projeto está sendo construindo segundo a JSR 294: Improve Modularity Support in the Java Programming Language. Segundo Raja Islam o benefício principal que será alcançado com a modularização será a redução do tempo de carga e deploy de aplicações Java.

Microsoft no JavaOne

Pode parecer estranho, mas a Microsoft apresentou a General Session do terceiro dia do JavaOne. No momento em acontecem as General Sessions não há nenhuma outra apresentação ocorrendo simultaneamente e todos os congressistas presentes participam, ou seja, são apresentações de grande importância e alcançam a maior parte do publico do evento.

Dan’l Lewin, Vice Presidente Corporativo da Microsoft, falou sobre esforço que vem sendo realizado a cinco anos desde o inicio da parceria entre a Microsoft e Sun para promover a interoperabilidade entre aplicações Java e .NET, segundo Lewin em uma entrevista realizada pela Microsoft no ano passado com mais de 5 milhões de pessoas, constatou-se que 73% dos entrevistados trabalhando em ambientes mistos (Java + .NET). Para maiores informações visite www.interoperabilitybridges.com.

Outras linguagens sobre JVM

Ola Bini da ThoughtWorks,  famoso por participar ativamente na comunidade open source e por desenvolver a linguagem de programação Ioke, também participou do evento e destacou o projeto Da Vinci, segundo ele, essa tecnologia contribuirá para que a Java Virtual Machine se torne melhor. Ola Bini também apresentou sua BOF 4434: Hacking JRuby.

BOF significa (Birds-of-a-Feather), as BOFs  são palestras informais, interativas e flexíveis. No JavaOne, geralmente acontecem no final do dia com assuntos complementares aos discutidos nas technical sessions (TSs) ou palestras técnicas que acontecem durante o dia.

Charles Nutter também esteve lá falando sobre o projeto JRuby que … No vídeo abaixo, Nutter falou um pouco a tecnologia:

Rich Hickey falou sobre sua linguagem: Clojure, que também roda sobre a JVM. Para saber mais confira os slides de sua “TS-4164 Clojure: Dynamic Functional Programming for the JVM Machine“.

Neal Ford fez uma comparação entre as linguagens Ruby e Groovy em sua “TS-4955: Comparing Groovy and JRuby“.

Falou bastante sobre JRuby, Jython, Scala e Groovy.  Nesta entrevista para o JavaOne, Guillaume Laforge da SpringSource comenta um pouco sobre isso:

Destacou-se também o lançamento da versão 1.6 da linguagem Groovy, confira a “TS-4215: What’s New in Groovy 1.6?” por Laforge.

Bill Venners, da Artima Inc., apresentou um pouco da linguagem Scala em sua “TS-4487: The Feel of Scala“.

Roberto Chinnici falou sobre programação funcional e orientada a objetos com JavaScript, seus slides podem ser visto neste link.

Java, uma plataforma em evolução!

De acordo com Jim White, o Java 7 está previsto para ser lançado em Fevereiro de 2010. Jim participou de algumas palestras que tinham como tema principal a evolução do Java, e disse que muitas das decisões para o Java 7 ainda não foram tomadas, o que indica que ainda há bastante trabalho pela frente. Enquanto ao Java 6, White, diz que será lançado mais cedo, em Setembro de 2009.

Joseph Darcy da Sun Microsystems, na “Ts-4060: Small Language Changes in JDK Release 7” apresentou algumas das mudanças que serão feitas na linguagem Java. Darcy chamou a atenção da comunidade para que torne-se parte da evolução e que participando e contribuindo, através do projeto Coin que tem essa finalidade.

Servlet 3.0

A especificação vem evoluindo através da JSR 315 e entre as principais novidades está a possibilidade de configurações toda a aplicação através de annotations ao invés de utilizar o arquivo web.xml e maior utilização do principio CoC (Convetion over Configuration) que visa diminuir a quantidade de configuração. Existem annotations para registrar Servlets, Filters, Listeners, e até mesmo para declarar regras de segurança e permissões de acesso.

Um outra recurso que ganhou bastante repercussão foram os novos Servlet Assíncronos, para maiores informações confira a “TS-3790: Java Servlet 3.0:Empowering Your Web Application With Async, Extensibility and More” apresentada por Rajiv Mordani, Greg Wikins e Jan Juehe.

Bean Validation

Validação através de metadados nos JavaBeans como no Hibernate Validator. Confira a “TS-5184: Bean Validation: Declare Once, Validate Anywhere – A Reality?” apresentada por Emmanuel Bernard da JBoss sobre o assunto.

Java Server Faces 2.0

Ed Burns e Roger Kitain, ambos da Sun Microsystems, apresentaram a “TS-4640: A Complete Tour of the JavaServer Faces 2.0 Plataform” onde falaram sobre as principais novidades do JSF 2.0. Nesta nova versão do JSF teremos melhor suporte a Ajax, componentes compostos que possibilitará melhor reuso de código e melhor suporte a eventos. E para completar ainda mais a discussão sobre JSF no JavaOne, Kitto Mann da Virtua, na “TS-5205: Writing Killer JavaServer Faces 2.0 UI Components” apresenta diversos conceitos importantes se criar inovadores e eficientes componentes JSF 2.0 e David Allen da RedHat falou sobre fluxo de páginas (page flow) e conversação (converstation) com JSF na “TS-5045: Converstations and Page Flows on the JavaServer Faces Plataform“.

EBJ 3.1

A evolução dos Enterprise Java Beans continua, na versão 3.0 pode-se notar grande avanço e uma simplicidade muito grande ao se comparar com versões anterior, nessa nova versão a meta de aumentar a simplicidade se manteve, por isso, a forma de empacotamento dos aplicativos foi simplificada e criou-se o EJB Lite API, que é um conjunto reduzido das funcionalidades disponíveis na especificação completa do EJB.

Além da simplicidade, novas funcionalidades foram incluídas como por exemplo, objetos Singleton, Callbacks de Startup e Shutdown, Timers baseado em Calendars, Session Beans assincronos e integração com JAX-RS. Para maiores informações confira a “TS-4605: Enterprise JavaBeans 3.1 Technology Overview” apresentada por Kenneth Saks, Senior Staff Engineer da Sun Microsystems.

Java Persistence API (JPA) 2.0

Linda DeMichiel da Sun Microsystems, na “TS-5214: Java Persistence 2.0: What’s New?” apresentou as principais novidades da JPA que evolui através da JSR 317:

1. Modelagem mais flexível
2. Novas formas de mapeamento O/R, novas annotations
3. Java Persistence Query Language mais poderosa
4. Criteria API
5. Suporte a Validação
6. Novos padrões de configuração

A Implementação de Referência ou Reference Implementation (RI) da especificação é o projeto EclipseLink que tem como base o antigo projeto da TopLink da Oracle. Andrei Badea da Sun e Dogule Clarke da Oracle apresentaram na “TS-5018: Developing Java Persistence API Applications with the NetBeans IDE and Eclipse Link” de forma um pouco mais prática como utilizar a nova API. Mike Keith da Oracle fez uma apresentação completa sobre os conceitos de mapeamento da JPA na “TS-5265: A Java Persistence API Mapping Magical Mystery Tour“.

Context Dependency Injection for Java EE

Gavin King da RedHat apresentou na “TS-6726: Context and Dependency Injection for Java Plataform, Enterprise Edition (Java EE Plataform)” uma introdução o que a especificação JSR-299 trará de novo ao Java EE. Segundo King teremos um novo e rico modelo de gerenciamento de depedências com suporte a objetos statefull, integração da camada web com a camada transacional, será muito fácil construir aplicações utilizando EJB e JSF juntos, e frameworks terceiros poderão facilmente integrar-se a API.

Spring 3.0

Rod Johnson da Spring Source apresentou as novidades do Spring 3.0 na “TS-5225: Spring Framework 3.0: New and Notable“. Segundo Johnson, o trabalho em tornar o desenvolvimento de aplicações Java para Web mais simples e poderoso continua, por isso, os arquivos XML serão ainda mais curtos, havendo necessidade de utilizá-los somente quando for preciso externalizar algum recurso.

A nova versão traz suporte a REST, melhorias no MVC e expression language. O Spring 3.0 será compatível somente com Java 5+.

Spring Roo

O Spring Roo é o mais novo projeto da Spring Source, e segundo Jim White, é uma espécie de Rails, também com muita meta-programação, que tem como base apenas Java e Spring. Rod Johnson disse que a missão do Roo é melhorar dramaticamente a produtividade de desenvolvedor Java sem comprometer a poder e flexibilidade através de geradores de código que proporcionarão a entrega rápida de aplicativos corporativos robustos e de alta performance.

Google Guice

E por falar em Spring, o Google Guice, também vem ganhando bastante espaço no mercado como framework de injeção de dependência, e os Googlers Bob Lee e Jesse Wilson, falaram sobre ele na “TS-5434 Introduction to Google Guice: The Java Programming Language Is Fun Again!“, confira.

Eclipse Galileo

Depois do Calisto, Europa e Ganymede, vem aí o Eclipse Galileo. O lançamento está previsto para 24 de Junho. O release incluirá 48 projetos, o destaca bastante crescimento, ao se comparar como o Ganymede que contemplava apenas 24 projetos. Em 26 de Junho, a Eclipse Foundation fará uma apresentação chamada Galileo in Action onde serão apresentadas as principais funcionalidades do novo realease.

Google App Engine

Como comentei no artigo anterior, o Google App Engine agora possui suporte a Java, e claro, isso não poderia deixar de ser assunto de destaque no JavaOne, por isso, os Googlers, Toby Reyelts, Max Ross, e Don Schwarz, apresentaram a “TS-3817: Google App Engine: Java Technology in the Cloud“.

Effective Java

Joshua Bloch do Google, que teve intensa participação do desenvolvimento da linguagem Java, desde o JavaOne 2007 vem de falando sobre boas práticas de programação, e destacando tópicos de seu livro Effective Java, em sua “TS-5217: Effective Java: Still Effective After All These Years” manteve o mesmo padrão dos anos passados.

Prêmios do JavaOne e Java Toy Show

No último dia do evento, James Gosling apresentou o Toy Show, onde foi apresentado diversas situações onde pessoas e empresas por todo o mundo utilizaram Java de forma inovadora, e também foram distribuídos os prêmios dos ganhadores do Duke’s Choice Award.

Slides e Vídeos

Os slides e vídeos das apresentações estão sendo paulatinamente disponibilizados no site da Sun Developer Network (SDN), não perca a oportunidade de baixar alguns slides para estudar, garanto que tem material de ótima qualidade publicado lá.

Alguns vídeos do CommunityOne também podem ser baixados aqui.

Conclusão

O JavaOne 2009 não trouxe tantas pessoas como anos anteriores, este ano apenas 9.000 pessoas se reunião enquanto em edições anteriores do evento mais de 25.000 estiveram presentes, é claro que existem diversos fatores para que isso tenha acontecido como a crise econômica e a gripe suína, por exemplo, mas de toda forma há uma grande diferentes que nos leva a reflexão. Neste ano o evento nos trouxe diversas tecnologias, frameworks, projetos e iniciativas que prometem manter a plataforma em constante evolução. Fiquemos Ligados!

Administration

Eine WebSphere 6.1 Installation kann neben über eine Web Oberfläche, auch mit dem Tool wsadmin administriert werden. Mit wsadmin können zwei Arten von Aufgaben erledigt werden. Zum Einen sind es operationale Aufgaben (Zugriff auf laufende Objekte in WebSphere), und zum Anderen Konfigurationsaufgaben (Konfigurationseinstellungen bearbeiten).

wsadmin

wsadmin bietet eine scripting-Schnittstelle (Jython) welche auf dem Bean Scripting Framework (BSF) aufbaut. Dadurch ist es möglich eine Java Applikation zur Konfiguration und Administration bereitzustellen, welche über die scripting-Schnittstelle angesprochen werden kann.

Das wsadmin Tool (lokal) ist in: <was_home>/profiles/<profile_name>/bin/wsadmin.bat (.sh) zu finden. Darüberhinaus ist wsadmin (global) im <profile_home> Verzeichnis zu finden. Wird wsadmin aus diesem Verzeichnis aufgerufen so muss zunächst das richtige Profil mitgegeben werden.

Hilfe gibt es mit dem Befehl: wsadmin –?.

Einstellungen können in der <profile_home>/properties/wsadmin.properties oder <was_home>/properties/wsadmin.properties Datei vorgenommen werden. Ferner kann über den Parameter –p eine eigene Einstellungsdatei mitgegeben werden: wsadmin –f ~/myScript.py –p ~/temp/custom.properties.

Ein einzelnes Kommando wird mit dem Parameter –c eingeleitet: wsadmin -c AdminControl.getNode().

Mit dem Befehl wsadmin ohne Parameter wechselt man in den interaktiven Modus.

Jython Skripte können mit dem Befehl: wsadmin -f myScript.py ausgeführt werden.

Was gibt es zu verwalten?

WebSphere 6.1 stellt 4 Objekte zur Verwaltung bereit:

• AdminControl – Verwaltung von laufenden Objekten mittels MBeans. The available MBeans are documented in: <was_home>/web/mbeanDocs/index.html.
• AdminConfig – Das AdminConfig-Objekt kommuniziert mit dem Konfigurationsservice in einem WebSphere-Server, um die Konfigurationsdaten für eine WebSphere-Installation zu bearbeiten. AdminConfig stellt Befehle zum Auflisten, Erstellen, Entfernen, Anzeigen und Ändern von Konfigurationsdaten sowie Befehle zum Anzeigen von Informationen zu den Konfigurationsdatentypen bereit.
• AdminApp  – Bearbeitung von Anwendungsobjekten.
• AdminTask – Ausführung von Administrationsbefehlen.

Darüberhinaus wird ein Help Objekt bereitgestellt. Über das Help Objekt können Informationen über die Methoden der Objekte zur Verwaltung sowie Informationen über Methoden und Attribute von MBeans.

Methoden des AdminControl Objekts anzeigen: print Help.AdminControl().

Informationen über die completeObjectName Methode des AdminControl Objekts anzeigen: print AdminControl.help(‘completeObjectName’).

Quellen

IBM RedBook: WebSphere Application Server V6.1: System Management and Configuration

While we all happy that python, ruby, js and other languages developers understood the JVM strengths and decided to port their code to run over the JVM using JRuby, Jython etc….porting from one language to another is typically worse comparing to writing in a unique scripting language that has been developed for the Java community!

Groovy is such a language, it’s a scripting language for the Java developers, and that’s how Groovy’s creator thought about it when they had develop it.

The main advantage is the ability to use the J2SE API internally in groovy (all of course all the advantages of scripting).

In example , the Java collection API  is so mature and it is awesome that a Groovy developer can use it naturally, moreover,  the Java community is blossoming and provide us with millions of external cool libraries which can be used by the Groovy developer.

Other than that, the root object in groovy ,as in Java, is java.lang.Object, which give us “for free” the .hashCode() and .equals() important methods …

The groovy language is trivial to grasp for a Java develop, which is bidirectional!

Think of groovy as a  Python like language that is tightly integrated with the Java which allowing you the same powerful and concise coding syntax as  Python but allowing you to stay on the JVM and protect your investment in J2SE, J2EE and all the plethora of great useful Java code out there without any parallel API sets or adapter layers.

While working on some database stuff for my CMS I got stuck, so I asked for help. The problem is that at the time of posting it was like in the middle of the night in America. So I looked around on the forums if I could be of any help to someone.

Then I found this thread where someone asked if he could run his PyGame in a browser. I never wrote a game… well not a real one at least, but it sounded interesting. So this is how I spend this day, looking for magic ‘Python applets’

Add me to the list of people who would like to know about it
After reading this I got myself a copy of Jython and tried some of my scripts(, falied) and made a nice swing gui with the interactive shell.

One thing I noticed is the lack of… A lot of stuff actually.
So step one is to get PyGame to run on Jython at all, if that works… convert to an applet.( http://www.jython.org/applets/ )

[offtopic]
Could it be possible to make a Python implementation in actionscript?(Flash)
Interesting thought… But just fantasy I guess.

[edit]
Did anyone here do but even the slightest research
http://archives.seul.org/pygame/users/Apr-2005/msg00111.html
PyGame on Jython is not even possible, so why bother thinking about PyGame applets?
It’s just not going to happen, unless someone writes a Python browser plugin.

[offtopic]
Now THAT is another cool idea, but even more unlikely to happen then a flash implementation of Python.

[edit]
I searched the whole interned and did not yet found a way to run PyGame in the browser.
The 3 closest are:

Jython, it does java applets, but no PyGame. Writing awt/swing games should be fine.
How about the other way around? Seek a light-weight Java game framework and import it into Jython. You can use java classes remember… Use them!( http://www.lwjgl.org/index.php )
It IS possible to do JNI from within a signed applet

Grail, the Python browser. It’s dead and old I think, but it had Python applet support.

I hate Microsoft and their wannabe Flash: SilverLight, but the seem to have produced something nice: Ruby and Python support! http://silverlight.net/learn/dynamiclanguages.aspx/
But then we arrive at the same point as Jython… PyGame!!! Silverlight uses IronPython
But there is light at the end of the tunnel, according to a blog post(which I lost), http://code.google.com/p/ironclad/ got as far as importing PyGame into IronPython. This does not mean it will run

This is how much energy I’m going to put in it…
In the future it might be possible to write Jython or IronPython games using PyGame and Java/Silverlight. Or someone might write a Python browser plugin…
But at the moment there is no good/tested way of writing browser game with Python.

Hi,

Today nearly at 7-8pm in evening, i was talking to one of my friend from CET Bhubaneswar (Pinku Pradhan)and suddenly this war emerged between us. Its about JAVA or Python.

Actually i am a JAVA guy from a long time, i think from past 3-4 years and never used Python.

So i had decided to check the details. Well as i am using JAVA , i personally thinks that it is the most secured platform for Web application, web development and for almost anything. Also there is no second opinion about the portability of Applications/Web Sites (etc. )Developed on JAVA platform.

JAVA have almost everything in it like it manages memory allocation, potentially compiles to very speedy code, integrates secure execution, works on both a big server and a little PDA, runs in both Unix and Windows, and comes with a big or can say endless library. I became far more productive as a coder when I switched to Java. I wrote a sample website for my institute project and it rocked. I hopped on the Java bandwagon.

But after all this today i had checked and after spending a long time and learning few initials of Python i am ready to accept one thing that JAVA is GOOD but still we cant ignore the presence of Python also.Few things which i noticed, like JAVA is quite verbose as compared to Python(thats why its take a bit more time to write something in JAVA).Then its about dynamic nature of Python which is also helpful.

So lastly i am very impressed with feature and friendliness of Python over JAVA Platform.Still what i concluded is Python is GOOD but still cant replace JAVA Platform.

LOOKING Forward to Learn Python …. n waiting for ….. Jython <http://www.jython.org/Project/>release