Mono-compliant Development Platform

There is a growing and unseen need for a Mono-compliant development platform. This would be something like Eclipse, but much lighter in base. This would allow people to extend it very easily in pretty much any language and a lot of different targets could be found. Extensability needs to go very far, too. Syntax highlighting and code-folding rules is not enough. If I want to define that all lists and tuples be displayed an element-a-line and no more than 5 lines used (with an embedded scrollbar to go through it) then let me do that. If I want dictionary literals to be displayed as tables, then so be that. If I want to very the if and else blocks side-by-side in color-coded boxes, then let me do that, too.

Just a thought.

No, this should not use Gtk+, because that isn't productive (.Net has a GUI API, already!).

My Name is not Scott

Some may know and now all will, that my name is Calvin. Over the years of working in various positions that require me to deal with lots of people over the phone (fielding calls from customers managing the furniture store, dealing with vendors and carriers for K-Mart, now) I have noticed a very odd and very consistent trend.

I tell them my name, "Calvin", and they persist to call me "Scott". How on Earth does anyone mistake the two? Now, many people (just ask my wife) will tell you that I speak softly and sometimes am misunderstood. But "Scott" for "Calvin" just doesn't make any sense, especially for the pure consistency of the occurrence! What is going on here?

People of Earth: My name is Calvin. Not Scott. It is Calvin.

Paint.Net on Mono

I technically admire the .Net platform, although I don't use it much myself, except following the tutorials on MSDN for C#, which I compile and run with Mono. Part of this is subscribing to the feed from the MS blogs, just to see if there is anything interesting going on. Through this I found Paint.Net, a nice little project that started small and seems to be growing nicely. I looked into running it on Mono, and was very discouraged to find the developers don't care and don't seem to want it to run on anything but the official .Net implementation on Windows. They act like Mono is a nothing to the side to whisk away like dust on the floor.

Now, am I wrong in expecting anything more? I don't think they should all install Fedora and start using Linux, but as long as they are developing a .Net project, couldn't they at least open the door a little? Their installer even refuses to install with Mono, so I can't even test the damn thing.

That's too bad, because I'm disliking GIMP more and more every day.

Linux Packaging and Autopackage

I got a comment on my previous little quip about the problems with Linux-based operating systems. It was just a link to the Autopackage website. I find it odd, as I had just got wind of Kyle Brooks response to some of the negative commentary about Autopackage. So, basically I agree with everything Kyle said and I know things like Autopackage exist. But, the user still needs to know how to run the .package, which is more difficult on some systems than others. Of course, a quick google of autopackage will tell them, but how will they know to google for autopackage? Now, some distros might be able to configure KDE or GNOME to look at the first line of the file and see its actually a shell script, but I believe most would not. Of course, doing so might open up some security holes, but if the user is running as the root user, they're screwed anyway.

Now, why do we even need things like Autopackage and why is there such controversy over it. (Yes, there is controversy) Quoting mike from the Autopackage forums:

As you may have realized, many Linux developers are very conservative. Some feel autopackage is bad, others just feel that software installation is not their problem.

The culture of "my responsibility ends once I upload a tarball" is very deeply ingrained in the open source landscape I'm afraid - over a decade of distros controlling everything has made any true innovation in this field nearly impossible.

In the beginning there was source code in a tarball and it wasn't good. Programmers would release a tarball, and maybe some compiling tips, and others would acquire the code from an FTP server at 150 baud or mail-order a copy of the code on magnetic tape storage. Systems were varied and different and often a user would work hard to build the program for his (or her) particular setup. Some did this so much, that they developed little scripts and tools and practices to make the whole thing a little easier, and organizations and businesses that adopted this software would follow the same lines. These evolved into the idea of distributions, which made it easier to do all this work.

Free Software/Open Source operating system distributions can be traced back to the three major BSD derivatives: FreeBSD, NetBSD, and OpenBSD. These used the Ports system to control the compiling of software for the system. Guidelines about library locations and configuration files were created and software intended for a particular distribution would follow those guidelines. However, due to the days before real distributions, the developers were not directly targeting these distributions. As many distributions came to be, their volunteers and employees would port useful software, making just enough changes to get it to work on their distribution. Sometimes this would make it to the main source, but usually it would be bundled in some way, such as a tarball, along with installation scripts for their distribution, like Ports for the BSDs. These were called packages. The users were happy because they had good software, the distros were happy because they had users, and the developers were happy because they didn't have to do the work to make the software run on all those different distros.

Fast forward twenty years or so and we haven't come far. Developers find it hard to package for so many targets and many refuse to do so, even believing they have no such responsibility. And, why should they? Most are working for free, anyway. Reducing the number of targets is an option, but anyone is free to make more and that is a large portion of the value of free software.

Through these years, those standards and guidelines have converged in many ways. Something like autopackage was finally possible and perhaps we need it.

Let me tell you what bugs the crap out of me. I hate finding a good program on-line and then having to open up a terminal and typing "emerge search foobar" to find this app. I hate having to tell my roommate, who uses an extra computer of mine, how he has to go through Mandriva's software management app to find out if that game has a package available or not.

I welcome Autopackage, but we need cooperation from the community and the distributions to make it work. Perhaps work like Autopackage can converge the much repeated work of packaging all this software and we can reduce distributions to installation auxiliary scripts.

All I know is I am tired of waiting for a package after the tarball is released.

What's wrong with Linux

I love Linux and the community it spawned and so much about it. However, overall, I've grown increasingly distressed. Things only seem to go downhill, and everyone just keeps on cheering.

Binary support is in desperate need and barely cared about. Packaging is a complete joke. The distributions are a mess.

I shall elaborate.

Pat 0.5.0 for this Weekend

This weekend I'll release Pat 0.5.0 with the following features (and more?):

• Selection from multiple tables with a From(table1, table2).select(table1.colA) type syntax
• Column instansiations to pass to insert and update operations, such as table1.colA("foo")
• Streamlined and cleaned up unittests
• More complete unittests
• Deletion of rows

And, possibly some other things. This should be good enough that I'll return my focus to Involgo, which is also about to shape up into a nice prototype of what I'm trying to accomplish. Hopefully, by the end of 2005, I'll be able to show what I've been trying to acheive, and maybe I can actively search for some VC to put my work to better potential.

Pat 0.5 Not Released on Time!

I was going to release Pat 0.5.0 tonight, with full support for multiple table queries with From(tbl1, tbl2).select() syntax, but its getting late. I've gotten selection working fine. I need to centralize all query generation and keep things cleaner, and that also includes migration of the update query generation to the new From class, which will control all CRUD, now. Internally, single table operations will just create a From with themselves to handle the request. This should all be operation by tomorrow and I'll release then.

I may have broken my release-a-day spree with Pat, but at least I did make progress tonight, and that's the important part.

