Modern scrollbars

Cappuccino now features new scrollbars which fade away automatically when not in use, giving more space for the content of your scroll views. If the user’s browser does not support or use overlay scrollbars, Cappuccino automatically detects it and falls back to old style scrollbars.

Documentation Overhaul

The Cappuccino documentation has not only been extended but also visually refreshed. Many more classes and methods are now in the documentation and it’s an easier read.

Popover Widget

A popover control is a small window that appears to ‘come out’ of a part of your user interface, and which remains attached to it until the user dismisses it. It’s an easy way to ask for extra information when that ‘create’ button is clicked, or to show a list of individually selectable downloads when the ‘downloads’ button is clicked.

CPPopover originating from a button.

Level Indicator Widget

A level indicator shows a discrete graduation from ‘empty’ to ‘full’, useful for certain gauges like space usage. Level indicators can also be editable and can be placed inline in table cells.

Level indicators, some in a ‘warning’ state.

Predicate Editor

Predicates are powerful tools for encoding ‘search patterns’, and combined with the power of Cappuccino’s Array Controller class they make it incredibly easy to create user searchable tables or other views. The new predicate editor allows users to create their own saved searches with almost no work for the developer.

Tooltips

A much requested feature has been tooltips. We didn’t want to release something that wasn’t as powerful and flexible as everything else in Cappuccino and we don’t think we will disappoint. Cappuccino tooltips can be attached to any control, position themselves intelligently and support multiline tips.

Stronger Interface Builder Integration

If you want to easily create and edit your user interfaces using a visual editor, you have the best tool in the market available for use with Cappuccino: Interface Builder. Every aspect of the nib2cib experience has improved, with better support for fonts, smarter realignment of widgets to match Cappuccino sizes and support for more controls than ever before. Best of all, the new XcodeCapp application automatically creates an Xcode project out of your Cappuccino project and lets you place UI components with ease.

New Installer

The new bootstrap installer is much simpler to use and installs all the packages you will need by default.

You know you want to.

Notable Improvements

There are too many improvements to list them all here but here are some highlights:

• CPNumberFormatter with CPNumberFormatterDecimalStyle.
• More powerful objjc CLI.
• CPButton continuous mode.
• Keyboard navigation, improved submenu handling and auto validation in CPMenus.
• Support for pattern fills when drawing using CG.
• Many new bindings features and optimisations, including CPNullPlaceholderBindingOption, CPContinuouslyUpdatesValueBindingOption and better object controllers.
• CPUserDefaultsController which can be used to easily bind controls to user default keys in Interface Builder or elsewhere.
• CPColorWithImages convenience function to quickly create a `CPColor` from single, 3-part or 9-part images.
• Support for autosaving and collapsing views towards the right in CPSplitViews.

For the full list of changes, see the Cappuccino 0.9.5 change log.

The Team

We’re also happy to announce we’ve added Klaas Pieter Annema, Aparajita Fishman and Antoine Mercadal to the core team. Their contributions to Cappuccino have been invaluable.

- The Cappuccino Core Developer Team

Download Cappuccino

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.

For most people this will not make much of a difference but if you are building from source, you might want to pull from the new repository instead. The Git URL is then:

git://github.com/cappuccino/cappuccino.git

If you are running a UNIX like system, you can update your Git clone using a command like this one:

find . -path "*.git/config" -type f -exec sed -i '' 's/github.com\/280north/github.com\/cappuccino/g' '{}' \;

If you find an old issue link, from a mailing list for instance, you will have to modify it by hand to find its new home. For example:

https://github.com/280north/cappuccino/issues/10

becomes:

https://github.com/cappuccino/cappuccino/issues/10

Feel free to help out and update links in the wiki.

Two of our favorite reactions were “this is the best conference I’ve ever been to” and “CappCon was better than WWDC.”

Announcements

Perhaps the most exciting part of the event was the amount of projects revealed and released! If you didn’t follow the event on Twitter, here is a quick overview of announcements made:

• Language.js: Objective-J author Francisco Tolmasky has open sourced his new parser generator. Language.js gives you first class error reporting as well as unprecedented speed. This new parser generator will be the basis for Objective-J 2.0, which will open many unheard-of opportunities for the language. Language.js on GitHub
• CoreText and CPTextView: Cappuccino core team member Nick Small showed off his new implementation of CoreText and CPTextView. These amazing new controls for rich text represent the first time ever we will have desktop-class rich text on the web, which also offers feature parity with Cocoa’s NSTextView. CPTextView will be available soon, but CoreText is open source now, in its own branch in Cappuccino mainline.
• Aristo 2.0: Sofa has worked hard to provide a new version of the already best-in-class Aristo theme that we have already started to implement in Cappuccino. Aristo 2.0 accomplishes some new goals, mainly to “under-promise and over-deliver,” something we’ll talk more about in the coming weeks. Preview of Aristo 2.0
• Frappuccino and RunKit: Austin Sarner and Mark Davis will be open sourcing their physics-based animation toolkit, and alternative UI framework.

