This InfoWorld article talks briefly about the promise of HTML5 and the potential problems with it due its slow-moving standards body WHATWG. The acknowledgement that HTML5 won’t really be finalized until 2022 made me blink twice. Or thrice. Seriously, 2022? What good is a web standard if it’s always going to be behind by decades? Also note that development on HTML5 was started as far back as 2004, and we’re only now seeing little bits and pieces being implemented by browser makers.

This prospect has completely killed off any enthusiasm I had for HTML5. It seems that in the ever changing world of the web, HTML5 will never be able to live up to its promises. Its development is just too slow. This eye-opener neatly ties into the remainder of the article, which comprises of a thorough side-by-side comparison of the leading RIA framework providers Adobe Flash and Microsoft Silverlight.

When faced with the naked facts of HTML5′s preemptive failure, the grumblings in the industry about RIA platforms dying, are becoming more and more unfounded. It seems only proprietary frameworks like Flash and Silverlight can provide excellent development and design tools, desperately needed by the RIA developer community. These frameworks at least provide a consistent environment in which rich internet apps can run, guaranteeing they’ll look and feel the same across browsers and operating systems. This is something I don’t see happening with HTML5 any time soon.

Any web developer will acknowledge the fact that developing with HTML, CSS and JavaScript is an utter pain in the butt. There are huge inconsistencies to work around with markup, CSS, fonts and JavaScript code. My brain hurts when I think about it. I had hopes for HTML5. Not anymore though.

The very nature of the web, the fact that it’s so ad-hoc, makes it difficult yet interesting to develop for. No, I won’t stop developing web apps. But I won’t dismiss RIA either. Each technology has its uses and perks. The trick is to choose the right tech for the right right. Don’t ditch proprietary (and often superior) platforms just because HTML5 is the “open” way to go. It will impair your ability to deliver truly innovative web apps/RIAs.

For now, Flash and Silverlight are still superior to anything HTML5 has to offer. And it’s going to stay that way for a while, I think. A long while.

Find my original posting at Amplify.
My tweet.

Important? I sure don’t think so.
Geeks like you and me naturally adore the idea of hooking up an Internet-connected device to a TV. This rumored Utopian device (grin) could enable the TV-watching crowd to stream a whole lot of other stuff into the living room besides static television programming. Yes. We could have easy access to YouTube, podcasts, photo sharing sites like Flickr and Picasa, Farmville and on-demand video. We could browse the wide-open Internet comfortably from our cozy armchair.. And we could have apps. Hundreds of thousands of apps and games, which are already available from the App Store.

STOP! Reality check. If we’re honest, we know this won’t gain any traction. Ever (well, not in the foreseeable future). Why? The answer is two-fold.

One: adding another set top box is just too complicated for “normal” users. Most folks can hardly work out which buttons to press in sequence in order to get the cable box turned on. Let alone switch over to a different box for the Internet-connected stuff. Also, a television is expected to behave like an appliance – it should be an instant-on experience. It surely shouldn’t crash, freeze or require a reboot every so often.

Two: cost versus value-add. Will the features that an iTV-like device adds be enough for the average consumer to put down another 100 – 150 USD, on top of their current cable box and DVD/Blu-Ray player? Additionaly, a box like this would probably incur subscription fees for premium content, e.g. from HBO.

Aside from the conceptual issues, there’s still Apple to deal with. Sure, they have the power to strike deals with content creators to deliver great content. But Apple being Apple, they’ll undoubtedly want to keep their draconian clutches snugly around the product, most likely making it as limited as the iPhone and iPad. So don’t expect this thing to take off in a meaningful way any time soon.

Note: I furthermore resent the idea that people think that apps are (or should be) taking over regular websites/web apps on these devices. As many others have already opined, this negatively impacts the open internet because Apple’s app ecosystem is designed to censor and limit the user’s view of the net. In my humble opinion, the future of the Internet still lies in freedom and choice. Devices like the iPhone, iPad, and perhaps iTV should integrate with the Internet, not become a sub-Internet.

Note: I own Apple products. So yes, I can slam Apple if I choose to.

com.aceontech.AppleRant.end();

Download this pattern here (Brusheezy link).

One piece of advice, maybe: please don’t use this as the general background for your web designs, unless it’s toned down somehow. Moderation usually bodes well .

Find the download page here (Brusheezy).

The set contains 32 hi-res textures with resolutions up to 1250 and 2500 pixels. The artist doesn’t require attribution, so these brushes can be used freely in a variety of ways. I personally scaled the splatters down to function as backgrounds to my navigation links.

Nite and enjoy .

Instead of writing this myself, I opted for the free jQuery plugin called LocalScroll, which was skillfully created by Ariel Flesler. This script is very, very simple to implement but adds a high degree of cachet to your page. It’s certainly a nice touch to vanity sites like portfolios or resumes.

