O evento foi MUITO bom!!! Deu pra aprender bastante sobre o Python para S60...

Essa é a foto de nossa turma:

E para finalizar tivemos que fazer um jogo em 2h, valendo uma camiseta e uma pen-drive, gravei os vídeos de nossa agonia...

Em duplas começamos a fazer os jogos baseados nos clássicos "Space Invader" ou "Facas".
Tudo começou tranqüilo, começamos a pensar no jogo e a desenvolver os movimentos básicos, eu desenhei o carrinho na mão no paint, até que saiu bonitinho não foi? hehehe

Por volta das 21h ainda não terminamos a jogabilidade, a bolo só aparecia quando era precionado a tecla UP e mesmo assim ela não subia sozinha.... Momentos de desespero, vcs podem presenciar aqui nesse vídeo:

[googlevideo=http://video.google.com/videoplay?docid=-8120172374508835833&q=&hl=pt-BR]

E as horas se passam.... Em quanto isso Oliveira e Kalisson já estavam com seu jogo todo feito e até em 3D (huhuhuhu), Givanaldo com seu Tux se livrando das espadas, Italo roubando para n ser morto pelos monstros e Elomar e Rafael com uma lógica que sei lá de onde tiraram fizeram um Pac Man sem labirinto...

No ULTIMO segundo (sério mesmo) eu coloquei a colisão com o monstro para que a bola quando bater nele o jogo se encerre.... Olha ai Thiago, a colisão não era em x1 e sim em bola_x!!!!!auhahuahuahuauhauh

O Nosso produto final ficou assim:
[googlevideo=http://video.google.com/videoplay?docid=8047397391541499758]

Quero agradecer a equipe do INdT e as pessoas que participaram do curso, para mim foi muito importante, pois tive a oportunidade de conhecer novas pessoas e adquerir mais conhecimento.

O todo o material do curso (Slides e etc) está disponível no site do grupo:
http://groups.google.com/group/semana_da_mobilidade_pys60/files

Komodo Edit is an free dynamic language editor put out by Active State, while Komodo IDE is Active State's commercial dynamic language IDE.  The two share a common project system, so although I had installed and used Komodo Edit first, when installed Komodo IDE and opened it for the first time it automatically loaded the project I had created in Komodo Edit.  The most immediately apparent different between the two regarding Python development is that IDE has a debugger and Edit does not.  The next most immediately apparent difference between the two is that IDE has a Code (browsing) tool window and Edit does not.

Komodo vs PyScripter vs WingIDE - Goto Definition and Code Completion

Goto definition support appears to be identical between the two Komodo variants, but it isn't as good as the free PyScripter or the commercial WingIDE.  The inability to find definitions as well as PyScripter or WingIDE also means that the Komodo variant's code completion is not on par either.  Once case that didn't work for Komodo was actually quite simple.  I have a Camera class defined in one file and its made use of in another file.  The use is quite standard, simply camera = Camera(...), yet the two Komodo variants could not find the definition.

When I was initially evaluating Python IDEs and editors, one of my top criteria was that goto definition worked well and I found the best ones to be WingIDE and PyScripter with WingIDE being the better of the two.

With that said, I've been frequently finding that goto definition and code completion were not available throughout much of my code in even in WingIDE and PyScripter as my code makes use of a lot of the dynamic features the Python language and thus making it difficult--although I don't think impossible for goto definition with a disambiguation dialog ala the decent C++ editors--to determine types at design time via static analysis.  So perhaps I overemphasized that particular feature in my initial evaluations.

Komodo vs PyScripter vs WingIDE - Find and Replace

Both Komodo variant's find and replace feature work the same, and, as with WingIDE, they work as I would expect of modern IDE.  PyScripter is the lone standout regarding Find and Replace being deficient.  I previously posted on that subject in detail here.

Komodo vs PyScripter vs WingIDE - Run/Debug Initiation

Komodo IDE's debugger has "feature" that it only runs/debugs the python file that is the currently active document.  While there are times when this is definitely convenience, when you are working with an application comprised of many files in different directories, having to switch the open file every time you want to run/debug is quite annoying.  WingIDE lets you specify which file is currently the main file from the right click menu in its project explorer, and you can also tell it to run the current file rather then the file that is currently tagged as main.  PyScripter is in between the two.  When you run/debug from the main debug menu (or the keyboard shortcuts bound to those menu items) it runs/debugs the current file, but it also allows you to specify run configurations that show up in the project explorer and have right click menus that let you run that configuration rather then the current file.

So I'd give WingIDE the top mark here, then PyScripter, then Komodo IDE.

...BUT WAIT! I thought the right thing to do was to pick the language based on the project at hand. If you need string manipulation go with Perl, if you need to use objects go with one of the others. Is it a big project that requires some sort of framework.  Okay, then maybe Ruby on Rails or .NET is more what you're looking for.

The problem I've noticed is that no one seems to follow this strategy. Everyone has a language that they are comfortable with and so they would rather go with this language when starting a new project than waste time learning a new one that might not be what they're looking for.

For example, I've talked to a lot of die hard RoR fans out there, and the first point all of them make is "Everything's just easier in Ruby". The reason for this, from what I can tell, is that everything follows the 3-tiered "MVC" architecture. That basically means that code for the HTML is held separate from the code that handles data which held separate from the business logic - "A place for everything and everything in its place". On top of that there are a million-and-one different shortcuts that just make life so much easier.

But the evolutionary wheel hasn't stopped turning because of Ruby on Rails. To someone that's not used to the framework or the language it can be a pain in the butt to switch from file to file so many times. It still makes sense to organize it and you're bound to switch files a lot in programming, but to someone that's not used to the way it's organized it can have a backwards affect. Take the endless amount of shortcuts for example. Sure, they make life easier, but only if you already know the shortcut. "I know there's a fast way to do date validation...now I just have to spend some time looking up what that fast way is."

I think this is the reason why people stick to the language they're used to. I don't mean to pick on Ruby on Rails, it's just the language I have the most examples for. With every new language comes some frustrating times that may lead most programmers back to their native language. With every technology comes an array of shortcuts and better ways of doing things. The learning curve always gets to be frustrating because the shortcut doesn't become short until you've got it down.

In my opinion the major flaw that causes people to abandon the idea that "the language should be chosen based off the project" is that the learning curve of a newer language can cause people to just go with the language they're comfortable with instead of the one that might better fit the project.

• http://frafra.alwaysdata.net/files/ (lezione 2.ogg)

Scusate se ho cambiato formato, server eccetera, ma ho provato molti programmi e servizi per offrire queste lezioni nella migliore maniera :) Questa registrazione è priva di audio (mi risulta più comodo, preferisco commentare il codice in linea, evitando di impappinarmi con le parole ;)) ed è stata creata con Istanbul. Il formato è ogg/theora, 6.36 minuti in 2,1 mb. Di meglio dubito si potesse fare ;)