The Future

Of course there were many more announcements and talks, and the videos and slides for every talk will be available in the coming weeks. The atmosphere at CappCon was infectious; people were thrilled to attend, learn, talk, and interact.

Most importantly, everyone present was a part of the future of Cappuccino. The takeaway from the event is that Cappuccino is stronger than ever, and with some incredible things in the pipeline, it’s poised to get even better.

Thanks to everyone who could attend, and we hope to see everyone again next year!

We’re excited to announce the first ever full-blown conference dedicated
to Cappuccino: CappCon 2011.

It’ll be in San Francisco, June 11-12. That’s the weekend after WWDC,
so for those of you coming for that, be sure to extend your stay by a
few nights.

We will post more details soon, but we want to get that date out there so you don’t miss it!

It’s going to be a lot of fun.

Be sure to sign up for ticket information when it’s posted on the official website here:

http://cappcon.org

If you have any quick questions you can ping @cappuccino on Twitter, or email Paul at paul@baumgart.us. And definitely get in touch if you think your company might be interested in sponsoring the conference.

Bindings

One of the most exciting features of this release is full Key Value Bindings support. Team members Klaas Pieter, Alexander, Ross, and of course many members of the community have put a tremendous amount of work into getting bindings ready for this release. With support for most major components, CPObjectController, CPArrayController, and undo/redo, bindings are already a killer feature. But we’ve gone one step beyond that and included support for bindings in nib2cib! So not only can you build your Cappuccino interface in Interface Builder, but you can now configure interface bindings in it as well.

CPTableView and CPOutlineView

We were incredibly excited to introduce table views—one of the most important and versatile components in any widget set—in our 0.8 release. In 0.9, we’ve matured the table view to production quality and added its supplemental component, the outline view. CPOutlineView lets you build tables that provide hierarchical data and it inherits from CPTableView, so it already benefits from all the additional work that has gone into the table view.

CPOutlineView

Table views now support bindings, group rows, inline editing, column reordering and resizing, and a whole slew of other features. Perhaps the most requested feature that is now supported: variable row heights.

One of the most important aspects of our table view is performance; we have been very careful not to sacrifice speed for any of these new features. CPTableView will still scroll like butter, even with hundreds of thousands of rows.

New Components

This release also introduces several new features to Cappuccino. You’ll find more controls from Cocoa and some new additions specific to Cappuccino. While there are too many to mention them all here, here are some notable additions:

• CPAlert: Totally rewritten for ease of use and featuring a new UI  designed by Sofa.
• CPBrowser: We’re shipping a great implementation of CPBrowser with this release of Cappuccino. CPBrowser provides columnar layout for displaying hierarchical data. This is very similar to the column view in Mac OS X’s Finder.
• CPCursor: A simple API for changing the user’s cursor. The class supports a number of cursors from the start or allows you to load your own images.
• CPPredicate: The CPPredicate school of classes gives you a very powerful way to filter through your data. A future release may include robust controls for users to visually edit predicates.
• CPStepper: A control that allows users to incrementally step through values.
• CPTokenField: A powerful text field subclass with support for autocomplete, CPTokenField allows you to build unique token managers, like the address fields in Mac OS X’s Mail.app.
• NativeHost: We announced NativeHost a few months ago, but this is the first time we’ve included it with a release of Cappuccino. NativeHost lets you build your Cappuccino application for desktop platforms and distribute it like any other desktop app. Support for Mac OS X is currently included, with Windows and Linux support coming soon.

The Future

We’re extremely proud of this release and all the time and work that has gone into it. We couldn’t have made it to this point this without all our contributors (67 and counting!), and a huge thank you goes out to everyone involved. The core team has grown considerably as well, now composed of 7 team members. We also want to thank everyone who has battle hardened this release through rigorous testing and feedback.

But what’s next? We have a ton of updates in the pipeline, and the master branch is already far ahead of 0.9. Cappuccino has been open source for over 2 years now, and it has been an amazing ride. The framework has vastly matured and a lot of people would have already slapped the 1.0 sticker on it. However, we’ve had a concrete goal of quality and completion in mind from the beginning, and can finally see the light at the end of the tunnel. Stay tuned in the upcoming weeks as we discuss our final roadmap toward Cappuccino 1.0!

