Chapter 15

Ten Resources for Object-Oriented Development

In This Chapter

Familiarizing yourself with seminal books

Learning from industry luminaries

Taking advantage of free online courses

Staying abreast of the latest in OO development

Software engineering, including object-oriented development, isn't a craft you perfect in an undergraduate curriculum and practice, unchanged, for your entire career. True, there are basic concepts that every aspiring software engineer must come to understand, many of which haven't changed in years or even decades. But becoming an effective software developer means making a commitment to continual learning throughout your working life.

Luckily, it's never been easier to acquire the knowledge and skills you need. Just consider the wealth of resources available to you: books, articles, tutorials, sample code, online courses. To help you comb through this (often overwhelming) supply of information, this chapter identifies ten resources you can use to obtain the OO skills you need to be successful.

Design Patterns: Elements of Reusable Object-Oriented Software

In a field as rapidly changing as software development, it's not often that a publication remains relevant over the course of two decades. But Design Patterns: Elements of Reusable Object-Oriented Software, first published in 1994, has done just that. At the time of this writing, the book was in its fortieth printing. It's widely considered to be one of the preeminent authorities on object-oriented software development and design. Design Patterns was written by a group of authors commonly referred to as the Gang of Four — Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides.

Design Patterns presents a number of generalized solutions to software development problems that occur frequently. The book isn't a series of concrete solutions that can be plugged into your applications as-is. Instead, think of each pattern as a template that you can tweak and refine to satisfy your specific requirements.

The book begins with introductory material on object-oriented development, including basic OO topics like inheritance, polymorphism, and programming to interfaces. These concepts are illustrated through the case study of a document editor.

The remainder of the book is devoted to twenty-three individual patterns. For each one, the authors describe the problem being solved and why that pattern should be used. Unified Modeling Language (UML) diagrams and sample code are also provided. The patterns are divided into three categories — creational, structural, and behavioral.

Creational patterns are those that create object instances and thereby prevent client code from having to call constructors directly. Examples of creational patterns include the Factory Method pattern, which delegates instantiation to subclasses; and the Prototype pattern, where new objects are created by cloning existing objects.

Structural patterns deal with how objects are composed to provide various capabilities. Examples in this category include the Façade pattern, used to wrap a complex body of code in a simple interface; and the Decorator pattern, which is a way to alter the functionality of individual objects rather than every object of a particular class.

Behavioral patterns are concerned with how objects interact with each other. Examples include the Observer pattern, useful for notifying dependent objects of state changes; and the Visitor pattern, which separates an algorithm from a collection of classes it operates on.

Chapter 4 covers how you can use these patterns in iOS.

martinfowler.com

Martin Fowler is a highly-regarded software engineer known for writing and speaking about various OO topics. Two of his best-known books are UML Distilled: A Brief Guide to the Standard Object Modeling Language and Refactoring: Improving the Design of Existing Code. He is also coauthor of the “Manifesto for Agile Software Development,” written in 2001.

Mr. Fowler's website, http://martinfowler.com (shown in Figure 15-1), is a great resource for all sorts of OO information. It focuses on areas of particular interest to the author — design, refactoring, agile, and others — but anything relevant to software development is liable to appear. In addition to articles from Fowler and some of his colleagues, the site includes talks, descriptions of OO tools, and a newsfeed.

Object-Oriented Programming with Objective-C

If you're looking for nuts-and-bolts iOS development, the Mac Developer Library presents “Object-Oriented Programming with Objective-C,” shown in Figure 15-2. Check www.dummies.com/go/iosprogramminglinks.

This guide defines what OO means from the Object-C perspective. It's not an in-depth examination of the language; instead, it's an explanation of how the language realizes the goals of OO.

The guide begins by explaining why Objective-C was chosen as the language for the Cocoa frameworks. From there, it dives deeply into OO programming and its basic principles — classes, abstraction, inheritance, dynamism, and so on. It then takes a step back and shows how you can employ these concepts to structure an OO application. The guide concludes by providing insight on how to effectively manage OO development projects.

You can find this guide on Apple's website, both as a series of pages and as a standalone PDF.