Pat 0.4.1 Released

Twenty minutes ago, I realized I forgot to update Pat today. So, I fixed a small bug, and released a minor update that allows column-column comparison clauses. I added unittests, made sure it all worked right. It does. Another day, another release. At least until Pat reaches maturity for my purposes, I'll keep this up.

Pat 0.4 Released

Following my "at least one release a day" pattern with Pat, I've released yet another version. Version 0.4, which supports multiple chained select calls, easier selecting by passing multiple Clause and Column objects in any order, and more, is now available at the cheeseshop.

Pat 0.3 Released

What a busy weekend. I wonder if it was worth it. I spent most of the actual weekend working on my sub-project, Pat. It works very well now, and with only a single more release, I'll move back to Involgo, which will be using Pat to manage its SQL more cleanly.

Three releases in just over thirty hours. That's a record for me, but I may have wasted my weekend. A few hours after releases Pat 0.3, I caught a blog entry by titus mentioning something called SQLAlchemy. It seems to be pretty much what Pat would become, if I put a lot more work into it. It includes things like joins and seems a mix of my model and the basic Python dbapi, with execute() and fetchone() methods.

It makes me question things. Have I broken the TOOWTDI rule? Did I waste those thirty hours? Should I continue with Pat or put her to rest in favor of a more complete solution?

If I had spent the same amount of time learning SQLAlchemy, would I have gotten to the point with it that I am now with Pat? Also, I don't know if it uses pysqlite2 or the sqlite module, where I requre the prior. I will have to look into this other contender and decide my course of action. For now, I should probably sleep. I should have done that hours ago.

Pat 0.2 Released

A very busy day I've had. Started on Pat, my little database module, and I've made two releases already. It can now generate table creation queries, can select individual column names, define tables by subclasses Table, do updates and more. It still has some major limitations, like it only can match columns by equality.

The next release should move from the keyword interface to passing things like UserTable.username=="Bob" or CustomerTbl.customerForYears>10. It will also support deletion of rows (which I just forgot for this one, oops) and default column values and specified text lengths.

As it is, it should prove useful. It can already do enough for my current purposes. Hopefully, someone else will find it useful. Let me know if you do. If not, let me know why!

Pat 0.2 Release at the Cheeseshop

PAT, Python's Easy Tables

I started to get a little tired with SQLObject. Although it is nice for most uses, it can be overkill and can be difficult when you dont actually want an ORM, but just a better way than writing all of your own queries. So, I looked around, couldn't find a simple table wrapping module, and wrote my own. The result is Pat, which stands for "Python's Easy Tables".

Pat is very easy to use, but still pretty rough around the edges. It is very much a prototype, but as they say, "Release Early, Release Often", so I'm doing that. I've registered the project at the cheeseshop.

What it Doesn't Do:

• Create tables
• Verify integrity
• Bake cookies like Grandma makes
• A lot of things

What it Does Do:

• Represent named tables with python objects
• Allow you to table.where(id=5) to select rows
• Allow you to T.where(id=1).update(name="One")
• You can string multiple where calls and end with an update and only trigger a single query, as all the where clauses are combined. No query is done on a select until you actually iterate over the returned Results object.

Project Page
Pat 0.1 (source)

Please, send me any bug reports, comments, complaints, etc.

Move away from Blogger and Blogspot?

I've settled in nicely to this blog. I disliked Blogger at first, as it seemed oddly limited, but I dealt with those limitations and I hadn't cared about them for a while. Now I do, again.

I've been messing around with an account on blogsome.com, which uses the popular WordPress blog system. I like it. It seems a little less intuitive than Blogger sometimes, like not being able to explicity order links, or edit my templates directly. But, it does allow for catagories, which is the big thing I don't like missing from Blogger.

I have a meager, if existing at all, group of readers. So I guess I'm not abandoning much. I'll give this some thought and do some more testing with blogsome. If I make the move, I'll probably run my own WordPress server from home. We'll see...

Improving the Self in a Structured Manner

Self, version 2.0
The Multiple Self
The Refactored Self (part 1)

These three posts are wonderful. The ideas are solid, and I've found most of them to be true on my own before finding them put to such great description and clearity. Moving in the direction of being more agressive with this would be a good thing for most of us.

About Me

My name is Calvin Spealman, and I am known in online forums as "ironfroggy" and in gaming circles as "NeverDead". I am an amature programmer, trying to get my foot in the door of the industry with my own start-up. This blog is largely a journal of that quest, and other tech-related postings.

I develope primarily in the Python programming language. My work is database and web related. I also do some minor work with Visual Basic and Microsoft Access and Excel, to make my "real job" easier.

Aside from the technical side, I also have an artistic flare. You can see some of my art on my DeviantArt page. I also have a second blog for political commentary, media reviews and quips, and things that just don't belong elsewhere.

People are Security Flaw of the Network

Today I grabbed some papers from the printer at work, looking for something I was waiting on. There were only papers for a co-worker, so I took them to her (as is customary at work). The first thing I saw when I looked to see if it was mine, is that the e-mail contained a username and password for a user on the corporate network. The user wasn't even one that seemed to be included in the e-mail. Even worse, it was a multi-recipient mail to many clerks from a supervisor. The SAs would have a damn fit if they saw that. No matter what security measurements they might take, people will still e-mail other people's passwords, which they shouldn't even have.

Selfish Sharing

Robert Kieffer and Ned Batchelder sparked a discussion that has interested a good many people. They were discussing the sharing of information we work to provide and the selfishness of keeping one's self as the only source and control of information that we share to everyone. Selfishly sharing information: what does it mean?

A good example is that I'm posting this article instead of just commenting on the page like everyone else. Of course, those comments aren't this long. So, I'll convince myself I have some justification. Why do I need to justify these actions to myself?

Many of us have websites. They are a bit of a status symbol these days, and something anyone can create. But, a site that is important can not be created by anyone, it can only be created by everyone. Only in the value of the audience do we feel a real value for our own websites and the information we provide within them.

So, although we want to give the content away, we want to keep close hold on the credit. We want everyone to value the content and to know that we were responsible for its creation and for its continued availability to them. As long as the content remains on our websites, we have value in the value the audience holds in our website.

Where does this leave projects like Wikipedia and more focused efforts like the Python Wiki? Although the spirit of sharing urges us to combine our collective content where everything can be found together, we are greedy for self value. We may even make such meager claims such as, "Google pulls the information together as well as a wiki", in order to justify our actions of keeping our content out of the wikies.

(what is the plural of "wiki"?)

The first thing that springs to my mind when pondering it, and the first thing that I thought of when reading the post on Ned's blog, is, "why do we need to make this distinction and this discission at all?". Content may be served from multiple physical servers, and available from multiple logical URIs, but why does this entail that it must be acredited to one person or organization for each source we can obtain it from? Why do we have to have such a hard line between our site and World Wide Web? The WWW was meant to be a sharing of information, and many people say that the Wiki is the heart of the spirit of the web. But people need some value in both the obtaining of information and the free distribution of information to others. It has to work both ways, and as we know, what each is giving must be worth less to that individual than what they get in return.

