www.codedevl.com

The Greying of an Engineer

2010-03-09T23:59:00.001-05:00

My birthday is upon me once again, this time in 11 minutes from the time that I compose this brief entry. As I contemplate what the next year holds for me I find myself having certain realisations floating around my head. I will attempt to share these with little fanfare and leave interpretations to the reader.

1. Throughout my entire life thus far, one item has remained a constant: I love to design software and have since I was in the single digit age range.

2. The reason I'm not a horribly rich coder is simply because my goal has never been that of becoming rich, whereas it has been that of writing great code.

3. There are is a lot of talent out there, but it has nothing to do with youth vs. older coders.

4. New methodologies come and go all of the time. Functional vs. Object Oriented paradigms, Low Level vs. High Level languages, Waterfall vs. Agile development. All are capable, all can be utilised in effective manners, it simply comes down to competence and compatibility of those involved.

5. You can teach an old dog new tricks, though after having learned said new trick(s), one might still prefer the original. (e.g. I think that jQuery is a wonderful invention, but don't expect me to use it as I feel it isn't explicitly clear. I'll take document.getElementById('idname') anyday over perl/rubyesque tokens.

Given that my goal was to post this before my birthday comes, I'm ending it abruptly here. Till my next post.. -Eric

You kids get off my lawn! (oh, and the Apple iPad)

2010-01-28T23:19:00.007-05:00

Lately I've been rather busy with work, primarily my main client as well as with the newer work I've been doing with a soon-to-be unveiled startup of which I'm a partner. Our product is launching by the end of the first quarter 2010 and I will be sure to update the site with all the details.

What is really on my mind lately is the annoyances I've been feeling more and more lately regarding what I feel is a loss of substance in the field of computing, interfaces and the sector of artificial intelligence research. Though just recently with the launch of the newly unveiled Apple iPad did I start to feel some alleviation. I will address several of the aforementioned items, but will leave the AI discussion for another post as it will be a lengthy one at best.

Firstly, as 2010 has rolled upon us I started reflecting on how it must be for kids these days and their constant exposure to computers. Primarily how difficult it must be for future programmers and software engineers to get started programming on machines so complex with operating systems so complex that to do even the simplest task requires learning what potentially are complex API's. When I was starting out with computers back in 1979-1980 one could buy a computer (which came with at least BASIC) as well as general instruction books explaining how to program in said language. Within 15-30 minutes any kid would be able to draw bitmapped graphics on screen and possibly even animate and/or add sound as well.

Given that the machine in question on which I first started (a 16-bit machine no less), the TI-994/a, was a 1.067mHz speed daemon, there is much to be said for its overall capabilities. This blog post is larger in size than that machine had RAM (a whole 16k's worth). So, it is true that with all of the amazing capabilities and speed of our newer machines (such as my primary machine with its 8 hyperthreaded cores over two physical quad-core Nehalem Xeon's and 6gb of RAM (of a possible 64gb)) it would be expected. Still, something is lost in the overall simplicity.

Furthermore, my recent curmudgeonly slanted mindset spread to thoughts about how access for all destroyed the quality of the average computer user, especially those networked users (which nowadays includes virtually everyone). When I first started online, there was no AOL, there was no web, there was the internet, but it was limited to Academia, Science Research facilities and the Government. We had modems primarily running at 110/300/440 and later 1200 baud and up. We had acoustic coupler RS232 interfaces (they while novel, are not something which I find myself longing for once again) and we were happy as can be. We knew that getting online and/or running into other computer programmers/enthusiasts (they were usually one in the same back in the day) would lead to interesting conversations/exchanges of a higher intellectual level as opposed to nowadays where the overwhelming majority of computer users are simply that, users who couldn't code their way out of a cardboard box.

Enter the Apple iPad. A machine designed for everyone BUT programmers/software engineers & developers. It provides the mundanes with the functionality to go on about their daily online existences and I'm truly hoping that such devices as this catch on. I hope that items such as this replace the majority of those users' computers. This would give us a kind of return back to the day when the technorati and intellectually gifted were the only ones with machines capable of creating new software. It will help like minded people easily be able to pick out those of similar ilk simply by their possessing an actual computer.

Now I realise that there are people complaining about the iPad specifically those under the spell of Stallman (RMS) and his free software foundation but it is time for them to be grown ups about the situation. If someone creates software, it is their right to keep the source closed, just as it is Stallman's right not to run it on his machine(s). He can be an idealist with cramming such a non-sensical mindset on everyone. Most people really could care less because there are those sources which provide for the applications people want and use, and have no desire (or capability) to modify them anyway, hence the iPad and future devices of similar type are perfect as end users are consumers of the fruits borne of software engineers, not producers of such software.

Now I realise that as usual, I'm diverging from my original topic by going off on a mildly related tangent, so i'll wrap this up by simply stating that it is my hope that with the newer type of device designed solely for the everyday user that we will see a reduction in actual programmable computer sales indicative of a clear divide between producers and consumers once again making a clear distinction between those with the mental prowess and logic abilities/desire to create software and utilise machines to their fullest, and those who are simply consumers of said labour.

Thoughts?

PyCon 2010

2009-09-30T23:39:00.002-04:00

I just made my submission to give a 30 minute talk at PyCon (US) 2010 in late February of the upcoming year. I was contacted by PyCon staff with the suggestion that I present a talk sharing my various Python based experiences at various places of employ. I made sure to get the submission in earlier this evening before the ability to do so was shutdown as the window for submisions closed for the 2010 event. Now I must wait until sometime in November to hear as to whether or not I'll be presenting. I will keep everyone posted either way.

Update to Post Regarding Hacking & Ruby

2009-08-28T02:08:00.005-04:00

This will be a very short entry as it is rather late and I'm looking forward to sleep. I would do but I do feel that I have to get some observations off of my chest after the past 6 hours of exploring ruby (for the third time).

#1. Ruby isn't as intuitive as one might suspect. Maybe python and others of similar influence (groovy) have raised the bar too high in terms of dynamic language syntax and expectations. The standard ruby idioms are inconsistent and ill-named in several cases, mostly involving native data sets.

#2. Namespaces in Ruby are an even bigger mess than perl. To some degree, perl's system seemed to make sense yet from what I've read, seen and with which I experimented, I find the namespace setup for Ruby to be subpar and dare I saw far from fluid in implementation details.

#3. Ruby is indeed very slow, especially when working with the Array types in combination with large datasets and continual pre-requisite 'include?' method calls for each datum in said set. I did find that I was able to achieve the same results wanted via Hash population followed by a dump of keys to an Array with a noticable speedup, removing the need for the very slow 'include?' method. Membership tests are a joy of high level languages, but a drain on some resources, ruby more than others though without a doubt.

#4. The novelty of mutable and immutable version of method calls (collect! vs. collect, slice! vs. slice) is just that. A novelty. This is an ambiguity which I believe does not help to further ease of readability and usability. It further necessitates that non-standard library code implement similar idioms and 'practices' for uniformity's sake with the downside being a snowball effect in this area.

#5. Ruby isn't sure if it wants to be perl, c, smalltalk or itself as can be determined by the mix and match of terms, keywords and standard method names. It doesn't feel like a concrete language that was purpose built, but more like an object system with various sources for tacking on the remaining pieces of the language so as to round out the feature range.

These experiences with Ruby (for the third time) may have been different had I not been spoiled by Python (most notably), or were I not coding in the field for the past 15 years. This is not the case nonetheless. I couldn't see myself coding in this language for anything mission critical or heavy duty and after looking at the problems many of the ruby back-ended software systems and/or websites vs. the other high-level dynamic languages have suffered, it becomes quite clear when industry giants such as Google and IBM throw their weight behind Python.

This isn't meant to be an argument starting post about Ruby vs. Python as they can be found elsewhere, though if the shoe fits...

Ruby & Project Realisations

2009-08-26T00:18:00.004-04:00

This isn't going to be a long post as it is rather late in the evening (morning) and not only am I trying to rest my leg (hyperextended my knee playing football (soccer for the Americans out there) on Monday evening), but I'm also in need of greater amounts of sleep having a four month old daughter for whom I am the primary care giver starting tomorrow given that my wife works in the academic world.

Short and to the point (for me at least) is that I'm delving back into Ruby (for the third time chronologically), but for the second time on a 'serious' level (i.e. with the intent to actually produce usable code and not simply proof-of-concept understanding code). I'm realising that while I love python which has been part of my daily work for the past five plus years, moreso Django/python in the past two, that it is becoming my 'Java/C#' if you will. By that I mean that it is my work language. It is a clean and elegant language which allows me to focus on getting what I wish completed, completed with minimal fuss and easy maintainability due to its explicit albeit brief and neatly aligned syntax. I feel though that something is missing.

If I can go back a little (and long time readers from previous versions of this blog circa 2002-2006 would remember me discussing this before) and bring up what eventually became my professional lingua of frustration: perl. Larry Wall's masterpiece which I utilised professionally from as far back as 1995 albeit I was working with rexx and pascal(!) more so then. I used perl and was attracted to it because of its expressive hacker roots, but was eventually disgusted by the lack of a decent enforceable object model for doing any kind of OOP work, not to mention maintainability was not its strong suit regardless of how meticulous one might be as a software engineer/coder, etc. This is what ultimately lead me to look at ruby but only briefly as it had residual taste of perl all over it. I found python shortly thereafter and have been happy ever since, until recently.

Sure I've looked and learned other languages in the meantime (as well as used them for personal and professional purposes), but just for the past three weeks or so I've realised that some of python's strong suit do indeed take some of the more guttural joy out of hacking out code. In my line of work I find formality and structure do wonders at getting solid code and meeting my clients' needs, which is the whole point. I'm at the point professionally where I don't get calls or emails saying that "something broke". It is much akin to Apple computers. Things just work without fail, as should be expected.

This ties into my other piece of the recent puzzle. I'm doing web framework design and implementation (amongst other custom software components) for primarily lifestyle, art and fashion magazines. It does pay the bills and it is at least involved with a creative branch of what can be a boring industry (publishing), though I find myself pining for more intellectually/scientific/theoretical research based projects/content. This isn't going to be happening anytime soon where I'm currently spending my efforts (professionally as it were). I have no design to stop doing what I'm doing and for whom I'm doing said work. I enjoy the relationship I have with my clients and there isn't anything wrong there. I'm being kept busy with new work so that's nothing about which to complain.

What I am looking to do is start working on some more experimental/theoretical designs and codebases/classes/packages in Ruby so that I can further explore the language and enjoy the more 'hack' mindedness which I find comes with such an expressive language. I will most definitely share my results with all the CodeDEVL readership (as well as podcast subscribers). I may even post a screen-cast soon as my copy of Snow Leopard for my Octo-Mac Pro (8-Core) should be here on Friday and includes new screen-cast capturing built-in to Quicktime X.

If anyone is in the Doylestown region of Pennsylvania and would like to meet up to talk code, please drop me a line. My email is simply 'eric' at this domain (assuming you're not reading this from the source blogger domain but the domain for which the header image at the top of the page states clearly.

I'll keep everyone informed. Until next time..

-Eric

New Development Machine Ordered

2009-07-25T22:39:00.003-04:00

After years of working primarily on laptops, I finally decided that it was time to move to a desktop. A brief history is in order so as to show the road travelled (for posterity). All machines were purchased new and the prices include necessary manufacturers extended warranties, etc.

April 2002 : Whilst getting prepared for an upwardly vertical move in my field after working at Alliance Remanufacturing as their Lead Software Developer for internal applications for the production, procurement, quality assurance and management divisions, I purchased an Apple 14" iBook G3 @ 700 MHz w/768 MB of memory for $2,500. This unfortunately was plagued with a flaky motherboard (logic board) issue causing video issues. The machine had 4 logic boards in 3 years under full warranty. I learned the value of AppleCare very quickly, as well as the quality and speed of Apple's customer service.

June 2005 : At this time I was working for Payment Processing Center, LLC writing cheque/bank draft processing backend software as well as managing a real time financial reporting web portal. The logic board in the iBook G3 gave up its ghost yet again and now being out of warranty, it wasn't worth fixing. The replacement came in the form of an Apple 12" iBook G4 @ 1.2 GHz w/1.25 GB of memory for approximately $1,550.

February 2006 : Due to a Federal Raid (later proven to be due to certain clientele and not my place of employ nor its directors), the iBook G4 was seized by the Federal Government for a period of many months with no promised return date. During the next few months I was forced to work on a Windows machine and it was like being a fish out of water. I'm a Unix person through and through and while I took solace in one of our FreeBSD boxes, it wasn't enough.

April 2006 : Still at Payment Processing Center though still without word regarding the seized iBook the decision to buy a professional level Intel based (Core Duo, 1st Generation) replacement. I ordered an Apple 15.3" Widescreen MacBook Pro @ 1.83 GHz w/1 GB of memory for approximately $2,700. The machine which would take me through several large projects for a multitude of clientele including but not limited to: a national retailer with 400 locations in the United States as well as an international magazine publishing group hosting several publications. It would ultimately be maxed out at the 2 GB of memory to which it was limited, being a first version Core Duo (NOT Core 2 Duo), and only 32 bit.

This brings us to today, with the MacBook Pro being out of Apple Care and currently being used as a desktop for over 1.5 years (hooked up to two external displays, two printers, one scanner, 3 external USB Hubs (4, 4 & 7), several external hard drives and an external Firewire Raid Array, it is time to move on to a more appropriate development machine capable of handling the newer software, operating system(s) and expansions needs as dictated by my work demands. Due for pickup later this week is an Apple Mac Pro workstations with dual quad-core xenon "Nehalem" hyperthreaded processors (effectively 16 cores) at 2.26 GHz each, with 6 GB of memory by default for approximately $3200. This provides the expansion abilities I need not to mention the fastest performing Unix workstation anywhere near that price range with the ability to handle 4 TB of storage internally as well as 64 GB of memory.

The end of this upcoming week can't come soon enough for me. It is amazing to think how far technology has come in just the past 7 years. From a fast Risc based G3 @ 700 MHz to what amounts to 16 64 bit cores at 2.26 GHz Intel Xenon "Nehalem" (Risc like design and performance customised for Apple by Intel).

More on the new workstation forthcoming.

Eric

Enforcing the Software Engineer Archetype & Related Principles

2009-06-13T01:46:00.006-04:00

It is hard to believe I've been engineering software for the past 14 years, mainly because that isn't reality. I started off like most others, as a programmer/developer and grew personally and professionally over time. As time progresses in our studies and experiences in design, development and deployment we change. This change is more oft than not, for the best.

When I was growing up, I looked towards getting a CS degree so as to become the aptly named "Computer Scientist". What I've found over the years via practical and situational based circumstances is that Computer Science isn't my primary interest. While it is true that there are pieces of the CS realm which have always garnered my attention, such as Artificial Intelligence, it doesn't ring true as a whole.

Today reminded me just how much I would like to think I have changed both in my focus, overall goals and discipline pertaining to the whole process of building software systems. Now the example I'm going to loosely reference is centered around phase one of a much larger long term project. This first phase was somewhat of a rush job as per the client due to botched (i.e. prematurely advertised) promotions for said application's 'live-date'.

I knew that taking this on such short notice would require a very strict set of time guidelines and clearly defined checkpoints and milestones if all was going to be implemented in a proper manner, one supporting a proper holistic software lifecycle approach. This of course required the initial overview of the phase being clarified, the requirements gathering phase, the initial layout with timeline estimates and expectations being put forth and finally said estimates being agreed upon with a little 'wiggle' room so as to allow for human error in the previous steps.

Well, here's what happened today which precipitated this posting. This project has a launch date of 15-Jun-09 and today being the last business day prior to that date, one could say that the end was almost upon me/us at the time. Weekends are out because as an adult and a family person with children, I value my personal and family time very highly, much higher than that of my professional work. That being said, I am indeed an experience professional and know how to accurately plan work into a give time frame clearly stating what can and cannot be realistically expected within a given time schema.

Today approximately one hour before the weekend officially arrived thus signaling the end of this phase of the project, both the designer and the overall project coordinator (not on the Software Engineer side mind you) started throwing out 'new' items for this existing phase almost completed. It is at moments such as these where the undisciplined and junior level individuals panic and ultimately sacrifice their own time for the sake of someone else's lack of professionalism by agreeing to make the changes.

I did the opposite. I made the correct move by stated clearly to all parties that we had agreed upon timelines and that they have been kept. The idea of introducing new components not part of the original design at such a late stage of the phase was outright idiocy. I pride myself in my completeness of the whole process and will not let a failure to plan on someone else's behalf negatively affect the quality work I strive so hard to ensure. Any changes need to be reviewed to ascertain what side-effects might be caused by their inclusion (especially into a more mature codebase at this point) and not to mention the quality/testing cycle which obviously wouldn't be possible due to time constraints.

What I am trying to get at is that I learned that for the sake of professionalism, quality and ethics, one must have the ability to say "No" when others fail in their planning/design. After all, the requirements gathering phase is when a competent Software Engineer brings to light questions that would hopefully coax such ideas from the requirements 'givers' if you will. It is our duty and creed to help our clients both internal and external to bring clarity to their actual needs as many times they are unsure of the specifics until discussed with others.

So I say unto aspiring Software Engineers of the future: People look to us for accountability, and part of that equation is keeping the other variables in the equation (team members, requirement providers, planners, designers and what not) accountable to the process, even if it means telling someone 'No'. Provide your reasons, and hold steadfast as these software engineering processes exist for the benefit of our projects' quality and overall success, not for the sake of being friendly or 'helping out' someone who failed to do their part in the overall planning and execution of a project and/phase thereof.

New Projects, and how to handle the juggling act that ensues.

2009-03-10T22:48:00.005-04:00

Today marks yet another year in which I've been aboard this mortal coil as it circles our solar system's centre point. So as I sit here watching to see if the remake of 'The Day the Earth Stood Still" is a much of a car wreck as has been stated and re-stated for the past few months, or if it will end up being one of those guilty pleasures. More so on to the point of this most recent update:

We in the United States of America are currently experiencing a rather nasty economic downturn/recession due to unregulated mismanagement of the country over the past many years and as such are having (as a country) to deal with roughly one in every nine persons of working age being unemployed. Yet in all of this unfortunate turmoil as brought about by the economic calamity, I find myself inundated with more simultaneous clients and projects than ever.

While I have managed multiple projects before, it was usually with the benefit of a staff. In this instance I find myself as the sole Engineer on the job. I enjoy being the centre of a given project, especially focused projects with clear requirements as they encompass the most fluidity in terms of project and process flow beginning to end. In this case however, due to a recent spate of decisions by several key individuals in charge of my various client entities, there has been an influx of new projects, primarily new ventures and re-launched (and recently acquired) web entities.

These are all primarily fashion and lifestyle media groups and magazines and while they all have a similar bent to them, the amount of design behind the scenes differs greatly from one entity to another. I find that the sites in which there is a solid plan are to most enjoyable on which to work because this is a start, middle and end whereas projects lacking any real direction simply waste a considerable amount of time, effort and never seem to measure up to properly designed sites.

There are several major concerns here when juggling this many projects, but thankfully there are just as many solutions:

Problem #1: Keeping focused on a specific code base.

Solution #1: Thanks to the beauty of multi-windowed environments, comments and code versioning systems such as Mercurial (Hg), Subversion or Git, we can save our place, with comments and safely return to them at a later time with notes on where we left off. A bigger part of the solution here is a proper code editor that focuses on all elements of a project in a shelf or sub window. By utilising an editor of this type (such as TextMate for OS X), we can keep one window open for each contracted project, each with its own attached drawer and as such simply minimising a given window completely puts a specific project out of sight and out of mind.

Problem #2: Estimations and management of many projects for multiple clients.

Solution #2: Give only rough estimates and keep in mind any potential work which may or may not come into the fray. There is also an amazing tool which only requires a writing surface and the appropriate complimentary writing implement (paper & pencil, whiteboard and a dry erase marker, etc.) The infamous GANTT chart, which allows for a wonderful representation of project portions/phases and time phases. One should not be afraid to over-estimate their time frames for a given project and/or portion of a project. One bit of wisdom which was learned after having it repeatedly played out by both myself and others is that men (not as much as on the women's side of the equation) generally underestimate by a factor of 3. If it is assume that a guy honestly believes that a project with take x minutes, in reality the time frame would be closer to x³ minutes. Gauge oneself over time and projects and adjust the factor accordingly, however start with the aforementioned suggestion as it has proven accurate in my experiences and that of others whom I know personally and professionally.

Problem #3: How should one handle priority requests and/or 'must dos' such as time sensitive changes or additions necessary to client business function regardless of assumed actual worth/priority.

Solution #3: This is much simpler than one would expect. When discussing the issue with the client (wether internal (if a salaried employee and dealing with internal 'customers') or external) point out that this will be shifting the entire project timeline by the time required to complete this unscheduled emergency. Now this isn't always practical or appropriate such as in situations in which a previously scheduled change was turned into a 'must do'. In situations such as these that portion of the scheduled project can be removed from ones GANTT (or other scheduling) chart(s) it their entirety.

There is one caveat with this approach; when removing a project portion due to unexpected/unplanned rushed completion, always add in additional time when shifting the remaining pieces of the project(s). The primary reason for this is simply because additional time should be made available regression testing and/or additional testing due to the reduced time frame and unscheduled manner in which said changes were made, one in which a great possibility for error introduction was more likely. The other major reason for doing as such is simply to protect oneself when another one of these situations occur. It would be foolish for anyone to think that if this happens once, that it is unlikely to occur again. Generally there are those who have little emergencies all the time, and those who 'suffer' from such events rarely if ever. If it happens once, be sure to assume it will occur again as it is usually the result of bad planning or communication somewhere between the engineer and the end customer though more oft than not it is a middle-manager or a sales person making promises which had they been honest and/or considerate of others, they wouldn't have made in the first place.

Handling multiple projects can be easy if one enforces certain rules (albeit with a willingness to bend as long as attention is paid to making adjustments so as to not allow oneself to be run into the ground by continually pushing more amounts of work into a time frame never intended for said work as such.). The importance of communication is key in this instance as expressing realistic time frames in the first place would resolve many of the ugly situation which sadly arise in real world environments on an ongoing basis.

Guiding the Future Generation...

2009-02-13T14:51:00.002-05:00

This is more of an announcement than a standard codedevl.com content update, of where there will be one in the upcoming week.

On 09 March, 2009, I will be partaking of the 'Career Week' activities at Central Bucks East High School by serving on a panel along with other professional in various fields of Engineering, Mathematics and Technology as a means of not only sharing what it is we do but also answering posed questions by the future minds of our respective fields.

I feel it is a very important responsibility of experienced professionals to better server their community (both locally and the whole world in the large scheme of things) by passing on what knowledge one possesses to the following generation(s) to ensure that the gain wisdom proliferates through the ages. I hope other readers of codedevl.com take an active role in this endeavour as well, and if so please feel free to post about it either here or on your respective sites.

Dealing with Horrible Legacy Code

2009-01-22T16:05:00.004-05:00

I know, I know.. it has indeed been a while. What can I say, I've been busy with work. Even though the US is deep in a recession so bad that Microsoft and IBM are executing mass layoffs (Microsoft's ever), there are those of us; especially on the Unix side of things (I gather Linux users as well) who are swamped with new projects.

As many readers would know, I have for the past year and a half been offering my software engineering services to an international publishing firm based out of New York with branches in Pennsylvania and Japan. Yesterday I was in Manhattan for a meeting of introductions to the individuals with whom I would be coordinating on not one, nor two nor even three projects, but four new magazine entities. This now brings my overall responsibility in terms of publications I handle to a clean half dozen.

I'm glad I'm not in the Microsoft world (for multiple reasons not to mention primarily because I refuse to work with junk and this includes any MS OS), but for the reason that with all of these layoffs, a mass amount will be MCSE's and VB/.NET programmers, architects and engineers. This does however segue into my first point (trust me, there is a relation).

In my most recent project, a sister publication of it actually needed some work done to their rss feeds. Apparently this was first and foremost to fix a broken rss subscription page (where one could select which 'feeds' to follow). This problem had been present for over a year from what I've told, and it was so bad that the page itself was throwing a PHP debug page when accessed. This is wrong on many levels, most immediately that the debug mode was still on in the server configuration (the other errors being that they were using PHP, and allowed something to go on for over a year, broken.)

Not wanted to reinvent the wheel as well as having a sense of right and wrong I contacted the original developers of the software and let them know that since they were the only individuals with write access to the entire group of applications involved (not to mention this was custom built by them), that it was their fault 100%, and their responsibility to fix it, and quickly at that. As a side note, I had been informed by my client that they had made repeated requests to said developers about this problem for over the past year and were informed that it would take 'a lot of time', and that they would be billed accordingly. Long story short, I got in the developers faces about professionalism, the fact that had they any procedures in place for regression testing when changes were made and a proper set of document and qa tests, this problem would have been squashed the moment it was introduced. Three hours after sending my well crafted letter, I received an email back from said development house that the problem was rectified, all is working and that there was no charge. No charge indeed, I wouldn't accept one if they tried as it was entirely on them.

This brings me on to point number two as I could rant about the prior issue if left to my own devices. My continued disdain for the overwhelming use of PHP. I know it was a great idea that filled a niche when it was created, but it truly has grown to be something rather heinous: the sucessor to visual basic. I say this because as with VB, the purpose was to make creating software in said language possible, even 'easy' for the 'non-programmer'. This is a simple point to remember so I won't waste additional time stating it. Non-programmers shouldn't be programming, period. You either are a programmer, or you aren't. If you aren't, you have no business behind the keyboard writing code for anything that ever goes into use in a company by anyone, including yourself. Engineering isn't a child's game and it requires discipline and continual study and exercising of one's skills. We won't pretend to do your job, you don't pretend to do ours as you are only making things worse.

This came about because while looking at the code to find the original rss problem (which was fixed without having to write any code in that monstrosity), I became disgusted at how hackish the whole application was. It was guilty of all of the following and more:

- ambiguous variable names

- includes of code snippets where objects should have been

- nested structures 4+ levels deep

- very few if any comments in the code

- very little meaning in those few comments that actually pass as informative.

- non-sensical file hierarchy for modules, includes, etc.

- hardcoding of parameters in both equality tests and branch based if statements.

& much, much more.

It is enough to make one partake in an involuntary protein spill reflexively. The good news of it all is that this old code base (I use the term code VERY loosely) will be redesigned and re-implemented by me and I can guarantee (because I DO guarantee my work) that it will be faster, cleaner, easier-to-use, easier-to-upgrade (including maintenance) than the existing system and will be constructed in a considerably shorter period of time.

It is times like these where I'm glad that these other places exist. It is hard to not look good when everyone else is so hideously bad. I just feel bad for the poor companies and individuals who utilise these companies' services.

recent job, nasty code built hackish bit by bit, quickly

no comments

php (*the open source equivalent of Visual Basic*)

New Projects & Version Control Systems

2008-12-05T20:34:00.007-05:00

It has been over a month and a half since my last entry and I apologise for the delay. I have been working tirelessly to finish up my primary design, development, implementation and maintenance functions on what has been my primary project for the past thirteen months. I've been doing this so that I may jump head first into my next project, which while not being a 'huge' undertaking is big enough. By big enough I mean that doing well at the project will land me the role of redesigning a major site from the ground up into the Django framework.

For the past 13 months I've been working heavily in the world of Django and find myself absolutely enamoured with it. I have designed a considerable amount of applications for Django, though none of them are released to the world because they are the product of a contract. My field of expertise was never in that of online applications and/or frameworks so it is stil a new world for me (if we exclude the nine years running a twelve line bulletin board system on a heavily modified Amiga).

I've always been happiest working in middleware and engineering backend systems, though I have to say that I'm finding a certain level of pleasure from the results of my front-end work. When i wrote backend systems, the only others who could appreciate said system(s) other than myself, were developers privy to the project. On frontend systems, there are actual users who I would like to think 'benefit' from my designs and implementations. It is nice to know from actual users that your work is appreciated. Call it ego stroking, or call it what you will but I find that it does inspire one to keep pressing on regardless. I happy to be doing these projects and as soon as it is launched, I'll be happy to post about it here.

This brings me onto the second purpose of this entry, my new favourite version control system. In the beginning of my experience using version control systems back in the 1990's, I simply used CVS like the rest of the world (sans those lucky enough to use Perforce). As time and technologies advanced to newer and better systems, I followed along and moved up to Subversion. Subversion was a well done upgrade for CVS users and easy enough for the uninitiated to learn. I used this most recently when I did work for Curlington Boat Factory (name changed to project myself) writing their point-of-sale returns authorisation/queue system in Python for four hundred some odd cash registers. This worked our quite well despite the fact that the software house for whom my partner (at the time) and I were contracting weren't able to provide the subversion server on their machines until we were ⁷/₈^ths of the way through said project. We ended up (very early on mind you) taking matters into our own hands and setting up on my partner's server at his apartment. This wasn't looked upon highly by said software house, but any CVS on any server regardless of not being in control of the software house was far better than no source control at all.

Next we come to my brief stint working for a OCD kid who started his business at the right time with mom and dad's money, but due to poor decisions on his behalf watched it dwindle in popularity, further plagued by poor management and attempts to treat a small business as if it were a conglomerate thereby sealing its fate with a tender kiss on its cheek. I thankfully left the company before the owner went psycho and let go of all the talent in a horribly vicious manner. Before all of that ugliness transpired, I went forward with trying the newest and brightest trend in distributed version control. I am speaking of the one and only 'Git', championed by a certain arrogant (albeit brilliant) Finnish kernel programmer. There was an immediate joy in using Git and I have to say that most striking feature is the blazing speed when dealing with a large quantity of files. I established all of the existing software base for said company (over ten years worth) into its first repository, utilising Git. Yes, for over ten years, there was no VCS in place. Git really did shine in this role, though I am pretty sure that due to myself and the system administrator not longer being there, cob webs must be forming in the places where Git once speedily did its work.

Let us fast forward to my newest discovery (if you can actually call it one as such). On this newest project which I just started today full time, I have been doing administrative setup work for the past few weeks on and off in small gaps of time as they availed themselves to me. The normal deal of establishing a dedicated server on a FreeBSD host (as Linux just will not cut it for me even though I've been using it since kernel v0.99d), along with all the necessary bits. Once the development languages, utilities, database and web servers were in place the issue of VCS came into play. For this time around I decided that Git, while great for many projects doesn't seem as pythonic a package as I'd like. Using Python long enough really makes one desire beauty, power, simplicity and consistency in all of their tools. This brings us to the most pythonic vcs of them all, Mercurial (known simply by its periodic table element, Hg). Mercurial, like Git is also a distributed version (revision) control system. Easy to setup, easy to use and highly recommended. I'm not going to wax poetic about the differences between these systems as they all serve a purpose. What I will do is state very clearly that Mercurial feels the most natural, works rather well and is quick at what it does. Your mileage may vary.

Until next time...

Django Projects Galore and Vile Ethics of other Coding Firms..

2008-10-16T19:51:00.006-04:00

It has happened yet again. I've been brought on for another Django project. This time it is about taking an existing site for yet another magazine publisher and converting their Wordpress driven site into a real full-blown site complete with blogs, forums, user profiles, dynamic main page content, complete customisation from within the framework and included applications and ultimately a site in which a developer is not needed for day to day changes.

As it exists, this publication is an off shoot of their primary magazine. A magazine whose website was written and managed by an outside from that I believe coded the entire site so as to require additional invoicing and servicing for all but the most minute changes. This is a disgusting business model and one with which I've had the misfortune of experiencing whilst working as a sub-contractor to a sub-contractor for Burlington Coat Factory.

The H-1B Visa Project Manager who wasn't too fond of me because I don't believe that coding in dress attire and/or a tie makes someone a better worker (to the contrary, i will NOT wear dress attire for day to day work as it is a pointless expression of old brick-and-mortar mindsets). He also was the first time that I was reprimanded for having an eloquent solution that adapted automatically to the growth needs of the end-clients database/system. I wrote the software to handle dynamically gathering and sequencing additional 'like' fields as they were added to Burlington's transaction schema. The way I designed and wrote the software, the MOMENT the schema changed, my software contributions would immediately include relevant changes, without a restart of any of the daemons I engineered. I was told that the reason why i shouldn't have done this is because the sub-contractor for which i was writing this code could then go back and charge an exorbitant amount of money each time minor changes were made. This disgusts me, and I find it ethically wrong.

I am an engineer and work independently by choice as I can first and foremost hold myself and solutions I produce, to higher standards; delivering what my clients want and need, not solely based upon what they say they want and most definitely not building them into a corner for profit over common decency and professional standards.

Once the project has been completed, I will be quite happy to share the url(s) with CodeDEVL readers.

Django 1.0 has been Released, Film at 23:00.

2008-09-10T11:14:00.002-04:00

I know that it has been a while since I have last posted, but I'm not one to post meaningless empty ramblings on a regular basis. I just want people to know that I'm still alive and will still be posting when I have something worthy of your time.

I will mention in brief that Django v1.0 has been released and we are all thankful to BDFL's Adrian Holovaty and Jacob Kaplan-Moss for their amazing efforts in making this release come to fruition. I would also like to add that the biggest 'gotcha' between .96.x and 1.0 is in the standardisation of certain db api arguments. maxlength has become (more aptly) max_length. There is also now a DecimalField type which can be used rather than the less accurate (for monentary purposes) FloatField. Read all about it at the Django Website.

Finally, for those interested, I have also started another non-computer related blog over at Bucks Bicycling, a site related to vehicular, commuter, recreational and sport cycling. I'm currently working on a fixed gear conversion of an old cheapie AMF Roadmaster Scorcher as well as a 1985 Schwinn Sprint road bike.

I will be posting shortly pending upon the official status of the newest Django 1.0 based project on which I've been secretly working.

Till then..

In defence of the lone coder archetype

2008-07-18T12:46:00.004-04:00

All too often these days we see companies and methodology evangelists touting the system du jour whether it be Extreme Programming (XP/Pair Programming), or Agile as being the "One True Path" to coding enlightenment. All other be damned is roughly what said mantra translates to in common speak. We're told to beware the engineer who works alone in a dark back room for weeks on end. We're told to such a thing is heresy against the gods of modern application development.

We're being lied to by the methodology evangelists. I'm not here to down speak any of the other methodologies currently in use for software development. I am here, however to point out the benefits of the 'lone engineer' (not to be confused with the lone gunman). Lets set a few things straight though.

A coder with little to no professional experience in the field is not the optimal individual for this kind of setup. This is more for a seasoned professional who has at least been a team lead on several projects from conception through maintenance phases. I'm not saying it isn't possible to pull it off without significant experience, but I wouldn't place bets on such an individual succeeding at the whole task at hand in said company.

This kind of environment requires a disciplined engineer. We're talking about someone who knows the questions to ask, and how to dig deep to find the true needs of the client(s). This also means that the engineer needs to stand his/her ground when it comes to setting a solid schedule for phases of the project(s). There is room for variability in terms of time frames for each phase, but that the plan must be laid out in a linear fashion. This is engineering after all, and one doesn't plan to build the rooms before the foundation is laid.

Agile methodologies are more akin (though not parallel to) modular housing construction. Individual sections or units can be build simultaneous and changed (to a certain extent) by separate sub-teams. Whereas the lone engineer mentality is more akin to traditional construction in which the design is finalised, the foundation is laid and construction occurs in layers from the bottom up with customisations being generally last.

This isn't to imply that software built in this manner cannot change or adapt in a timely manner, far from it. Seasoned engineers/developers understand that the only true constant is change. We constantly work on new ways in which to design flexibility and mutability into our systems regardless of the specifics. This however just goes back to one of my earlier points in that this requires someone who isn't wet behind their ears. You can only know and plan for the unexpected via flexible designs after having cut your teeth in real world projects, and by faltering. Everyone makes mistakes, and it is through these mistakes that we grow and better ourselves. I'm not implying that senior level engineers don't make mistakes, I'm just pointing out that their success to failure ratio is pretty strong in favour of the success side.

One of the key benefits of the lone engineer methodology is that focus can remain solid with no deviation due to intra-coder/intra-team conflicts. And while this can at teams be a negative, overall it proves itself beneficial towards the ultimate goal, a finished software package/eco-system designed from the ground up to benefit the requisitioner(s)/client(s).

The issues of coding standards still must be kept, however there is definite consistency when only one individual is involved. This is also a liability as said engineer must have strict standards, commentary and documentation from beginning to end so that in case of any situation rending the engineer on the project incapacitated in any form, another could come in and continue with minimal delay. These are issues which affect other methodologies, some more than others.

There are downsides as well though. There are no direct peers upon which one can depend in times of need or collaboration. There are no peers to assist in code review sessions, meaning that the QA of any project must be proficient at testing, and enforce strict recursion testing when any changes are made to a product in production as QA becomes that final line of defence against human error. The reality is, no usable (as in serves a real purpose) piece of software is bug free and to think otherwise is the sign of a fool. What is realistic is having a system robust to handle errors when they occur, even if that is infinitesimally infrequent.

I'm getting off track here. My point is that in this newer, more extreme era in which coding fundamentalists believe they possess the one-true-way of coding and all others be damned, we must step back and realise the grave miscalculation they are making so boldly. After all, those methodologies weren't what were utilised to get us where we are today, nor were they even thought of when some of the staples of our art were invented. This doesn't mean that the next great piece of software or language won't be produced in such a manner, as it/they may. It means that we as professionals shouldn't be so narrow minded with tunnel vision when approaching different methodologies in an attempt to find which works best for the project/company/industry at hand.

SimulaE Cartography Program - simulae-kaart.py

2008-06-26T21:37:00.004-04:00

As a quick follow up to the previous entry regarding rooms being a void and not an object, I can happily announce that the first working alpha of simulae-kaart has been committed to code this evening.

The function of this bit of code is simple: Produce the necessary wall/barrier objects needed to create the voidspaces we call rooms.

The current working codebase does the following already:

* Allow graphical design in a 2d environment utilising unicode representative tokens.

* Returns Multidimensional Lists designating literal start & end points of wall objects

* Allows for walls in traditional cardinal orientation (north-south, east-west, nw-se & ne-sw)

* Also allows for arbitrary wall/barrier positioning at any angle (true 360 degrees).

* Default scale based on cubic decimetres, variable scaling coming soon.

Upcoming functionality to be added:

- Auto population of a given map grid

- Auto insertion of portal objects inside any giveen barrier/wall object.

- Automatic map scaling down to the smallest micro and largest macro levels

Stay tuned for further information. If anyone else is interested in signing up for future beta

testing, I can be reached at this domain, under the email account of eric.

-e

Simulae3 Update: Room Object? What ever do you mean?

2008-06-05T22:50:00.003-04:00

This is just a simple, quick update to let it be known that the issue pertaining to how to accurately represent a room in Simulae3 has been resolved. I spent about an hour with a blank book of graph paper and pen poised in my hand and thought about the problem till the following realisation hit me:

Rooms are an abstract, a void. They only exist as a concept without substance to us. They are the empty space created by barriers, some of those barriers contain portal objects (e.g. windows, doors, openings). It is using this logic that the next piece of Simulae3 can be designed.

SimulaeKaart.py

A simple cartography-based program (kaart) being the word for map in Nederlands (Dutch). Physical space will be represented in 10 centimeter square grids (though variable map design may be possible). The whole point of this is that in the real world, we use GPS and surveying to accurately place physical locations, Simulae3 will be no different.

The other quick note is that the concept of rooms are also knocked out in that a room knows not of its purpose, it is only by human reasoning and deduction that a particular enclosure/void/"room"'s purpose can be ascertained. If you take an empty house with two rooms near the room with the stove and dishwasher, how does one know which is the dining room (if either). One doesn't, one chooses to assign that role by the placement of the appropriate objects (appropriate to a dining room that is) within said void.

Simply put, this conundrum has been resolved and the next phase of design and coding can continue.

Migraines: A common misunderstanding

2008-05-28T00:22:00.004-04:00

Mi - graine: (n)
A headache characterized by throbbing head pain, often greater on one side; may be preceded by a warning (aura) and accompanied by nausea, vomiting, and sensitivity to light and sound; in rare cases, weakness, language problems, or other neurologic disorders are associated with migraine.

Over my years of coding I've endured what I thought were migraine headaches, not uncommon to those of us who spend waking moment after waking moment staring at multiple screens as part of both work and hobby. I say "thought" because up until this past weekend, I was sure that the harsher headaches I had endured qualified as the infamous 'migraine' variety. I was wrong.

On this past Saturday, I had the pleasure of seeing one of my best friends (and also my best man at my wedding) tie the knot with his sweetheart (both are coders by trade as a sidenote). The day was perfect, the weather was wonderful (as it was an outdoor ceremony) and all was well in general. I on the other hand aside from coping with sciatica down both sides of my body (a relapse of a previous L4/L5 left disc rotation), awoke with what I thought, was one of my annoying 'migraine' headaches. I took Excedrin Migraine along with Vicodin for my other-pain and proceeded onto the wedding with my wife. The headache didn't subside, regardless of a second round of 'migraine' strength medication.

The first lesson to be learned here is that Excedrin Migraine (I'm pretty sure any over the counter "migraine" medication as well) , while great for 'bad' headaches, is lightweight against 'textbook' migraines (more on this later).

After the wedding was over and we made the drive home (hellish for me as my headache seems to have grown from annoyance to throbbing), I started to feel dizzy with a bit of nausea, yet did not succumb to an involuntary protein spill thankfully. I ended up retiring fairly early figuring that my 'migraine' was just particularly bad and was exacerbated by the fact that our table at the reception was next to the live band.

Sunday morning arrived and that horrible headache was still present. I took two vicodin and several aspirin in the hopes that it would finally kill the beast within but it was all for naught as much to my dismay, the headache only soldiered on. I spent much of the day in a narcotic (vicodin) induced stopor in an attempt to mask the pain which was at this point pressing heavily on my head, and would remain this way the rest of the day into the evening when I retired early in an attempt to once again let tomorrow come without the now 36 hour headache. Little did I know that this was about to get worse, much worse.

Memorial Day arrived, complete with plans to go to my in-laws for a barbeque and family goodness. 04:00 on the clock and I arose from my sleep to the udder shock that the pain was not only existant, but worse. I quickly (well, as quickly as I could) went downstairs to take three Advil (I was now out of Excedrin Migraine), and then return to bed, hoping this was finally the end. The time was 08:00 according to the clock and I was expected to rise. Problems. The headache was still there, and it was rather angry with me. Outside of glancing to see that it indeed was 08:00, I had to keep my eyes shut, the dizzy feelings, nausea and pain from the light (through the blinds, mind you) was unbearable. It felt as if my head had been mounted between the the grips on a vise. I at this point, took the decidedly un-male action and asked my lovely wife (and child) to get me to the Doylestown Hospital Emergency Room. Something was obviously wrong and I was quite worried, not to mention blinded by the pain.

After what seemed like an hour (when in reality it was half of that), I entered the ER and was promptly thrown in a wheelchair, tagged and admitted to ER room #5. At this point the pain caused me to writhe in pain in my open-backed hospital gown in my new metal bed. Another 10 minutes came and went, along with an increase in the pain until one of the nice ER nurses (and a doctor I believe) tapped my arm to place an IV line, which was utilised shortly thereafter to inject a medication (a narcotic of which I'd never heard) that immediately overpowered the pain with a feeling of numbness. This enabled me to speak somewhat lucidly to several nurses as well as a doctor about all of the aforementioned backstory leading up to this point.

First comes the catscan at this point to check for abnormalities. None found. Then the blood tests, no oddities either. ER Doctor then comes to the conclusion that a LP (Lumbar Puncture) was the next logical step. I consented, though it was not to be, after a considerable number of jabs and sharp pains, said doctor gave up and contacted a Neurologist who would come in later to do said LP.

The pain started to return and I was given another dose of said magic narcotic. All remained well for another 90 minutes or so (at this point, I've been in ER room #5 for approximately 6 hours). During this time the Neurologist arrived and I spoke with him and allow him to have a crack at a lumbar puncture. Needless to say he was an expert at this procedure and was able to withdrawal 4 vials of the clear cerebrospinal fluid from my spinal column. He then surreptitiously disappeared for what seemed like hours.

It was at this point, my pain surprisingly started to return, first on the right side of my head, but then started to migrate over to my left side as well. The pain became so severe that I could tell that the lights were on in the next room over (separated by a curtain), even though I had a folded over pillow case upon my eyes, with my hand over that. The lights in my room had been out since my arrival as they were painful, even with my eyes shut. I felt as if I were going to tear the metal sides of my bed clear off. I suffered like this for another 60 or so minutes as we were awaiting the results of the spinal fluid from the lumbar puncture, and it was already stated that I was given an extraordinarily large amount of narcotics already and they worried about providing anymore until they knew more about the cause of my pain.

After all was said and done, I was told that this whole episode of the worst head pain in my life, was a 'real' migraine. I was told that they would provide me some additional medication intravenously before being discharged which would 'kill the headache' this time. I was also being given more subscriptions, one for vicodin (as if I didn't have enough for my back pain, which I already try to avoid using), but a medication which i had never heard of before, specifically meant to stop migraines at their onset. That final migraine killing injection came, along with a complimentary spewing of my stomach contents shortly thereafter and I was on my way to being released. I was informed by the doctors that there were a few things I could do to keep migraines at bay aside from the medication provided.

"Caffeine, Caffeine, Lots of Fluids, and of course, more Caffeine."

I'm thankful to all of the wonderful nurses, doctors and specialists who provided help to me after suffering what ultimately will be remembered and hereafter referenced by me as the 60-hour migraine. I will never use the term "migraine" mistakenly to mean a "severe" or "bad" headache as they not only aren't in the same ballpark, they're not in the same league, region or country.

I decided to share this with everyone in the coding community because I'm sadly sure that this will happen (if it hasn't already happened to some of you) again, and to others. I hope that having read this, those who find themselves suffering one of these 16 tonne behemoths will not wait an exorbitante amount of time before doing exactly that which I did, contact professional medical help as quickly as possible. No one should have to suffer that kind of pain any longer than it takes to realise what said pain was; that being a 'real' migraine.

Wishing everyone good health.

Eric

Simulae3: A Testament to Socratic Design.

2008-05-21T00:34:00.004-04:00

Socratic Method: the pedagogical technique of asking leading questions to stimulate rational thinking and illuminate ideas.

When I first started working on SimulaE (long before it was even referred to by the aforementioned name), it was a solo project. This isn't to say that I haven't written all of the code from day one to this very moment, because I have. I can however say that the design portion of its various incarnations wouldn't have evolved in the manner which they did were it not for the diligent use of the Socratic Method.

My earliest versions of designing the Simulae virtual world simulation suite of libraries and what not were designed and written by me in response to the original interactive fiction/text adventure engines, then consequentially MUDs (Multi User Dungeons). The proof of concept of building a better designed mousetrap was simple enough to bring to fruition. This took place over years, dependent upon my free time and interest in furthering what was simply a flight of fancy for me from my programming youth and Zork playing escapades.

What really became apparent was when I worked for another company and had the pleasure to work with a very intelligent individual by the name of Tim. He is a systems/network administrator as well as a capable coder though the latter is not his primary goal, nor role professionally.

Tim was interested in my Simulae project and as such I found a kindred spirit through whom I could interact by applying the aforementioned Socratic Method. Through a constant back and forth barrage of theories and examples along with postulates about the hows and why virtual components modeled after reality need to be viewed in a certain light, we would come up with a whole new understanding about the direction of the project.

It was during this time initially working together that the present tense English Parser component (parser.py) came to be realised and produced. It took a total of seven point-releases to go from simple noun verb understanding to parsing complex compound sentences with a massive understanding of 45,000 adjectives, 9,500 verbs and multitudes on various parts of English speech. This series of productive success if anything re-enforced the validity of this methodology in the realm of software design.

It is now though, with this in mind that I have taken utilising this method to the next level and enacting it with completely uninvolved individuals (uninvolved in the sense of the projects topic and internals). In the past several days Simulae3 has emerged from the bowels of my TextMate application. The code is simple, shorter and far more capable than any previous incarnation and things are moving forward at a great clip.

This brings me to the current point of interest and a call for assistance for anyone willing to get into sometimes heated dialogue about object models. The object model system is based around the three basic SimulaeObject types. The only piece of the puzzle still causing an issue is the matter of Portal Objects (entranceways between other container type objects.)

For the sake of argument, just look at it this way: A room is a container, that leads from one room to other rooms of 'greater' building enclosure. A set of lips in a Mobile Object (hereafter MOB) (e.g. 'actor' in OO/UML terminology) is simply a Portal Object to the mouth of said MOB. A window is simply a portal between the outside 'container' object (in this case a root SimulaeObject), and the room in which our Actor/MOB would be in (to see said POB destination from said perspective).

I need others with whom I would be able to work out ideas so that this conundrum can be resolved and the next phase of Simulae can come about for code release and testing. If anyone is interested, contact me at this domain via my email address: eric

I am going to finish on that note being that due to medical reasons dealing with my sciatica, I ingested a full dosage of two Vicodin tablets (as per my primary physician), and as such I'm getting ready to crash hard. I hope to hear from some of you in the hopes of moving forward, but I'd like for Tim to give me a call in any case so that I we can bounce some ideas back and forth on these issues.

SimulaE - Model Update

2008-04-27T22:10:00.003-04:00

I've made mention of my virtual world simulation project on multiple blog entries, most recently related to Ruby and making a rewrite of the existing engine in said language to test out its applicability (the language not the simulation), which by the way I found to be the lesser language for this kind of application, but I'm not saying anything about the language as a whole. Either way, onto SimulaE, which after all is what this post is about today.

I have been rattling my brains (and occasionally those of my friends) regarding the basic SimulaE Object model, which up to this point has served its purpose. Though the time has come for it to evolve. It can implemented in a simpler manner and I have known this in my mind all along though it hasn't been an issue in the process of designing the parser which has for the most part been satisfactorily completed. Now that my focus has returned to the object model, I feel it a fine time to share that update thus far. Comments are always welcome and most are appreciated.

The fault before was that I broke the objects into the wrong sub classes. Originally I had the parent Object class, and subclasses for Room objects, Exist Objects and Person Objects. This is a horrible idea and leads to unnecessary complexity.

The newest model:

Object (super class)

MovableObject (isa Object)

PortalObject (isa Object, isnota MovableObject)

PortalObjects, hereafter POB are a much more dynamic version of the previous "room" objects. A POB behaves in the following manner(s):

1. Object(s) enter into the object containing said portal.

2. Exits an object when contained therein.

3. Can exit (when specified) to a specific object, though by default exists to the parent container object.

If a MovableObject, hereafter MOB, is not contained within the same container as the POB, POB leads into the container.

If the MOB is contained within the same container as the POB, POB leads out of the container.

By working in this manner, we ensure that the simulation object model more closely mimics the real world, whilst still allowing for exceptions to transpire for non-real world based applications of this group of models as well as anything they may be working on at CERN in Switzerland which breaks our current understanding of physics.

I haven't had time to implement this new set of models yet, but as I write that code, I will be posting the revised Python source.

Quick Django Tip: Dynamic Application Object Retrieval

2008-02-24T23:44:00.004-05:00

In my recent django adventures I needed to introduce site-wide search functionality and in the process of doing so, encountered a small roadblock towards doing so. Apparently due to the nature of Django's API for db interaction (as of the last stable release version), there is a limitation as to the use of python variables in API calls. I found this to be a hinderance, but only for so long.

The follow code snippet was something I whipped together which by utilising Python's 'eval' built-in, overcame the aforementioned limitation regarding the API's ability to interpolate native Python (e.g. non-django explicit) varaibles.

Things to know to understand the following example:

search_input is a list of cleaned and pre-processed user-driven terms, split into separate expressions, (e.g. ["dynamic langauge", "agile", "programming", "paradigm"]).

search_schema is a dictionary in which the key is the django model/class through whose objects we are attempting to search, and the value is a list of specific model attributes to attempt said search. (e.g. User_Profile : ['firstname' , 'lastname', 'address_1', 'bio_info', 'favourite_books'])

container_xref is a simple alias mapping for the actual django application names to our internal references inside this search code base. Obviously this whole bit could be written without said setup, but for readability given the scope of the actual application involved, and the fact that I was not searching simply a few static fields in one django application, but several dozen fields through about two dozen separate applications, this container_xref dict was appropriate. It is through this mapping dict which we place any matched object results (so as to not waste any additional space via unnecessary list initialisations.) for eventual results generation.

Note: the key "total_results" in the container_xref was a simple means of keeping track of overall search matches, rather than relying upon the Django templating engine (view) from doing work responsible from the processing (controller) perspective. In retrospect, there are better ways this could have been handled, and in future point revisions, this will be addressed.

------


for search_string in search_input:
  for application in search_schema.keys():
    for attribute in search_schema[application]:
      code_to_eval = "%s.objects.filter( %s__icontains='%s' ).order_by('-id')" %       
                     (str(application), str(attribute), str(search_string))
        try:
          eval_results = eval(code_to_eval)
          for eval_result in eval_results:
            if eval_result not in container_xref[application]:
              container_xref[application].append(eval_result)
              container_xref['total_results'] += 1
        except Exception:
          ### Case specific exception handler types, assignments and resultant actions 
          ### specific to each application in which the above is implemented, go here.

-----

As can be seen from the above, simple inline substitution proceeded by evaluation of said string results in post-compilation dynamic search functionalities within django, addressing simple problems one might run into with the existing API which will most likely be addressed in future versions.

Your results may vary.

Eric

Ruby: Somehow I overlooked this Gem of a Language

2008-02-19T13:51:00.006-05:00

About 5 years ago I started looking into a language that prior to it's "Rails" fame, was lesser known and even lesser utilised. I tried it a bit and found it leaving me wanting more. I've kept tabs on it over the years, reading the tutorials and writing several quasi-AI experimental applications for my SimulaE research, but I ended up being enticed by Python, a language which I stand by, including the wonderful (but until recently unused by me) framework Django (Python's Rail's equivalent, focused on Publishing).

I've programmed professionally using Python for several contracts/years now and find it quite enjoyable. In fact, I'm currently coding specifically in Python for Inkedmagonline.com, but that doesn't mean that I don't continue my personal exploration and education for both personal and professional reasons. I decided to re-experience Ruby by picking up the hallowed PickAxe book and giving it another honest chance. I'm glad I did.

I believe that Python, and the values espoused in Tim Peter's "De Zen van Python" (The Zen of Python) (my copy just happens to be in Dutch, otherwise I'd post it for others) have helped me to look at Ruby in a different light. There are some key differences in the two languages, but I can see now the inherent power in Ruby that I was overlooking before. In fact, some of those key pieces, syntactically as they were which make Ruby so enticing this time around are the very same 'features' I feel are missing in Python. It only took me working in an environment with situations where said language features would prove the best solution to the problem(s) on hand for me to realise it.

I am not going to spend time detailing all of the specifics, though I may mention one or two nonetheless. I'm more so bringing this point up so that others might be reminded that giving something new a single chance might be to your own disadvantage. After all, I didn't like Python the first time I tried it either. I think it is partially a matter of how we grow as developers that allow us to know what we're missing, that same spark of realisation that gives us the "a ha" of relief when we find it hiding in a new language, programming methodology, etc.

What brought me back to looking into Ruby a second time is of all things, Smalltalk. The whole "everything is an object" concept is nothing new to me, or to programming languages. However in dynamic strongly typed languages, it is. More importantly is manner of how even rudimentary objects such as integers, floats and strings are treated in Ruby. They have methods which can be both called using the standard instance.methodname call format, and have their standard methods overridden. The second being something far more wonky and kludgy in Python (and a non-option in perl).

The fact that key methods are instance based such as "len" or "length" for example makes a world of difference for consistency. It speaks to the overall design that "Matz" (Yukihiro Matsumoto creator of Ruby) had in mind during the planning phase. In Python, a language in which everything is truly an object as well, this starts to get rather confusing. While Python does treat every integer and string as an object, it mixes the traditional functional paradigm for calling items such as 'len' so that to find the value of 'a', one would type len(a), as opposed to the more object based a.len .. This seems counter-intuitive and quite frankly a real surprise when you look at the overall design of Python.

I'm not ripping on Python as I do wholeheartedly enjoy the language, I'm just starting to feel aches and pains over decisions which are ingrained into the language, as well as not being seen as an issue or being addressed in py3k (or Python 3000/Python v3.0) as it were. I just think that my eyes have been opened to Ruby again and I like what I'm seeing. I am actively looking to find a future professionally as it were utilising it as nothing beats having fun while accomplishing what one would hope accounts to 'great' things. We'll see what the future holds.

Next Step: Migrate my SimulaE virtual world/real model object simulation from Python into Ruby as a test run. Lather, rinse, repeat and then see what the side-by-side comparison's look like.

Until next time...

The Importance of Being Challenged

2008-02-05T21:02:00.000-05:00

In this most recent engineering, architecting and development endeavour which I simply refer to as my "job" or "contract", I have come to some conclusions which I feel require sharing. I'll be very straightforward so as to not waste certain readers' time. Many of the more seasoned lifetime coders will know (and have experienced many times over) that which I am writing about, which can be summed up as such: If you are not being constantly challenged, you are atrophying as a developer.

I often write about my own experiences as I know them better than any single other developers experience(s). This is not because I feel that I'm the end all be all of coders. Far from it, I do feel that I'm good at what I do, however I prefer to look at my writings as a form of navel gazing, a self-reflective ascertaining how I can better grow in my art and profession. It is exactly the same manner in which I'm going to proceed regarding today's message.

As I have mentioned, I have most recently jumped into a contract situation at the personal request of a rather successful life-long entrepreneur and given that the opportunity sounded rather interesting, I turned down a salaried position worth almost double because the challenge that was proposed. Please don't get me wrong, I took a position fixing a half-assed php open-source hot or not style rating system because the employee responsible by no fault of his own necessarily, and due to a lack of a sense of urgency was unable to get a system such as that prescribed, in place by a contractual client deadline. This was not the reason I took the contract, whilst simultaneously being precisely why I took the contract.

I'm not a fan of php, and most definitely not a fan of a vast majority of already written php applications open source or otherwise. What I am referring to more so is that I was brough into an environment where it wasn't the same old same old. Now I wouldn't have stayed were the job going to continually require php specifically just out of my distaste of said language. I did know that while I don't consider myself a web developer, I would be required on more than one occasion to work on web applications.

These weren't to all be simple ones either, any moderately proficient web developer and non-web developer alike could figure a good many of these solutions out. What really did it for me was that I would be required to not only work under a fairly frequent set of short deadlines due to the nature of the publishing industry as well as the time frame required to keep the site and features current.

The importance of all off these ramblings is this simple point. Being experienced and disciplined as a Software Engineer/Developer/Architect, etc. ad nauseam helps me to know 'what' I need to do, and gives me insight as to how I might go about solving an issue. It is however, the actual specifics which put those tidbits of understanding and knowledge into play which go outside a given comfort zone. It is only then, when we find ourselves in unfamiliar territory, under threat of tight deadlines coupled with our own personal desires to do our best and produce code to which we are proud to associate our name.

I know that earlier in my career there were times (albeit very few, which I can honestly say) that I too fell into this 'comfort zone'. I found out though, that this comfort zone is boring and causes one to stagnate. We code because we love it. Coding and problem solving is in our blood, and in our hearts. It is how we look at the world and as such isn't something from which we can remove ourselves.

If you only know low-level languages, learn a high level language. If you only work in functional programming paradigms, learn object or aspect oriented ones. If you only work with interpreted languages, learn compiled langauges, etc. I'm not saying give up your current lingua franca, I'm simply saying expand your horizons. The more ways you have of looking at, describing and ultimately understanding a given problem, the more ways you have to solve said problem. This doesn't solely benefit you, it benefits everyone for whom your code will be written and utilised.

You knowledge needs to be a living, dynamic pool of information, not a static, never changing one and the way to ensure that is to aggressively fight off the status quo. Be aggressive, absorb all that you can. The best way to do this isn't by dipping your toes into the shallow end of the kiddie pool, it is accomplished by putting on your goggles and climbing that high dive, plunging in head first.

Take a chance for once, you might just learn something.

Till next time..

Arc: An evolution of Lisp/Scheme, or a outdated implementation at launch.

2008-01-29T22:55:00.001-05:00

So the day has finally come in which prolific geek & insightful essayist Paul Graham along with Robert Morris released Arc, their evolutionary love child of Lisp & Scheme. I think it is safe to say that many of us have (and will continue to) read Paul's wonderful essays on a multitude of geek and coder centric topics, and generally with much joy and agreement. Many of us have been following the work that Graham and Morris have been undertaking with the new baby "Arc".

Now that this day has arrived, we can see that it wasn't as deserving of all the pomp and circumstance to which we were planning for it to be attributed. Seems that there are a considerable amount of deficiencies and intentional short comings to the language. Normally this wouldn't be seen as anything out of the ordinary for a 'new' language, and would be generally a non-issue.

The problem is that this is the year 2008 and people have come to expect more from their languages. Ignoring established standards along with ignoring the need for designing to meet the needs of developers globally all the while using the cop-out of it being purely for exploratory programming is just bad form.

The world doesn't need another Lisp, the original is wonderful just as it is, that's part of its beauty. I don't see anything in Arc that couldn't be done as functions and/or macros in Lisp that required the entire 'creation' of a new language. The way I see it is this; for prototyping as well as production usage we already have several languages that excel in those domains, specifically Lisp and Python.

Generally the idea of rewriting existing languages with little difference from their predecessor(s) is a waste of time and effort which could've been better spent elsewhere. There are exceptions to this scenario such as that of Ruby. It is a language that in the past I used to dislike because of certain key flexibilities much akin to the reasons for spaghetti perl, but it successfully fixes many of perl's wrongs, and corrects some of Pythons short comings as well. It serves serves enough of a purpose as that of supplanting perl with a better thought out design, and thanks to Rails, its future looks solid.

Arc on the other hand is like a still born fetus. Much was expected and there was potential to be just like its parent(s), but death was announced during a delayed delivery and upon further examination, it was discovered that it wasn't a proper offspring, but a clone in fetal form. My advice to Paul and Robert is the following: recall the release, and make it truly something worthy of release, with proper compatibility and compliance with modern norms. Make it usable to others as opposed to just a few tinkerers interested more in lisp and scheme basics.

An on a more pleasant note to Paul; Please keep on writing your essays and providing your viewpoints as they are appreciated, I just wish that your judgement call in the case of 'Arc' was as well thought out as your writings have proven to be over time.

The New Django Powered Inked Magazine Website is Up!

2008-01-04T14:13:00.001-05:00

This will be rather brief as it is more of an announcement than one of my more traditional journal entries.

After a short two or so months from start to finish, I have successfully setup my first Django powered website. Inked Magazine has been relaunched effective January 2nd, 2008. This replaces the Joomla powered site which existed prior to both myself and the current ownership of the magazine were involved in the project.

Phase one has been completed, with extras. The customer photo galleries, the cover photo application, the user profile system as well as the main magazine feature areas have been established and are active. As of today, I will have available for all registered users the ability to host a blog on our site (using our software which I wrote in a few days), mind you it is still early in the feature process, though it without doubt serves most blog authors needs.

I will be adding features as time progresses, but until mid-January 2008, I'm on a tight schedule to build the entire forum application so that the beginning of the "New and Improved" Inked Network can go live.

I don't think one needs Ruby on Rails when you have Django. Much of the same great functionality and without having to use Ruby all the while using Python. [Update: After having revisited Ruby as a language on its own, sans Rails notoriety, I've found that my previous assertions regarding Rails specifically was unwarranted. It simply took my experiences with Django and Python to make Ruby and Rails far clearer to me.]

I will return to my normal posting after the Forum application is up and running.

Till then, keep on coding.

Reflections on 2007, Looking forward to 2008

2007-12-31T21:43:00.000-05:00

Given that it is nary a few minutes past 22:00 on the east coast of North America, I figure it is time for one of 'those' looking back and looking forward type posts, but with a codedevl slant. This past year has been a rather bizarre one as it marks the first year of my professional career (over 13 years) in which I've been employed by more than two firms/companies. I mean technically I've only been employed by one firm, the time prior and currently I've been self-employed, so does it count?

While this isn't necessarily an issue for many others out there, it was a point of concern for me as I have been traditionally conservative in my career moves and choices. It isn't as if I'd suddenly threw caution to the wind and job hopped. I will say that it was all thanks to the federal government for starting the ball rolling over a year ago when they raided the offices of a previous employer due to nefarious actions of several of their customers (unbeknownst to any of us at the time). The government claims it wasn't a raid but a search and seizure. As far as I know, that is classified as a raid, more so because the agents were wearing bullet proof vests with guns drawn.. all three dozen of them.

I've started to obvious stray from the where I was going. Simply put I found myself working with a skeleton crew at a company for an additional five months while legally being unable to process our normal transactions, hence no hope of future work. The warnings started coming and as such, the few of us which remained knew the end was near so we all started prepping for the day when it would all come crashing to an end, an end to a wonderful half decade as a working family as it were. It took less than a week for me to land a new gig working on a project for Burlington Coat Factory and previously mentioned in a previous entry. I do have to say that I grew more as a software engineer during that first jump into contracting than I had in many of the prior years, including my time as team lead, department lead and CTO.

I brought all of this us because it lead to how I started out the year of 2007. I was finishing up my contract having successfully deployed the new point of sale returned goods system for Burlington's stores nationally. I knew when my last day would be and started to look for interesting jobs, but preferably salaried ones, which I found without trouble, so much to the point that I finished my contract on a Friday and started my next job with Blue Gravity Communications, Inc. the following Monday. As that saga has also come and gone (by my own choice), many things have changed, primarily my outlook on contracting vs. salaried employment, my work environment and my work ethic.

I found that there really isn't a major difference between salaried employment and contract employment, other than the 'false sense' of security in a salaried job. The reality of it is that one can be let-go from a salaried position very easliy, unless you're in Nederland, France, Denmark, Sweden or Norway (and a few others I'm sure I forgot). The overall benefits of being self-employed become clear rather quickly once the newness of contracting fades away. You have more responsibility, and more freedom.

You work harder to prove and build and/or strengthen your reputation, and don't mind it. You have flexible hours (at least in my case and/or other cases where on-site 9-5 is not required, which is a pretty common flexibility. You don't have to deal with as many managers or supervisors. You don't have to stress over working with a certain group of people forever. You are able to work multiple clients simultaneously (as much as you can personally handle), and finally, you truly have more control over yourself and your future than ever afforded in a salaried position.

My environment was always a sticking point throughout my various locales of employment, ranging from a room full of others in a different department, a room full of peers, a room full of subordinates (though I hate the term, being very much an egalitarian), and of course, in a room all by my lonesome. I worked many of my years in a solitary environment, for a full time employer and as such had plenty of human interaction. Yet during those years I yearned for more interaction, a room in which I could openly be around others. I finally got my chance when I became CTO and Development Lead at one company. I was able to secure an open office with no partitions and a relaxed layout.

This proved to be an enjoyable environment, but I found later on that it didn't allow me to produce my best work. Separating myself from the others didn't do much to help either. It was only when I worked as a contractor for my first time that I started to realise what my environmental needs are. I returned into the salaried world and worked side by side with some great people, even entering into the halls of foosball with one of my aforementioned peers. It was only after I re-entered the realm of self-employment contracting for Pinchazo Publishing Group, Inc. (owners of Nylon and Inked magazines most notably), that I setup my home office an came to terms with a new reality.

I work best, in my home office, alone with minimal contact from others with the exception being my request to speak with others over designs or processes changes in order to meet project/structural demands. I do enjoy the company of others but know that I work more diligently, more exacting and am ultimately more focused when in my own space. I did find however that this new environment does have its perks, one of those being flexible time to meet up with peers and past co-workers for quality time.

This leads me to my final point of realisation. My work ethic has changed dramatically for the best. To be honest I found that I was too easily distracted in other environments when a salaried employee. I had far less "in-the-zone" moments when in a workplace, and on someone else's payroll. Again I think this is due to distraction and a certain level of security (a false one at that). I'm not particularly fond of making this public admission, but at least I've recognised it and willingly state it for the record. I know what I need to be the best that I can, producing the best work of which I'm capable. Now that my reputation and future prospects rely mostly upon my current projects and the manner in which they are complete, it makes me stay more focused and on task.

I also must say that due to the lowered stress in my career at this juncture in time, I am able to enjoy my art/trade for more than ever before. When one couples that feeling of relief along with my combined experiences, gained knowledge and wisdom (or lack thereof at times), caring becomes a top priority. I care about my work, and I strive to produce the best that I can. I own the process, the engineering, the schedule and the maintenance and as such demand of myself nothing but my best, and I love every moment of it now. I know what I'm worth now, and I know what my code and expertise are worth and what it takes to ensure that I'm operating at my best.

Finally, this brings me onto my outlook for the upcoming year. Hopefully, much of the same and barring any catastrophes, I see a very promising future ahead with the current outfit for which I'm contracting. The work is exciting, doing things the right way and engineering a whole system is something upon which I thrive. I look forward to learning new technologies, I'm excited about the prospect of new advances and of course, I'm happy that I love coding and truly feel as if I've found my ultimate environment to do what I feel that I do best: Engineer great software.

Happy New Year to all, here's looking forward to a great 2008!

Eric