The Journal of Object Technology

The “Journal of Object Technology” (JOT) is a free, peer-reviewed journal devoted to, you guessed it, object technology. You can find the journal's website at http://www.jot.fm (see also Figure 15-3). JOT was founded in May 2002 by Bertrand Meyer, a well-respected voice in the area of programming languages and creator of the Eiffel programming language.

JOT provides previously unpublished articles, surveys, tutorials, and other helpful resources. Although JOT's publication schedule is sometimes sporadic, it remains active and was in its eightieth issue at the time of this writing. Occasionally, JOT produces a special issue, often coinciding with work from a particular conference. All past issues are available for viewing on JOT's website.

The site also features a blog, newsletter, and RSS and Twitter feeds that provide helpful supplementary information.

Massively Open Online Courses (MOOCs)

MOOCs are becoming increasingly popular ways of delivering educational content. The idea is that high-quality courses that were previously available only to students enrolled in a higher learning institution are now provided for free on the web. Anyone can register for an account, enroll in courses of their choosing, and complete them at their own pace. MOOCs often use forums and other means of collaboration to create a mutually beneficial community for its students. The breadth and requirements for completing the courses vary widely among different services.

Many widely popular MOOCs provide courses in computer science and specifically OO development. Figure 15-4 shows three of the most popular MOOCs.

Udacity is run by a collection of CEOs, professors, and entrepreneurs. Udacity's courses aren't carbon copies of existing university courses; instead, they're created for Udacity by its contributors. Courses of interest to OO developers include general introductory computer science and software design.

Coursera provides a collection of courses from universities around the world. At the time of this writing, this collection included courses in over 500 languages from nearly 100 institutions. Coursera has a good number of computer science courses and a few devoted to OO.

edX was founded jointly by Harvard and the Massachusetts Institute of Technology (MIT) in 2012. edX courses are contributed from its consortium of member universities. At the time of this writing, this consortium contained 29 universities from all over the globe. Among the many computer science courses available on edX, “Paradigms of Computer Programming” provides a thorough look at OO programming and how it relates to other paradigms. This course is provided by the Université catholique de Louvain in Belgium.

Some institutions are providing alternatives to full-blown MOOCs simply by making raw course materials available on the web without the typical structure of an online course. Examples include Stanford Engineering Everywhere (SEE) and MIT OpenCourseWare (OCW). These programs don't offer the sort of guidance and community features that traditional MOOCs do but are still good sources of information. Both SEE and OCW have courses dealing with OO and other software topics.

Ambysoft

Scott Ambler is a software consultant who focuses on agile development practices. Over the years, Mr. Ambler has written hundreds of articles and almost 20 books on all sorts of software engineering topics. Of particular relevance to this book are the resources concerning objects, patterns, reuse, and agile development. You can find the full list of Mr. Ambler's writings at http://www.ambysoft.com/onlineWritings.html (see Figure 15-5).

Also on Ambysoft's website is a collection of dozens of podcasts and interviews mostly related to agile methods. Mr. Ambler also conducts surveys from time to time about all sorts of topics in IT.

Craig Larman's Use Case Primer

As I discuss in Chapter 2, before beginning development on any iOS application, it's critical to understand the system's requirements. In recent years, especially with the rise of agile development, use cases have become the most widely used mechanisms for capturing requirements. Use cases walk through the steps that the user (or other actor) takes in order to exercise the various capabilities of the application.

Craig Larman's use case primer is a good place to start when you need a thorough understanding of how use cases are structured and used. Larman is a consultant who specializes in applying agile methodologies to large-scale development organizations. He has written several books and articles on agile, as well as others on UML, design patterns, and software architecture.

The use case primer (shown in Figure 15-6) is a chapter from Larman's book Applying UML and Patterns. Check www.dummies.com/go/iosprogramminglinks. Although many references are made to the Unified Process (UP), the majority of the information in the chapter can be applied to use cases in general.

The primer begins with an explanation of what a use case is, how it's structured, and why it's useful in capturing requirements. Larman breaks use cases into three categories — brief, casual, and fully dressed — based on size and thoroughness. A fully dressed sample use case is discussed in detail.

