Rather than take a traditional page-design approach, we architected the database and interaction to be slim and exchangeable. First, the database was managed by use of two .NET-based Web Services written in C# that ingested via POST marking transaction success with 32-character IDs, output via XML and with multi-purpose edit functions using switches and variable inputs. Next, the authentication was built on a combination Basic and session-based approach using ASP – quick and efficient and easy to modularize should the system need to be moved to another platform. Finally, the front-end was built on a single HTML page with jQuery and jQuery UI to support the large number of Ajax exchanges and interactive features.

The result is a clean, easy to use, transportable DAM-CMS capable of complex transactions (multi-tiered, synchronous updates), hooks to a Silverlight-based rough cut editor from Southworks, and most of all, easy and quick to modify without affecting the production environment. By deploying a single jQuery-based controller separate from the parser and presentation components, new objects could be introduced to the interface based on a modifiable, dynamic XML document at login (or pushed in real-time, even after the user had logged in).

Some of the things we learned seem pretty silly but in fact were critical to the project completing in such a short amount of time.

First, segregate all the processes – by constructing the database, the web services, and the interface separate from each other, different developers could rapidly deploy all of it and mesh together quickly at stop-points each day. Chandler and I (with a big assist from Srini and Mio) were able to work independently and merge as he completed parts of the web service, or make changes as parts of the interface came together. Likewise, during testing, changes to the interface and sequence could be done in real-time and re-tested within minutes instead of having to go back to the drawing board. This was eased by the fact that issues could be easily attributable and divisible to interface or back-end, and handled separately.

Second, it’s the little things that make a difference. Providing small visual cues – update notifications at the top of the page that disappear, Ajax loader starburts, highlighted labels and input boxes – all give the user information, information that helps them get through difficult or tedious and complex processes (for example, in creating a VOD asset, a user had options that might require upwards of 50 different pieces of information – eliminating unnecessary components on the screen made it easier to get through).

Finally, architect it but be flexible. Changes happen, and while developers and project managers all try to keep scope creep from happening, we all know that in the real world, so does feature change. It is unrealistic to assume that projects will get started 6 months before the deadline. It is also unrealistic to assume that, in such a project with a short deadline, that you’ll remember to include everything. Likewise, it’s also unrealistic to assume that during the process you’ll realize that the planned interface will work – prototyping is great but it takes time and testing that you may not always have. Being able to be flexible by following a basic interface design, using modular builders (in jQuery UI or other framework) and XML-based instruction sets, and providing error catching systems in both the front-end as well as the web services makes the project continue to move, even when not all the parts are correct.

In the end, we had a lot of hiccups and it didn’t go as smoothly as we’d hoped but it did get done and delivered on-time. The client goes to training in 9 hours and there will likely be another round of changes, but that we were able to post a full-featured DAM CMS in such a short amount of time gives us new methods and targets for the future.

If Oracle buys MySQL as part of Sun, database customers will pay the bill.

In April 2009, Oracle announced that it had agreed to acquire Sun. Since Sun had acquired MySQL the previous year, this would mean that Oracle, the market leader for closed source databases, would get to own MySQL, the most popular open source database.

If Oracle acquired MySQL on that basis, it would have as much control over MySQL as money can possibly buy over an open source project. In fact, for most open source projects (such as Linux or Apache) there isn’t any comparable way for a competitor to buy even one tenth as much influence. But MySQL’s success has always depended on the company behind it that develops, sells and promotes it. That company (initially MySQL AB, then Sun) has always owned the important intellectual property rights (IPRs), most notably the trademark, copyright and (so far only for defensive purposes) patents. It has used the IPRs to produce income and has reinvested a large part of those revenues in development, getting not only bigger but also better with time.

If those IPRs fall into the hands of MySQL’s primary competitor, then MySQL immediately ceases to be an alternative to Oracle’s own high-priced products. So far, customers had the choice to use MySQL in new projects instead of Oracle’s products. Some large companies even migrated (switched) from Oracle to MySQL for existing software solutions. And every one could credibly threaten Oracle’s salespeople with using MySQL unless a major discount was granted. If Oracle owns MySQL, it will only laugh when customers try this. Getting rid of this problem is easily worth one billion dollars a year to Oracle, if not more.

