CocoaHeads Paris this evening (may 27, 2009)

A meeting for Cocoa developers in Paris.

Main subjects today:

• F-Script
• Projet Osculator

Location: La Cantine – 151 rue Montmartre, Passage des Panoramas
12 Galerie Montmartre, 75002 Paris

More information here.

Learn how to use F-Script with Daylite in new book by Eric O’Connell

Daylite, the popular business productivity suite from MarketCircle, employs F-Script as a user-facing component allowing advanced control over various tasks, including producing custom reports. Daylite’s report engine (which is also used in Billings, MarketCircle’s other flagship product) provides a powerful platform to produce reports of all kinds, tapping directly into business data. Eric O’Connell’s new book, Daylite Reporting Fundamentals, covers this technology in detail, including advanced usage with F-Script.

NSConference is in one month (time to register!)

One day of workshops + a two days conference for Mac developers in Hatfield, near London, UK. The conference is organized by the excellent Mac Developer Network, publisher of Late Night Cocoa, Mac Developer Round Table and other popular shows. More information at the conference web site.

Here is the conference program:

Sessions

Designing and Developing Custom Cocoa Controls – Matt Gemmell

Take a look at any of the most popular Mac applications and it quickly becomes clear that standard UI controls no longer suffice. Custom user interface is the order of the day, but consistency and intuitive interaction have never been more important – and that principle applies both to what the user sees, and to the code which makes it work. In this session, Matt Gemmell discusses how to create your own controls while maintaining consistency and usability, for both the user and other developers who may use your code.

Pimp My App – Mike Lee

In a global software economy, it’s foolish for Europeans to compete on price. Someone who lives in a smaller economy than yours can always undercut you. Instead, you must compete on merit. You need to make your application better than any free knockoff. You have to sweat the details and add value to your application. You need to pimp your app.

We’ll start at Pimp 101, and learn about the second 80%, the work that begins when you think you’re done. We’ll talk about the idea of a hook, the thing that makes people want to talk about your app with their friends — and other facets of polishing an application, such as performance, stability, and beauty. We’ll talk about the importance of professional artists.

Then we’ll delve into human interaction, and the subtle art of empathy. We’ll talk about your feature list, and how discipline in application design can save you time and make you money. We’ll talk about rule #1: don’t annoy the user, and some common mistakes. Finally, we’ll apply all we’ve learned by pimping an existing app.

Foundations of Objective-C – Andre Pang

One reason for Mac OS X’s success is Objective-C, combining the dynamism of a scripting language with the performance of a compiled language. However, how does Objective-C work its magic and what principles is it based upon? In this session, we explore the inner workings of the Objective-C runtime, and see how a little knowledge about programming language foundations–such as lambda calculus and type theory–can go a long way to tackling difficult topics in Cocoa such as error handling and concurrency. We’ll cover a broad range of areas such as garbage collection, blocks, and data structure design, with a focus on practical tips and techniques that can immediately improve your own code’s quality and maintainability.

New Cocoa Programming Superpowers – Philippe Mougin

In some ways, we are still in infancy when it comes to harvest the enormous amount of power brought by dynamic object systems and frameworks such as Objective-C/Cocoa. Fortunately, new tools and technologies can help us. In this session, Philippe will get you up to speed with F-Script 2.0, a set of open source tools that complement Xcode and Interface Builder. You will learn how to use them, discover how they can bring Cocoa development productivity and fun to new highs, and acquire new programming superpowers not seen before on any other platform!

Integrating with Apple’s Photography Applications and APIs – Fraser Speirs

Learn how to integrate your service or application with Apple’s photography applications iPhoto and Aperture. If your application consumes images, you’ll want to know how to get the most out of the Apple photography ecosystem. In this session, Fraser Speirs will cover the SDKs for iPhoto and Aperture and touch on some of the major System APIs you’ll want to be aware of when dealing with photographs on Mac OS X.

Building a secure Cocoa application – Graham Lee

