I’ve been a big fan of Cappuccino since late 2009 and have written and spoken about it pretty extensively. This past July I went to sunny Tetbury, UK to record a video course entitled “Cappuccino for Cocoa Developers.” Here’s some background on how the course came into being…

In addition to being a tony little country village where Prince Charles has one of his castles, Tetbury is famous for being the home town of iDeveloperTV, a company much loved by indie Mac and iOS developers for putting on NSConference, along with the extensive library of video courses and podcasts it has produced over the years. This past Spring, Steve “Scotty” Scotty invited me to give a presentation on Cappuccino at NSConference in the UK. It was extremely well-received, so I reprised the talk at the first CappCon in San Francisco this past Summer.

My goal for both talks was to show existing Cocoa developers how they can leverage their existing skills to craft desktop-caliber web-apps. In the course of preparing for these presentations, I ended up developing a series of carefully-designed tutorial apps, designed to feel comfortable to Cocoa developers while highlighting some web-specific architectural considerations.

These tutorial applications thus formed the basis of the 4 hour course. We shot the video against a white background so that the “talking-head” video could be mixed-in with the screen capture from my laptop as you see here:

The net effect is quite like having your own personal trainer. Scotty’s role is to make sure that I highlighted the points that may not be obvious to first-time learners.

The video is delivered in high-quality, DRM-free H.264 video that you download to your machine. Sync it to your iPad if you wish, then watch it in bed before dreaming of Cappuccino. The resolution lets you clearly read the code while listening to the discussion. Work along with the same source code shown in the video, adapt it to your needs, then build something meaningful to you. Since data persistence in web-apps is a major consideration, I’ve even included the source code for a simple RESTful Web Service written in Ruby on Rails so you can see how things work end-to-end.

I’m extremely proud of the work I did in creating this course, and I think Dave at iDeveloper TV did a bang-up job with the editing. Scotty has been kind enough to release the course at the exceptional price of US $29.99 in order to put in reach of everyone. Complete details can be found here:

http://ideveloper.tv/video/cappuccinocourse.html

I hope you enjoy the course. Feedback is greatly appreciated. Hopefully, I’ll have the chance to make some additional courseware in the future.

If you haven’t been paying attention, we’re holding the first ever Cappuccino conference in just 10 days in San Francisco! Today, we sold our last tickets to the event! We do have a wait list, and we’re trying to figure out how to add more tickets for the event, so sign up to get notified when more tickets become available.

Yesterday Google announced their revolutionary web store. We’re super excited about this and thrilled that there are already eight Cappuccino apps on the web store today.

We’re really proud of these applications built with Cappuccino.
If we’ve missed any, please leave us a comment and we’ll be sure to add it!

To showcase our new NativeHost technology, we’re proud to announce the brand new GitHub Issues App, written entirely in Cappuccino and available for both desktop and web:

The online version is running on Heroku’s Node.js beta at http://githubissues.heroku.com. If you’re already using GitHub’s Issue tracking feature, then this app will work for you right out of the box. Simply type in your repo’s identifier (username/reponame), and we’ll fetch all the issues for you. You can also log in with your GitHub account to access private repositories.

Open Source

The GitHub Issues app was put together by some truly excellent members of the Cappuccino community, and we’re open sourcing it so that it can serve as an example of how to build and architect a full blown application with Cappuccino and Atlas.

If you don’t have Atlas you can still build the app using the Jakefile in the repo, but you will need Atlas to edit the visual interface files. You can find the source code at http://github.com/280north/issues. So don’t just use it, clone it, patch it, and of course, file bugs!

Cappuccino, NativeHost, Heroku, Node, Oh My!

This app uses and integrates a tremendous amount of new and exciting technology. If you take a look at the source you should find examples on how to do everything from setting up a server to talk to Cappuccino, to optionally deploying your app to the desktop, to talking to other JavaScript libraries:

• We use our brand new NativeHost technology which allows the app to run both on web and desktop.
• We make extensive use of the new tableview component, added in version 0.8
• We integrate with markdown and mustache.js and show you how to intermingle Cappuccino chrome with HTML pages.
• In web mode we use node.js running on Heroku’s new Node Beta.
• We of course use the awesome JSON GitHub Issues API.
• We lay out almost all our UI code visually in Atlas.

If you’d like to help improve the app, or just have questions about the code, make sure to get in touch with us and the rest of the Cappuccino community in the IRC channel or on the mailing list

Thanks!

I wanted to thank everyone who helped bring this app together, including the fantastic guys at the GitHub and Heroku, and of course Randy Luecke and Ludwig Pettersson who actually did the hard work of putting this thing together.

Today we’re adding an exciting new open source component to the repertoire of Cappuccino tools. If you’ve checked out out any of the Atlas betas, you’re probably aware that they’re distributed as a desktop application. What you may not know is that despite this, Atlas is still itself a full fledged Cappuccino application (written in Atlas no less). Atlas has had the ability to create both web and desktop applications from the start, requiring nothing but the click of a button:

