Conference Day - 1.12.2014

As the complexity of systems and softwareintensive systems grows, Software Architecture becomes an important cornerstone for the entire system's life-cycle.

Over the last two decades Software Architecture has established itself as an important engineering discipline employing state-of-theart methodologies and techniques that attract both practitioners and researches from around the world.

The 1st Israeli Conference on Software Architecture intends to bring together researchers and practitioners alike to exchange ideas insight and best practices.

The participants will be able to learn from case studies of practical approaches as well as insight from research activities that can bring immediate benefit to them.


Conference Day | Monday, December 1st, 2014

08:30 Gathering & Registration

Welcome address:

Hayim Makabee, Co-founder of IASA Israel, Researcher – Yahoo Labs
Oded Cohn, Vice President, Director of IBM Research – Haifa


Keynote: Joseph W. Yoder, The Refactory, Inc.

Topic: Taming Big Balls of Mud with Diligence, Agile Practices, and Hard Work

10:15 Coffee Break

Software Architecture – Approaches and Methodologies

Chair: Dr. Amir Tomer, Kinneret Academic College

11:45 Coffee Break

The Software Architect's Roles and Responsibilities

Chair: Dr. Adi Levin, Align Technologies

13:15 Lunch

Software Architecture in Practice

Chair: Tomer Peretz, Orbotech

15:30 Coffee Break

Experts Panel: Expected Competences of SW Architect

  • Lior Bar-On – Senior Development Architect, SAP
  • Dr. Irit Hadar – Head of Software Architecture Lab, Haifa University
  • Atzmon Hen-Tov – VP R&D, Pontis
  • Nir Sella – Head of Software Department , Rafael

Chair: Alexander Katz, Acacia Solutions

17:00 Adjourn

יום סמינרים – 2.12.2014

אג'יליות מוחלטת:
תנו למשתמשים לעשות את העבודה!

The Adaptive Object-Model Architecture

כיצד משלבים אספקה רצופה של תוכנה עובדת עם תכן פשוט, כפי שמציעים העקרונות האג'יליים?

הפיתוח האג'ילי משחרר, מצד אחד, את המפתחים מכבלי ה-top-down design, אך מצד שני הוא מאפשר למשתמשים את החופש להציף את המפתחים בשינויי דרישות תכופים ובתביעה לעוד ועוד features – תופעה המכונה בשם Featuritis.

ארכיטקטורת  Adaptive Object-Model) AOM) מאפשרת להמשיך ולשמור הן על אספקה רצופה והן על תכן פשוט באמצעות תמיכה במודלי-תחום (domain models) הניתנים לשינוי, ע"י הפיכת כללים עסקיים לנתונים מפורשים וע"י ייצוג עצמים, תכונות ויחסים בהגדרות חיצוניות.

במבט ראשון נראה כאילו מערכות AOM סותרות את העקרונות האג'יליים, אך הממצאים מראים כי תחת תנאים מתאימים ארכיטקטורת AOM הפכה את המשתמשים למאושרים יותר ונתנה להם את היכולת לשלוט בקצב השינויים.

בסמינר יוצגו מרכיבי הליבה של ארכיטקטורת AOM, בהתבסס על דוגמה ממערכת עובדת, וייסקרו דפוסים חיוניים נוספים לסגנון ארכיטקטורה זה. בנוסף, יוצגו מספר מערכות מורכבות מהעולם האמיתי, אשר המרצה היה מעורב בפיתוחן, ויודגם כיצד הן נתנו למשתמשים את השליטה הנחוצה להם כדי לשנות ולהרחיב את התוכנה בביטחה.


Tutorial Day – 2.12.2014

Seminar and Workshop on

Ultimate Agility:
Let Your Users Do Your Work!
“The Adaptive Object-Model Architecture”

Agile practitioners value both the incremental delivery of working software and design simplicity. But when working on Agile projects, developers can become overwhelmed with the rate of requirements change. To keep up, an Adaptive Object-Model (AOM) architecture supports changeable domain models by casting business rules as interpreted data and representing objects, properties, and relationships in external declarations.

This workshop presents the core elements of AOM architecture. We show several production AOM complex systems and demonstrate how they have given users the control, they needed, to confidently revise, extend, and grow their software.