For my students and UNLV colleagues: if you had never heard of the DreamSpark program, you should jump on it.  A program launched in 2008 by MSFT (don’t groan) can get you free software.  Yes, free.  Yes, I’ve gotten some of it.  In a blatant (and conducive) attempt to move budding developers and IT staffers to the Redmond dark side, they’re offering Visual Studio (2005 & 2008), Windows Server 2008, Expression Studio and more for free.  So while the university’s alliance program is broken and paltry, you could have just headed straight to the source and gotten legit, keyed copies.

Now the new stuff: just released by MSFT – WebsiteSpark.  Like it’s older brother, the new program is aimed at small companies – no more than 10 employees – and offers:

• 3 Visual Studio licenses
• 1 Expression Studio 2 or 3 license
• 2 Expression Web licenses
• 3 users license for WinServer 2008 and SQLServer 2008
• 4 processor license for self-hosting WinServer 2008 and SQLServer 2008

That’s a buttload of very expensive stuff for nothing.  The caveat is that you must launch a new web app (that’s app boys and girls, not a paltry PHP site) and if you hit it big, you have to exit the program and pay a $100 fee.  That’s peanuts compared to the value.  Or you could go to a bunch of MSFT seminars and collect copies but that takes a lot of time and snoozing through 4 hours of demos.

Several sites are reporting that a major attack on Wordpress blogs started yesterday. The latest version of Wordpress, 2.8.4, is not vulnerable to this particular worm, so upgrading now could save you a lot of headaches. The worm creates a new, hidden administrator account on your blog, allowing whoever’s behind this thing to access the guts of your blog, databases and all.

How do you know if your site has been affected? Lorelle on Wordpress offers two possible ways to find out:

There are strange additions to the pretty permalinks, such as
example.com/category/post-title/%&(%7B$%7Beval(base64_decode($_SERVER%5BHTTP_REFERER%5D))%7D%7D|.+)&%/.
The keywords are “eval” and “base64_decode.”

The second clue is that a “back door” was created by a “hidden” Administrator. Check your site users for “Administrator (2)” or a name you do not recognize.

Wordpress has acknowledged the attacks and encouraged users to upgrade their sites. Wordpress.com users aren’t affected, as the whole system has already been updated to 2.8.4. If you’ve already been afflicted by the attack, start on the steps in Wordpress’ FAQ.

I’ve already done the upgrade and it is the same, painless upgrade as usual.  Just be sure (especially if you’re using FireFTP) that you set the transfer options to Automatic Mode (Tools > Options > Downloads/Uploads : top fieldset).

For those who don’t know, a micropayment solution describes a system whereby the product being bought is a significantly small amount (something like $2 or less, so basically iTunes music would be one), and is usually coupled by either a pre-pay or a carting/aggregation system. Some day-to-day examples that have succeeded outside of iTunes would be something like pre-paid transit passes in NYC which remove one fee for each use. In the UK, there’s sQuid which is a similar service but can be used for many types of transactions. In Japan, the phones are tied directly to bank accounts for vending machine purchases.

Having worked on a number of e-Commerce back-ends for varying clients, this has always been an issue that perplexed me. On the one hand, consumers all know that at some point, to access content or acquire goods, that a payment needs to be made. On the flip side, content is so easily accessed for free on the Web (whether legally or quasi-legally) that consumers have started to become used to getting it for free. So how do we impose payment systems that allow for micro-purchasing? The example scenario is for, say, news. Several news providers have already started charging for access to news (which in reality is no different than buying a newspaper) and several others are moving in that direction, but is the subscription model working? Or perhaps will we see a pay-per-content-item system emerge?