What I am getting at, is why can't Ned's Python Parsers page exist as both a page on his website and as a page on the wiki simultaniously? I won't go into implementation details, but he should be able to write the page on his website, and then submit it as a page on the wiki. If anyone wants to make changes to the wiki, they can. If we wants to merge changes in from the wiki, he should be able to. If he makes changes while his and the wiki-version are synced, they should show up on both, otherwise he or someone else might merge them in some semi-manual manner.

In any case, this would all be through good standards. There would not be any central servers involved. Neither individual or organization would have to do anything manual unless they themselves are changing something.

If we want to truely share, why do we have to give it away? Is it really sharing if we ourselves can not share in all of the value. Sharing by putting the content into something like a wiki allows everyone to share in the value of obtaining the content, but there is a lack of balance in the value of providing that content to those who would wish to obtain it.

We must share both the value of the content and the credit for that content.

Decoupled Designs and Modularity: Do they get in the way of the job?

So, I've been hacking away at Involgo as regularly as I can manage. During this prototyping phase, I'm just implementing everything in pure python objects and using the cPickle module for persistance of the database (or store as I call them in Involgo). I'm reaching the point where I want to move from this to a more robust backend, most likely using SQLite to store all the data.

This leads me to two related issues: I don't want to break the pickle code, because it may still be useful, mostly for in-memory, never-persisted stores that could be useful. And, I may at some point move to something other than SQLite. So, it seems I should decouple the backend that stores the data from the interface to the store, and everything else in the project, as much as possible. This is taking some time, both in design and implementation.

I just begin to wonder, when am I spending to much on good design and not enough on actually getting the work done, because I want to make sure its done right? What good is it to plan how to do it just right, if the work isn't getting done?

Pandora Impresses Me Again

Pandora, which I have written about before, does not cease to impress. Aside from an ever enjoyable experience, they really seem to listen to their users. I was thrilled to have the first comment on my blog be from none other than Pandora CTO, Tom Conrad. Nice way to make those early adoptors feel welcome.

I was even more impressed when I received an e-mail from Tim Westergren, Founder of Pandora, announcing the new Pandora 2.0, which is very nice, and has a lot of great improvements over an already wonderful system. What impressed me was the generous upgrade of my three month subscription to an annual one, free of charge. Wow. I only did a quarterly subscription because my trial ran out, I hungered for more, and I don't like to spend too much money without saying something to my wife.

My only fear is that as Pandora grows, this kind of personal touch will be lost. It is nearly inevitable, but how can any growing company continue to live small to the people?

Now, if only my speakers hadn't broken.

Linux Driver ABI Stability

There has been a spark unleashing flames across many blogs, slashdot comments, mailing lists, and forums. Everyone is abuzz over the issue of the Linux kernel's ABI for device drivers.

The current Linux kernels do not define a stable ABI. Between releases, small tweaks to drivers are often necessary to keep up with little changes in the interface between those drivers and the kernel core. This means that every driver must be compiled for exactly the same version of Linux, and it makes for a difficult situation for hardware developers, who want to support Linux.

Now, everyone has something to say about it and no one seems pleased. Either you're outraged at the very suggestion of allow binary drivers to work reliably without releasing source code so customers can recompile their drivers with every kernel upgrade, or you can't possibly comprehend how anyone finds it a bad idea for manufacturers to be able to develop one binary driver they can release with their product and know that it will work when the user plugs in the card and copies the driver over.

Well, there are some points on both sides. While it is true that it violates the GPL to distribute binary only drivers with the Linux kernel, we don't have to distribute the drivers with the kernel. When you pick up a cheap Ethernet card and open the box, do you know what's on that little disc thingy? Drivers. We don't have to distribute drivers for every known hardware with every release of the kernel. Besides, I'm tired of downloaded ham radio drivers over and over. I never use them.

What baffles me is how no one seems to grasp the simple concept that if it is illegal to distribute them so, they won't (successfully) do so, without a battle they'll loose. That leaves the only benefits all for the users and kernel developers. The users will have better hardware support, and be able to get cousin Mindy to try Linux, finally. The developers can stop redeveloping drivers for devices that already have drivers, but for whatever reason do not have (good) Linux drivers, and they can then focus on the kernel itself.

Everyone wins with binary ABI stability. While we're at it, maybe we can get the ABI implemented in Vista and OS X, but with the best native implementation in Linux, of course.

A key thing to remember here is this: users do not want to recompile anything. Period. Source is nice to be available, and I think it should be, but source should be the option, not the necessity.

Second Blog

I and a friend have started a new blog, Mental Outlash. This is where I'll be posting non-tech stuff, such as my political commentaries, media reviews, and anything else along those lines.

Python Equality, Comparison, and Hashing

There has been a lot of talk on python-dev about the behavior of the default __eq__ and __hash__ and the comparison of objects, specifically with the concepts of "Identity Objects" and "Value Objects".

This brings me to think about something I've pondered, and I'm sure has been discussed before: does a programming langauge have to compare apples and oranges? Perhaps it is a historical artifact that everything can be compared. When everything is just a representation of byte patterns, everything can be compared numerically, but this doesn't always make sense for what is being compared. Boolean logic is tied into nearly every computer langauge, so that everything can be considered true or false. Well, what about raising an exception on 1=="1" instead of just resolving to False? How about denying a conversion of an object to true or false, where it has no logical boolean equivalent?

Why does everything have to boil down to black or white?

Repetitive Information Injury

I read, tagged, and blogged about RII, a restult of NADD.

I quickly realized that I am a sufferer of this condition. I waste many nights that could have been spent working on something, because I do just what this article describes. I don't have much to say about it, just read it, please.

GPL 3.0 Will Highlight the FSF's Misdirection

The drafting of the GNU General Public License's second major revision is to begin in the near future. This third version will be good for solidifying what the GNU Project, the Free Software Foundation, and Richard Stallman, the man behind it all, truely stand for in the area of software users' rights. The next revision will be good for the FSF, but bad for nearly everyone who uses their license.

The GNU GPL has four main clauses, if you look at it in a simplified manner.

1. The right to use the software for any reason
2. The right to my copies of the software
3. The right to modify the software
4. The right to redistribute the original or modified versions of the software

Number four is pretty much the gotcha for most people. It is what keeps many companies, who are interested in open source and free software, away from using the GNU GPL, and sometimes for releasing source code at all. Who wants to release code to a community who think they should have the right to pass it along to those who did not pay for it?