The way we’ve accomplished this is with a technology we call NativeHost. NativeHost allows you to take existing Cappuccino applications and with no additional work target them for the desktop. It accomplishes this with an incredibly small and lightweight wrapper around the WebKit browser engine. In this respect, it is similar to a number of existing technologies, including Adobe AIR and Titanium, but that’s where the similarities end.

Why deploy to the desktop?

We believe that applications are moving to the web, but as things stand today, there are still some valid use cases for choosing to distribute a downloadable executable. By allowing you to seamlessly deploy to both desktop and web, we hope to remove one of the blockers keeping people from choosing HTML5 as their next target environment. There are a number of scenarios in which you might decide that the desktop currently fits your needs better:

• When your application needs access to the local filesystem or other native APIs not available to web applications running in browsers.
• When you need enhanced offline access.
• When your target users work in an environment that does not trust the cloud yet (providing a downloadable and not using any web buzz words goes a long way here).
• When you need integration with OS features like the taskbar, dock, application switcher, etc.

This is actually precisely why we created this technology. We were originally planning on releasing Atlas as a cloud-based IDE, but soon discovered our users were much more comfortable currently running it as a desktop app. With NativeHost, we can fulfill these needs today, but switch to the web in the future. Whatever your reasons are, NativeHost aims to provide the best solution for Cappuccino applications.

Why NativeHost?

Before creating NativeHost, we evaluated a number of existing solutions but found that they all suffer from either or both of two major drawbacks:

• Many tools require modification to the existing web app to work on the desktop, or worse, require you to target this environment from the beginning. They aren’t really about making web apps works well on the desktop, but rather for creating desktop apps using web technologies. We see this as the worst of both worlds: creating an application that can’t currently take advantage of all the native platform’s advantages, which simultaneously will require a lot of extra work to deploy on the web.
• The flip side to this is tools that provide only a very thin layer around your web app and thus hardly feel native at all.

Again, we feel that the ultimate distribution platform is the web, and that the desktop is almost a transitional necessity today. So with that in mind, we certainly didn’t want to create a tool that required adding a bunch of new API that won’t work online. However, we also wanted an experience that truly felt good on the desktop. NativeHost is able to accomplish this because it is so tightly integrated with Cappuccino. It provides a seamless experience to both the application developer and end user. The goal is to have any existing Cappuccino app just work on the desktop without requiring any new code. This is manifested in an increasing number of integration points:

• The Cappuccino “main menu” automatically populates the native Mac OS X menu bar. On other platforms it will do what is expected by users on that platform. For example, in a Windows version of NativeHost the menu would be attached the top of individual windows.
• Cappuccino windows (CPWindow) automatically become “native” windows. In the browser Cappuccino windows are typically drawn inside the main browser window. In native host they become real operating system level windows that can be minimized, etc.
• Secure access to the native file system without new API: use existing methods like XMLHttpRequest.
• Cappuccino’s document architecture is integrated with the operating system.
• Operating system open/save panels are used.
• Just like any native application your application can register itself to open specific file types. When the operating system requests that your application open a document that information is passed on to Cappuccino for your application to handle.

Getting up and running with NativeHost

The easiest way to try out NativeHost is with Atlas. Open or create an application, select “Native Desktop” from the “Platform” menu, then press the “Build and Run” button. This will build and launch the current application using NativeHost.

We’ve also recently added support for NativeHost to the Cappuccino build tools. If your “Jakefile” does not contain tasks for “desktop” or “run-desktop” you can copy them out of a freshly generated project’s Jakefile (changing the application name where necessary).

Once you have an application with an updated Jakefile simply execute “jake run-desktop” within the project’s directory to build and launch the application using NativeHost.

NativeHost has some additional features, like the ability to start a webserver in the background to handle tasks using APIs not exposed to WebKit. We’ll talk more about these features in a future post.

Currently NativeHost supports Mac OS X, but we’re working on other platforms. If you’re experienced with developing native applications on other platforms and interested in helping out, feel free to get in touch.

If you have any problems using NativeHost, the Cappuccino community will happily help you out. Join us in the IRC channel, on the mailing list, or file a bug.

We just shipped another update to the Atlas Beta today, and one of the coolest new features is the addition of a plugin API to allow you to create custom controls that you can use as easily as the ones you get by default. To kick this off we’ve provided a sample plugin for the Google Maps API. You can take a look at what its capable of here:

We’ve also put together a tutorial (see below) on how we built this plugin so that you can learn to do the same with your code. The MapKit framework and plugin are of course completely open source, so feel free to take a look!

Atlas Plugin API Tutorial with MapKit from 280 North, Inc. on Vimeo.