tag:blogger.com,1999:blog-79072462012-01-28T06:09:11.306-08:00Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.comBlogger441100tag:blogger.com,1999:blog-7907246.post-1169232780476840162007-01-19T10:53:00.000-08:002007-01-19T10:53:01.916-08:00

Sometimes I wonder why I stopped coding. No,the above mentioned link isn't about me, but I couldn't state it better than this. I feel that I miss today the drive to just "fuss around" with stuff. Now I want to get things done, and little things that get in the way really break the flow.Besides the database issues that the article describes so well right on the first page, there is another one

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com7tag:blogger.com,1999:blog-7907246.post-1132351661863086152005-11-18T14:07:00.000-08:002005-11-18T14:07:41.906-08:00

This is a new project that goes along with my latest sound explorations... I just saw the announcement of PyKaraoke 0.4. PyKaraoke is a karaoke player, written in Python, of course. I'll check you and write about it over the course of this weekend.

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com87tag:blogger.com,1999:blog-7907246.post-1131377124595314102005-11-07T07:25:00.000-08:002005-11-07T07:25:24.643-08:00

After a long time without writing any code... and thus without writing anything in this very blog... I'm finding some time to write code again, now for my personal use. The Linux Sound Font Manager is a new project, aimed a making it easier for a user to add, test, or remap sound fonts. It's part of my ongoing battle with multimedia in Linux. Why does Linux need a Sound Font Manager? There are

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com115tag:blogger.com,1999:blog-7907246.post-1115338966867470352005-05-05T17:22:00.000-07:002005-05-05T17:22:46.933-07:00

It's nice to be back after a couple months of unrelated work... let's start catching up, a lot of interesting things are going on the Python world. First of all, there is a interesting discussion going on the Python Web SIG regardingJavaScript libraries. After a long thread discussing why everyone else loves Rails (which is something that really makes many Python programmers envy!), we're

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com134tag:blogger.com,1999:blog-7907246.post-1110848918157217192005-03-14T17:08:00.000-08:002005-03-14T17:38:59.263-08:00

It's nearly one month since I posted my last rant here. I was very busy, and working on a lot of different stuff, so I did not really had time to get my hands on code. But the forced rest was good, because it allowed me to take some time to investigate some of the underlying ideas that were bothering for long.I was a relative early adopter of the then-called event driven programming, when the

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com87tag:blogger.com,1999:blog-7907246.post-1108939112145073512005-02-20T14:38:00.000-08:002005-02-20T14:38:32.146-08:00

