Skip navigation

Category Archives: apps

It’s been a long year. I have been working my Diomedes Adobe AIR IRC Client since at least April of last year, but I didn’t commit anything until June 7th (2009). Well now that it’s been a full cycle around the sun, I have made some changes.

  • I’ve fixed all remaining worst bugs that I know of.
  • I am now going to create a two-app system where 0.2.0 stays stable, with only critical bug fix updates and an alpha-app which will have the latest bleeding edge updates. Previously, updates could severely break the client for all users when automatic updates were installed, but no more. New features will be included only in minor version updates.
  • Updated the README information required for individuals interested in contributing.

Coming soon in 0.3.0:

  • SSL support.
  • Per channel logging.
  • Customizable channel view (with CSS and HTML!)
  • UI overhaul

A site design overhaul is coming for apphacker.com too!

Of course, Diomedes is open source and hosted on GitHub!

Advertisements

My Adobe AIR IRC client has a new repository home. Git is awesome as is github. Also added some bug fixes associated with ipv6 and action highlights. Going to add bnc and SSL support soon!

I have long suspected that not many people were using Google Wave due to lack of notification tie ins with communication tools people actually use such as email, Twitter, IM, etc. Now it’s confirmed (sorta)! From their blog (emphasis mine):

While you’re building your extensions, if you’d like them to be included in the gallery, please be sure to submit them for review. You may also want to check out Mashable’s Google Wave API Challenge.

via Google Wave Developer Blog: Introducing the Google Wave Extensions Gallery.

Mashable has had quite a few challenges, and I don’t think anyone has ever mentioned them. Seems like an act of desperation! I am just kidding, however I do think that their unwillingness to connect Google Wave to real email and IM services has left them with a product nobody wants to check, especially since it hasn’t achieved any kind of critical mass. I suppose the rationale is that by not connecting with real email and IM you force the transition to this supposedly new technology without having people depend on what they’re used to. Don’t think that’s working out for them. :O

Because according to level 4 Motorola support on why I can’t install Google’s own .apk web install app to allow scripting:

due to carrier restrictions the option to enable untrusted sources has been disabled

Guess, what, due to carrier stupidity I’m returning this otherwise pretty nifty phone. I’m also looking to turning off AT&T completely, dumping my iPhone, and going with an android phone.

For a few years now there has been a steady trend toward more powerful websites. Websites with more features, new interactions, beginning to resemble desktop applications. Google is a known proponent of this approach, and they’ve come up with an operating system that is basically a browser running client side applications.

Definition of a client side app
A client side app, sometimes also referred to as an RIA or rich internet application, is a website that launches a powerful front-end application usually written in JavaScript.

Benefits of client side app
A powerful, fast, responsive and dynamic UI. Desktop UI metaphors such as context menus, interactive visuals, drag and drop and others that allow for complex and intuitive user interaction. A comprehensive user interface experience where all aspects and features are contained within a unified application. Less reliance on links and standard web elements adhering to a hyperlink document metaphor. Dynamically updated interface immediately connected to a back end service – think instant messaging or Google Wave instead of a forum as an example.

Proponents of client side app
Google, a vast horde of Silicon Valley startups, tech reporters such as TechCrunch, and even Microsoft, Apple and Adobe are making noticeable impact in client side applications. The new HTML 5 specification. JavaScript libraries such as Google Closure, Dojo, and jQuery.

How to think about a client side app in the implementation
The danger is to think that some use of AJAX and dynamic UI elements is enough but it isn’t. The common refrain is the comparison to a desktop application, so let’s pursue that analogy.

Desktop analogy
There is a benefit to be realized from drawing a connection between a client side application in a browser and a desktop application. Desktop applications don’t download parts of its UI from a remote server. For example, some web sites may use XMLHTTPRequests to grab server side generated HTML from the backend. Desktop apps don’t do this, they can’t (unless they use something like a WebView), and neither should your client side application. Grab your data from the backend as a desktop application could handle it, as JSON or XML, and allow the client side application to determine how to display this information to the user. From launch until close, your client side application should render the UI, not the backend.