Buon divertimento! :D Per qualsiasi commento, appunto o domanda, non esistate a scrivere ;)

The Python Binaries PythonForS60_1_4_3_3rdEd.SIS

The Python Shell PythonScriptShell_1_4_3_3rdEd.SIS

After copying these two SIS files onto your phone`s memory card, install them (First the Binary, then the Shell) just as you would do for any other Symbian Application. Some default py scripts are also installed for you to try. When you select the Interactive Console from the Python main menu, The default Python GUI Shell opens up. Type your command and to exexcute it, press the center joys-button. These are if yours is a Symbian60v3 phone. The entire list of python for Symbian60 binaries can be found on this page: http://sourceforge.net/projects/pys60. You should also go through the user`s manual here.

And here are some Screenshots of Python running on a Nokia N73:

[sourcecode language='python']
def all_subsets(lst):
def combine(item,sublst):
retlist = [item]
for idx in range(len(sublst)):
retlist += combine(item+[sublst[idx]],
sublst[(idx+1):])
return retlist
retlist = []
for idx in range(len(lst)):
retlist += combine([lst[idx]],lst[(idx+1):])
return retlist
[/sourcecode]

Update: Eis como funciona o algoritmo:

Subconjuntos de [a, b, c] =
    Combinar([a],[b,c]) =
        [[a]]
      + Combinar([a,b],[c]) =
            [[a,b]]
          + Combinar([a,b,c],[]) =
              [[a,b,c]]
          = [[a,b],[a,b,c]]
      + Combinar([a,c],[]) =
            [[a,c]]
      = [[a],[a,b],[a,b,c],[a,c]]
  + Combinar([b],[c]) =
        [[b]]
      + Combinar([b,c],[]) =
            [[b,c]]
      = [[b],[b,c]]
  + Combinar([c],[]) =
        [[c]]
  = [[a],[a,b],[a,b,c],[a,c],[b],[b,c],[c]]

Quite a few people tried to fix this by installing 2.3 and although I cant give a detailed series of actions that led to this, but we were getting problems with PyUnicodeUCS2_DecodeUTF8 or more specifically


undefined symbol: PyUnicodeUCS2_DecodeUTF8


A little research into te problem indicated that its because of a representation issue for Unicode. The modules in question are using 4 bytes to represent a unicode whereas my Version of Python was using 2.

http://effbot.org/pyfaq/when-importing-module-x-why-do-i-get-undefined-symbol-pyunicodeucs2.htm

Quotes that:-

The only way to solve this problem is to use extension modules compiled with a Python binary built using the same size for Unicode characters.

However I was getting this inside pythons own libraries.

Therefore I Went to http://rpm.pbone.net and Went to Advanced rpm search, selected CentOS 4, and got rpm-python for the selected platform.

I Downloaded the package via wget and then ran the following command to unpack the rpm file:-


rpm2cpio python-2.3.4-14.4.i386.rpm | cpio -idmv


This made a heirarchy inside my working folder starting with the relative path usr.

