Gregor's Ramblings
HOME    PATTERNS    RAMBLINGS    ARTICLES    TALKS    DOWNLOAD    BOOKS    CONTACT

25 Years of OOP

February 5, 2016

ABOUT ME
Gregor Hohpe
Hi, I am Gregor Hohpe, co-author of the book Enterprise Integration Patterns. I like to work on and write about asynchronous messaging systems, service-oriented architectures, and all sorts of enterprise computing and architecture topics. I am also the Chief Architect at Allianz SE, one of the largest insurance companies in the world.

OOP is one of the conferences that originated in the "OO" era of the early to mid-nineties. While most of these events have shed the double "O" -- OOPSLA has become SPLASH and JAOO has become GOTO, OOP stayed true to its name and remains one of the premier German developer conferences. This year OOP celebrated its 25th anniversary. Here are my impressions.

Eoin WoodsFor the 25 year anniversary, Frank Buschmann of POSA fame setup a special jubilee track with famous folks who have been around the block once or twice. First up was Eoin Woods (pronounced "Owen"), co-author of Software Systems Architecture. Eoin spoke on dissolving systems, meaning instead of a giant monolithic chunk these systems consist of an almost organic structure of distributed components. He observed that this not only changes the architecture, but also the role of architects.

True to the spirit of the track, Eoin gave a history of preferred software architectures from monoliths in the 80ies to distributed monoliths (consisting of large pieces) in the 90ies, Internet connected systems in the 2000s and Internet distributed systems in the 2010s. He predicts that systems in the 2020s will be intelligent connected. Along this evolution, the role of architects also changed: with monolithic systems, the vendor pretty much gave us the architecture, leaving us to focus on writing programs. In the 1990s software architecture emerged as a serious topic, for example with the WICSA conference (German speakers can never say this with a straight face). Also, Mary Shaw's and Dave Garlan's seminal title Software Architecture dates back to just 1996 -- not actually that long ago.

As systems become distributed, being dissolved into microservices and connected via API's, architecture takes a stronger role. Maybe this explains my observation of new software architecture conferences popping up in recent years, e.g. the Software Architect Summit and O'Reilly's Software Architecture conference. Eoin observed that just in the 2010s the discipline of software architecture matured with a focus on decision-making, sustainability, managed evolution.

Reflecting on the current state of software architecture, Eoin observes that software architects have become pretty good at structure, relationships, certainty, but not so good at dynamic structures, data and algorithms and operational aspects.

Ralph Johnson: Modeling vs. Coding

Ralph is now officially retired, but appears as active as ever: he is working for Metaficient, which builds end-user programming tools for the financial industry. No quite coincidentally, his talk reflected on the different ways we are looking for models, abstractions, or patterns to make programming easier and more expressive. He consciously excluded visual modeling as he wanted to focus on the essence of the model, not the notation (this is also why he did not mention our EIP patterns).

Ralph was not the only speaker who reminded us of the “Scandinavian School of OO”, which pursued an object model that maps objects to real world items and a vocabulary that is meaningful to users, allowing users to participate in the design process. This actually worked well in business domains, but not so well in things like physics simulations. In contrast the "American School of OO" was driven by pursuit of efficiency through reuse, i.e. economics.

Ralph also reminded us of two famous and very insightful quotes from George Box:

  • All models are wrong, but some are useful.
  • Simple but evocative models are the signature of the great scientist, but over-elaboration and over-parameterization is often the mark of mediocrity.

The most enjoyable part of Ralph's talk was to have the opportunity to chat with him for a good 10 minutes afterwards. I was surprised not more attendees would line up to talk to the Ralph Johnson of GoF fame. I guess German attendees are a bit shy. Ralph reminded me to have another look at Data Model Patterns, which shares many parallels with Martin Fowler's Analysis Patterns, although the books are based on different meta-models: relational vs. object-oriented.

James Grenning on Agile

Being one of the original authors of the Agile Manifesto, James reflected on what went right and what went wrong with "agile". Much of what went wrong relates to Scrum. The most noteworthy sound bites were:

  • "There are 6 times more certified Scrum masters than certified Scrum developers. It seems 6 Scrum Masters are needed to manage one Scrum developer."
  • "If there always is a Scrum master, who are the poor Scrum slaves?"
  • "Why do we have to sprint all the time? Sprinting over long distances makes no sense."

Linda RisingI fear my employer actively supports James' first point: we recently sent around 100 project managers through Scrum certification. They'll be looking for developers to chase through sprints now.

Linda Rising: Patterns: My Journey

It was great to see Linda again. I attended her talk mostly to see her speak as I was part of a good portion of the patterns journey from workshopping Enterprise Integration Patterns at PLoP 2002, Conversation Patterns at EuroPLoP 2008, and attending various PLoPs and ChiliPLoPs. Linda has a knack for making connections between seemingly disconnected domains and a great way of highlighting subtleties that may otherwise go unnoticed. For example, I really enjoyed Linda's description of the difference between a patterns conference and a usual (academic) conference: in a normal conference, a person submits a paper, which is either accepted or rejected, based on the state it is in at the time of submission. Authors of accepted papers are allowed to present their paper, but leave pretty much with the same state of knowledge they came with, aside from interesting Q&A perhaps. Pattern conferences work differently: papers are actively "shepherded" to improve them and to get them into prime time for the conference. During the conference the author does not speak at all -- the paper must speak for itself. Instead, fellow participants and other authors comment on the paper in a so-called writers' workshop. The author leaves with fantastic feedback on his or her paper. While giving feedback on a paper sounds trivial, you have to have experienced a well-moderated writers' workshop to really understand its power. Dick Gabriel's thoughtful book Writers' Workshops appears out of print, but he made the PDF available on-line.