This last clause is the one I've always had trouble agreeing with. I think I should be able to make copies of software, if I have a desktop and a laptop, for example. I should be able to use it for anything, because if I bought it, that copy is mine. If they want to limit the warranty to certain uses, that's OK, but they shouldn't limit me to certain uses. There may be something I don't like about the software, or maybe I don't entirely trust it. In either case, I should have the option to see and modify the source code, to ensure I know what it is doing, or that it is doing what they say it is. But, they worked hard making that software and need to make a living to feed their families and pay off that house, so what right do I or should I have to say to my pal, who wants a copy of the software, "Sure, I'll send you a copy. Don't worry about buying it for yourself!".

I believe the forth clause is a mistake, not only in that Richard Stallman keeps it in there, but that he brought it into the license in the first place. There is some history behind this opinion that is very important to the issue at hand.

When the GNU General Public License was first created, and back in the days when Richard Stallman was jumpstarting the Free Software movement and founding the Free Software Foundation, the software and technology world was a very different picture. When the first users of Stallman's Emacs wanted to acquire a copy, they didn't download the source or prepackaged RPMs from the FSF website, or their distributions automatic package manager. They wrote him a letter, including a blank data tape and money to return it through post, and Stallman would copy the source code onto the tape and mail it back to them. Those days, I don't think there had to be much worry if someone redistributed your software, because distributing it was so difficult for both you and for them.

What this begs us to ask, however, is, "why is this still a GPL clause and why does anyone think its essential?" All of the other clauses of the GPL are enough. That last clause brings about all the problems. User's should have every right to make their own personal copies, to modify source code, and to use the software in any way. But copyright law is there for a reason, and I want to pay of that new car. Redistribute patches, if you'd like, but developers who can't or won't do it all for free, deserve to be compensated for their work.

And, yes, I know there are ways to make money on GPL software, but it much more difficult and risky. Developers deserve the same kind of per-consumer compensation as creators in any other medium.

The problem with the GPL's new version is that the changes will only strengthen this problem's hold on the GPL. More provisions will be put in place to ensure the users' rights of redistribution and the circumvention of the developers' rights to control the distribution of their own intellectual property.

I know what you're saying, "So, don't use the GPL!" And, I won't. My problem with all this is that many do and will continue to use the GPL misguidedly, and that the GPL symbollically stands for the concept of free software and open source licenses, so this huge error just reflects badly upon the whole community. Stallman may have started it, but at this rate he'll lead the movement to its end in his blindness and inability to admit that, though he had a good idea, he made one or two mistakes in the initial executions of that idea. Idealism is nice when you're ideals are grounded, but dangerous when you follow them simply because they are your ideals.

Rethink what your thought, and always make sure you still know what you're doing.

Brian Ray's Blog : Python: IPython as primary Shell

Brian Ray's Blog : Python: IPython as primary Shell: "IPython , a Python interactive shell developed for the scientific computing community by Fernando Perez is such a powerful tool, I just may replace my default login settings from just bash [1] directly to IPython over bash.

How may people do this? I mean really! Is it practical to cross this line?

If you are new to IPython, there is a decent intro article from ONLamp. Although, I fail to see how this article fits into the LAMP [2] world. Still, it unveils some need features like: magic: Quickly assess special IPython features. Tab Completion: auto-complete code attributes, classnames, methods, and more Introspection: Easy access to Doc Strings and internal documentation History: store a dumpable session of commands Debugger Access: internal access to pdb Run: a safe way to run a file and ignore the __name__ == '__main__', trick Macros: capture command history into a macro

All great stuff. Also mentioned in the article is System Shell Access. For example, you can use cd, pwd, and ls directly in IPython. To escape to the shell use '!' or '!!'.

The IPython Manual notes in the section IPython as system shell. I loose job control if I use iPython this way. Although, I haven't had many issues so far.

Starting IPython with 'ipython -p pysh', creates a special envirom"

I found this interesting because of recent ideas I've been drawing up for a Python Embedded Shell. The Python syntax for `foo` being taken as repr(foo) is to be removed, so I thought, "Why not have a special interpretter to expand `foo` to execute a program named `foo`?"

I went into it more in my mind, so I'll lay out the ideas here.

• foo=10 would be taken as normal
• print $foo would be used to print it to the terminal
• foo would just run the program, foo (I updated from the original thoughts)
• $foo would run a program stored in the string foo by name
• if, while, def, class, elif, else, and for all work as they currently do.
• That $ syntax is only needed where it would be otherwise confused for a program name.
• `foo` would resolve to a special object representing a new process running by executing foo. This process object would have stdin, stdout, and stderr file-like object attributes. It would also have kill, pause, and continue methods.
• New operators exist for piping. Such as foo->bar to pipe stdout of foo to stdin of bar. foo!->bar pipes stderr, instead. null is known as a built-in process object, which just pipes everthing to /dev/null or an equivalent.

Very basic, not well polished. Besides, I think I like Monad, the Microsoft Shell, which is still in Beta, a lot better than my idea or any command line I've ever used. Sorry, my Linux buddies, but a good idea is a good idea, no matter who comes up with it.

Dynamic Linking for Module Attributes

In much Python code, foo.bar refers to some attribute of the imported module "foo". There is only ever one instance of any module, so could attributes of modules be given pointers somewhere in the module object (internally) and thus importing scripts can be compiled such that foo.bar would be resolved to some new bytecode that says "load the object pointed to at this location". The location would be null when compiled, but importing would consult a table mapping the module's attribute references in the script to the locations in the bytecode of those null pointers. This would effectively work like dynamic linking in C/C++, and would reduce a lot of attribute lookups to a pair of pointer dereferences.

Focus, Direction, and Real Life

My wife and I have a baby on the way, my best friend moved in with us after running into some hard times, co-workers are causing my daily headaches, and my car broke down in my driveway. Where do I find time to code?

As it is I seem to barely have time for my code, and I wasn't making the progress I'd like even when I was impressed with the progress I was making. Factor in my continuing frustrations over the lack of writing and art I've been able to spend time on, and my output just looks dismal. Real Life, the good and the bad, are cutting into the things I always though real life would be made of, for me.

I pretty much know that until I can support myself and my family independantly, I don't have time for coding, writing, and art. I only have time for one. It forces me to look at it from a bussiness aspect, of which would bring me money quick enough to allow me to resurrect my other hobbies? It also instills growing fears of loss if I fail at any of them. Not only will I continue to work a dead job, but I'll continue to have no time for creativity.

Where's a grant when you need one?

Python Coroutines Schedulers

Just wanted to post a quick thought, mostly so I would remember it. I want to try to write a small decorator to turn any function into a coroutine, associated with a particular scheduler. When called, the coroutine would return a handler, and the scheduler would continue normally. it would be able to tell when a coroutine was called by another, and handle that appropriately, allowing the yields of the inner call to be yielded by the handler as an iterator. This would allow coroutines to be called pretty much just like functions, with everything being scheduled in the background pretty nicely.