Mac OS X has a reputation for being a secure operating platform, and many of its security features are available for third-party developers to use in their own application. But there’s also a more fundamental aspect to security – understanding how your software will be used and anticipating how it may be misused. In this session Graham Lee will describe techniques for designing secure applications, then take a tour through the OS X security capabilities developers can use to turn the security dial all the way to 11.

Spotlight and QuickLook vs. Core Data – Marcus Zarra

Marcus will walk through how to integrate a Core Data based application with both Spotlight and QuickLook. Add these important, and usually overlooked features, into your application to add that additional polish that we all expect from OS X applications. In this session we will discuss how these features work and how to get them to work with Core Data in a performance aware way.

Building Applications with Core Animation – Bill Dudney

Core Animation is one of those technologies that is too easy to over hype. It does so many cool things that it is hard to not be overly enthusiastic about what you can do with it. Well Core Animation is not magic but it does make doing several things with your user interface much easier. In this session we are going to see what Core Animation is and how you can use it in your UI. In addition to learning about doing animations with Core Animation we will also learn how to use Core Animation to simplify your drawing and maximize the performance of your application. Come to this session and learn how to build applications that take advantage of this really exciting technology

What a Performance – Drew McCormack

Take a journey through the Mac performance cosmos, with stopovers in exotic destinations like Xgrid Foundation, NSOperation, and Grand Central Dispatch. Never observed an XGActionMonitor in full flight, or got your NSOperation priorities right? Join us for this once in a lifetime opportunity. We’ll look at the emerging trends, and common threads that bind all levels of the performance equation. How are the techniques used in High-Performance Computing similar to those used in modern Cocoa apps running on the latest multi-core laptops? Don’t know, but come along and we’ll see if we can figure it out. This talk will cover everything, from the death of multi-threading, to Snow Leopard niceties like blocks in C and OpenCL. Not to be missed.

Conference Workshops

iPhone Development – Bill Dudney

If your an experienced Mac Developer looking to write your first iPhone application Bill will spend a day helping you get up to speed.

The iPhone is on a tear. With the millions and millions of iPhones sold the market is almost too big to ignore especially for experienced Mac developers. In this workshop you will be brought up to speed on what is different with iPhone development. While Cocoa Touch is very much like App Kit there are differences. This workshop will pull you up the learning curve fast. Here is a list of the topics we will cover;

• View Controllers (what they are how they work etc)
• Table Views (how to use them, esp how to add custom cells)
• Drawing (how its diff on the iphone, no lockFocus backing store is always a layer etc)
• Multi Touch Event Handling (how to do pinch/zoom)
• Accelerometer/Location (cool tech that is only on the phone)
• Photos and Address Book (integration with personal data)

User Interfaces – Mike Lee

This workshop will spend the day looking at how decisions should be made when designing user interfaces.

Core Data – Marcus Zarra

This workshop will spend the day looking at practical issues of using Core Data in your applications.

Core Data for Cocoa Developers
A very brief introduction into Core Data followed up by best practices for configuring both the Core Data stack and Xcode to make the project as maintainable as possible. Also known as “Pimpin Apple’s Code”. Followed by Q&A.

Model Design
How to get the most performance out of your data model, how to choose the best persistent store for your data storage and access needs. Tips include how to pre-populate data into your Core Data persistent store and add data in later versions of the application simply and easily. Followed by Q&A.

Data Model Versioning and Migration
How to make your persistent store upgrades smooth for you as the developer and for your users. Tips and tricks to help reduce the headaches of data migration and how to avoid a Arithmetic progression of NSMappingModels. Followed by Q&A.

Evening Agenda

If you are staying for the evening activities you will get to attend

The Conference Dinner

A great conference dinner where developers can spend the evening talking geek stuff with nobody complaining.

The Mac Developer Roundtable “LIVE”

There will be a late after hours recording of The Mac Developer Roundtable “LIVE”.

First CocoaHeads meeting in Paris