Python never ceases to surprise me. Today I noticed something really simple; it's one of those things that can go on unnoticed for ages, but make the code read better. When coding in several other languages -- C, C or Delphi -- there's the need to declare things before using them. As a consequence, class declarations tend to be organized to satisfy this restriction (of course, there are

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com175tag:blogger.com,1999:blog-7907246.post-1108736697999379722005-02-18T05:51:00.000-08:002005-02-18T08:14:39.856-08:00

Well. I may be exaggerating a little bit, but for people like me that easily get lost in the transition from the big picture into the details of the software, Trac is a great tool. My initial experience with Trac was due to the CherryPy project, that adopted it a while ago. Later, I participated in a private project that also relied on Trac for documentation and ticket management. It's a great

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com94tag:blogger.com,1999:blog-7907246.post-1108643754482477302005-02-17T04:13:00.000-08:002005-02-17T04:49:47.403-08:00

Well, this is not exactly a post about Python, but it relates a lot to my development experiences. I've been interested in PC virtualization techniques for a long time. I was an early user of VMWare, back when the license (and the price) were not so restrictive. I followed projects such as Bochs, which is a fine piece of software, but it's too slow for practical use; and later Plex86, that for

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com57tag:blogger.com,1999:blog-7907246.post-1107569675894122692005-02-04T18:14:00.000-08:002005-02-04T18:14:35.893-08:00

It's nice when one finds someone else talking about something that's seemingly evading his own understanding. Permanent URIs (or URLs, for old hats like myself) are one such a beast, at least for me. Roberto de Almeida wrote a good article on URLs for blogs a little while ago. I only found the link today but it still reads fresh. It helped me to organize my thoughts on this subject in some

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com13tag:blogger.com,1999:blog-7907246.post-1106912458608218402005-01-28T03:40:00.000-08:002005-01-28T03:43:42.543-08:00

Ian Bicking has summed up pretty well what's the problem with documentation, by large: "Tell me what to do, please". Going down this road, I have some suggestions to offer.Every framework author should eat his own dog food. Most of them do... but 'cheat'; they sprinkle some salt over it, so it doesn't taste so bad. Sometimes they feel that it's not enough and drink a wine while using it too. Of

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com68tag:blogger.com,1999:blog-7907246.post-1106840498114399012005-01-27T07:41:00.000-08:002005-01-27T08:50:40.383-08:00

We coders have a strange standing on reinventing the wheel. Most of the time, a programmer will agree that he should reuse code. It's plain logical. So when we see someone baking his own library we say, 'why don't you use library X'? It usually leads to a heated argument as the programmer in question can't justify his reasons to write a new library instead of reusing something that works (at

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com7tag:blogger.com,1999:blog-7907246.post-1106345506315877082005-01-24T13:54:00.000-08:002005-01-28T08:26:00.070-08:00

I've been playing with extensions to store persistent classes and custom methods using SQLObject. The need arised as I was trying to write a relational representation of the Petri net model for a business framework. The standard model boasts few basic concepts (basically speaking, transitions, places, tokens and arcs). The relationship between the entities is simple, and easy to map with

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com33tag:blogger.com,1999:blog-7907246.post-1106439551433606792005-01-23T16:03:00.001-08:002005-01-22T16:19:11.433-08:00

I spent a few hours working on a multicast file transfer program, written in Python, with a friend of mine. The experience was filled with ups and downs. It was good to see that we were able to handle low level stuff such as broadcast packets, for example, in Python. On the other hand, two things were a problem from the start: timing, and raw performance. Timing problems surfaced out as we were

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com38tag:blogger.com,1999:blog-7907246.post-1106331575283945712005-01-21T09:51:00.000-08:002005-01-22T08:14:02.573-08:00

Ruby on Rails is making a lot of noice these days. I first heard about it on comp.lang.python, where it was mentioned a few times. Later, I noticed how many people wanted to write an application on Rails. And this weekend, it has made it to Slashdot home page. That's attention. Rails is already Ruby's killer application. Rails has appeared in a very interesting moment. First it was Perl, and

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com15tag:blogger.com,1999:blog-7907246.post-1106323543659519252005-01-21T07:56:00.000-08:002005-01-22T06:50:36.610-08:00

There's a debate going on about the best way to support inheritance in SQLObject. Better to have this discussion now than never; there is demand for this feature, but there's still no consensus on the best way to do it. Based on a patch initially offered by Daniel Savard, Oleg Broytmann started last November and maintained a private inheritance branch, and got it working with some patches

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com6tag:blogger.com,1999:blog-7907246.post-1105887615518520242005-01-16T07:00:00.000-08:002005-01-16T07:09:05.803-08:00

If for any reason you ever need to write low-level network protocols, and if you need direct access to the wire, a good starting pointer is on the Vaults of Parnassus Networking section. It contains pointers to some implementations of the libpcap library, the de-facto standard for low level network access. There is also a free port of libpcap for Windows, named WinPcap. The reason to use libpcap

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com24tag:blogger.com,1999:blog-7907246.post-1105742722147393112005-01-14T14:45:00.000-08:002005-01-14T15:07:50.950-08:00

Developing a strategy for application deployment is always hard. Every environment has its own characteristics. It's far easier to see the problem with popular applications that are installed by the end user. Custom applications are sometimes installed by an expert; sometimes the developer himself is available to do it. This helps to make the difficulty of this task to be greatly underestimated.

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com41tag:blogger.com,1999:blog-7907246.post-1104941291201865142005-01-05T08:08:00.000-08:002005-01-14T15:35:17.136-08:00

On a recent thread on comp.lang.python (which originally discussed some perceived problems about Python evolution, the topic of generic programming was brought up by Roman Suzi. In ensuing debate, there were some great posts, specially one by Alex Martelli (once again), where he goes into detail to explain why Python interfaces are different. Roman wrote a great followup to it, pointing out that

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com12tag:blogger.com,1999:blog-7907246.post-1104766140227610412005-01-03T07:29:00.000-08:002005-01-03T07:41:10.376-08:00

Integrating teams isn't an easy task. There's much written about it, and it's usually one of the major complaints in management. Software development teams are no exception to this rule. But until recently, most projects could be split in two relatively well-defined classes: small (and thus more manageable) projects, and big projects. Big projects impose such a management overhead that they can

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com26tag:blogger.com,1999:blog-7907246.post-1103129533107428352004-12-15T08:52:00.000-08:002004-12-15T08:52:13.106-08:00

A quote from the Python Is Not Java article (great reading, btw): XML is not the answer. It is not even the question. To paraphrase Jamie Zawinski on regular expressions, "Some people, when confronted with a problem, think “I know, I’ll use XML.” Now they have two problems."

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com33tag:blogger.com,1999:blog-7907246.post-1103120264237006702004-12-15T06:17:00.000-08:002004-12-15T06:17:44.236-08:00

Since being introduced in the language, generators (and their lesser cousins, list comprehensions) are finally making it into the community mindset. In the long term, I think that this change will have a lasting effect on the way we write Python programs. In the beginning, Python was a conventional scripting language that happened to have a exceptionally clean syntax and a solid object model. So

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com116tag:blogger.com,1999:blog-7907246.post-1103066759978836822004-12-14T15:25:00.000-08:002004-12-14T15:30:55.723-08:00

There was a time, not a really long ago, when business programming meant basically processing data. The visual interface options were really limited, so much more time was spent in the business logic than in the UI part of the system. Now times have changed for better, and GUIs are the norm; in fact, it's so common place now as to make one wonder how were things done before. For many programmers,

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com56tag:blogger.com,1999:blog-7907246.post-1101504962025750542004-11-26T13:38:00.000-08:002004-11-26T14:46:43.983-08:00

What follows can't still be considered a definite version of this idea. It's still a prototype of an idea that I have been working on in a rather fuzzy way, to solve a practical problem that arised as I started to used templates and a declarative style approach to model business entities. Consider it as an attempt to write it down to clarify things for myself; if you find it useful, or at least

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com45tag:blogger.com,1999:blog-7907246.post-1101233393427674482004-11-23T09:35:00.000-08:002004-11-23T10:09:53.426-08:00

There are a number of resources about workflow on the Internet. Finding the good ones is not that easy, though. First of all, the search term is too generic (Google found nearly 8 million results for it alone). There are a number of commercial offerings with little or no info on their web pages, besides mentioning "workflow" as one of the features. The academic sources are, for the most part,

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com4tag:blogger.com,1999:blog-7907246.post-1100699029525946912004-11-17T04:49:00.000-08:002004-11-17T05:50:52.850-08:00

This document was originally posted as a reply to a c.l.py post asking for more information on adaptation vs type checking for Python. It was well received, and I thought it deserved a spot here. This is a revised edition, with more information and some clarifications. Adaptation is the act of taking one object and making it conform to a given protocol (or interface). Adaptation is the key to

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com10tag:blogger.com,1999:blog-7907246.post-1100653952141002232004-11-16T16:10:00.000-08:002004-11-16T17:12:32.140-08:00

As part of my workflow project, I came across an interesting problem. Transition entities are modelled as classes derived from a base ActionDef class, because each action in the system needs to have its own custom code. As the system grows, I needed to design a repository for such classes. The easy way to implement the repository is to put everything inside a package. It's reasonably scalable; a

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com16tag:blogger.com,1999:blog-7907246.post-1100185670855301992004-11-11T06:52:00.000-08:002004-11-11T07:07:50.856-08:00

It's been about two months since I started rebuilding my development environment using only free tools. For a long time, I was stuck in the search for a good IDE. It took me a while to figure out that I was not missing the IDE, but a set of good project management tools. Once I realized it, I could find several good code editors that supported my basic requirements: the ability to create projects

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com6tag:blogger.com,1999:blog-7907246.post-1100179874724810082004-11-11T04:54:00.000-08:002004-11-11T05:31:14.723-08:00

There was a time when a database meant a flat file, fixed record repository. Indexes were added later, bringing better performance for several tasks. During the sixties, hierarchical database systems were developed, allowing to model complex real-life structures better. Even today, old-style mainframe systems (such as IBM's IMS) are still in production, managing huge databases. SQL was only

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com11tag:blogger.com,1999:blog-7907246.post-1098274974481571462004-10-20T05:20:00.000-07:002004-10-20T05:22:54.483-07:00

IniFile is a ini-style configuration module that uses a template to define the configuration file structure. The code below includes some samples. Feel free to use as-is. """ inifile.py Library for reading and writing ini-style config files. The ini file structure is provided as a class, with nested classes acting as the sections. Usage: # declare the ini file structure using a class

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com24tag:blogger.com,1999:blog-7907246.post-1098272995477592022004-10-20T04:42:00.000-07:002004-10-20T04:54:11.466-07:00

I'm happy to announce that the metatemplate module is now sufficiently mature for a beta-quality release. I've been using it for my own projects over the past few weeks. The latest changes involved cleaning the code, and the addition of a new __attr__ private member to the template which allows to map alternative names to Python names. This feature was needed to allow template attributes to be

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com1tag:blogger.com,1999:blog-7907246.post-1097172431428965302004-10-07T10:51:00.000-07:002004-10-07T11:07:11.430-07:00

Python is an excellent language for web development, as it can be easily verified by the number of options when it comes to web-enabled frameworks. Most frameworks implement a object publisher -- a piece of software that finds the correct object and activates it upon request. Each object is 'published', or associated with some part of the site. All object publishers -- or at least, all that I'm

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com3tag:blogger.com,1999:blog-7907246.post-1097001205556324212004-10-05T10:51:00.000-07:002004-10-05T12:32:53.210-07:00

It's been a while since this blog was last updated. And it has a good reason. I've been working with code to allow the expression of complex data structures using Python classes. This project was started as an experiment for data-entry forms, and is now reaching a quite usable state. This is controversial stuff; some people argue that this is only a obfuscation, and that the same results can be

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com225tag:blogger.com,1999:blog-7907246.post-1095619072197161492004-09-19T11:13:00.000-07:002004-09-19T11:37:52.196-07:00

A remark on Wing IDE wxPython integration page caught my attention today:"A Caveat: Because Python lends itself so well to writing data-driven code, you may want to reconsider using a GUI builder for some tasks. In many cases, Python's introspection features make it possible to write generic GUI code that you can use to build user interfaces on the fly based on models of your data and your

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com60tag:blogger.com,1999:blog-7907246.post-1095361232799525422004-09-16T13:00:00.000-07:002004-09-16T12:06:23.483-07:00

It's quite interesting when different topics fuse together so nicely. Over the last days at c.l.py, and over this blog, I've been ranting about IDEs and frameworks for business applications. In an independent thread, I've also written a note about the seemingly connection between programmer behavior and the choice of programming language. Simon Brunning posted a comment on this blog pointing me

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com4tag:blogger.com,1999:blog-7907246.post-1095279616863395442004-09-15T13:20:00.000-07:002004-09-15T13:20:16.863-07:00

It's been a few busy weeks since I returned to the world of business application development. This time, however, I'm having a chance to take a fresh look at it. Although I'm still too used to some tools to change my mind very quickly (IDEs, for example), there are a few things that I'm really keen to try out. One of them sounds like anathema -- do I really need a true RDBMS for my apps? (note:

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com10tag:blogger.com,1999:blog-7907246.post-1095258960046631832004-09-15T07:36:00.000-07:002004-09-15T07:40:30.373-07:00

I've been discussing over the past few days at c.l.py the state of the Python IDEs. Other threads have popped out on this same very subject since I resumed reading the mailing list a few weeks ago. To put things into perspective, IDEs are also a hot topic at one well known magazine. It's hard to keep the discussion from becoming religious. I'l try my best to respectfully put my own opinion here.

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com17tag:blogger.com,1999:blog-7907246.post-1095078145388551142004-09-13T05:22:00.000-07:002004-09-13T05:22:25.386-07:00

I believe that there are some things that you just can't take apart from the whole -- they're an integral part of the package. Code beauty and good behavior are strangely connected.Python is a wonderful programming language. It is, for the lack of a better word, elegant. Programs written in Python tend to look good, and read nicely, even when the reader is a newbie. Much has been said about this

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com6tag:blogger.com,1999:blog-7907246.post-1094226622163504792004-09-03T08:50:00.000-07:002004-09-03T13:36:37.166-07:00

Now that I'm trying to get to speed with business app development in Python, I decided that I needed to take the full course. Up to now, I used to make a quick database prototype using MS Access to jumpstart the process. It's fine for small stuff, but not so for something that is going to be used professionally. So I'll be using UML from the start, and I'm going to select good Python-aware tools

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com17tag:blogger.com,1999:blog-7907246.post-1094057878411046522004-09-01T09:56:00.000-07:002004-09-08T12:09:41.960-07:00

An object relational mapper, or ORM, is a piece of software that sits between the object model used by an application and the relational model used by a conventional RDBMS system. It's a useful piece of software, as it allows one to blend the best of both worlds. The application can be written in terms of objects, and the database can be managed using conventional tools. A little bit of historyI

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com22tag:blogger.com,1999:blog-7907246.post-1093943744666893692004-08-31T01:46:00.000-07:002004-08-31T02:15:44.666-07:00

I am installing a brand new Python environment on a low-end PC to keep up with my software development tasks while I'm off my office. The PC is really low end by todays standard -- a Pentium 166 -- but still, it should be enough for by needs, that is, mostly writing code. It has a few advantages too - in the sense that I'm not going to be able to test everything by the old lazy hit-the-run-button

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com7tag:blogger.com,1999:blog-7907246.post-1093009523852561702004-08-20T06:45:00.000-07:002004-08-20T06:50:35.413-07:00

After some thought, I decided to give it a try and implement real time playback using the MIDI Streams API. I installed ctypes, an outstanding Python library to support native DLL calls from Python. After hacking with it a little bit, I managed to implement the basic midiStreamOpen and midiStreamClose calls. The library is actually fairly easy to use, but there were a few gotchas: I mistakenly

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com3tag:blogger.com,1999:blog-7907246.post-1092753667560224652004-08-17T07:41:00.000-07:002004-08-17T07:41:07.560-07:00

I must be crazy. I've never did multimedia programming before, and my first project is a guitar simulator. Why did I chose such a project? Well, I like to play MIDIs at home. I have a small collection of MIDI-Karaoke files, and we have fun singing in family. There are many MIDI Karaoke files out there, but in many cases the sound of the guitar is crap. Many people assume that it has to be so, but

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com26tag:blogger.com,1999:blog-7907246.post-1092082019540349992004-08-09T13:06:00.000-07:002004-08-09T13:06:59.540-07:00

Nu Cardboard: Blog Notes I found this blog today, while checking the news from Daily Python. Hey. it's really nice, and it seems to be very well structured. That's the type of stuff I'm looking for myself. The author has promised to publish the source code, and I'm really looking forward to check how some things were implemented. Even if he doesn't publish it, the tips about CherryPy and Cheetah

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com58tag:blogger.com,1999:blog-7907246.post-1092080201819365572004-08-09T12:27:00.000-07:002004-08-09T12:36:41.820-07:00

About one year ago I stopped coding and following Python's development. Not because I didn't like it, but other professional activities required my full dedication. Now it's over, and I'm back to my home office trying to figure out what the next big revolution will be. Over the past year, I missed the blog explosion, but I think that there is still time to catch up. And for all my programming

Carlos Ribeirohttp://www.blogger.com/profile/16043745572254494898noreply@blogger.com1