- Mature command framework
- Data Binding and Validation Framework
- Multiple Window Support
- Factories for common GUI controls complying GUI standards (Wizards, Dialogs,...)
Tuesday, August 29, 2006
With the rise of object-oriented thinking, frameworks became more popular than never before. A framework is an approach of software reuse and enables developers to establish software systems on an abstract layer. This diploma thesis focuses on the layered architecture where each layer has a predefined task which can be implemented together with a provided framework. This diploma thesis covers the following key points:
- Introduction to Software Architecture
- Relevant patterns for J2EE, like MVC, DAO, ORM, Lazy Load or Dependency Injection
- Architecture of object oriented frameworks
- Technologies: Hibernate, Spring, Spring Web Flow, Struts, JSF and OpenLaszlo
Sunday, August 27, 2006
- The BPEL standard provides no auditing capabilities
- In BPEL engines, auditing is (if available at all) implemented in different ways
- Auditing over multiple BPEL engines (e.g., integrating various partners) is hardly feasible
Read more about our ideas in our paper.
Saturday, August 26, 2006
Until recently, Apache Ant was seen as the default mechanism to do build-automation in Java projects. Since the Apache Maven project released Version 2 of their tool, it appears, that Maven has finally outrun Ant in popularity. This can be seen e.g, by observing other Apache projects, like Cocoon, that actually changed recently from Ant to Maven like many others. In this BLOG article I want to give some impressions of Maven 2 in comparison to Ant; and focus a little more in detail on dependency management.
The advantage of this concept is most probably it's flexibility. Many things can be done; the user is definitly not limited to "typical" development/build processes. I used e.g., Ant for some time to generate websites (offline) using XML and XSLT. Additionally as Ant was the dominating tool for the last years, it has substential tool support (e.g., Netbeans uses Ant build-files as default project file).
However, in todays complex problems, the Ant approach has several drawbacks. What immediately comes to my mind:
- New users are often confuses what "best practices" should be used for a build process
- Reuse of Buildfiles is typically "Cut and Paste"; meaning: if you once spent a lot of time in fine-tuning a build file for a project it is difficult to use the same approach on a new project.
- As a consequence: different developers often have different approaches in writing build-files.
- Handling of libraries is awkward; we will come to that point later again.
Hence a complete build process including unit-testing can be started with one command and only minimal configuration in the so-called project object model XML file. But even a simple default project can be generated with one Maven command.
The consequences are clear: the beginner is not confused by many options and possibilities, but instead gets a clear route how to start; including directory and config filename defaults. This also has the positive consequence, that many Maven projects look very similar in structure, hence new developers have an easy time in getting into a new project.
Library (Dependency) Management
Maven approaches this problem very differently: within the Project Object Model, the developer declares on which other systems this applications is dependent on including the version! E.g., coming back to Hibernate: In Maven you would declare a dependency to Hibernate Version 2.1.0 and Maven would figure out which additional dependencies exist (e.g., Hibernate might need dom4j and log4j and ...). This makes things much more transparent. Additionally Maven stores all libraries in on single directory (ordered by system, version, ...) and not within the project itself, which saves a lot of storage space, when multiple projects are developed on one system.
Friday, August 25, 2006
This BLOG is dedicated to new trends in Software Engineering:
Who we are?
Members of this BLOG are from
- Software Engineering Group at Vienna University of Technology, Institute for Software Technology and Interactive Systems
- PhD-Students from our groups
- Guest researchers
- Research partners from Senactive
- Alexander Schatten (IFS, TU Wien; Austrian Computer Society, Working Group: Open Source Software)
- Stefan Biffl (IFS, TU Wien; Austrian Computer Society, Working Group: Software Engineering)
- Markus Demolsky (PhD)
- Dietmar Winkler (IFS, TU Wien)
- Josef Schiefer (Senactive)
- Rupert Meinl (Senactive)
- Gerd Saurer (Senactive)
- Heinz Roth (PhD IFS, Senactive)
- Szabolcs Rozsnyai (PhD)
- and more yet to come...
What we do?
One of our key research areas is the development of event-driven systems which includes the areas of event stream processing (ESP), complex event processing (CEP), event-driven architectures (EAPs), and real-time analytics.
Additionally, we hope, that this BLOG helps students from our lectures, project partners and colleagues from research projects to stay updated and connected to our group.
What is the focus of this BLOG?
In this BLOG we will focus mainly on these aspects:
- Trends in Software Engineering (e.g., aspect oriented programming, trends in middleware, service-oriented architectures, attribute oriented programming)
- Software Processes (traditional, agile, VM-XT, ...)
- Open Source Software and Software Engineering best-practices
- Quality aspects in Software Engineering
- Software Testing
- Java best-practices
- .net best-practices
- Short reports and impressions from conferences we attended
- Reviews of interesting articles and books we read
- Applications of Software Engineering in E-Commerce
We plan to update this BLOG regularly, at least once a week. References to other articles and material will be part of BLOG entries.
To stay updated, please subscibe to the Atom news feed provided for this log!
We also would appreciate to stay in touch with our readers, so do not hesitate to write comments to our articles!
We hope, you will enjoy this BLOG!
the SE team!