A meeting for Cocoa developers in Paris.
Monday, March 23, 2009 19:00
La Cantine – 12 Galerie Montmartre, 75002 Paris, France

More information here.

17th International Smalltalk Joint Conference – Call for Contributions

Where: Brest, France
When: August 31 – September 4, 2009
http://www.esug.org/conferences/2009/

This call includes:

• Developer Forum
• International Workshop
• Student Volunteer
• Camp Smalltalk 29-30 august 2009

For the past 17 years, the European Smalltalk User Group (ESUG) has organised the International Smalltalk Conference, a lively forum on cutting edge software technologies that attract people from both academia and industry for a whole week. The attendees are both engineers using Smalltalk in business and students and teachers using Smalltalk both for research and didactic purposes.

As every year, this year’s edition of the largest European Smalltalk event will include the regular Smalltalk developers conference with renowned invited speakers, a Smalltalk camp that proves fruitful for interactions and discussions. Besides, this year will be held the 5th edition of the Innovation Technology Awards where prizes will be awarded to authors of best pieces of Smalltalk-related projects and an international workshop on Smalltalk and dynamic languages

You can support the ESUG conference in many different ways:

• Sponsor the conference. New sponsoring packages are described at http://www.esug.org/supportesug/becomeasponsor/
• Submit a talk, a software or a paper to one of the events. See below.
• Attend the conference. We’d like to beat the previous record of attendance (170 people at Amsterdam 2008)!
• Students can get free registration and hosting if they enroll into the the Student Volunteers program. See below.

The conference features the following events:

• Camp Smalltalk – There will be a Smalltalk camp the 29-30 august 2009
• Developers Forum
• Technology Forum
• International Workshop

Developers Forum: International Smalltalk Developers Conference

This year we are looking for YOUR experience on using Smalltalk. In addition, we are looking for tutorials. The list of topics includes, but is not limited to the following:

• XP practices
• Development tools
• Experience reports
• Model driven development
• Web development
• Team management
• Meta-Modeling
• Security
• New libraries & frameworks
• Educational material
• Embedded systems and robotics
• SOA and Web services
• Interaction with other programming languages

Submissions due on 1st June 2009.
Notification of acceptance on 15 of June 2009.
More information at http://www.esug.org/conferences/2009

How to submit?

Pay attention: the places are limited so do not wait till the last minute to apply. Prospective presenters should submit a request to esug-info@esug.org following the template below. Please use this template since the email will be automatically processed!

Subject: [ESUG 2009 Developers] + your name

First Name:

Last Name:

Email where you can always be reached:

Title:

Abstract:

Bio:

Any presentation not respecting this form will be discarded automatically

International Workshop on Smalltalk Technologies

http://www.esug.org/Conferences/2009/InternationalWorkshop

Smalltalk is considered as a design pearl and as a beacon in the realm of programming languages and programming environments. We are proud to invite submisssions to the International Workshop on Smalltalk Technologies which is held as part of the ESUG 2009 joint event. The goals of the workshop is to create a forum around advances or experience in Smalltalk. We welcome contributions on all aspects, theoretical as well as practical, of Smalltalk related topics such as

• aspect-oriented programming
• meta-programming
• frameworks
• interaction with other languages
• implementation
• new dialects or languages implemented in Smalltalk
• tools
• meta-modeling
• design patterns
• experience reports

Format: 10-12 pages in lncs format. Detailed author instructions are available at Springer web site.

Important Dates:

• Submission: 15 of June 2009
• Feedback: 31 of June 2009

Technology Forum

We are proud to announce the 5th Innovation Technology Awards. The top 3 teams with the most innovative software will receive, respectively, 500 Euros, 300 Euros and 200 Euros during an awards ceremony at the conference. Developers of any Smalltalk-based software are welcome to compete.
More information at http://www.esug.org/conferences/2009

Student Volunteer Program

If you are a student wanting to attend ESUG, have you considered being a student volunteer? Student volunteers help keep the conference running smoothly; in return, they have free accommodations, while still having most of the time to enjoy the conference.
More information at http://www.esug.org/Conferences/2009/Student+Volunteers