PyPy and More Platforms

PyPy is coming along nicely. It gets closer to matching CPython for speed every day, but it still has its problems. It brings more questions to my mind about the matter of duplicated efforts with all of these Python implementations.

What we really need is a standardized from of representing Python code in Python code. Things like a Statement class and Expression instances, for example. This would allow people to easily write code to optimize and analyze code parsed by any front-end and compiled to any back-end.

Helping a Friend

A very good friend of mine has moved in with us this weekend. Some hard times, which were severely drawn out, lead to a four-hundred mile relocation back home, so I've cleaned out my office and set up the spare bed, to make him feel at home. Hopefully, things will get better in fast time. At least it all doesn't seem to be getting to him. Maybe, I'll get back to my old gamer-self with someone to thrash on in Halo, again.

My Take on Python Concurrency

The mailing lists and blogs have been abuzz lately with discussions, arguments, and good and bad ideas about how to deal with concurrency in Python. There is a general distaste against using vanilla threads, due to the difficulty in managing shared resources. Generators are an increasingly popular option, but they don't offer any pre-emptive nature, if you are into that sort of thing. And, of course, the Global Interpreter Lock is bashed and many pray for its removal, but that will only happen if a real concurrency mechanism is added not just as some library, but into the library itself.

Now, off the bat I'll say that I don't hate threads, but I really wish there was a better alternative. I do want to see the GIL go away. Finally, I don't like having to explicitly suspend my task every so often to allow something else to process for a while. This is tedious and does not always reflect the nature of the task well.

Active Objects seems like the most Pythonic approach, and like they could work well with existing, non-concurrent code. With Active Objects, you have objects designed to work concurrently. Calls to their methods are typically queued so that only one method of one active object will be executing at a single time. Thus, the active object does not need to syncronize on its internal state data. Extended loops in a method could get greedy, however, but that is a small matter.

The biggest issue is dealing with shared objects, which happens so much in Python's pass-everything-by-reference world. Methods can be crafted to be safer, such as by taking only basic types (integers and strings) and containers of those or containers (lists of strings and tuples of dictionaries mapping strings to booleans, etc.). But, inevitably, you will have to pass something more to a method.

One approach could be to copy objects before passing them, even to deep copy them all. Another would be to create special shallow objects that represent the state of the original without copying all of it. But, perhaps the best choice is to simply use more active objects. If we pass one active object to the method of another, and are accessing all data through their "active methods", then syncronization is generally secured. Perhaps it would also be beneficial to define a common locking API for all active objects.

Python is a wonderful, dynamic language, but there is some speculation that the very dynamic rules that make Python great, are also making it so difficult to settle on a good concurrency mechanism and to allow safe, concurrent code. Many Pythoneers scuff at the idea of true protected and private attributes, but maybe that's just what we need.

The ability to modify everything may be useful, but maybe it should be controlled a little more. We should be able to execute code in the context of protections on certain objects, like giving read-only versions of modules or write-locked lists. This becomes faulty when you realize you can just call object.__getattribute__, but I have a possible solution: the protected class. It would be a new built-in class, and anything inheriting it would be given special abilities: object's methods would treat is specially and following its access rules (properties would be immutable, exception through the functions defined for them, for example) even when using object methods directly, or other introspection mechanisms. Combining this with crafted globals and built-ins for 'jailed' code, could be a sucessful way to execute multiple lines of code in parellel without worrying they will step on each others' toes.

Python Object Space Demo

I've whipped up a little test of object spaces. You can create global contexts and run code within that context. You can also queue functions to be called (the API forbids multiple threads per space), and set response functions to be called at the return of a function called in context of the space. It is very simple, but effective, I like to think. The initial code is available here.

Branching out with Blogging

I may be creating some new blogs. I hold back posting some things, because I want to post on so many topics. I'm considering keeping this blog for general ranting, political commentary, and the like. I may also create the following blogs:

• Ranting and Raving about Games and Movies
  
• Ranting and Raving about Software
• Ranting and Raving about Art

The last one is likely not to be created, although I may resume my art and end my very long hiatus from Deviant Art (see my DA page here). This will allow me to more easily and openly blog about more specific things more often, without worrying that no one will read a blog so mixed with topics so unrelated.

Weekend Involgo Plans

With some luck and determination, I'll be able to make some good progress over the weekend. I've had overtime all week, and I still have to come in for a full shift on Saturday, but I'll have some time before work then and again on Sunday, and I'll have a prototype of my Involgo database working by the end of the weekend, I believe. Depending on the exact conditions of the prototype at that point, I may or may not be posting a link to an initial alpha release. We'll see.

Will XForms eliminate XUL?

Will the introduction of a complete XForms implementation in the Mozilla platform eliminate the need for XUL? I wouldn't be surprised if the current implementation uses XUL for the actual rendering of the forms, but wouldn't it make sense to work toward eliminating XUL from the Mozilla platform, in favor of a standard alternative? On a related note, it seems there could be plans to incorporate OpenGL or some similar API to the new canvas element, which would mean that if you allowed document rendering to a canvas element (XML is finally looking cool) you could have the entire window just be a big canvas element, render the browser's own XForm document to it (which would render the pages in their own canvas elements!) and all of this, being drawn with a clean and proper API, could be hardware accelerated, where such is available on Mac OS X, Windows with Avalon, and decent configurations of X.org.

Pandora Take Two

Since my last post about the service, I got a comment from Tom Conrad, the CTO of Pandora. I've had more time to think about the service, its good qualities, and its drawbacks. I'm sure Tom keeps a custom blog aggregator to find anyone posting about Pandora, but I'm still honored for that to be my first post (not counting the Blog Comment Spam I had to delete). I'm surprised I don't see any posts by Tom on Ned's blog, though, I guess Tom just peeks around on Blogspot and doesn't catch the independents.

Anyway, Tom did say to feel free to continue blogging about Pandora, which I will do, because I have some more thoughts I'd like to share, especially knowing that he is listening.

Pandora is great. Its the best online music service I've found, and possible the greatest source of music I have, next to listening to Nights with Alice Cooper on the nights at work when I get the desk with the radio. When I say something is the best I've found, that doesn't really say a lot. It does in Pandora's case, but I'll clear it all up here.

What Pandora does right:

• Deployment as a web app
• Multiple stations
• More fine grained than genre and year
• Finds new music
• Dirt cheap subscription ($36/year or $12/quarter)
  

What Pandora does wrong:

• Can't listen by genre and/or year
• Think computers are the best at organizing music
• Pass up on the greatest source of music listening habits since iTunes. Maybe better than iTunes.

The last point is where I'm going, so bare with me. Let me go over the good in more detail. I'm giddy over the pricing. I can't believe people really pay $.99 a song from Apple, and I'm sickened that the music execs actually think that isn't enough.