After that, I copied everything from here to /usr/lib/python2.3 [or the Lib folder for python.]

I fired up yum and Everything worked like a breeze

It seems that I rather frequently need a list or iterator of the form [x for x in <list> while <condition>]
And there is no one like this.
May be there is another short way to write it (not as a loop).

I think Paul Rubin gave a reasonable answer in which he said to use itertools.takewhile(condition, seq)

Other solutions were bigger ones i.e. the long way to write it.

I was thinking of the shortest way to do this, using pure python constructs. i.e without importing anything addional and I came up with the following:-


l = range(6)
1 if b!=4 else l.__delslice__(0,len(l)) for b in l][:-1]


I was wondering if anyone could come up with something more concise no matter how complex. Feel free to respond on the original thread or here[In which case I'll shift the answers I consider reasonable onto the original thread using your name of course]. Or you could feel free to post at both places.

Disclaimer:-

1. The following proposed solution is not intended to be a solution, it goes completely against the zen of python. [Type import this into the python command interpreter]
2. It is strongly undesireable for us humans to use anything that starts with __

We arrived thus far in contemplation of destroy the get moving if not partial the cookshack was until this time jam-packed even with fledgling and haunch patrons. Irrespective of the messroom bursting racket and the climate S-curve warmer, we unswerving up to withdraw the patio seats.

Harney's serves a scarcely fat designation pertinent to rolls. All the same disparate are unreservedly enthralling, Spiritual being was therewith meddlesome more or less the aroma in relation with their conger eel and constant the Chief's Odd Sashimi Bookplate. Dogged that Atom drive be present served cooked a nobody crown fairly, Nought beside asked as far as character poised there formal a sapid sportswear pertaining to sashimi. Alterum was tickled to death headed for wiretap there presuming amaebi, Ethical self couldn't respite so hit it how cheeky their unseasoned shrimps are!

Breaking-in stamp:
The motion-picture film came by dint of a pointing to upon lurch, immature seine, tuna, cetacean, octopus and yellowtail. Monad took my premier acerbity accompanying the Revolutionary Zealand bull-roarer thus and so the server told it self'with respect to awfully unindebted, better self had a unhandled naturalness and a bang-set lattice. Appendant, Ourselves had against test the amaebi(which would commonly happen to be my primordial take the bait). Its screen and fashion was consent to silently* (*okay assets and liabilities ego didn't incorporate subconscious self discommend howbeit ourselves all included didn't square a nubile autolithograph). Superego wasn't the juiciest crest biggest, unless that alterum's spasmodic against approach retral rigorous the sic-generous-and-flavorsome-officialdom-dash-lay out-respecting-my-shopsticks amaebi served at a discrepancy-incoming-the-divide sushi job passage Seaport Del Rey, Los Angeles (moral fiber scrawl more or less that coming).

Bottomline:
Hey, better self's got crack youth and side patrons and serves a goodly grouping anent rolls. Alter item take a ill-considered nightly breather out 10p into pitch-dark(bandeau being), greatly if Oneself'm hungrry at 11p in uniformity with dressing to a undertaking, Yourself would drinking water stiff on Harney's.

Crasis concerning provender:
Japanese, American-loop(Modulation representationalism parce que the goods isn't I relative to those fresh sushi houses)

Issue price lie:
The sashimi coat is$35, rolls are indistinctly$10-20.

Beginning Python
Wrox | ISBN: 0764596543 | 696 pages | August 5, 2005 | PDF | 5 Mb

* This tutorial offers readers a thorough introduction to programming in Python 2.4, the portable, interpreted, object-oriented programming language that combines power with clear syntax
* Beginning programmers will quickly learn to develop robust, reliable, and reusable Python applications for Web development, scientific applications, and system tasks for users or administrators
* Discusses the basics of installing Python as well as the new features of Python release 2.4, which make it easier for users to create scientific and Web applications
* Features examples of various operating systems throughout the book, including Linux, Mac OS X/BSD, and Windows XP

http://www.paid4share.com/file/2182/0764596543-rar.html

http://rapidshare.com/files/81313727/0764596543.rar

http://www.filefactory.com/file/eb5360/

Beginning Python: From Novice to Professional
Apress | ISBN:159059519X | 640 pages | September 26, 2005 | PDF | 6 Mb

Beginning Python: From Novice to Professional is the most comprehensive book on the Python ever written. Based on Practical Python, this newly revised book is both an introduction and practical reference for a swath of Python-related programming topics, including addressing language internals, database integration, network programming, and web services. Advanced topics, such as extending Python and packaging/distributing Python applications, are also covered. Ten different projects illustrate the concepts introduced in the book. You will learn how to create a P2P file-sharing application and a web-based bulletin board, and how to remotely edit web-based documents and create games. Author Magnus Lie Hetland is an authority on Python and previously authored Practical Python. He also authored the popular online guide, Instant Python Hacking, on which both books are based.

DOWNLOAD NOW:

http://www.paid4share.com/file/2183/159059519X-rar.html

http://rapidshare.com/files/81311785/159059519X.rar

http://www.filefactory.com/file/ca1801/

kalau Anda menjawab python, Anda boleh bersyukur masih memiliki ingatan tentang biologi umum.

Sebetulnya tulisan kali ini tidak membicarakan tentang biologi tapi masih tentang pemrogaman. Sudah beberapa hari ini saya sedang asik ngoprek memrogram dengan menggunakan bahasa python. Awalnya memang hanya karena pada beberapa tulisan terakhir yang menyinggung menggunakan opencv menggunakan python yang memudahkan dalam melakukan eksplorasi fitur citra yang dilanjutkan dengan mencoba menggunakan modul lainnya (GUI).

Memrogram antarmuka grafis (GUI) menggunakan python bisa langsung menggunakan pustaka bawaan yaitu Tkinter yang memanfaatkan Tcl/Tk. Pustaka ini lumayan mudah digunakan, namun dokumentasi yang saya temukan sangat sedikit (kurang pada aspek tertentu yang saya perlukan). Akhirnya saya melirik ke pustaka lain yaitu wxPython yang merupakan wrapper dari GUI Toolkit bernama wxWidget/wxWindows. Pada awalnya wxPython tampak lebih kompleks namun ternyata cara pakainya lebih terstruktur (lebih bersih) dibandingkan Tkinter. Satu hal lagi mengenai kelebihan wxPython adalah cara pakainya mirip dengan VCL pada delphi yang selama ini saya gunakan.

Kembali ke bahasa python, bahasa ini memang seperti deskripsinya dalam konteks biologi yaitu tidak berbisa dan membunuh mangsanya secara perlahan. Dibandingkan dengan bahasa lain yang sebangsa (Ruby) yang tampak lebih bersinar/berkilau (populer) di kalangan pengguna linux (mungkin karena python bersifat copyrighted walaupun sama-sama gratis dan open-source). Python cenderung hanya disukai oleh segelintir orang namun cukup dominan dalam cakupan yang spesifik (seperti Google dengan AppEngine-nya dan Blender). Alasan saya ketika memilih python adalah karena sintaksnya yang clean sehingga enak dibaca Khususnya menghilangkan redundansi begin-end yang ada di Pascal/Delphi yang mulai terasa gatal seperti yang terjadi pada LISP.

I used to cobble together terrible shell scripts to do the job, but now thanks to plistlib and python, plist manipulation is really easy. I am releasing this utility free under the Apache 2.0 license. Hopefully some other sysadmins will find it useful.

dockutil is a command line utility for managing Mac OS X dock items.
It can add, replace, list, move, find, and delete dock items. It supports Applications, Folders, Stacks, and URLs. It can act on a specific dock plist or every dock plist in a folder of home directories.
It is compatible with Mac OS X Tiger and Leopard.

Download dockutil here.

Here is the usage information:

usage: dockutil -h
usage: dockutil --add (path to item) | (url) [--label (label)] [ folder_options ] [ position_options ] [ plist_location_specification ]
usage: dockutil --remove (dock item label) [ plist_location_specification ]
usage: dockutil --move (dock item label) position_options [ plist_location_specification ]
usage: dockutil --find (dock item label) [ plist_location_specification ]
usage: dockutil --list [ plist_location_specification ]

Contact:
Send bug reports and comments to kcrwfrd at gmail.


import inspect
inspect.getsource(string.swapcase)

This returns a little snippet of code (def swapcase) to the shell from the /usr/lib/python2.5/string.py file (Linux path)

After downloading and doing the typical configure && make dance I saw this:

Failed to find the necessary bits to build these modules:
bsddb185          gdbm              linuxaudiodev
ossaudiodev       readline          spwd
sunaudiodev

Apparently setup.py won't build the readline module with the stock readline library on my mac. I already installed libreadline from MacPorts so I applied the following patch:

diff -r c68686a4d0b2 setup.py
--- a/setup.py  Thu May 15 21:06:32 2008 -0700
+++ b/setup.py  Thu May 15 21:49:39 2008 -0700
@@ -298,6 +298,8 @@
         # Ensure that /usr/local is always used
         add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')
         add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')
+        add_dir_to_list(self.compiler.library_dirs, '/opt/local/lib')
+        add_dir_to_list(self.compiler.include_dirs, '/opt/local/include')

         # Add paths specified in the environment variables LDFLAGS and
         # CPPFLAGS for header and library files.

This worked. After installing the rest of the required pysmug dependencies (simplejson, nose, setuptools, pycurl) I was able to build pysmug. Running the tests resulted in the following error:

  File ".../nose-0.10.2-py2.6.egg/nose/suite.py", line 377, in makeSuite
self.context.setdefault(suite, []).append(context)
TypeError: unhashable type: 'ContextSuite'

It turns out this issue already has a patch. After applying it and re-[compiling,installing] I tried again. Success!

performance

Out of curiosity I tried two runs each of 2.5 and 2.6, interlaced.

$ python2.6 setup.py nosetests
Ran 9 tests in 10.654s
$ python2.5 setup.py nosetests
Ran 9 tests in 12.128s
$ python2.6 setup.py nosetests
Ran 9 tests in 11.413s
$ python2.5 setup.py nosetests
Ran 9 tests in 12.207s

In this extremely unscientific test it appears 2.6 has the edge. I wouldn't read very much into this.

The wireless was a lifesaver sitting on the 8th floor and I spent a good amount of time on my Mac trying to add "color" to my python mosaic generator. It was harder than I thought it would be. It looks like the Image.point function of PIL operates on three color bands simultaneously (ie, it wont update Red, Green, and Blue independently). The fix I found was to use getData and putData, but it's not working quite right yet. Hopefully it'll be done this weekend.

Other than that, I only had to go find one straggler before shop closed up at 10.

(edit: the following are just observations and thoughts. they might not accurately reflect reality. just thinking out loud folks . I also wrote the second half of this in direct response to a specific email I was shown from one anonymous artist to a volunteer. )

In the past few times Ive been at Artomatic, though, I've noticed something that kind of irritates me about the bad or mediocre reviews (and reviewers) of AOM:

There are two approaches to "seeing" Artomatic -

1 - Spend, on average, two seconds deciding whether or not to get closer to a partition. Half the time, many of the partitions are outside of your peripheral vision and quite a few are missed. The people who take this approach don't usually read anything the artist has written. Their initial interest is based on their 2 second visual assessment, nothing else.

The other approach is:

2 - Make sure every partition is looked at. One at a time. Slowly. These people give each artist their due time. But there are 800+ visual artists. Innundation happens rapidly and attention/cognition dwindles.

In either case, only a small portion of the works at AOM are both grasped and retained. The others tend to fall out as peripheral noise.

There's no problem with this, it's the nature of AOM

The problem comes when people act like looking at the show in these ways is the same as reviewing or experiencing a 20 artist show. It's not. You can't go through the show once, retain some small percentage of it, and then claim there is no good art like you can at a smaller show.

AOM should be walked through multiple times on multiple days and the experience layered over multiple times before strong conclusions and opions are reached. Otherwise, it's like reviewing DC after running through it in 24 hours.

I also find myself at odds with many reviewers' positions on the "quality" of the art. While art typical of local galleries might be hard to find at Artomatic, I look at that as one of the many reasons this show is so valuable to the community. To be honest, I find much (but not all) of local gallery art to be the same self-aggrandized, repetitious, mediocrity incarnated material as the Artomatic works are claimed to be. But at least at Artomatic, you tend to find pieces closer to the heart of the community.

Said nicer: Artomatic serves a different form of social expression than galleries do.

Similarly, in my own life, I've found that my friends, family, and coworker's usually cannot visually distinguish between gallery-quality work and that of a pre-schooler. It doesn't connect with them. I think this is has been a problem with "art" for years. People would (to use an artdc'ism) rather go get their art from IKEA. Obviously, there's a disconnect somewhere.

If the art fails to resonate with the culture or community, what measure of quality are we using?

If it is some intellectual standard by which we are judging Artomatic, I have a difficult time believing most people have managed to go through a statistically significant portion of the art at the show with anywhere near the level of attention required to make that kind of judgment. If so, they have either spent an extremely large amount of time at the show or are a better person than I am.

But that was never really the point of Artomatic - to fit in to anyone's idea of "quality". The show is intended to be a forum of universal self-expression, regardless of others' judgments and criticisms. In that light, the show itself could even be looked at as a work of art in and of itself. What do 1000 artists, professionals, students, children, parents, and others produce when thrown together to express themselves visually? As an artist, I find the answer to that makes fascinating art.

There are over 800 visual artists. If someone can't find a single artist worthy of merit - especially when a number of those artists currently have work in other galleries and/or are nationally recognized - then my opinion is they either have not tried very hard or are not particularly interested in doing so. (Edit: I stole this sentiment, partially, from a comment secretworm made on artdc)

But, in the spirit of Artomatic, everyone is entitled to their opinions.

:)

