John Cook is an applied mathematician working in Houston, Texas. His career has been a blend of research, software development, consulting, and management. John is a DZone MVB and is not an employee of DZone and has posted 175 posts at DZone. You can read more from them at their website. View Full User Profile

A Simple Guide to the PROs and CONs of High Level Langs, OOP, Funct. Programming, GC, and More

  • submit to reddit

Mike Swaim gave a presentation today entitled No Silver Bullet, an allusion to Fred Brook’s classic essay by the same title. You can download the slides here.

Mike discusses the pros and cons of the following software development techniques:

  • High level languages
  • Object oriented programming
  • Declarative languages
  • Functional programming
  • Data oriented design
  • Metaprogramming
  • Static typing
  • Duck typing
  • Garbage collection
  • Allocating on the stack
  • Tail calls
  • Resource acquisition is initialization
  • Symmetric multitasking
  • Heterogeneous multitasking

There’s a nice collection of links at the end of each section.

Check out the whole slideshow, attached, for all of the topics' pros and cons.

SilverBullets.pdf1.27 MB
Published at DZone with permission of John Cook, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)


Chuck Dillon replied on Wed, 2012/04/18 - 1:04pm

I nice summary but you've stepped on one of my pet peeves.   You list the advantages of OOP as encapsulation, modularity and reuse (promotion).  That is not true.  Those are good design principles that should apply to any design effort in any language.  The advantage of OOP in this regard is that those tools can, but don't necessarily, promote application of those design principles and the practice of reuse.  OOP is neither sufficient nor necessary to achieving those goals.

Similarly you miss, but illustrate, a disadvantage of OOP which is that it obfuscates understanding of those good design principles.  It leads some to believe that OOP is sufficient to gain the benefits of those principles when it is not.  It leads some to avoid other tools or ignore these principles because they erroneously think those design principles will not be attainable when that is just not true.

The recognized (decades ago) need to broadly apply encapsulation, modularity and reuse to design and practice begot OO, not the other way round.

Erik Post replied on Thu, 2012/04/19 - 8:21am

Also, the slides mention objections to 'static typing' that only apply to particular forms of static typing. Ad hoc polymorphism (e.g. type classes in Haskell and Scala) doesn't have these problems.

Paul Russel replied on Sun, 2012/06/10 - 9:29am

Looks good, with one major omission. Metaprogramming and Lisp – one of the major insights I got using Lisp in school. The metaprogramming language of Lisp is Lisp. Enough so the you can readily create domain-specific languages within Lisp. One of the main failings of C++ templates is that they are yet-another programming language, within C++, with limited inflexible semantics.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.