License: Expat (sometimes called MIT)
Hy is a wicked funny hack that lets you interop (in both directions)
with Lisp from Python (or with Python from Lisp).
It's pip installable:
$ pip install hy
=> (print (.join ", " ["Hello" "World"]))
(REPL even has cute readline bits mostly workingish, with a few known
And the source is on GitHub @ http://git.io/hy (star it, fork it, hack it)
It's undergoing changes quite quickly - so, be careful!
OK, what is it (technically)
Hy is a set of hacks, implemented in Python, to lex and compile a Lisp
variant (called `Hy', which looks very similar to Clojure in some ways)
into Python AST, and transparently load it into sys.modules using a PEP
302 import hook.
I gave a lightning talk about Hy at PyCon, in case anyone's having
flashbacks. You can see that talk on my blog
(http://blog.pault.ag/post/46982895940/), or watch a full hour-long talk
about Hy at Boston Python at http://www.youtube.com/watch?v=ulekCWvDFVI
Right, so that means?
You can do hilarious (hylarious?) things like write full Django
projects in Lisp, or interop with pymongo, or even use pdb
to debug Lisp code.
Wait, are you serious?
About it working? Yup!
About making this lisp-variant production quality? Not really.
It's just really funny, and helps teach people about how awesome Python is.
*: but you have to write them in Python for now (code plot'ed) :(
Yep! http://hy.rtfd.org/ - could use help!
With lots of love,
Special thanks to the current contributors:
* Thomas Mashek <thomas(a)thescoundrels.net>
* Amrut Joshi <amrut.joshi(a)gmail.com>
* Christopher Allan Webber <cwebber(a)dustycloud.org>
* Will Kahn-Greene <willg(a)bluesock.org>
* James King <james(a)agentultra.com>
* Julien Danjou <julien(a)danjou.info>
* Nicolas Dandrimont <nicolas.dandrimont(a)crans.org>
.''`. Paul Tagliamonte <paultag(a)debian.org>
: :' : Proud Debian Developer
`. `'` 4096R / 8F04 9AD8 2C92 066C 7352 D28A 7B58 5B30 807C 2A87
I am happy to announce flufl.enum version 4.0.
What is flufl.enum? It is an enumeration package with a simple syntax, and
concise and specific semantics. flufl.enum is compatible with Python 2.7,
3.2, and 3.3. It is proposed for inclusion in Python 3.4 by way of PEP 435.
My thanks to Eli Bendersky for his help with both the code and in authoring
the PEP, as well as everyone who participated in discussions on python-dev,
python-ideas, and at the PyCon 2013 language summit.
Changes since 3.2:
- Added the IntEnum variant. When you create an enumeration with this base
class, the resulting enum values *are* ints and can be used anywhere a
Python int can be used, including in the C API. (LP: #1132976)
- make() is deprecated. You can now just call Enum() or IntEnum() to
programmatically create enumerations. (LP: #1162375). These constructors
now also accept a space-separated string of attribute names which are
auto-split and auto-numbered. They also accept a dictionary mapping names
- IntEnums values support __index__() for slicing (LP: #1132972), as well
as__int__() for coercion to a concrete integer.
- EnumValue.__int__() is deprecated; use IntEnumValue (via IntEnum) instead.
- EnumValues now have a .value attribute to access the actual, underlying
value. (LP: #1132859)
- Previously deprecated attributes .enumclass and .enumname have been
removed, as well as the module function make_enum(). (LP: #1132951)
- Minor API changes: the repr of enum values say "value=" instead of "int=",
and multiple enum values in a single enum definition now raises ValueError
instead of TypeError.
- Single argument Enum() calling as a synonym for getitem is deprecated.
- Other bugs fixed: LP: #1026403, LP: #1132830, LP: #1124596
Full documentation is available here:
The project home is at:
You can report bugs at:
Download the package from the Cheeseshop:
or from the Launchpad project page above.
Read PEP 435:
gui2py is a “fork” of PythonCard (a simple software construction kit
based on wxpython), but improved trying to enhance it with a modern
look & feel (better visual designer, property grid, drag & drop
toolbox, etc.) and keeping it simple and powerful (i.e. adding MVC
List, Tree, Grid, easier layout with Notebook, Sizers and Web-like
It was based initially mainly on PythonCard (and also on wxPython
Demo, wxGlade and other related projects), but also it includes a lot
of experience and personal needs (it would be used to port a legacy
ERP-like system for SME, actually composed of a large Visual Basic 5.0
classic codebase). For more info see:
It is also aimed for teaching in introductory and intermediate
programming courses (prior web development assignments), so it was
In parallel, gui2py is part of a meta-project called rad2py (Rapid
Application Development for Python), an academic research about
software engineering best practices and quality assurance, whose goals
are to integrate an IDE (code editor, debugger, unit test and other
tools) with agile methodologies and a well defined software process
(mainly for metrics collection, analysis and estimation):
As gui2py it is not completely backwards compatible with PythonCard, a
lot of code was changed/removed or added, it was "forked" in a
separate project to not cause confusions.
Migration should be easy, and an automatic tool is planned to convert
PythonCard resources and source code to gui2py requeriments.
New features are only available on gui2py, and they could not be
backported to PythonCard.
This alpha release is functional and "stable" for development
porposes, but expect some APIs to change in the near future, and a lot
of features still need to be incorporated.
Screenshots (Windows, Mac OS X, Ubuntu):
Quick Start Installation Guide:
Feedback is welcome, and of course, if you are interested, I've
created this group where anyone can participate:
My special thanks to all of the PythonCard's, wxPython's and Python's
developers that made this possible
gcc-python-plugin is a plugin for GCC 4.6 onwards which embeds the
CPython interpreter within GCC, allowing you to write new compiler
warnings in Python, generate code visualizations, etc.
It ships with "gcc-with-cpychecker", which implements static analysis
passes for GCC aimed at finding bugs in CPython extensions. In
particular, it can automatically detect reference-counting errors:
Major new features in 0.12
* support added for GCC 4.8 (along with 4.6 and 4.7)
* addition of a new "gcc-c-api" component to isolate much of GCC's
internals (and the differences between 4.6-4.8). I plan for this to
eventually be its own project, aiming at providing a stable API and ABI
for working with GCC, once it has proven itself in the context of the
* link-time-optimization support, for e.g. whole-program visualizations
across multiple source files.
for more information, and for details of the numerous other changes.
Tarball releases are available at:
Prebuilt-documentation can be seen at:
The project's homepage is:
The plugin and checker are Free Software, licensed under the GPLv3 or
Content-Management mit Plone (German)
Date: September 12 - 13, 2013
Location: Leipzig, Germany
(The following is in German, the instruction language.)
Der Kurs richtet sich an Autoren und Redakteure sowie Contentmanager
und Webmaster, die Inhalte mit Hilfe des Content-Management-Systems
Plone erstellen und pflegen wollen. Es sind keine Grundkenntnisse
Plone ist in Python implementiert. Im Gengensatz zu den anderen
Kursen der Python Academy geht es nicht um das Programmieren, sondern
um das Nutzen von Software. Wer tiefer einsteigen und mit Python
programmieren möchte, zum Beispiel um Plone zu erweitern, kann
aus vielen Kursen auswählen. Unten sind die nächsten Kurs-Termine
Our next courses:
14.04.-17.04.2013 (Leipzig) Python für Nicht-Programmierer (German)
15.04.-17.04.2013 (Leipzig) Python für Programmierer (German)
18.04.-20.04.2013 (Leipzig) Python für Wissenschaftler und Ingenieure (German)
03.06.-05.06.2013 (Leipzig) Einstieg in Django (German)
06.06.-08.06.2013 (Leipzig) Django für Fortgeschrittene (German)
10.06.-12.06.2013 (Leipzig) Python for Scientists and Engineers (English)
13.06.2013 (Leipzig) Fast Code with the Cython Compiler (English)
14.06.2013 (Leipzig) Fast NumPy Processing with Cython (English)
24.06.-26.06.2013 (Leipzig) Professional Testing with pytest and tox (English)
09.09.-11.09.2013 (Leipzig) Twisted Training (English)
12.09.-13.09.2013 (Leipzig) Content-Management mit Plone (German)
04.11.-06.11.2013 (Leipzig) Introduction to Django (English)
07.11.-09.11.2013 (Leipzig) Advanced Django (English)
There's a new mailing-list related to Python code-quality tools.
Are you concerned about the evolution of various code checkers?
Do you have questions or suggestions?
Call for Papers
Dyla'13, 7th Workshop on Dynamic Languages and Applications
Colocated with ECOOP, ECMFA and ECSA
In-cooperation with SIGPLAN and SIGSOFT
1–5 July, Montpellier, France
!! Important dates
- Submission deadline: *April 19th*
- Notification: mid-May
- Workshop: July 1st
- Ecoop early registration: mid-May
The advent of Java and C# has been a major breakthrough in the
adoption of some important object-oriented language characteristics.
This breakthrough turned academic features like interfaces, garbage
collection, and meta-programming into technologies generally accepted
by industry. Nevertheless, the massive adoption of these languages now
also gives rise to a growing awareness of their limitations. A number
of reactions from industry testify this: invokedynamic bytecode
instruction has been included in latest Java virtual machine release;
the dynamic language runtime (DLR) is gaining popularity; C# adopted
dynamic as a valid static type. Gartner prognoses further growth
(http://blogs.gartner.com/mark_driver/2008/12/10) of dynamic
Researchers and practitioners struggle with static type systems,
overly complex abstract grammars, simplistic concurrency mechanisms,
limited reflection capabilities, and the absence of higher-order
language constructs such as delegation, closures and continuations.
forward in addressing these problems while getting more and more
popular. Making these languages mainstream requires practitioners to
look back and pick mechanisms up in existing dynamic languages such as
Lisp, Scheme, Smalltalk and Self. Practitioners also need to further
explore discover new dynamic approaches in the context of new
challenging fields such as pervasive computing.
The goal of this workshop is to act as a forum where practitioners can
discuss new advances in the design, implementation and application of
dynamically typed languages that, sometimes radically, diverge from
the statically typed class-based mainstream. Another objective is to
discuss new as well as older "forgotten" languages and features in
this context. Topics of interest include, but are not limited to:
- programming language extensions
- programming environment extensions
- executing environments
- static and dynamic analyses
- optional type-checking
- meta-object protocols
- reserve engineering
- domain-specific languages/tooling
- testing environments
- live programming
!! Targeted audience
The expected audience of this workshop is practitioners and
researchers sharing the same interest in dynamically typed languages.
Lua, Python, Ruby, Scheme and Smalltalk are gaining a significant
popularity both in industry and academia. Nevertheless, each community
has the tendency to only look at what it produces. Broadening the
scope of each community is the goal of the workshop. To achieve this
goal we will form a PC with leading persons from all languages
mentioned above, fostering participation from all targeted
!! Workshop Format and Submission Information
The workshop will have a demo-oriented style. The idea is to allow
participants to demonstrate new and interesting features and discuss
what they feel is relevant for the dynamic-language community. To
participate to the workshop, you can either
- submit (before __April 19th 2013__) an article (ACM Tighter
your presentation and/or tool. Articles whose length ranges from 2 to
15 pages will be carefully reviewed by a program committee including
but not limited to the organizers. Each accepted paper will be
presented for 20 to 30 minutes and be published to the ACM Digital
Library (at the option of each author) and the workshop's web site.
The submission website is
- or give a 10-minute lightning demo of your work. A dedicated session
will be allocated for this, provided there is ample time available.
A session on pair programming is also planned. People will then get a
chance to share their technologies by interacting with other
!! Program committee
- Carl Friedrich Bolz, Heinrich-Heine-Universität Düsseldorf, Germany
- Camillo Bruni, Inria Lille-Nord Europe, France
- Adrian Kuhn, University of British Columbia, Canada
- Lukas Renggli, Google, Switzerland (http://www.lukas-renggli.ch/)
- Juan Pablo Sandoval Alcocer, University of Chile
- Bastian Steinert, Hasso-Plattner-Institute, Germany
- Veronica Uquillas Gomez, Vrije Universiteit Brussel, Belgium
- Simon Urli, University of Nice-Sophia Antipolis, France
- Didier Verna, EPITA Research and Development Laboratory, France
- the 4 workshop organizers
!! Workshop Organizers
- Alexandre Bergel (http://bergel.eu)
- Damien Cassou (http://damiencassou.seasidehosting.st)
- Jorge Ressia (http://www.jorgeressia.com)
- Serge Stinckwich (http://www.doesnotunderstand.org)
!! News feed
Follow us on twitter: http://twitter.com/dyla2013
For further information: http://rmod.lille.inria.fr/web/pier/Events/Dyla13
We are pleased to announce that PyCon Ireland will take place in Dublin
When: Saturday 12th - Sunday 13th October
Where: The Burlington Hotel
(Information on ticket prices, etc. will be announced soon.)
We will also have a two-day sprints held after the conference, this is free
for all to attend.
When: Monday 14th - Tuesday 15th October
Where: Venue TBA
Call for Sponsors:
Form open for submissions from 12pm on Tuesday 9th April.
Call for Speakers:
If you have any questions, please email pycon(a)python.ie.
PyCon Ireland 2013 Committee
Python Ireland / Chairperson diarmuid(a)python.ie