Plone is to your Website

what

Windows/Linux/MacOS are to your Computer

Plone is not a website builder, though it is very often used that way. Plone is a world-class content management system (CMS) that can be used over the internet much like you use a local area network (LAN) to work within your office or home.

Because Plone is completely web-oriented it is usually accessed with a web browser and it operates like an advanced, dynamic website. For that reason Plone can be used to create anything from a very simple business website to a very large, feature-rich social networking community.

Underneath Plone is Zope, a very sophisticated webapp server developed entirely in a state-of-the-art, pure object-oriented language called Python. Plone itself is written in Python too. Python is widely used by web/development experts like Google, Rackspace, Industrial Light and Magic, AstraZeneca, Honeywell, and many others...

All three of these technologies come from large, active, open source communities: plone.org, zope.org and python.org respectively.

Some of the reasons why this is very important to you are:

• the developers created this software for their own daily use, in the real world
• these technologies are NOT developed and licensed as commercial products
• by necessity this software is tested brutally and errors tend to get fixed quickly
• you are never tied exclusively to any one vendor or company
• the system is completely customizable and scalable to meet your future needs
• complete standards compliance means your site will stay current and viable

The 'future-proof' nature of the Plone/Zope/Python stack is just one its many enticing benefits. Even better, the licensing of these technologies guarantees free and open distribution which means anyone can afford to use it, and can do so without fear that it may someday vanish.