Either way, the system itself is the culprit. In my somewhat out-of-the-box opinion, there needs to be a new model altogether. Imposing traditional payment schemes simply hasn’t worked for the micro-payment world (though I could argue that RedBox might actually be a close-to-perfect model but its also partly the targeting). Pre-pay, post-pay-aggregation, bank cards, none seem to work really well, and most of the systems that have emerged with promising outlooks later died untimely deaths (as pointed out by one of the Answer respondents).

Anyway here was my response…

I think that we still haven’t tapped the right balance in micropayment solutions that is able to satisfy the needs of the providers and the consumers. There is too little transparency and too little fluidity in the process, and we have (as a development and developer-provider community) dwelled to much on protecting the value of our content and not offering alternatives to letting customers acquire it (mind you, I am a rabid advocate of DRM solutions, so don’t think that I am not in support of content protection, it’s just that we tend to either do it with an iron fist or not at all).

I think customers are more than willing, in the end, to pay for services but the system itself needs an overhaul, likely one we haven’t come up with yet. In the same way that Amazon capitalizes on long-tail marketing, we need to look way outside of how we do things now in order to create environments where the provider and consumer of media services can co-exist. To that end, while there are several successful vendors of such products I don’t think anyone is a leader right now because I think the market will shortly turn itself over.

I do know, from my own experiences, that changes in digital asset management is the starting point for the vendors, but from a standpoint of providing explicitly heuristic access to content, not just providing massive libraries and letting the users hunt for it. A Pandora type experience with a flowing payment process (mixed pay for right to use and pay for use on a very micro level) is something I envision as an evolution. Providers are going to have to work together instead of living in silos of licensed content and use intelligent agents to disperse desired media.

Clarification posted 9 hours later
[reference to responses made later] those are some really great points. I agree that the current state of micro-payments is in waning death mode but argue that a re-thinking of the approach and process (and yes, the interminable fee structures that traditional money systems place on the products) can revolutionize the system. iTunes is a successful venture for every reason stated in several responses, but after raising the price point past the $1 mark, it’s beginning to lose its lustre and it’s debatable if it’s a true micro-payment system anyway (it’s really just a shopping cart for smaller products like the 99¢ store). When I think of micro-payment, I there’s two traditional approaches but they are still both pre-pay or cart-and-pay systems; the evolution I see would be be much more superfluous than that.

Several years ago, a good friend and myself came up with the idea of sending barcode images to cellphones via MMS as a means of ticketing for events, most notably nightclubs with VIP access (and two years later we see Fandango using scanned bar-code “ticket at home” systems that are pretty much the same but not digitized), but the system itself was paid for using micro-transaction on account (in other words, the transaction itself was attributable to the benefiting business, which could then be passed on in hard form to the customer if the business desired).

Like this, what outlandish ideas can you come up with that can revolutionize how payment models work?

While is why I am extremely proud of the evolution of the CMS that I designed and built for the Wimbledon Live player (see this post).

To understand the complexity behind designing the UX it’s important to understand the nature of the data and the critical effect of the workflow. First, video was being supplied from six sources, some to us using Saviant direct to our servers, some we pulled via FTP, and then of course the live streams (some HD and some SD). Then there were multiple parties…NBC (as the news reporter) needed editorial control over metadata, while iStream’s Managed Webcasting team needed to control the timeline over when items went to publication. My team, RnCS (Research & Creative Services) needed to insure that everything was tested before going live so we needed to throw the whole thing through a staging server before hitting a production server that then fed a cluster of edge servers on Akamai’s network.

So we structured it in several parts. First we put automated bots to determine when new assets had been dropped, specifically seeking out XML files that held the initial metadata, and dropped that into the CMS DB. Once there, the appropriate parties were notified by email (or in my case as PM, by SMS) – to update metadata, insert images, begin video transcoding, etc. Through the entire process, we designed screens to make it as easy as possible to follow the flow of assets, provide enough ability to each staff person so that overlaps in duties existed but that checkpoints assured data integrity throughout.

The grid above, for example shows the visual layout of the thumbnails that would appear in the cover-flow style playlist inside the player. Deep linking was provided so editorial users could create pointers on the MSNBC/NBCSports sites. Drag and drop allowed us to reorder objects to maximize the visibility of prominent players.

