SEPL Group Homepage
The SEPL seminar is held on Sunday at 14:00, building 37 (Alon), room 201.
News and Announcements
20 last messages
Place: 37/201
Speaker: Dany Moshkovich, IBM
The complexity of software systems is continuously growing across a wide range of application domains. As systems become complex, the models that describe them become more difficult for human comprehension. In addition, different stakeholders may have different viewpoints on a system; thus, raising the level of abstraction to address a user’s semantic perception of the system can significantly improve the usability of models. In this talk I’ll describe our System Grokking technology designed to support software architects in incremental and iterative user driven understanding, validation and evolution of large complex systems through modelling on higher levels of abstraction. System Grokker enables semi-automatic discovery, manipulation and visualization of groups of domain specific software elements and relationships between them, to represent high-level structural and behavioral abstractions.
Place: 37/202
Speaker: Yossi Gil, The Technion
Location: 37/201
Speaker: Mayer Goldberg and Mira Balaban
This week in the SEPL seminar Mayer Goldberg and Mira Balban will lead a discussion on the paper:
Oddleif Halvorsen and Øystein Haugen, Proposed notation for Exception Handling in UML2 sequence Diagrams
Everyone is invited to participate and contribute!
The SEPL seminar will return to normal activity on April 16, with a talk about Executable UML and debugging models, by Andrei Kirshin from IBM.
Hope to see you in the coming activities,
Location: 37/201
Speaker: Shiri Kremer-Davidson, IBM
Model Driven Development (MDD) is rapidly gaining industrial acceptance. It helps in solving difficult problems of separating technology from functionality. It does so by defining an abstraction over the low level details and leaves the binding to an implementation platform to the transformations.
In this talk I will describe different experiences we had with customizing MDD for different industries. I will start by introducing MDD and meta-modeling. Then I will describe different approaches for implementing meta-models and introduce the eclipse modeling framework that enables rapidly defining model based tools. I will finish this section by describing the features required in a MDD based environment.
Finally, I will describe in more details our experiences in adopting MDD in different industries (e.g. Telecom, Electronics, Automotive, Web) and dive into our latest Telecom experience the "Telecom Service Creation Environment". This environment enables developers to create services without deep knowledge of telecom specific protocols. I will describe the project, its meta-model, its transformation and demo the tool.
Location: 37/201
Speaker: Michael Elhadad, BGU
This week we host an open discussion practicing and teaching Design-by-Contract (DbC), lead by Michael Elhadad.
Place: Room 202, Alon building.
Speaker: David Harel
This week's SEPL seminar is joined with the dept. colloquium, hosting David Harel. Therefore, the talk will be tommorow, Tuesday, at 12:00, 37/202.
Title: In Silico Biology, or On Comprehensive and Realistic Modeling
Abstract: The talk shows the way software and systems engineering, especially of reactive systems, can be applied beneficially to the life sciences. We will discuss the idea of comprehensive and realistic computerized modeling of biological systems. In comprehensive modeling the main purpose is to understand an entire system in detail, utilizing in the modeling effort all that is known about the system, and to use that understanding to analyze and predict behavior in silico. In realistic modeling the main issue is to model the behavior of actual elements, making possible totally interactive and modifiable realistic executions/simulations that reveal emergent properties. I will address the motivation for such modeling and the philosophy underlying the techniques for carrying it out, as well as the crucial question of when such models are to be deemed valid, or complete. The examples I will present will be from among the biological modeling efforts my group has been involved in: T cell development in the thymus, lymph node behavior, embryonic development of the pancreas, the C. elegans reproductive system, and a generic cell model. I will also discuss a long-term "grand challenge" — to model a full multi-cellular organism.
Place: Room 201, Alon building.
Speaker: Julia Rubin, IBM
Software product lines refers to engineering techniques for creating a portfolio of similar software systems from a shared set of software assets using a common means of production. Manufacturers have long used analogous engineering techniques to create a product line of similar products using a common factory that assembles and configures parts designed to be reused across the varying products in the product line. For example, automotive manufacturers can now create tens of thousands of unique variations of one car model using a single pool of carefully architected parts and one factory specifically designed to configure and assemble those parts. Software product lines are rapidly emerging as a viable and important software development paradigm allowing companies to realize order-of-magnitude improvements in time to market, cost, productivity, quality, and other business drivers.
In this talk we describe the principles of software product line architectures. We describe the correlation between architecture and feature models, and present a model-driven framework for development of software product lines. Our tools and methodologies facilitate the reuse of software using a component-based development approach. Combining the composition of software components with product-line requirements, our approach enables transformations into various product artifacts, including build scripts and production-level code.
Everyone are invited to participate and contribute!
Place: Room 201, Alon building.
Speaker: Shmuel Tishberowitz, TAU
In recent years, Aspect Oriented Programming (AOP) has emerged as a promising model for modularizing large and complex programs, advancing towards wider acceptance for mainstream commercial development. The use of AOP techniques for developing commercial applications poses, however, a number of challenges — especially when such applications are composed of large numbers of binary components containing independently developed aspects.
The interaction of such independently developed aspects with each other and with the rest of the system can lead to unexpected problems. First, aspects in binary distributions can be mistakenly treated as ordinary classes, thus ignoring their complex interaction with the rest of the system. Second, independently developed aspects might inadvertently make inappropriate assumptions about their application environment, thus creating unintended effects.
In the talk I will present AspectJTamer, a tool for addressing these issues. First, AspectJTamer provides support for identifying aspects that are present in binary distributions and for documenting their specific interaction points, thus making explicit both their assumptions about, and their weaving scope within, an application. Second, AspectJTamer provides a mechanism to control the weaving scope of binary aspects in a flexible manner, thus offering supplemental constraints overriding the assumptions made by independently developed aspects.
Place: Room 201, Alon building.
Speaker: Eran Toch, Technion
Abstract:
The rigidness of enterprise software systems is a fundamental problem in information systems engineering, demonstrated by the high expenses involved in developing new systems or enhancing existing ones. In an attempt to provide a flexible model of system development, we present approximated service retrieval, a conceptual model of automated software systems implementation, using techniques taken from the field of information retrieval and the Semantic Web. In this model, system requirements are described using a query language, and are met by finding and composing Web services. The theory that lies at the heart of the research is aiming to model correspondence between queries and services (e.g. equivalence, resemblance and containment) with different levels of approximation. As services can vary considerably in their structure and behavior, the chances of a perfect match are low. Thus, current methods are limited in their usability with real-world services. Therefore, the research proposes an approximated approach, which performs flexibly match between queries and services. Our results show that by enabling a minor degree of semantic approximation in the retrieval process, several problems are becoming feasible with respect to recall, representation and computation complexity.
Place: Room 201, Alon building.
Speaker: Open discussion
Oren Mishli's talk on SEPL today is postponded. Instead, we will hold the open discussion about dynamic OOP vs. Static OOP. This discussion already was held on 13/1, but got carried away to entirely different subjects. We will re-hold it today instead of Oren's talk.
Abstract (reminder):
Dynamic OOP vs. Static OOP – Is dynamic programming an advantage or a danger?
In a recent talk, we discussed meta-classes in Python as an example of dynamic object-oriented programming. Dynamic object-oriented languages gives the programmer many possibilities: From implementing AOP and design patterns as library meta-classes, to changing the behavior of objects and even entire classes at run-time. The question that rises is: What is the cost of those possibilities? Are their benefits greater then their drawbacks?
This week talk will be an open discussion on those questions. - What are the advantages of dynamic programming? - Teaser: How many design patterns can be implemented as a meta-classes? More then 50%? - What is the cost of dynamic programming in run-time and memory footprint? - Is dynamic programming significantly less safe then the mainstream static programming? - Is static programming significantly less flexible and expressive then dynamic programming?
Everyone are invited to participate and contribute!
Place: Room 201, Alon building.
Speaker: Ohad Barzilay, TAU
Title: On Teaching Software Engineering in the Academy
This talk is made of two parts. On the first part, we describe an action research that accompanied the recent changes in undergraduate computer sciences curriculum. We present the transition and the issues raised in moving from C to Java in "Software 1" (a CS2 course), by contrasting it with the elite military programming course (BASMAH). The different perspective taken by the military course highlights some implicit properties of an academic course that one might want to reconsider when designing such change.
In the second part of the talk we describe a new elective software engineering (SE) course. SE is multidimensional. It involves activities in various areas and disciplines such as system engineering, project management and computer science. In modern SE curricula one can usually find designated courses that address these various subjects. We propose a multidimensional SE course framework, aiming at giving the students a comprehensive cross-paradigm practical and theoretical experience. The whole is greater than the sum of the parts; this idea is applicable also for the proposed course since such a course also enables to investigate the relations between the various SE dimensions, to examine fundamental field principles from different aspects and software evolution and trends. We describe such course framework and share our experience teaching it for the first time in Tel Aviv University, highlighting the course scope, pedagogic decisions and relevance.
Michael Elhadad's discussion about Design-by-Contract was moved to 19/3/2008.
Place: Room 201, Alon building.
Open discussion: Dynamic OOP vs. Static OOP – Is dynamic programming an advantage or a danger?
In a recent talk, we discussed meta-classes in Python as an example of dynamic object-oriented programming. Dynamic object-oriented languages gives the programmer many possibilities: From implementing AOP and design patterns as library meta-classes, to changing the behavior of objects and even entire classes at run-time. The question that rises is: What is the cost of those possibilities? Are their benefits greater then their drawbacks?
This week talk will be an open discussion on those questions.
- What are the advantages of dynamic programming?
- Teaser: How many design patterns can be implemented as a meta-classes? More then 50%?
- What is the cost of dynamic programming in run-time and memory footprint?
- Is dynamic programming significantly less safe then the mainstream static programming?
- Is static programming significantly less flexible and expressive then dynamic programming?
Everyone are invited to participate and contribute!
Place: Room 201, Alon building.
Speaker: Onn Shehory, IBM
Title: Software Self-Healing with Panacea
Abstract: Self-healing capabilities allow software systems to autonomously overcome problems occurring during testing and run time, and thus improve overall system behavior. The Panacea framework provides a design methodology as well as ready-to-use healing elements aimed at enhancing software systems with self-healing capabilities both at design time and at run time. The Panacea approach is based on inserting self-healing elements into the system at design and coding time, to be used later for healing at testing and run time. Specifically, the Panacea framework is based on inserting annotations into the system code at design and coding time, to later on serve as an interface for runtime monitoring, managing, configuring and healing of the annotated system components.
Place: Room 201, Alon building.
Speaker: Guy Wiener, BGU
Title: Dynamic OOP and Meta-Classes in Python
Abstract: The most popular object-oriented programming (OOP) languages nowadays - Java, C++, C# - are statically-typed and based on a static model. They do not allow to manipulate their classes at run-time. As a result, many programmers view OOP as a methodology with limited flexibility and expressiveness.
OOP languages do not have to be static. Several new scripting languages break this rule by implementing a highly dynamic and flexible version of OOP. These are dynamically-typed languages that allow to manipulate objects and classes at run-time. This ability give a lot of flexibility to the programmer, and those languages are gaining much popularity.
One of the more impressive and useful usages of this approach is the implementation of a meta-classes system in Python. Meta-classes are classes that create other classes as their instances. Using meta-classes lets programmers implement design patterns and aspect-oriented programming by using the programming language itself, giving a higher level of expressiveness and code re-use.
In this talk I will give a short introduction to those new approaches in OOP, and present meta-OOP programming in Python, with its powers and problems.
This talk was given originally in the graduate students seminar
Place: Room 201, Alon building.
Speaker: Vered Gafni, Tel-Aviv University
Title: Component-Based Development of Embedded Systems by Formal Contracts
Abstract: This talk is based on work performed within the EU funded SPEEDS research project. SPEEDS is a concerted effort to define the new generation of end-to-end methods that will enable industry to evolve from model-based design of hardware/software systems, towards integrated component based construction of complete virtual system models.
The talk focuses on a formalism for handling specifications of embedded systems built as composition of components. It is intended to support SPEEDS method of component-based “speculative design” where different aspects of the overall system are developed concurrently by engineers from different disciplines, yet consistency of separate aspects specifications, and correctness of the implementation with respect to each aspect have to be guaranteed.
In the proposed formalism, a component is specified by a set of contracts defined over a common interface. A contract is pair of properties classified as assumption and promise, respectively. Conjuction of contracts is defined; the resulting algebra is ompositional and supports satisfaction and refinement relations. Composition of components (defined over separate interfaces) is defined by fusion, an novel operator that generalizes conjuction and parallel composition.
Place: Room 201, Alon building.
Speaker: Benny Pasternak, TAU
Title: Automatic Generation of Unit Tests
Abstract: In the last years, unit testing has evolved from an ad hoc approach to a common practice. It is the corner stone of modern software development methodologies such as XP and TDD. Such methodologies require that all classes have unit tests which can be run using an automated unit testing framework. However, writing effective unit tests is a difficult and tedious task. Unit testing tools have been developed to assist developers in writing, maintaining and running unit tests. Tools can be divided into the following categories: frameworks for running unit tests, automatic test generators, test prioritization, and test selection tools. The talk will focus on automatic test generators. I will present our automatic unit testing generation tool as well as several other tools that employ different generation and test assertion techniques.