I had been unsure what this session was going to be about until yesterday's discussion during John Sindelar's session. My driving passion for the past few years has been on acquiring the skills to create effective processes at each stage of the software development cycle and developing a team that is all working together to execute at each stage of the software development process as efficiently and effectively as possible.

In his keynote address to Agile 2009, Allan Cooper makes the point that there are actually four stages of software construction: Understanding the problem to be solved and the macro way to solve it (the big idea), designing the user interaction and interface, engineering the solution, and executing the construction. Each stage has a different goal, outcome, required tool, and state of mind. I raise the point, because yesterday we were bouncing back and forth between solutions to problems in the construction phase, the design phase, and the engineering phase. I would argue that each require a different skill set and each are important, but should be considered separately.

If you have not seen the slides from his keynote, they are definitely worth reviewing. You can find the link to them here: http://www.cooper.com/journal/agile2008/. I will be picking up on these ideas today, and using them to give a structure to our discussion as we discuss ways in which defining and cataloging design patterns can help us in three out of the four stages.

I'd also be interested in what kinds of script triggers are becoming standard patterns for different kinds of layouts. Here is one we use for pop-up mini windows. It manages closing the window if the only record visible is deleted (we run with full menus and the tool bar showing so deleting a record is an option):

SeedCode Calendar: Calendar: Edit Event: On Event Record Load
#
#==============================================
# Function: Closes the Event Detail mini window if the only record visible there is deleted.
# Parameters: none
# Notes: Called from an OnRecordLoad script trigger on the Event Detail layout
# : This is really just window management: when a user clicks on an event and the deletes it, the window would persist if not for this script.
# Author: SeedCode
# Version: 5.05
#==============================================
#
If [ $$sc_ScriptTriggers_Off ]
Exit Script [ ]
End If
#
#Did we delete the last visible record?
#
If [ Get ( FoundCount ) = 0 and ValueCount ( WindowNames ( Get (FileName) ) ) > 1 ]
Close Window [ Current Window ]
Commit Records/Requests
#
Perform Script [ “Refresh Calendar { UseExistingData ; DontRefresh }” ]
#
End If
#

too much for my needs but an interesting example: http://mikhailedoshin.com/cookbook/index.html

Definitely looking forward to this Don. The patterns I use the most in this context (reusable / problem solving) are things like "select a contact", "new off screen window", and "pass & check parameters". Will be interested to hear others examples.

"A design pattern refers to a reusable and applicable solution to general real-world problems. " - Smashing Magazine

After I posted that last comment, I realized that while I don't have anything that exactly addresses the question, there are a few go to books:

Christoper Alexander (Albert Harum-Alvarez's favorite): http://www.amazon.com/Pattern-Language-Buildings-Construction-Environmental/dp/0195019199/ref=sr_1_1?ie=UTF8&s=books&qid=1261532856&sr=8-1-spell


Algorithm patterns:
Algorithms in a Nutshell: http://www.amazon.com/Algorithms-Nutshell-OReilly-George-Heineman/dp/059651624X/ref=sr_1_4?ie=UTF8&s=books&qid=1261533069&sr=1-4

Donald Knuth: http://www.amazon.com/Art-Computer-Programming-Fundamental-Algorithms/dp/0201896834/ref=sr_1_4?ie=UTF8&s=books&qid=1261533266&sr=1-4

The Practice of Programming (http://www.amazon.com/Practice-Programming-Brian-W-Kernighan/dp/020161586X/ref=sr_1_1?ie=UTF8&s=books&qid=1261510397&sr=1-1

Interface Design Patterns:
Jennifer Tidwells Book (It's Great): http://www.amazon.com/Designing-Interfaces-Jenifer-Tidwell/dp/0596008031/ref=sr_1_1?ie=UTF8&s=books&qid=1261532553&sr=8-1-spell

A good roundup from Smashing Magazine: http://www.smashingmagazine.com/2009/06/15/40-helpful-resources-on-user-interface-design-patterns/



Software Construction Patterns - Mostly Object Oriented in Nature

http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns

Gang of Four: http://www.amazon.com/Design-Patterns-Elements-Object-Oriented-ebook/dp/B000SEIBB8/ref=sr_1_2?ie=UTF8&s=books&qid=1261510289&sr=8-2

Cocoa Design Patterns: http://www.amazon.com/Cocoa-Design-Patterns-Erik-Buck/dp/0321535022/ref=sr_1_1?ie=UTF8&s=books&qid=1261532909&sr=1-1

Smalltalk Best Practice Patterns: http://www.amazon.com/Smalltalk-Best-Practice-Patterns-Kent/dp/013476904X/ref=sr_1_2?ie=UTF8&s=books&qid=1261532945&sr=1-2

Nothing great unfortunately. After I suggested this session, I started doing research. I have tons of books on Patterns in Object Oriented programming (the classic is by the "gang of four" http://www.amazon.com/Design-Patterns-Elements-Object-Oriented-ebook/dp/B000SEIBB8/ref=sr_1_2?ie=UTF8&s=books&qid=1261510289&sr=8-2), but nothing great for Procedural Programming.

It seems that all of the pattern books for Procedural programming have to do with Algorithm patterns. To that end, I have started reading The Practice of Programming (http://www.amazon.com/Practice-Programming-Brian-W-Kernighan/dp/020161586X/ref=sr_1_1?ie=UTF8&s=books&qid=1261510397&sr=1-1) and Code Complete ( http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&s=books&qid=1261531396&sr=8-1 ).

I am very much open to what the group thinks, but my interest in this session stems for a desire to catalog and make reusable the pattens we repeatedly use in our development. From my point of view there are three main categories of relevant patterns: Algorithm patterns (these include the FileMaker centric structure of the algorithms we use for looping, sorting, and munging data [as we do more often now that we are using variables and super variables]), solution patterns (These include the patterns we use regularly for solving solution problems. These include things like window management, error handling, plugin checking and deployment, new record creation, detecting and displaying duplicates... ), and interface patterns.

It may be just that this time would be better spent with a different session and I could continue reading my interface design and computer science books. I have just been feeling that the community would be well served if there was some type of documentation of the most common and effective ways of solving these issues which we all repeatedly solve in different ways.

Hey Don, Do you have a reading list on this topic? (URLs or Books) Would like to get a head start on this so I don't spend the whole session working on vocabulary. ;-)

I'm looking forward to this one.

This makes me think of a possible related topic or session. A handful of script steps can be particularly hazardous - GTRR, Delete Record, Close Window, etc. It would be great to begin documenting some of these pitfalls from a design patterns perspective. I'd even love to see or build some reliable wrapper scripts that handle some of these common steps reliably.