We hope to see you there and have fun together.

F-Script review on Ars

Ars Technica takes a look at F-Script 2.0 Beta:

Fun Script, also known as F-Script, is a command-line based interactive Cocoa shell. The open source F-Script offers a new way to create and interact with Cocoa objects using a simple scripting language and a Smalltalk-like development environment. Recently, the F-Script shell went beta, providing a new way to interactively build Cocoa. Read more…

F-Script 2.0 Beta 1

F-Script 2.0 beta 1 is out (download here). Here is what’s new since the latest alpha:

Handy syntax for specifying dictionaries

Looks like this (for a dictionary with two entries):

#{key1 -> value1, key2 ->  value2}

This creates an NSMutableDictionary object.

Easy access to standard IO streams

Three globals, stdin, stdout and stderr give access to the standard IO streams. You can invoke the print: method on stdout or stderr, passing a string to output. For example:

stdout print:'hello world'

You should use this instead of the old sys log:'hello world', as the sys object is not available when developing F-Script classes.

Switching between automatic GC and reference counting

You can now choose to run F-Script.app either with automatic Objective-C garbage collection or in reference counting mode, thanks to a new option in the preference panel. Personally, I use to run with automatic garbage collection whenever I can and switch to reference counting mode when I need to load frameworks or bundles that do not support automatic garbage collection.

F-Script Anywhere

A developer preview version of F-Script Anywhere 2.0 is included in the distribution!

Updated documentation

In particular, a new tutorial, Creating Cocoa classes with F-Script, provides a quick introduction to this new feature of F-Script 2.0.

Enjoy!

MacDev 2009 Sessions

The MacDev 2009 conference program looks great. A number of sessions are already described here. There will also be workshops and other activities. I’ll be giving a session modestly titled New Cocoa Programming Superpowers:

In some ways, we are still in infancy when it comes to harvest the enormous amount of power brought by dynamic object systems and frameworks such as Objective-C/Cocoa. Fortunately, new tools and technologies can help us. In this session, Philippe will get you up to speed with F-Script 2.0, a set of open source tools that complement Xcode and Interface Builder. You will learn how to use them, discover how they can bring Cocoa development productivity and fun to new highs, and acquire new programming superpowers not seen before on any other platform!

F-Script 2.0 Alpha 7

Alpha 7 is out (download here). Four main user visible changes:

Class instance variables

We now have support for class instance variables. In the following example, we use this capability to define a class that keeps track of how many times it has been instantiated:

MyClass : NSObject
{
  "Define the class instance variable that will keep track of allocations"
  allocationCount (class instance variable)

  "The +initialize method is handy to initialize class instance variables"
  + (void)initialize
  {
      allocationCount := 0
  }

  "Perform the allocation"
  + alloc
  {
      allocationCount := allocationCount + 1.
      ^ super alloc
  }

  "Return how many times the class has been sent an alloc message"
  + allocationCount
  {
      ^ allocationCount
  }
}

New methods for compression

Compression and indexing used to be provided by the same methods (i.e. at: and derivatives such as at:put: and removeAt:). In F-Script 2.0, compression is done using a different set of methods: where:, where:put: and removeWhere:. Having dedicated methods for compression will make code clearer and will allow for interesting new features in a future version. Of course, the old way of doing compression still works for backward compatibility, but you are encouraged to switch to the new methods.

For those new to array programming, compression allows selecting some elements of an array. It takes an array of booleans as argument and selects the elements of the receiver whose positional matching element in the argument is true. For example, say we define the following array of numbers:

numbers := {-5, -6, 3, 4, -1, 10}

Here is how we can select the elements in our array that are positive:

numbers where: numbers > 0

Now, we remove all negative elements:

numbers removeWhere: numbers < 0

Finally, we replace elements equal to 10 by 100:

numbers where: numbers = 10 put: 100

In the end, our array is equal to {3, 4, 100}.

Mandatory return instruction