Speaking of making things available, Linda pointed out that she makes all her material available freely and encourages us to give her talk ourselves. Her main motivation is to share the message with as many people as possible.

When will I, will I be famous?

Regular readers already know that most of my references originate from cheesy 80s songs or the movie The Matrix. Staying in tune with Bros' 1987 hit, I felt a big step closer to stardom when I was invited to join a panel on Software Engineering 10 years from Now with none less than (OTI) Dave Thomas, Ward Cunningham, and Richard Soley, Chairman of OMG. These guys have seen the last 30 years of software engineering from up-close and certainly left their mark, so I was a bit nervous about being able to add much at all. Hence, this was the first time I was inclined to actually prepare for a panel.

Luckily, at a dinner at Frank Buschmann's earlier in the week, Kevlin Henney and I recalled that exactly 10 years earlier, at JAOO 2006 we had a similar panel, that time with Dave as moderator and Kevlin as one of the panelist. So I felt it'd be a good start to recap some of the items that occupied us back then and see what they feel like 10 years later:

  • In 2006 folks were concerned about AOP (Aspect-Oriented Programming). It seems we are no longer that concerned because it has gotten pretty quiet on that topic. Dave clearly expressed his view on AOP with a strong thumbs-down vote.
  • In 2006, there was still some quite some activity on mapping, e.g. O/R or Objects-XML. Kevlin already commented back then that mapping sucks. Today it seems we found peace with solutions that don't totally suck and stopped trying.
  • Another topic 10 years ago were CSP - Communicating Sequential Processes. This one actually got traction with Erlang being popular and Go being based on CSP.
  • DSLs are still a topic, but somewhat of a niche. It turns out that building good DSLs with great tool support is possible, but requires some smart folks like Markus Völter and Bernd Kolb.

Alas, Ward was even better prepared and had a whole opening speech drafted up, which included visions of Starbucks Hacker Spaces. Being part of such a star-studded panel, I actually managed to take some notes myself. I hope the audience didn't think I was replying to e-mails during the panel. Here some of the key messages I was able to capture:

  • Ward: We have already seen all the things that will be important in 10 years.
  • Ward: the "Internet of Things" will be just "Things". The Internet weill be taken for granted.
  • Richard: The most widespread languages are still same old Fortran and COBOL.
  • Richard: Security is and will be a key consideration.
  • Dave: Tooling and affordances are still very weak. The accidental complexity can kill us.
  • Dave: Cheap hardware has been saving us: we did not achieve isolation because we are smart enough to understand Erlang, but because processors are so cheap that we can use a micro-services architecture.
  • Dave: The future belongs to people with domain knowledge. You better understand some domains.
  • Dave: With 10TB local storage on your laptop you won't need to reach out to a server for every little thing. Peer-to-peer communication will see a revival.
  • Dave: we will see quantum computing, but you and I won't be using it.
  • Dave: People need to understand software physics, for example threading does not make things magically faster.

Frank Buschmann and Kevlin HenneyI wasn't able to take notes on my own comments, but recall touching on the following topics:

  • It seems that after preoccupying ourselves with things like type systems and languages, we now focus on truly important aspects of software development: security and resilience.
  • Some part of having to deal with these is self-inflicted as we moved to more dynamic, but also more complex run-time architectures.

Frank and Kevlin on Objects

Frank and Kevlin gave a another great review of object-oriented programming, highlighting how much we owe to Simula-67. Simula has some distinct features like the ability to "park" procedures, which are referred to as "classes". The story goes that Bjarne Stroustrup wasn't allowed to use Simula at AT&T and hence extended C to become C++.

Their talk was lined with fantastic sound bites, like the observation that the opposite of setset is unset, not get. Likewise, get doesn't even have an opposite. get and set just happen to rhyme.

We also often forget that the terms "class" and "instance" were already part of Structured Programming (looking at Amazon, it seems that by now all good Computer Science books are out of print -- or I am simply getting old).

Kresten Krab Thorub on Messaging with Erlang

Kresten gave a really nice talk on Erlang, making the case that Erlang will not be a mainstream language, but will have a big influence on future languages, much like Smalltalk influenced Java. Hos talk struck the perfect balance between being contemplative and easy to follow. Erlang originated from building reliable, distributed systems -- something that has become increasingly relevant.

The key to Erlang's robustness is isolation: components execute independently and communicate via messages sent across in-memory message queues. Kresten explained that the big relief when moving from C++ to Java is not have to worry about deallocation. When moving from Java to Erlang you gain "state containment".

Kresten's talk reminded me how lazy I am when it comes to learning new languages. I think the last language I learned is Python. So I downloaded Go-lang to get of my butt and learn a new language. I was also wondering whether Erlang could make for a suitable language to program some Conversation Patterns.

Share:            

Follow:       Subscribe  SUBSCRIBE TO FEED

More On:  EVENTS     ALL RAMBLINGS   


Gregor is the Chief IT Architect of Allianz SE. He is a frequent speaker on asynchronous messaging and service-oriented architectures and co-authored Enterprise Integration Patterns (Addison-Wesley). His mission is to make integration and distributed system development easier by harvesting common patterns and best practices from many different technologies.
www.eaipatterns.com