Tutorial Day | Tuesday, December 2nd, 2014

Seminar and Workshop on

Ultimate Agility: Let Your Users Do Your Work!
“The Adaptive Object-Model Architecture”

Presented by Joseph W. Yoder, The Refactory, Inc

08:45-09:00 Welcome
09:00-10:00 Intro and Overview
10:00-11:00 AOM Basics (Type_Object / Properties / Type Square)
11:00-11:15 Coffee Break
11:15-12:00 Interactive Hands On Exercises (AOM Basics)
12:00-12:45 Dealing with Behavior (Strategies / Rule_Objects)
12:45-13:45 Lunch Break
13:45-14:30 AOM Putting it All together
14:30-15:15 AOM Hands On Exercises dynamic system (Advanced)
15:15-15:30 Refreshments
15:30-16:15 Case Review of Working Systems
16:15-17:00 Process for Developing and Related Techniques
17:00-17:15 Q&A


Agile practices liberate us from the straightjackets of top-down design. But, the ease with which requirements can change encourage users to overwhelm us with requests for features. The result: Featuritis. Adaptive Object-Models support changeable domain modules by casting business rules as interpreted data and representing objects, properties and relationships in external declarations. Now users can change the system themselves as their business dictates without having to deal with programmers at all. It’s the ultimate in agility!

Agile practitioners value incremental delivery of working software. This typically means that there is not a long, involved design phase that precedes implementation. Design simplicity is also important. At first glance, Adaptive Object-Model based systems seem to fly in the face of these values. Yet we have found that under the right conditions, choosing to implement an Adaptive Object- Model architecture has made our users happier and have given them back the control they need to confidently revise, extend and grow their software on their own.

The centerpiece of this workshop will be a presentation of the highlights of several real-world systems the authors have worked on. Our examination of each will showcase ways in which the incorporation of an Adaptive Object-Model Architecture made the systems more adaptable and our users more agile, thereby justifying the additional effort and complexity of this approach. The Adaptive Object-Model Architecture will be presented as a system that represents classes, attributes, relationships, and behavior as metadata. Additionally, a review of a process for developing AOMs will be examined.


What you will learn

  • See how to let users build and modify complex structures like business rules themselves, so that you, the programmer don’t have to anymore.
  • Learn when and when not to use this architecture.
  • how to make new types of objects with attributes, relationships, and behavior through using the Type_Object, Properties, Entitiy_Relationship, and Rule_Object patterns.
  • Learn about the other machinery, mechanisms, end-user tools, and design patterns commonly used to implement AOM systems
  • Understand when to consider AOM architectures for building end-user adaptable software.
  • Understand the basics of using metadata to represent objects, properties and relationships.
  • Be able to identify the risks of exposing programming and model extension facilities to users, and how to mitigate these risks.
  • Learn how a system that is a model based on instances rather than classes allows users to more quickly change the system by simply changing the metadata (object model) to reflect changes in the domain.
  • Understand an incremental process for developing highly adaptive systems and how important an agile process is for evolving and growing these architectures.


Joseph Yoder

Joseph Yoder is a founder and principle of The Refactory, Inc. and Teams that Innovate, companies focused on software architecture, design, implementation, consulting and mentoring on all facets of software development.

Joseph is an international speaker and pattern author and longstanding member of The Hillside Group, a group dedicated to improving the quality of software development. He is coauthor of the Big Ball of Mud pattern, which illuminates many fallacies in the approach to software architecture.

Joseph has chaired the Pattern Languages of Programming Conference (PLoP), as well as presented tutorials and talks at various international conferences. Joe teaches Agile Methods, Architecture, Design Patterns, Object Design, Refactoring, and Testing in industrial settings and mentors many developers on these concepts.

Joe currently resides in Urbana, Illinois where he had led teams of developers who have constructed systems based on enterprise architecture; specifically adaptable architecture. Projects involve working in various environments such as Ruby, Java, and .NET deploying Domain-Specific Languages for clients.

Joe thinks software is still too hard to change. He wants do something about this and believes that putting the ability to change software into the hands of the people with the domain knowledge seems to be one Who Should Attend promising avenue toward solving this problem.