-Randy

You can find a full list of changes here.

The 0.7 release used Rake, a Ruby build tool similar to “make”, to manage the build process of Cappuccino applications, as well as Cappuccino and Objective-J itself. In an effort to speed up the tools, reduce the number of dependencies, and allow us to focus on a single language family, we have replaced the Rake dependency with a simple port of Rake for JavaScript, aptly named Jake. Since Jake is written in JavaScript, other JavaScript and Objective-J build tools like the Objective-J compiler can run within the same process, speeding up the build time significantly.

Additionally, we have expanded the command-line/server-side JavaScript environment used for Cappuccino’s tools, now available as a separate project called Narwhal. Narwhal aims to support the emerging CommonJS module and standard library specifications on multiple JavaScript engines.

We started working with the Rhino engine, since the existing build tools were built on Rhino, and have recently added support for the JavaScriptCore / SquirrelFish engine. The performance of Narwhal on JavaScriptCore is an order of magnitude faster than Rhino, vastly improving build times. Currently “narwhal-jsc” supports Mac OS X, but other platform support is in progress.

Another major change was the refactoring of the “press” tool, which attempts to strip unnecessary files from your application bundle. As part of that refactoring we moved the “–flatten” feature, which inlines all code and files into one or more JavaScript files, into a separate tool, unsurprisingly called “flatten”. Flatten now supports splitting your application into multiple files which will be downloaded by the browser in parallel, via the “–split N” option.

For more information on all of these tools, check out the Tools wiki page.

Lately, though, we’re beginning to realize that we didn’t quite go far enough. Memory issues have long plagued JavaScript developers. Because the garbage collector is opaque to the developer, and nothing like “finalize” is provided by the language, programmers often find themselves in situations where they are forced to hold on to an object reference for too long (or forever) creating a memory leak.

Just as we’ve done before, when we tackled this problem we decided to look at what has worked in the past. Finding inspiration in the elegant simplicity of C, we knew we’d found the right solution. And so, we’re pleased to announce the immediate availability of a manual memory management system in Cappuccino.

A lot of Cocoa developers disparaged garbage collection when it came to Objective-C, and we’ve come to realize they were absolutely right! Why rely on machines to solve problems for us when we can do it by hand. So, we’ve taken the Cocoa reference counting system and implemented it in JavaScript. We’ve replaced the existing no-op -retain, -release, and -autorelease methods with fully working implementations. When an object’s release count reaches 0, the object’s dealloc method will be called, and the memory will be able to be reclaimed. Now you have a clear way to clean up unwanted references when an object is no longer being used. Just make sure you do your reference counting correctly!

To do this right, we’ve created a global object table. These objects aren’t going anywhere on their own! If you don’t release an object, it will stick around forever, ensuring you’ll always have it when you need it. This global table acts as a lookup table for any object, allowing us to finally implement pointers in JavaScript. Since $ has become the coolest way to do completely non-standard lookups in an almost indecipherable way, we thought we’d jump on the bandwagon. Pass any pointer to $ and you’ll get the associated object! How do you get a pointer you ask? $$ of course! For example:

var o = [CPobject new]; // +new returns with a retain count of 1!
var p = $$(o); // returns a pointer to o

o === $(p); // we dereference the pointer and get the right object!

Zombies come standard, too! Just set OBJJ_ZOMBIE_DETECTION to true and objj_msgSend will throw an exception if you ever message an object that’s been dealloc’d.

We’ve even take the time to properly -autorelease all objects returned from class methods in Foundation, but we’ve made absolutely no effort to properly retain those objects in Cappuccino code that uses them yet. So we need your help. Every line must be scrutinized (but we shouldn’t to automate this process, as it would surely be too error prone). Rather than focus on developing new features or fixing bugs in the issue tracker, we hope that all Cappuccino contributors will spend their time writing memory management code so that we can fully realize this web development revolution!

We’ll be including these exciting new features in a future release, so you should get started adding manual memory management code to every single line of Cappuccino you’ve ever written! In the meantime, check out the working code on Github.

Please note this is an April Fools joke!

Randy also has his own Cappuccino app he’s been developing called TimeTable. It’s a time tracking app thats set to launch soon, so keep an eye out!

Anyone following Cappuccino can see that Nick has been a valuable member of the community. He’s always offering help in the IRC channel and on the mailing list, and he’s also the most active contributor outside 280 North. On top of all that, he’s been working on some exciting new ideas for Cappuccino, some of which we hope to fold into the main repository in the coming months.

So congratulations to Nick! And as Cappuccino continues to progress, we look forward to adding even more committers to the project.