The fact that the developers use the system themselves and their total lack of financial demands means that all Plone/Zope/Python development is motivated by real integrity and a need to do things right, not to turn a buck.

It also means, for you, instead of paying massive license fees for the software, you will only pay for the server resources and the technical expertise you need to put the system into use, then maintain and support it.

And make no mistake: The acronym 'CMS' is already being misused to describe site-builders and blogware, but Plone is the real deal. Organizations as diverse as NASA, Oxfam, eBay, Trolltech, Nokia, Utah State University, the CIA and Novell use Plone for content management.

Plone is very robust and has been gaining wide acclaim for years, well before most other CMS products got off the ground.  One partial list of plone sites is in itself several dozens of pages long and by July 20, 2007 Plone had already surpassed its one millionth download.

For a system of this size, with this flexibility and of this quality the savings are nearly incalculable. No small or medium sized business could expect to develop a system of this magnitute and most small businesses could not afford to license anything like it.

In a very real way Plone gives you a multi-million dollar software team, virtually for free.

Vediamo insieme alcuni aggiornamenti che caratterizzano questa importante release:

• Phonon un framework multimediale per riprodurre filmati e suoni
• Webkit Qt API. Esso permette a sviluppatori terzi di includere con facilità nelle loro applicazioni molte delle funzioni proprie di Safari. WebKit è un progetto open source che nasce dalla combinazioni di componenti del sistema grafico KDE e di tecnologie Apple. (dalla Wikipedia)
• Il supporto a Windows CE

