• Py65 0.4 Released Jun 6, 2009

    Posted by Mike Naberezny in Hardware,Python

    Py65 0.4 has been released. Py65 provides tools for simulating hardware based on 6502-like microprocessors.

    Here are the highlights of this release:

    • We now support an additional microprocessor simulation: the 65C02. While still a work in progress, it is fairly complete and quite usable. It is based on the W65C02S microprocessor from the Western Design Center (WDC).
    • The monitor now supports assembling and disassembling the 65C02 opcodes. You can select the target microprocessor with the new mpu command.
    • There have been many other small additions and fixes to the monitor, the most useful of which is that most commands now have shortcuts such as d for disassemble.
    • A manual has been started and will be periodically published online. It is currently focused on the monitor usage.

    For a complete list of changes in this release, please see the changelog. Special thanks to Oscar Lindberg for making major contributions to this release.

    If you’re new to Py65, the README has an overview, installation instructions, and a link to the online documentation.

  • Supervisor 3.0a7 Released May 24, 2009

    Posted by Mike Naberezny in Python

    Supervisor 3.0a7 has been released. You can either easy_install it or get it from http://dist.supervisord.org/supervisor-3.0a7.tar.gz.

    For the very long list of additions and fixes in this release, please see CHANGES.txt.

  • PyWorks 2008 Slides Nov 15, 2008

    Posted by Mike Naberezny in Hardware,PHP,Python

    Slides from my PyWorks 2008 talks are now available. This conference was shared with php|works and I enjoyed this format. It was great to see many of my Python and PHP friends at the same event. Thanks to everyone who attended my talks.

    Py65: Microcontroller Simulation with Python

    Download Slides (PDF)

    This talk introduced the venerable 6502 microprocessor family, building small computer systems with these parts, and then simulating those systems with Py65.

    The audience participation was great. We had fun stepping through some small assembly language programs on the simulator. One attendee wrote:

    This was fascinating and the speaker was awesomely enthusiastic. The overview of microcontrollers and their significance was enlightening and entertaining. The simulator design presented was fantastically simple and very Pythonic. I can’t wait to see where this project goes.

    Thanks and I’m glad you enjoyed it. For updates on the Py65 simulator, please watch my blog and the Py65 project page on Ohloh.

    URL Mapping with Routes

    Download Slides (PDF)

    We explored the Routes library from the ground up, setting it up and then exploring its options and matching. We worked through many of the examples with live demos on the Python interactive interpreter.

    The talk was attended by several Pylons users, who gained a better understanding of how Routes works by seeing it outside the context of any particular web framework.

    URL Mapping with Horde/Routes

    Download Slides (PDF)

    Bonus Slides! Horde/Routes is a PHP 5 library that is a direct port of Routes. Since there were so many PHP folks at this conference as well, I ported all of the examples in my Routes talk to work with Horde/Routes.

    These slides will help you get acquainted with the PHP version. Since the two presentations are otherwise identical, you might also find it an interesting comparison between Python and PHP 5.

  • Py65 0.1: Introducing Py65Mon Nov 9, 2008

    Posted by Mike Naberezny in Hardware,Python

    Py65 0.1, a 6502 microprocessor simulator written in Python, has been released and is available on the Python Package Index (PyPI). You can now easy_install it:

    $ easy_install py65


    Since my initial announcement of Py65, there have been many bug fixes and unit tests added. The most noticeable addition is a new machine language monitor. It will be installed automatically and is started with the py65mon command:

    $ py65mon
    Py65 Monitor
    <6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>

    At the prompt, type help for a list of commands or help command for help on a specific command. The monitor commands are very similar to the excellent VICE Monitor, so VICE users should feel right at home.

    The biggest difference from VICE is that the load command requires a load address as the second argument and starts reading the binary data from byte 0. It does not expect byte 0 and 1 of the file to contain a Commodore-style load address. Also, assembling and disassembling from the monitor are not yet implemented but are planned.

    Hello World

    Just like Michal Kowalski’s 6502 Macroassembler & Simulator for Windows, Py65Mon will trap writes to $E001 and echo the bytes to STDOUT.

    This is enough to get us to our first “Hello World” program running under Py65. First, we’ll write a short assembly language program to print the message. Save it as hello.asm.

    CHAROUT=$F001      ;Originally $E001, now $F001 since Py65 0.2
      LDX #$00
      BEQ DONE
      JMP LOOP
    MESSAGE = *
      !text "Hello, World!"
      !byte 0

    We then assemble the program into a binary, using Marco Baye’s Acme Cross-Assembler:

    src$ acme --format plain --outfile hello.bin hello.asm

    The --format plain switch instructs Acme not to prepend the Commodore-style load address in the binary. If you’d like to get going quickly, you can also download hello.bin.

    With the binary ready, we can start the monitor and load it in:

    src$ py65mon
    Py65 Monitor
    <6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>
    .add_label c000 hello
    <6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>
    .load "hello.bin" hello
    Wrote +29 bytes from $c000 to $c01c

    Py65Mon supports symbolic addressing in most commands. The first command, add_label, defines hello as a label for address $C000. The second command loads the binary into that address.

    We can now set the program counter with the registers command, and execute the code up to RTS with the return command.

    <6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>
    .registers pc=hello
    <6502: A=00, X=0d, Y=00, Flags=20, SP=ff, PC=c000>
    Hello, World!
    <6502: A=00, X=0d, Y=00, Flags=20, SP=ff, PC=c00e>

    Now we have run the program, printed “Hello, World!”, and returned to the prompt. We can see the program counter is left at $C00E.

    You can also use the step command to step through the program. Just set the program counter to the start address again ($C000 or hello) and repeatedly enter step. As you are stepping repeatedly, you can simply hit ENTER to repeat the last command.

    From here you can also explore other commands, e.g. mem c000:c003 to display the memory in that address range. The default radix is hexadecimal. You can also prefix with $ for hexadecimal or + for decimal, like mem +49152:+49155.

    Next Steps

    Py65 and its monitor are now complete enough to run most simple 6502 programs, including many from the 6502.org Source Code Repository. The next versions will include more I/O devices and monitor commands, with the goal of running a sophisticated 6502 program like Lee’s Davisons’ Enhanced 6502 BASIC.

  • Speaking at PyWorks 2008 Aug 29, 2008

    Posted by Mike Naberezny in Hardware,PHP,Python

    PyWorks is a new conference from the folks at Python Magazine. It is being co-hosted with a PHP conference, php|works, and attendees of either conference have access to talks on both the Python and PHP tracks. Being a user of both languages, I think this a great idea and I’m looking forward to this format. I’ll be giving two talks at PyWorks 2008:

    Microcontroller Simulation in Python

    This talk will present Py65, my open-source simulation of a small microcomputer system based on the MOS 6502. The 6502 is a very famous microprocessor that was used in early microcomputers like the Commodore 64, but its design has stood up for over 30 years. Cores based on the 6502 are now widely used in embedded devices, with WDC estimating annual volumes in the hundreds of millions of units.

    Using Python and software tools such as Py65, low-level software for embedded systems can be developed and tested much faster. This talk will discuss the design and implementation of Py65, how it and tools like it can help, and will also touch on other Python libraries that can assist with embedded development. (PyWorks Abstract)

    URL Mapping with Routes

    Routes is a Python package that provides a solution to the problem, “how do I map URLs to my code?” Its solution is an interesting one, and is actually a re-implementation of a feature from Ruby on Rails. Routes itself has also now been ported to PHP 5 as part of the Horde project. Routes is used by the Pylons web framework and other frameworks in Python, and is relatively easy to use as a standalone package.

    The Routes method of URL dispatch is based around pattern matching rather than object publishing. For those new to Routes, we’ll have an introduction to the basic Routes concepts and how it works. We’ll also dive into the Routes internals and follow some URLs through their recognition phase, learning about how Routes does it job along the way. Web developers and framework implementers alike will gain a better understanding of Routes and how to use it effectively. (PyWorks Abstract)

  • OSCON 2008 Slides Jul 25, 2008

    Posted by Mike Naberezny in PHP,Python,Testing

    Slides from my two talks at OSCON 2008 are now available:

    Both talks were well attended had great audience participation. Thanks to everyone that attended and I hope you enjoyed them.

    About seven people came up after the Integration Testing talk with good questions and feedback. I think that 45 minutes was enough to provide good starting points for the topics covered but it was clear that these users were engaged and ready to dig into it more. If I give this talk again, it is going to be in a tutorial format so we can get much deeper into the material and have some exercises.

    After my Supervisor talk at the end of the day, I had the pleasure of going out to dinner with Roger Hoover and some other Supervisor users. It’s been very exciting to see Supervisor picking up traction over the past year. Supervisor is being used in several large architectures of companies whose names you know. If you’re using Supervisor and wouldn’t mind us telling others about it, please contact me.

  • Py65: 6502 Microprocessor Simulator Jul 1, 2008

    Posted by Mike Naberezny in Hardware,Python

    I’ve started a new Python project called Py65. It aims to provide building blocks for modeling 65xx microcomputer systems in software, with a focus on homebuilt hardware. Using simulation, embedded systems software can be developed and tested much faster.

    In its current form, Py65 supports the original NMOS 6502 microprocessor from MOS Technology. The venerable 6502 and variants of it powered such famous microcomputers as the Commodore 64, game systems like the Atari 2600 and Nintendo Entertainment System (NES), as well as thousands of consumer and embedded devices today.

    I haven’t released a package for Py65 yet but I’ll be doing this after some organizational changes are complete. For now, you can get it from its Subversion repository linked from the Py65 page on Ohloh.

    The Python interactive interpreter itself can be used as a monitor:

    >>> from py65.mpu6502 import MPU
    >>> mpu = MPU()
    >>> mpu
    <6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>
    >>> mpu.memory[0x0000:0x0001] = (0x69, 0x16) #=> $0000 ADC #$16
    >>> mpu.step()
    <6502: A=16, X=00, Y=00, Flags=20, SP=ff, PC=0002>

    The simulator currently supports all legal NMOS 6502 opcodes and I have written a large unit test suite to verify its core. Most of its tests look like this one:

    def test_bne_zero_set_does_not_branch(self):
      mpu = MPU()
      mpu.flags |= cpu.ZERO
      mpu.memory[0x0000:0x0001] = (0xD0, 0x06) #=> BNE +6
      self.assertEquals(0x0002, mpu.pc)

    Py65’s own unit tests hint at what tests for your own assembly language programs could look like. I am especially interested in unit testing my own embedded software and I will be working on an assertion vocabulary and test helpers for this.

    There are a lot of possibilities for what could be done with Py65. For now, I plan to include a system for mapping virtual devices into the microprocessor’s address space, add more hooks into the simulator, and include support for additional 65xx family hardware.

    Py65 does not include an assembler. If you need one, I recommend André Fachat‘s excellent xa assembler which is currently maintained by Cameron Kaiser.

  • Horde/Routes 0.3 Released Jun 15, 2008

    Posted by Mike Naberezny in PHP,Python,Ruby

    Horde/Routes is a URL mapping system for PHP 5. It is a direct port of the Routes, a Python library that is part of the Pylons project. Horde/Routes is a standalone library designed to be integrated into any MVC framework.

    This release brings in some changes from Routes 1.8. The most noticeable change is that custom actions on RESTful routes are now delimited with the forward slash (/) instead of the semicolon (;). This was done for parity with Ruby on Rails.

    I have also fixed some bugs, notably that the resource route generator failed to generate routes that recognized PUT and DELETE requests on “formatted” resources (/messages/1.xml). This fix will be merged upstream to the Python version.

    I am also using the Python version and I met with Ben Bangert, the author of the Python version, at PyCon 2008. Each release of Horde/Routes has resulted in patches to the Python version. It’s nice how this small ecosystem has developed around the routes concept between these projects (Ruby on Rails, Pylons, and our work in Horde).

    Since Horde/Routes 0.3, the default RESTful routes generated by Horde/Routes are fully compatible with the latest version of ActiveResource. We have a new project at work that is using Horde/Routes and ActiveResource together and it works well.

  • Parsing Quoted Strings in Ruby Apr 28, 2008

    Posted by Mike Naberezny in Python,Ruby

    Python has a nice module in the standard library called shlex that parses strings as a Unix shell would. Here’s a Python interpreter session demonstrating its usage:

    >>> import shlex
    >>> shlex.split('foo "bar baz" qux')
    ['foo', 'bar baz', 'qux']

    It’s useful for creating your own mini-languages or external DSLs that need to parse quoted strings like the one shown above.

    We recently built an inventory tracking application in Ruby that has a user interface for selecting search filters. To expose the same search capabilities as a web service, we created a simple query language. I was looking for an shlex equivalent in Ruby.

    It turns out that the Ruby Standard Library has a module called Shellwords:

    >> require 'shellwords'
    => true
    >> Shellwords::shellwords('foo "bar baz" qux')
    => ["foo", "bar baz", "qux"]

    Shellwords is a little less capable than shlex but handles the most common use case just fine. It’s a convenient solution for a problem that comes up too often.

    Update: Ruby 1.8.7 has added the shortcut methods Shellwords.split and String#shellsplit. Very nice.

  • Speaking at OSCON 2008 Apr 2, 2008

    Posted by Mike Naberezny in PHP,Python,Testing

    The OSCON 2008 website has published its talk schedule. I’ll be giving two talks at OSCON this year; one on the Python track and one on the PHP track.

    Supervisor as a Platform

    I will quickly introduce you to Supervisor and the immediate benefits of running your server processes under it. We will then dive into how applications written specifically for Supervisor can take advantage of it as a platform — writing your own event listeners to observe Supervisor and the process lifecycle, controlling with XML-RPC, and extending the Supervisor core with your own Python extensions.

    This will be an expanded version of the talk given at PyCon 2008. Since PyCon, there’s been quite a few interesting developments in Supervisor like the ability to extend supervisorctl and progress made on configuration reloading. We’ll touch on these as well, so if you attended the PyCon talk there will still be new and interesting material in this talk for you.

    Integration Testing PHP Applications

    While more PHP developers are recognizing the importance and benefits of unit testing, the uptake of PHP developers using automated integration or acceptance testing is relatively slow. This testing is equally crucial to maintaining the integrity of applications.

    I’m going to help get you started testing at the application level with practical tips and source code. We’ll look at how to structure your HTML markup so it’s more easily testable, making tests easier to write and maintain with CSS selectors, organizing your tests, and testing with or without a browser.

    I’d also suggest you check out Sebastian Bergmann’s tutorial session on PHPUnit’s integration with Selenium RC.