Download the plugin here. To make this work, you will need a recent version of jQuery running on your page and another plugin by Ariel Flesler called ScrollTo (LocalScroll is based on ScrollTo and requires it to function correctly).

An example HTML header:

Code block

<head>
	<meta charset=utf-8 />
	<title>Scrolling Page</title>
	<script src="lib/jquery-1.4.2.js" type="text/javascript" charset="utf-8"></script>
	<script src="lib/jquery.scrollTo-min.js" type="text/javascript" charset="utf-8"></script>
	<script src="lib/jquery.localscroll-min.js" type="text/javascript" charset="utf-8"></script>
</head>

Now all you need to do is create some anchor links and link to them. To make the smooth scrolling work, you need to write a bit of JavaScript.

Code block

<h2><a name="resume">Resume</a></h2>
<h2><a name="portfolio">Portfolio</a></h2>

Your document ready function should look something like this:

Code block

$(function() {
	$.localScroll({
		stop: true
	});
});

And.. That’s it. Refer to the plugin’s documentation for all of its options.
Happy scrolling!

I’d like to share the excellent free background textures I used for alex.manarpies.com. It was created by DeviantArt user ‘Princess-of-Shadows and was compiled from scans of actual materials.

Find the original page here.

The image pack features 5 distinct textures with varying degrees of grunginess. You can use them as-is, or bestow some Photoshop wizardry upon them to cook up some custom coloring and effects. I went for the latter approach:

Here’s how I achieved this effect:

1. Set the texture layer to black and white.
2. Set the texture layer’s blend mode to Overlay.
3. Set the texture layer’s opacity to 70%.
4. Create a new layer under the texture layer and fill it with a color, perhaps a shade of pale blue.

It may have come to your attention that the textures won’t repeat especially well when used as a background. However, as they are pretty hi-res, you could give the backgrounds a fixed background position. For instance (CSS):

Code block

background-color: #d2e0dd;
background-image: url(bg_site_blue.jpg);
background-attachment: fixed;

Grungy background patterns seem to be in vogue lately, and there’s a lot to be had of them on the net – too.
But, please, don’t kill the effect by mere overzealousness. Moderation in everything, my friend.

Have fun with them and report back with your creation .

Conceptually, namespaces in JavaScript involve creating a stored function. This function subsequently contains private variables, private functions and public functions by means of the return construct:

Code block

var SomeNamespacedObject = function() {
	// private vars
	///////////////
	var somePrivateVar;
	var anotherPrivateVar;
 
	// private functions
	////////////////////
	function doSomethingPrivate() {
		// private business goes here
	}
 
	// public functions
	///////////////////
	return {
		doPublicStuff : function() {
			// public business goes here
		},
		doMorePublicStuff : function() {
			// more public business
		}
	}
}();

You can now reference your namespaced object like so:

Code block

SomeNamespacedObject.doPublicStuff();

Namespacing introduces some pros and cons, but I generally namespace my JS code, sometimes only for the sake of making it look more object oriented. Also, it makes me sleep better at night knowing not all of my variables are being broadcast publicly and I’m not polluting the global variable space.

Pros:

• Cleaner
• Encourages code reuse
• Encourages encapsulation (private vs. public)
• Prevents overwriting of existing functions

Cons:

• Verbose
• Perhaps a bit confusing to JS newbies

My advice? Namespace that JavaScript, my friend.

As you can imagine, these are quite an amount of technologies to master, and fast-moving ones at that. So, ultimately, this blog should serve as a sharing platform to fellow web developers and a personal documentation archive for myself. Feel free to contribute in the comments, or via Twitter (via@aceontech).

I’ll be posting more code samples here and will use GitHub and Gist to share sample code and code snippets. I have created a GitHub open source repository, available here:

• Website:http://github.com/aceontech/iphonedev
• Read-only git repo:git://github.com/aceontech/iphonedev.git

Thanks to ndesign studio for the intermediary use of their WordPress theme. I’m currently working on a more specialized blogging platform, which will include a new design, thus I’ll be replacing WordPress with my own system soon.

A DynamicEvent is a type of custom event in Flex that is easier and quicker to set up than the full-blown approach. By applying the latter method, you normally go through the following steps:

1. Define a subclass from flash.events.Event
2. Make the event available to other ActionScript (through addEventListenter()) components or MXML components (using the [Event] metatag)
3. Dispatch the event, using dispatchEvent()

Full documentation on custom events can be found in Adobe’s LiveDocs, here.

Generally one uses the above approach when you need to pass arguments to the code that’s targeted by the event. When you don’t require this, however, you can opt for the DynamicEvent. It’s not necessary to go through the whole rigamarole of subclassing; all you need is a name for the event, like so:

Code block

var yourEvent:DynamicEvent = new DynamicEvent("yourEventName", true);
dispatchEvent(yourEvent);

The second argument set to true means the event will bubble.