Each level of user had various modal windows to insert data. Even imagery was uploaded first to the staging, processed for size and then sent to production.

Because of the nature of edge servers, we also had to purge the cache after any update, so we provided a three-section grouping that allowed us to send the feed XMLs to production and clear the cache in one shot. And to make THAT process even easier, we built it so that it was accessibly by mobile phone so even if I was in transit, I could still update the CMS in a timely fashion.

Finally, the live streams had the ability to be toggled on and off so that the matrix of available feeds, particularly the Smooth HD stream, was optimized and prioritized. To be sure, there was still much room for improvement but given that the whole CMS was built in 6 days and now, five days into Wimbledon, has eased us into a steady, smooth workflow, speaks volumes for making it easy to use, intuitive (for example, the color designations on the player match the ones in the CMS, big text and extensive micro-transaction Ajax created an interactive environment), and overall a good experience.

TIOBE Index, July 2008 by TIOBE bv

Position		Delta	Language	Ratings Jul 2008	Delta Jul 2007	Status
Jul 2008	Jul 2007
1	1		Java	21.345%	+0.33%	A
2	2		C	15.945%	-0.42%	A
3	3		C++	10.693%	+0.19%	A
4	4		(Visual) Basic	10.447%	+0.72%	A
5	5		PHP	9.525%	+0.87%	A
6	6		Perl	5.131%	-0.20%	A
7	8		Python	4.973%	+1.95%	A
8	7		C#	4.000%	+0.29%	A
9	9		JavaScript	2.757%	+0.24%	A
10	10		Ruby	2.735%	+0.64%	A

(For my students) In case you’re wondering why HTML is not included in this list, the definition used by the index is:

A language is considered a programming language if it is Turing complete. As a consequence, HTML and XML are not considered programming languages. This also holds for data query language SQL. SQL is not a programming language because it is, for instance, impossible to write an infinite loop in it. On the other hand, SQL extensions PL/SQL and Transact-SQL are programming languages. ASP and ASP.NET are also not programming languages because they make use of other languages such as JavaScript and VBScript or .NET compatible languages. The same is true for frameworks such as Ruby on Rails, ColdFusion, Cocoa, and technologies such as AJAX. Finally, we have also excluded assembly languages, although Turing complete, because they have a very different nature.

And finally, for those of you in my weekend classes…yes, it’s 2 hours after class and yes, I am still up.  Good night.

Please note that this is a beta build and not intended for production use.

First, lots going on with iStreamPlanet, our Silverlight development and other technology advancements.  For those of you who are able to, head on out to CES – it looks like this will be a pretty good show this year.  And if you have a chance to head to Mix08 – there will be some really cool things to see there too.  In any case, the contractors didn’t finish our new office build-out so me and the team are stuck in temporary office space – no thanks to Wynn practically pushing us out the door from the office I’ve been residing in the last 5 years.

Second, I know a lot of you use and have gotten comfortable with Firebug.  Here’s a similar plugin I found that you should also get.  It allows you to do a lot of those user variations that you might not otherwise account for – exact screen resolutions, Javascript on/off, etc.

Finally, I admit, I use cheat sheets.  It’s bad enough trying to remember markups, commands, syntax, functions, and methods for 1 or 2 languages, what about 5 or more languages that a web developer typically has to know (and if you have no idea what I’m talking about, see below)?  UK-based Internet dude Dave Child, who writes good, poignant articles and blogs about a ton of topics, has a great set of free (yes, FREE – and if you use them you should send him a note and thank him for saving you a few bucks after all the tuition you’ve paid) cheat sheets in PDF format for download.  I recommend grabbing them (at least the list below) as soon as you can – with the Web, you never know when something’s going to disappear.  Check out the list and links here.

And as far as the list of languages you should know as a web developer (and this rant is aimed directly at my students) …