I love when Pandora plays a song, and I think, "Hey, this is pretty good, who are these guys?" Of course, I also get Tivo flashbacks when I think, "Hey, why are you playing that?" It does find some nice tunes and I would be out of my league to acquire and organize a playlist of that quality and size. Now, I'm a Linux user (though more and more distastefully), so I'm happy Pandora went the web app route. It makes it so much easier to refer the service to my friends, who can just go to www.pandora.com and start listening, just like that. And, thank god they don't just group by year and genre, because I might be in the mood often for 80's music, but lots of music not made in the 80's will fit that class of music.

Sometimes, I just want to listen to 80's music, and how do I tell Pandora that? I can't seem to search for shared stations by name so I can just find anyone's "80's Music Mix" station. The redefinition of the very meaning of a station is a god-send, I must say. I can listen to the same station as thousands of people, and skip over any song I don't like. That freaking rules, because I hate when the radio plays something I don't like.

Now, what is the biggest thing that Pandora is missing? First of all, let me say this is speculation on some level, because if they take advantage of this, it must be completely on the internal level. They have thousands of listeners voting songs in and out of various groupings and all of this is stored into a wonderful database of golden information. So, Tom Conrad, I ask you, where is the "Play what other's like to listen to with this" option? The Music Genome Project may be a great venture and successful at what it does, but nothing beats a fellow human with a common taste in music. How about mining that database for common listening patterns, generating collective stations?

I'm sure they may find this a scary idea, because in essence it seems to go against the very beginnings and roots of Pandora itself, but it is also quite possibly the biggest value in the service for the company behind it, and to not take advantage of this would be, to put it simply, kind of stupid. (Sorry, Tom)

C#, .Net, and Mono

So, I've been doing some tutorials on MSDN on the C# language. It seems like Java without the emphasis on a virtual machine. Or, like C++ with emphasis on portability of useful code. Either way, the gun is in a lock box instead of just having the safety on or being taken away completely. I'm going to be looking into Python.Net and IronPython very soon, as well, and the Boo programming language, which is a Python-ish .Net language.

So, from the get-go, I admit that I do like C# for what it is. I've been looking for a compiled language for those cases when I would care to have one, and maybe it would be a good way to diversify my skill set. I've even considered an eventual implementation of Involgo in C#. With Python.Net I can wrap a .Net assembly for Involgo into the original Python API, and let any existing code still work, but likely faster.

C# looks like it would let me do a lot of the things that I like Python for, but without making them too difficult to manage like some other compiled languages. Delegates are nifty for passing function-like objects. I can pass objects without a specific type when I really need to, or have static typing when I need/want/think I want it. And, the automatic usability from so many languages is just "to die for".

I do wonder, however, what the consensus among the .Net community is for the Mono project. Most .Net users are definitely Microsoft users, so what do they think about us "others"? In the FS/OS world, the community is king. In their world, the community is surely strong, but it is far different. I wonder often about this rift between geeks. We're all after the same thing, we just think there are different ways to go about it.

Lepers in America

Before Leprosy was cured, all the lepers would be sent to live together, away from the rest of the world. It might seem cruel by todays standards, but a horrible, killing disease is what it is. And, someone infected might as well be that disease walking.

Today we have several horrible diseases plaguing the planet. We have HIV spreading across the globe, for example. We don't put people with HIV into special camps. No, instead we just tell them, "remember to wrap it before you tap it." Meanwhile, the little AIDS demons continue to laugh at the world they may some day cripple.

Now, I'm not suggesting that we lock every with an STD up, but shouldn't there be some accountability? If you are walking around able to cause such an ammount of death and destuction, you'd think someone would say, "Hey, you better own up to this."

Crazy people are still punished for killing people, but is it a crime to know you have HIV and sleep around anyway? If you knock someone up, you have to support the child, but do you have to pay for their HIV medications if you infect them? People in this country won't even where protective masks when they have a bad cold, so why should I expect anything reasonable?

Pandora makes me want to spend money on music again

I love music, and I hate to buy a CD. To think how much I'm paying for that CD, with the full knowledge of how much it really costs to make, and how much the bands I love even get from the sales. I'd rather buy Ogg Vorbis streams directly from the band members, but that won't happen while the RIAA is still running this country.

Still, Pandora has given me the desire to spend money on music again, by giving me actual value in its service. Thanks, Ned, for blogging about this.

Is there room in the bubble?

There never really was 'a' bubble, and so 'the' bubble didn't really burst. There were bubbles, and there were a lot of them and a lot of them got big, and a lot of them burst. There are still a lot of bubbles.

Do any of these bubbles have room for me? Can I make my own little bubble and hope I don't pop it myself?

I'm evaluating my options for a start-up. I'm considering costs, estimating revenues, and trying to decide the timetable in which I could make it actually work. I'm doing my best to balence a quick turn around with a solid investment of my money and time.

Lots of geeks have done this, and I'd like to think I could be one of them who succeeds. And, I do think that I will, too.

Involgo Progress from Scratch

I made plans, I designed things, and I spent lots of time making very little progress. Finally, thanks to a suggestion on IRC, I just dove in, scrapping the ill-fating code I already had, and just making things work. My little object database now works, kind of. It doesn't store data between sessions, it just keeps them as Python objects in memory. I'm able to easily and quickly add in all the features, debug the database, and iron out my ideas. When the major features are generally operational, I'll add some basic persistance for more testing. Dive in: procrastination is the disease of the failures.

C-Pound is Looking Sharp

I took the time to view the video interview about the LINQ project and C# 3.0's first-class query mechanisms. I was actually impressed with it, and it solved some problems I have with Python. It also made me think how the same solutions could be applied in Python, or any such dynamic language.

What is most interesting about LINQ, I couldn't be sure of from the video. Does it pull in all the data and apply the anonymous functions to it for conditional filtering, or does it take the where clause and actually generate that into a request to the server? Now, this doesn't matter for XML documents and especially direct queries on CRL objects, but with relational tables it really is important.

This is what Python needs: a generalized way to generate patterns to match, using existing operators. There are some tricks available, like allowing sometype==value to return a callable that can be passed an instance of sometype and return True if it equals value. This can be used to generate lots of pattern matchers. The problem is that some things aren't so easily redefined, like and and or operators, and it isn't easy to define that operation if you also want == for instances of sometype. That requires defining an instance method and class method of the same name for one type. Possible, but very tricky.

It would be very useful to add first-class pattern matching to Python. I'm thinking of a syntax along the lines of ?==x to generate a pattern object representing the pattern needed. What is important, however, is that it would create more than an object that can be called to test if something matches the pattern, but other code would be able to introspect the pattern, merge patterns together, generate SQL code from them, etc.