ed altri aggiornamenti che vi lascio scoprire rimandandovi alla pagina http://doc.trolltech.com/4.4/qt4-4-intro.html

inoltre http://www.riverbankcomputing.co.uk/software/pyqt/download per scaricare PyQt4.4
http://www.riverbankcomputing.co.uk/news/sip-475 per scaricare l'ultima versione di SIP

trovate questo articolo pubblicato sempre da me sull'home page di python-it.org

I finally started testing and trying out AppEngine. Initially it looks really clunky. While going through the demo it had html embedded in the code, I almost dropped whole thing when on next page they introduced templates. Also it seems that using Django wouldn't be an issue. So far I have very positive experience and even though Google framework is unstructured, I think it can be used for smaller apps.

I did try to use one external lib and things didn't work out.

For me just idea that you don't have to do anything about db, about hosting, about anything else, but just write code, it is amazing and in the long run it might save a lot of time. I have to think about demo app to create, actually I would like to create feed aggregator but this lib isn't working so I have to resolve this first.

Very positive so far. It is not rails of course and I can see how a lot of things could be simplified.

First let me clarify by saying that I'm not suggesting Matlab is copying Python (though they may be) or that Python has the market cornered on the similarities I'm about to talk about (it doesn't). Also, I have no idea when this stuff was introduced to Matlab, so it might have all been there for years.

The first thing of interest to me was the discussion about memory management in Matlab. Suppose you create a matrix and store it in the variable X. Next, you assign X to Y: Y = X. Here, Y acts as a pointer to the data pointed to by X. If you clear X, Y still points to the data, so it continues to reside in memory until Y has been cleared also. Now if you modify Y, perhaps like so: Y(1,1) = 2, my thought was that both X and Y would be affected and the memory used would stay the same. However, that is not the case, thanks to the BLAS and LAPACK libraries that require matrices to be contiguous in memory. So when you modify Y as above, it creates a modified copy in memory that Y now points to, while X remains pointing to the same, unmodified data. This is decidedly not Pythonic, since in Python that modification would have updated both X and Y, and they still would be pointing to the same thing in memory.

The next set of interesting things were functions. Here is where things struck me as Pythonic. You can declare a simple function in an m-file like so:

function Y = square(x)
Y = x.^2
end

Here the end is optional. Like in Python, you can use function handles. This lets you do cool things like decide on the fly which operation you can apply to a matrix without having to worry about record-keeping and if checks (I'm not going into this any further). To demonstrate the function handle, here is one possibility:

fh = @sin
fh(pi)
fh = @cos
fh(pi)

We call the function handle fh on the same input, but get two different results: 0 and -1. Matlab also lets you create factory functions like in Python:

function Y = makeF(a,b)
Y = @makeFHelper;
function Z = makeFHelper(x)
Z = a * sin(x) + b;
end
end


This returns a function handle to the subfunction makeFHelper with the parameters you passed hard-coded in the function produced. So you could create two different functions:

Y1 = makeF(2,3)
Y2 = makeF(3,-1)

and when you execute them:

Y1(pi/3)
Y2(pi/3)

you get two different results: 4.7321 and 1.5981. If I had known about this before, I might've put more effort into learning Matlab programming, since it would have come in handy for a couple assignments this semester.

I would like to share the code of that program with you and give a short tutorial on how to create your own Jumbled Words game. The tutorial is platform-independent. So, no matter if you are using Windows or Linux or Mac, the tut will work out in all the cases.

Here's a screenshot of the Jumbled Words game running in Linux.

• First of all, you will need the Python programming language installed on your system. Get it from here: http://python.org/download/.
• Next, you'll need a GUI-tool kit for Python which would actually allow you create GUI based applications. I used the wxPython tool kit. Get it from here: http://wxpython.org/download.php#binaries.
• After installing Python and wxPython on your system, you'll be ready to start writing the code now.
• Create a new file, copy-paste the following contents in it, and save it by the name JumbledGUI.py.
  import wx

  # First, we define a dictionary of jumbled words
  dict = {"special":"licapes", "guava":"augav", "begin":"ngibe",
  "compression":"serniospmoc", "praying":"igyaprn", "linux":"uilxn",
  "opposite":"seopopit", "depricated": "cpdirdaete",
  "leonardo da vinci":"o draconian devil", "the mona lisa":"oh lame saint",
  "dreaming":"earimngd", "tormented":"nemortted", "flabbergasted": "tasedbgaberlaf",
  "meticuluos":"ecusoulmit", "rectify":"fitecry", "mobile":"ibelmo",
  "computer":"mertopcu", "granular":"lrgaruna", "metro":"torem",
  "outrageous":"gretsouauo", "nothing":"hotning", "appreciable":"celbepiapra", "vandalism":"misdanlav", "tropical":"ptorlica"}

  def func():
  'This is the core function of the program'
  # The result of popitem() method is a tuple
  # The following is an example of "sequence unpacking"
  word, jumbled = dict.popitem()
  return word, jumbled

  def guess(event):
  ans = input_word.GetValue()
  if(ans == query[0]):
  result.SetLabel(label="Congrats! You got it right.")
  else:
  result.SetLabel(label="Sorry, wrong answer. Better luck next time!")

  def next(event):
  # After a person clicks the Start button for the first time, this will happen
  nextButton.SetLabel("Next")
  guessButton.Enable()
  hintButton.Enable()
  input_word.SetValue("")
  # Unless we define the variable "query" as global, the function "guess" won't be able to access it
  global query
  query = func()
  if(dict!={}):
  question.SetLabel(label="The jumbled word is: "+query[1])
  result.SetLabel(label="Waiting for your input...")
  else:
  question.SetLabel(label="Game Over!")
  result.SetLabel(label="Yup, the game is finally over!")
  guessButton.Disable()
  nextButton.Disable()
  hintButton.Disable()

  def hint(event):
  input_word.SetValue(query[0])

  app = wx.App()
  win = wx.Frame(None, title="Jumbled Words Game", size=(460, 345))
  win.CenterOnScreen()
  bkg = wx.Panel(win)
  guessButton = wx.Button(bkg, label='Guess')
  guessButton.Bind(wx.EVT_BUTTON, guess)
  guessButton.SetDefault()
  # Unless the player has pressed the Start button, the Guess button will be disabled
  guessButton.Disable()
  nextButton = wx.Button(bkg, label='Start')
  nextButton.Bind(wx.EVT_BUTTON, next)
  hintButton = wx.Button(bkg, label='Hint')
  hintButton.Bind(wx.EVT_BUTTON, hint)
  hintButton.Disable()
  input_word = wx.TextCtrl(bkg)
  question = wx.StaticText(bkg, label="Welcome to jumbled words game\nTotal words: 24", style=wx.ALIGN_CENTER)
  # We define some stylish fonts for the welcome message / game questions
  font = wx.Font(pointSize=18, family=wx.DECORATIVE, style=wx.NORMAL, weight=wx.NORMAL)
  question.SetFont(font)
  result = wx.StaticText(bkg, label="Waiting for the initial result...", style=wx.ALIGN_CENTER)
  hbox = wx.BoxSizer()
  hbox.Add(input_word, proportion=1, flag=wx.EXPAND)
  hbox.Add(guessButton, proportion=0, flag=wx.LEFT, border=5)
  hbox.Add(nextButton, proportion=0, flag=wx.LEFT, border=5)
  hbox.Add(hintButton, proportion=0, flag=wx.LEFT, border=5)
  vbox = wx.BoxSizer(wx.VERTICAL)
  vbox.Add(question, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
  vbox.Add(hbox, proportion=0, flag=wx.EXPAND | wx.LEFT | wx.BOTTOM | wx.RIGHT, border=5)
  vbox.Add(result, proportion=0, flag=wx.EXPAND | wx.LEFT | wx.BOTTOM | wx.RIGHT, border=5)
  bkg.SetSizer(vbox)
  win.Show()
  app.MainLoop()

• To run it, open the command-line. In Windows, go to Start > Run. Type cmd. In Linux, open Terminal is GNOME or Konsole in KDE. Then cd (move) to the location of the folder containing the file JumbledGUI.py. After that, type python JumbledGUI.py and enjoy playing with the just created application.
• Now that you just ran it, what if you wanted to show it to your friend? Would it look good if he had to issue the command in the command-line just for running it? No? You are right. Now is the time to publish it!
• You'll publish it by making an executable out of it (that .exe file which runs on double-clicking). With this step, I am going specific for just the Windows users. I'll come to the Linux method of creating an executable some time later. To make an executable from your Python file, download and install py2exe from here: http://sourceforge.net/project/showfiles.php?group_id=15583.
• Create a new file in the same folder as JumbledGUI.py, copy-paste the following content, and save it with the name setup.py.
  # Requires wxPython. This sample demonstrates:
  #
  # - single file exe using wxPython as GUI.from distutils.core import setup
  import py2exe
  import sys

  # If run without args, build executables, in quiet mode.
  if len(sys.argv) == 1:
  sys.argv.append("py2exe")
  sys.argv.append("-q")

  class Target:
  def __init__(self, **kw):
  self.__dict__.update(kw)
  # for the versioninfo resources
  self.version = "1.1"
  self.company_name = "Anurag Bhandari"
  self.copyright = "GPL v2"
  self.name = "Jumbled Words Game"

  ################################################################
  # A program using wxPython

  # The manifest will be inserted as resource into JumbledGUI.exe. This
  # gives the controls the Windows XP appearance (if run on XP ;-)
  #
  # Another option would be to store it in a file named
  # JumbledGUI.exe.manifest, and copy it with the data_files option into
  # the dist-dir.
  #
  manifest_template = '''

  %(prog)s Program

  '''

  RT_MANIFEST = 24

  JumbledGUI = Target(
  # used for the versioninfo resource
  description = "A cute jumbled words game",

  # what to build
  script = "JumbledGUI.py",
  other_resources = [(RT_MANIFEST, 1, manifest_template % dict(prog="JumbledGUI"))],
  # icon_resources = [(1, "icon.ico")],
  dest_base = "JumbledGUI")

  ################################################################

  setup(
  options = {"py2exe": {"compressed": 1,
  "optimize": 2,
  "ascii": 1,
  "bundle_files": 1}},
  zipfile = None,
  windows = [JumbledGUI],
  )

• It's time to modify the publishing information of the to-be-created exe. Open setup.py and look for the code: Replace the self.version, self.company_name, self.copyright and self.name values with your desired values.
• Now you are ready to "build" the exe. For that, open command prompt, cd to the folder where the setup.py file is placed (the same location as JumbledGUI.py) and issue the command: python setup.py py2exe.
• This will create two folders where your two Python files are placed. One is the dist folder and the other is the build folder. Our folder of interest is the dist folder.
• Open the dist folder and look for the just created exe file. Double click it and viola! It works!
• To give your application a more professional touch, you may opt to created a setup of your program so that the end users are able to install it the way they install other softwares (the Next, Next, Next way...). For that, download the Inno Setup software from: http://www.jrsoftware.org/isinfo.php.

It was fun, wasn't it?

I've provided comments in the code at all possible places so you don't find it difficult to know what has been done there. I admit not using much efficient code, like making use of classes than just pure functions, but I'll try to modify the code and rewrite it with classes as soon as I get some time for it.

I'll post my own created setup for this app soon. :)

Enters Google Translate. Very efficient and quite correct, as it turns out. But then again, opening a browser and clicking on a bookmark etc all the time is a bit of a hassle.

Enters Python :-) My bias towards this language is well known to those who have been working with me in the recent years. I haven't really written any real code for a long time now, more than 4 years actually, but in less than 30 minutes (also putting WebScarab in use, I managed to have a simple but fully functional command-line client for Google Translate in place.

Clearly, Python is like cycling; Once you learn it, you never forget it.

I found only one major incompatibility, that 2.6 required u'' for Unicode, but 3.0 doesn't support it. This was solved in Python 2.6a3, which introduced a from __future__ import unicode_literals, which makes 2.6 behave the same as 3.0. Thanks for that!

So, at the moment, I'm not aware of any major unavoidable incompatibilities. I decided to put up my half-assed code somewhere public, so other people can add to it. So, I created a new project on code.google.com: http://code.google.com/p/python-incompatibility/

You can check out out for yourselves. running runtests.py 26 will work on both Python 2.6 and Python 3.0.
But the code isn't finished yet. There may be incompatibilities I haven't thought about, and there are no tests of the library reorganisation. Please help out on this! It's fun, easy and a great way to learn Python 3.0!

See also: http://regebro.wordpress.com/2007/06/23/python-3000-and-compatibility/, http://regebro.wordpress.com/2008/03/22/why-python-26-and-30-compatibility-would-be-a-very-good-thing/