Returning a value from a method must be specified explicitly using a return instruction (a caret followed by an expression). For example, the following method returns the string ‘hello’ :

- myMethod
{
    ^ 'hello'
}

Prefixed classes

In F-Script 2.0 all public classes are now prefixed. Consequently, Array, Block, Number and System become FSArray, FSBlock, FSNumber and FSSystem. The old classes are still there for backward compatibility (with the exception of System), but are deprecated. Tricks are in place to ease the transition but if you have defined categories or subclasses, you must change them to relate to the new classes.

Java Productivity Primer

Last year, I joined a team in charge of creating and supporting a Java software factory for a large financial institution. The main architect of this development environment was Arnaud Heritier, one of the leaders of the Maven project. Together with other colleagues from OCTO Technology, he put up a very modern and interesting environment for helping both local and offshore Java development teams to become more productive. After a while, we got the opportunity to write about some of our best practices, and we produced a little white paper that is now available for download.

It’s a primer that provides a gentle introduction to state of the art productivity-enhancing practices in the Java enterprise world. In addition, I think development teams can also use it as an effective vector of communication oriented toward management to strengthen proposals related to modernization of development practices.

So, enjoy Java Productivity Primer: Twelve guidelines to boost your productivity with a software factory!

Late Night Cocoa on F-Script

I’m on Late Night Cocoa, discussing F-Script 2.0 with Scotty of the Mac Developer Network. You can listen to us here.

F-Script Discussion Group

I just created a F-Script group on Google Groups. You are invited to join and to use it for technical questions or discussions about F-Script and related subjects. This is also the place where you can get notified of the latest releases.

You can access the group at http://groups.google.com/group/f-script

A New Conference for Mac Developers: MacDev 2009 Announced

One day of workshops and a two days conference for Mac Developers, organized by the excellent Mac Developer Network. The workshops+conference will run from April 15 to April 17, near London, UK. I’ll be speaking there! More on the conference Web site.

Type inference for F-Script

F-Script is mostly latently typed and, as such, could benefit from a type inference system. Among other things, type inference can be used to detect a number of programming errors at compile time (which is nice) without cluttering programs with explicit typing.

Creating such a system for F-Script can draw from techniques already in use with some latently typed languages. Beside, in the case of F-Script, there is a way to improve the efficiency of these techniques to produce a powerful and effective type inference system. The key point is that while F-Script code is largely exempt of explicit typing, most methods invoked from F-Script are actually Objective-C methods for which explicit typing information is often available. This means that we have a massive amount of type information we can feed the type inference system with, making it easier for it to infer new type information in F-Script code and, ultimately, to detect potential programming errors (or to help with automatic optimization, etc.)

This interesting approach is presented by Andrew Weinrich and Ben Liblit, from the University of Wisconsin-Madison, in « Type Inference in Mixed Compiled / Scripting Environments ». In particular, they describe how it is implemented in flint a type checking and static analysis tool for F-Script under development.

Summary:
Programs written in statically-typed languages are commonly extended with scripting engines that manipulate objects in the compiled layer. These scripting environments enhance the capabilities of the program, at the cost of additional errors that would be caught by compile-time type checking. This paper describes a system for using type information from the compiled, statically-typed layer to perform type inference and checking on scripting code. To improve the quality of analysis, idiomatic rules based on common programming patterns are used to supplement the type-inference process. A proof-of-concept of this system is shown in flint, a type-checking tool for the language F-Script.

F-Script for Automator

Dominique Dutoit has released an F-Script action for Automator. It lets you add custom F-Script code within your Automator processes. You can get it here.

The input of the action (i.e., the output of the previous action) is automatically bound to a variable named “input” in the F-Script workspace. Usually, it is an NSArray object. The output of the action is the value of the last F-Script expression executed in the custom F-Script code (automatically boxed in an NSArray if needed).

You’ll need to have the F-Script framework (download here) installed in /Library/Frameworks/ or ~/Library/Frameworks/.

Enjoy!