Desktop applications do not display an inordinate amount of buttons that send you to other desktop applications. In fact most desktop apps never send you to another application. In a client side application links to other sites take you out of the application to some other place: a link closes your application if it does not open a new tab or window. How many desktop applications have interface features that simultaneously send the user to a different desktop app and then closes itself?

The initial HTML is really an application download
The best way to think about a client side app is to imagine that the initial HTML download is an application download. Allow the client side application to perform the rendering of information and UI elements. Don’t utilize back end generated HTML, even if there is a small performance hit: you’re loading an application, not a website document. The first time a user downloads your application it is also an installation. You prepare the client side database/storage mechanism, you obtain user preferences, you explain your application. Smart use of browser caching can help prevent new downloads of your application on subsequent visits. Updates are actually new versions of your application that will require a new download via cache busting techniques.

Compile your application
Make use of tools such as Google Closure’s comiler. Make use of sprites and condense your CSS into a single file. Think of using tools such as buildbot and scons to generate the application that will reside in production to help you with these steps.

Conclusion
The desktop analogy can go a long way to help you develop a more powerful experience for your website. I know this is probably a horse that seems beaten to death but there is still confusion and often optimal designs are not implemented. Developers or product managers imagine that their one little AJAX jQuery slider feature on an otherwise static page means they’ve marked that “I have a client side app” check box, when the entire approach may be wrong. As a developer who in some ways specializes in writing JavaScript as rich internet applications it strikes me when speaking to potential employers when they are not sure what to do with someone like me. Often people may pay lib service to the idea of a client side application with a “we want that” but then can’t find a place for it yet. They want it, because it is a great thing to have. To get it, a little shift in thinking may be required.

Analysis And Conclusion – Review Tom’s Hardware : Web Browser Grand Prix: The Top Five, Tested And Ranked.

I’ve been using Chrome for about three weeks now and I thought I would never switch from Safari to any other browser. It’s very nice, the extensions are key and you know I did make my own music extension for Google Chrome. You should give it a try!

At least on the Mac OS X dev channel, starting out with a blank popup.html for a page or browser action will break your Google Chrome extension terribly. More than likely you will have to restart Chrome and clear your cache before your extension will load again. 

Probably related to the automatic resizing of popups.

Why would you start out with a blank pop up? Because maybe the popup features dynamically generated content.

Start at least with a   in your popup. Otherwise if you have an error in your JavaScript and the content doesn’t generate you’ll end up having to restart Chrome instead of just reloading your extension.

Posted via web from Apphacker’s learning curve

Popup

If a browser action has a popup, the popup appears when the user clicks the icon. The popup can contain any HTML contents that you like, and it’s automatically sized to fit its contents.

Page Action and Browser Action popups are sized automatically. If you generated the content dynamically and start out with an empty popup, at least on Mac OS X, Chrome has difficulty sizing your popup once you add wide content.

The solution is to set your popup width via CSS before you add content in a stylesheet linked to or inside the popup.html.

Posted via web from Apphacker’s learning curve

  • myVideo.addEventListener(‘ended’, function () {
  •   alert(‘video playback finished’)
  • } );
  • This works for programmatically created audio and video elements as well.

    Posted via web from Apphacker’s learning curve

    Sending a request from a content script looks like this:

    contentscript.js  
    ================  
    chrome.extension.sendRequest({greeting: "hello"}, function(response) {  
      console.log(response.farewell);  
    });  
    

    Sending a request from the extension to a content script looks very similar, except that you need to specify which tab to send it to. This example demonstrates sending a message to the content script in the selected tab.

    background.html  
    ===============  
    chrome.tabs.getSelected(null, function(tab) {  
      chrome.tabs.sendRequest(tab.id, {greeting: "hello"}, function(response) {  
       console.log(response.farewell);  
      });  
    });
    

    Very important to note that from an extension you use *chrome.tabs.sendRequest* (note the *tabs* instead of *extension*) and from a contentscript you use *chrome.extension.sendReuest* (note the *extension* instead of *tabs*)

    Totally different methods. Completely tripped me up for about an hour.

    Posted via web from Apphacker’s learning curve