Larman then provides a series of guidelines to follow when identifying and drafting use cases. The remainder of the chapter shows how you can use UML to create use case diagrams and how you can utilize use cases within an iterative development process.

uml.org

Although Craig Larman's use case primer makes a good case about why UML is helpful in creating effective use cases, it doesn't go into detail about UML. For that, head on over to http://uml.org, shown in Figure 15-7.

Grady Booch, Ivar Jacobson, and James Rumbaugh developed UML in the 1990s. In 1997, the Object Management Group (OMG), the standards consortium that runs uml.org adopted it. The website features an extensive introduction to the language and links to third-party tutorials and training classes. If you're feeling really ambitious, you can even download the full UML specification (warning — it's gigantic). And if you decide to use UML as part of your development process, uml.org also has a list of tools and vendors that will help you get the most out of the language.

For those who have a deep interest in UML, OMG offers a certification program meant to be a “rigorous, comprehensive, and fair test of a person’s knowledge of OMG’s specifications for unified modeling language.” Three levels of certifications are offered — fundamental, intermediate, and advanced.

Agile Alliance

Even the most beautifully conceived object-oriented application can fail if the development process is inadequate. That's why a portion of Chapter 2 is devoted to software development lifecycle (SDLC) processes. As mentioned there, these processes help to ensure quality, traceability, and repeatability (among other characteristics) within your software development project.

Most of the widely used software development processes in the industry today fall into the category of agile. While agile has many manifestations — scrum, extreme programming, and test-driven development to name just a few — all of them share the same underlying philosophy. Development tasks are completed in short iterations that add incremental value to the product. Feedback from stakeholders is frequent and requirements are refined along the way.

The Agile Alliance seeks to promote the use of agile methods to improve the software industry as a whole. The Alliance's website (http://www.agilealliance.org, shown in Figure 15-8) is a great resource regardless of your knowledge about the subject. Beginners will want to start with the What Is Agile? section and then take a look at the Agile Manifesto and the Twelve Principles of agile. More advanced readers can skip over to the Resources section, where you'll find a list of books, articles, guides, and user groups. Note that some resources, such as the research papers made accessible through a collaboration with IEEE, require an Agile Alliance membership. Memberships are available at the individual and corporate levels. Major corporate members include IBM, PayPal, and Lockheed Martin.

The Agile Alliance has been hosting an annual conference since 2002. Resources from each of these conferences is made available on the website.

Rajiv's YouTube Video Series

In the spirit of open online learning espoused by the MOOCs previously described, your trusty author along with collaborators Michael Herold, Joe Bolinger, Thomas Bihari, and Jay Ramanathan have developed a curriculum designed to expose students to the end-to-end process of software development as practiced in industry. This curriculum is available as a series of YouTube videos, the first of which is shown in Figure 15-9.

The video titles and their links are as follows:

• Enterprise Software Engineering
• Introduction: www.youtube.com/watch?v=VPbKo7uSOYM
• Business Context: www.youtube.com/watch?v=nHsU-TpyJZI
• Software Engineering Process: www.youtube.com/watch?v=jnHXggkb_vM
• Software Engineering Process Examples and Case Studies: www.youtube.com/watch?v=RU9a2Gd-vMQ
• Requirements: www.youtube.com/watch?v=Hsr-Npd_YHE
• UML: www.youtube.com/watch?v=7zUaFyCMg3I
• Analysis: www.youtube.com/watch?v=Hy169OyrSvA
• Architecture: www.youtube.com/watch?v=Sztag3aqZr0
• Project and Risk Management: www.youtube.com/watch?v=ArfaMzcI8Uc

The goal of this curriculum is to give the student a holistic view of how software is conceived, designed, built, and maintained in the real world. It was generated by an awareness that many students coming out of traditional computer science undergraduate programs view software engineering as being too narrow and often limited to constructional aspects learned from textbooks and small-scale projects. Such students struggle to extrapolate abstract concepts to on-the-job situations because they lack an understanding of software development as a whole.

Of course, this curriculum covers object-oriented development and many of the other related topics described in this book, such as UML and agile methodologies.