1. HTML/XHTML (and you should know the difference)
2. CSS (and be current and know the hacks)
3. Javascript & Javascript prototyping
4. ASP Classic (sorry guys, I still think it’s a good fundamental language)
5. SQL (for MySQL)
6. PHP (both functional and object based)
7. XML (and variants of it, plus XSL)
8. ActionScripting
9. And if you really want to get ahead, you need to learn at least one of the following to stay ahead of the curve in the next few years: ASP.NET, JSP, Ruby on Rails, or C#

And no, AJAX is not a language as many of you still think – if you thought it was…GO LOOK IT UP!

See you in class … don’t be late!

The reason we do a “Luhn-10 check” on an entered credit card is to verify that the user did not enter invalid information before it gets sent to the credit card processor. Why? Because a transaction request, whether it’s valid or not, costs the site owner money! Every request is charged a base transaction fee (and this varies depending on the size of the company, the volume of transactions and many other factors; my company for example, has a transaction fee of 12 cents*). So in other words, we want to make sure that if we’re about to get charged that fee, we’d better make sure ourselves that we have as accurate a number as possible.

Luhn-10 (which used to be known as Mod10) was developed by an engineer at IBM in the 1960’s. The basic premise is that a homogenous formula, when applied to a string of numbers, will always yield the same result. In the case of Luhn-10, the result is 0. For this example, use the Visa card:

4563 9601 2200 1999

Step 1: Reverse the number. Beginning with the (new) first number of the whole sequence, multiple every odd digit by 1 and every even digit by 2:

Step 2: For all of the results that are greater than 9, add the two digits in the result:

Step 3: Sum those numbers:

9+9+9+2+0+0+2+4+1+0+6+9+3+3+5+8 = 70

Step 4: Modulus the sum (this is why it used to be called Mod10). In arithmetic, the modulus is the remainder after a number is divided by a specified number:

70 = 0 mod 10

All major credit card providers use the Luhn-10 system (Visa, Mastercard, American Express, Discover, Diner’s Club, Carte Blanche and JCB). There is currently an alternate system that uses a 1 instead of a 0 as the modulus but they are not widely accepted cards. Note that there are several card numbers that are widely accepted as test card numbers and are always overlooked. The most common one is 4111111111111111 (and is therefore never considered to be a real credit car number). Also note that credit card numbers can have 13, 15, or 16 digits

Here’s the scenario that we faced.  iStreamPlanet produces a software application that is run during live poker tournaments which places an overlay on top of the encoded video similar to poker tournaments you might see on TV.  The actual system uses an interface built in C++ that writes an XML file as it is updated, which in turn is read by a Flash component layer and then drawn into the video card (the result is something that looks like the image below).

For those of you who have been through any of the scripting classes, by now you should recognize that this needs a multi-dimensional array to work best.  Don’t be scared off by multi-dimensional arrays – think of them as just Excel spreadsheets.  So if you have a spreadsheet that looks something like this:

Then the your array would have been written as:

Download the materials here: Multi-Dimensional Array Sorting from XML Data in ActionScript (ZIP)

In the course of adding components to the application, we needed to output the current chip counts of each player and present them in order of most to least chips.  Of course, our XML ordering was based on the C# output which was not sorted and also contained string data where we needed to sort numerically.

First, we read the XML.  To do this you’ll need to open a socket:

Next, we created a function that broke up the data and put it into the array.

At this point we need to consider how to sort the data.  Remember that our original spec required that the output be sorted in descending chip count order.  But notice that the XML data that has symbols in it.  If you know a bit about programming, you’ll know that sorting is done based on the operating system preference.  In this case using a normal sort() function, Player 7 (Roosevelt) with $15,616 chips would be first…

While ActionScript does have conversion capabilities, the problem in this scenario is that the symbols will not allow conversion to a numeric.  So let’s create a function that will “convert” the formatted field into a number.

Using the conversion function (and note, you can use this function – albeit very simplistic – to do pretty much any type of string replacement), now we can finish off the original function.

Now test the movie (Ctrl+Enter) and check out the chip counts.

Incidentally, if you’re a poker buff, check out how this actually looks on screen by watching the World Series of Poker at http://www.worldseriesofpoker.com/