I wonder how well the community would respond to this. It would probably be best to promote a common and hopefully standard pattern package, and to propose syntax integration of the module at a later date. That would also give time for the pattern matchings to evolve. Hopefully this will happen, because Python is improving every day, but if it doesn't do so in the right places, it will fall from its rising seat of glory.

(More examples of the Pattern Syntax)
(All comparison operators work as expected, such as `?>10' to test for values greater than 10)

`?foo' to test for an instance of foo

`?is foo' to test is something is foo

`?in foo' to test is something is in foo

`?contains foo' to test if foo is something

`?hasattr foo' to test if something has the attribute 'foo'

`?attr foo ?==10' to test if something's 'foo' attribute is equal to 10

`bar?foo' to test if bar is of type foo, where bar is the name of an iterated object, such as in a for loop or list comprehension. This can be used to clarify when there are more than one object per loop to test.

`?[4]?=="four"' to test if the 4th item in a list-like object is equal to the string "four".

`?foo,bar' test if something is of type foo or type bar

`?all foo,bar' test if something is of both type foo and type bar

Any thoughts on this?

Fan-Tab-ulous!

I've always found myself to be a proponent of tabs in favor of spaces in source code. It makes more sense, because the reader can choose whatever tab-width they want, so it makes the source code more accessable, with a properly configured editor. Lately, though, I find myself using two spaces instead of a tab character. I still feel tabs are better, so why am I using spaces?

On Game Ratings, Companies, and Retailers

There is a three-fold source to the recent debates and arguments surrounding the video game world. Most people who care, and plenty who don't, have heard about the scandles with Grand Theft Auto: San Andreas and the Hot Coffee mod. That isn't what I want to focus on, because that has already been blogged to hell and back.

The system is broken. While most studies show the average gamer as being 34 years old, the industry is still trying to sell games to kids and teenagers. Now, I have no trouble with giving a game an AO rating, but why do retailers have a problem selling them? They sure are cutting out a huge section of their consumer base. Besides, Wal-Mart actually does card for M games, last I checked, so why not sell AO games and card them as well?

The bottom line is this: if most of the people buying games are adults, why should they always aim for a rating that lets teens buy it (T or M is usually the highest rating they want)? The answer is that the stores don't carry AO games, but that just brings back the questions about the average gamer age.

In the end, we just need to work to make everyone realize that AO games aren't bad. You can carry them in your store and card anyone who looks too young, just like smokes. Only AO games don't kill people, they help stressed out adults relax after a long day of working as a productive member of society.

The Perfect Python IDE

There are a lot of things I look for in a good IDE. Looking for those things, I've tried Kate, KDevelop, Eric3, Komodo, and Boa-Constructor, to name only a few. Some of them give me a few things I like, each one giving different things. But, none of them have all of the core features I really want in a Python editor.
So, here I am laying them out. Maybe an IDE will be developed meeting these requests, or maybe I'll do it myself eventually, possibly joining one of the above mentioned projects.
Such an imaginary program we will call, for the time being, The Perfect Python IDE.

• Indentation is important in Python programs. The fact that one can not mix tabs and spaces brings hardship to anyone who commonly edits multiple projects' files simultaneously, when they use different indenting rules. The Perfect Python IDE sees what kind of indenting is being used in the current file, and auto-indent following that style.
• indentation exists both in the actual code and in how the code is displayed. Sometimes a line may be lengthy on a particular display, or when I'm using a horizontally split view. The Perfect Python IDE dynamically wraps the line's display without affecting the source code itself, and even indents the following line for clarity.
  
• Of course, The Perfect Python IDE knows that if any feature gets in the way, its not a feature; it is a bug. That's why it only follows through with an auto-completion when I explicitly tell it to, and it always implicitly goes away the moment it sees I don't want auto-completion.
• Even the smallest of projects needs a sense of history. You never know when you'll want to undo something you saved a week ago, so version control is a must. An IDE should naturally compliment such a system, like CVS or Subversion. The Perfect Python IDE only asks me for a path to the local working copy, or a svn+ssh:// URL to the repository, so it can just keep the working copy files hidden while I work on them.
  
• As long as I'm just giving The Perfect Python IDE the URL to the repository, there isn't a need for any silly project files.
  
• Now that my files are stored in a repository on a remote server, interested people might work on the code, too. They'll probably want the code to work when they update their working copies, so I'd better test before every time I commit something. The Perfect Python IDE can see my test/ directory and my test_*.py scripts and run them, being sure to set the PYTHONPATH for my package.
• UnitTests being run is one thing, but doing something with them when the tests fail is something to be really proud of. The Perfect Python IDE extracts the tracebacks and bookmarks all the lines in the call stack. It even numbers them and displays local values at the time of error.
• The Perfect Python IDE may be perfect, but part of that is being exactly what I want it to be, or what you want it to be. Those things may be different, but The Perfect Python IDE can be different, too. It can be customized at any point; and, it can be customized in Python. Of course, it is used as an editor of those very same customization scripts.
  
• Not everything needs custom code to make it act right. The settings and configuration can go a long way, too. The Perfect Python IDE never asks me to restart it for settings to take affect, and it always lets me know exactly what any particular setting does.
  

Do I ask too much? I could probably ask for more. Did I not specify well enough what I want? I'm mostly listing it to get things straight in my own head. Does something already exist that does this all? I haven't it. Do Vim or (X)Emacs do the things I ask? They're ugly. I pay for high-end computers and large monitors for graphical interfaces, not consoles.
Yeah, they both have GUI modes, but they kind of suck. They're little more than terminal emulators enhanced for that particular program. Either of them could be a good GUI IDE, but communities around them just don't seem to understand the reason to make it looks "pretty", so I doubt they will, at least, not for a very long time. Despite what many techno-machos say, programs really are better when they're pretty.

Lonely Coding

There are a lot of interested I've carried throughout my life. I've dabbled in so many arts and craftworkings and skills, but never really mastered anything. I've wanted to be a writter, a painter, a movie director, a programmer, and probably a dozen other creative endevours. I've shared all these with someone.

There are three people in my life that I've ever really considered my best friends. Unlike the childhood movies you might be used to, we weren't like the four musketeers. As a matter of fact, for the most part they barely know each other. But what they all have in common is that at one point, we were supposed to do something big.

I was supposed to start a successful art career alongside Ben.

Matt and I were planning to build a solid tech company from our ideas.

And, along with David, I may have made gripping films of a powerful nature.

None of it came to pass, even though we are still great friends. Ben doesn't draw anymore, David never finishes any stories he writes, and Matt might be a decent SysAdmin, but he can't code a lick.

So where does this leave me? After much of my life looking forward to realizing a dream of potential alongside one of my best friends, how do I drag myself through it alone? It makes me wonder how much I wanted to success, and how much I wanted it alongside a really good friend.

Blogger not cutting it

I don't think this website/blog is going to last any longer than any other I've had. I'm going back to the homegrown path. I've been finally learning how to use Atop and Nevow, and I'm on the path to building a decent and usable system with it.
All the blog services I've looked into just lack something I want. Particularly, the kind of organizational system I'm looking for. I'm building my new FrogTongue with a Tag concept, where Tags are basically labels and any number of them can apply to any number of items of content. Tags can even imply that other tags are applied along with them. This will be very flexible, so I can cover a lot of different topics and keep things seperated where they need to be.
I'll be releasing FrogTongue at some point in the very near future. It won't take me long, and I don't intend to do a lot with it. Involgo and Picos keep me busy enough, at is it.
Thankfully, I'll have some help in that area, with a new coder joining the project. My best friend, actually, who is new to programming, but a very smart guy and I'll be giving him some tasks to do in Involgo, which will be very closed and controlled, so he can learn with some definate goals.
Hopefully this all goes well, and we can get Involgo out the door before the end of the year.

Fitting in with a Tough Crowd

I began this post a while back, saved the draft, and pretty much forgot where I was going with it. Make what you will of it...

I want people to think that I'm cool. I want to impress people, and more importantly, I want to impress the kind of people who otherwise would impress me. I want all the other geeks to think I'm cool. Hey, I'm human.

How do you impress a geek? You be a better geek, in some respect. You write a very useful application, or create an amazingly efficient library for handling a common task. You be the geek the other geeks wish to be. I want to create software, and I want that software to be useful, maybe even to the point of making the world even just a little bit better. If I manage to impress some fellow geeks along the way, then I say that is even better.

To the point I had in mind when I began writing this: I should but do not wish to change my coding style if I want to impress anyone. People commonly don't like my coding style, for various reasons, none of them good reasons, even. There really aren't good reasons to dislike a particular coding style, and I want to make it clear why I think so.

Firstly, why I don't think we have no reason to dislike a particular coding style, and how this is different from liking a particular coding style, which I do think we should do. Source code is supposed to be human-readable instructions to computer, but in truth they are no more readable at the lowest level than an executable binary. In the lowest levels, they are all bits, after all. Source code, however, is stored in a convention of bits, which a computer can process not only as instructions to follow, but as instructions to display to the user. The computer, in other words, can display the text on the screen. The biggest mistake in the software development world is the lack of instructing the computer to display this source code text intelligently. Source code presentation has not improved much over the years. We went from displays of hard-delimited lines, to having word-wrapping functionality that didn't do a good job, so we still keep old rules around about the length of the lines, because that's easier in the short-term than just making the word-wrappers smarter. We got syntax-highlighting, and that was pretty basic, but it stuck and works OK. Code-folding came along a long time after that, and it spread quickly and helps a lot, and its at least something near to intelligent, but it still works with those hard-delimited lines.

Why power of the tab

In itself and its symbolism

The tab is a controversial character, because it isn't really a character. The controversy began with the bad decisions in its original creation. The tab exists, really, in two forms, which work together and sometimes separately, causing most of the problems. The tab is a key on the keyboard and also a character present in many text files. It is the tab character's presence in source code that irks as many people as it makes happy.

Intel, Apple, and the Victims

Right off the bat, I want to say that if you are starting a good band with a good sound, name your band "The Victims", because when I wrote that I immediately thought, "That would be a great name for a band."

So, to the topic at hand. I wanted a blog and every blogger with a sense of trend is talking about the Apple/Intel deals going on before our eyes, and behind our backs. But, not just behind our backs, but behind the backs of several big name companies and tech-world shakers who are going to become very nervous at board meetings for months to come, maybe years, maybe until the very last board meeting their particular company holds. If Cringley is right about Apple and Intel merging, or even if they are only striking lots of extremely friendly, exclusive deals, there is a lot at stake in the world, technologically, economically, socialogically, and politcally.

The first and most important point to make here is to simply point out the amazing sense of irony this situation brings to the table. Do you honestly and fully realize what is going on here? Apple, the only major competetor to Intel's prize architecture over the years, is poised to become their biggest customer. Apple on Intel chips is a strange a sounding phrase as Sadam marrying Mother Teresa!

This move is going to have a two-fold affect on the open source movement, particularly the Linux people. On one hand, everyone is going to have a much slicker choice of alternatives for Windows very soon. On the other hand, this will open up the idea of using something other than Windows to the mind of Average Joe User, so he will be more willing to take a chance on free systems like Linux. It will be interesting to see where these trends balence.

Over on Slashdot, this guy makes an interesting comment about the biggest mythical challenges to the Apple/Intel pair that could pop up. The "Microsoft acquires AMD" is a little bit of a stretch, but the IBM/Cell/Linux idea is probably a crowd favorite. I've been waiting to get my hands on a Cell chip for a long time now, and seeing what it might be able to do in the hands of all those skilled Linux developers and other open source coders is really a fantastic thought. I'd love to get a look under the hood myself.

HP is definately going to be in on this deal, in my opinion. They already make Apple's iPods, they have close ties to Intel (Pavilion and Celeron sure bring in a pretty chunk of change for the two of them), and with a move to Intel it will be much easier for Apple to shift the hardware work over to another party, and focus on the software work they are so blessed at.

These are the cards, and the major players have their hands. How will they play them? What wild cards do they have up their sleaves? I for one am very interested to see how this game plays out. I was about to purchase an iMac or an iBook, but now I'm going to step back and watch, and way, and hope for the best. Rought waters are ahead, but we might come out of it all for the better, or hell could break loose and we'll all be stuck in the mud.

First Post

(That title is in honor of the great and silly internet past-time of First Posting)

I ran a blog on my website (www.ironfroggy.com) a while back, with a very small number of readers. I probably knew each of the readers personally from before the blog, actually. The main reason I hosted it there was to roll my own blog technology. I actually wrote a very basic web-scripting system in Python, that let me embed posts, basic data, etc. into web pages. I even wrote my first GUI application as a tool for managing the posts and categories. To top it off, it was all multi-user enough for my wife to run one, too, and to merge our personal blogs from our homepages into the front page of the website, all in my own primitive scripting format.

What a trip.

Well, for the moment I can't spend the time maintaining my own server and all that, so I decided to move to a blog service. I wanted one that will still let me host from my own site, which blogger.com will let me do. And, when I saw I could post from my phone, I was hooked. Finally, a good way to vent on my lunch break at work!

So, what should a blog be? What should my blog be. I suppose, as any blogger does, I would post about the things that interest myself. I will post about my views of the world, my ideas for software and technology, and maybe some thoughts on my first book I am slowly writing.

This I write for myself, to take my jumbled mind and lay it down, for a moment, into a coherent enough a set of ideas that I can make sense of it, for a moment. Perhaps, just maybe, you can do the same.