Group items tagged

"Apache Camel is a powerful open source integration framework based on known Enterprise Integration Patterns with powerful Bean Integration. Camel lets you create the Enterprise Integration Patterns to implement routing and mediation rules in either a Java based Domain Specific Language (or Fluent API), via Spring based Xml Configuration files or via the Scala DSL. This means you get smart completion of routing rules in your IDE whether in your Java, Scala or XML editor. Apache Camel uses URIs so that it can easily work directly with any kind of Transport or messaging model such as HTTP, ActiveMQ, JMS, JBI, SCA, MINA or CXF Bus API together with working with pluggable Data Format options. Apache Camel is a small library which has minimal dependencies for easy embedding in any Java application. Apache Camel lets you work with the same API regardless which kind of Transport used, so learn the API once and you will be able to interact with all the Components that is provided out-of-the-box. Apache Camel has powerful Bean Binding and integrated seamless with popular frameworks such as Spring and Guice. Apache Camel has extensive Testing support allowing you to easily unit test your routes. Apache Camel can be used as a routing and mediation engine for the following projects: * Apache ServiceMix which is the most popular and powerful distributed open source ESB and JBI container * Apache ActiveMQ which is the most popular and powerful open source message broker * Apache CXF which is a smart web services suite (JAX-WS) * Apache MINA a networking framework"

" Why Object Teams? Team spirit for your objects Building complex systems from isolated objects often yields poor structure which readily decays during system evolution. Objects should team-up in order to co-operate and jointly deliver complex behaviors. Objects play specific roles within a given Team. Context based dispatch Role instances are attached as specializers to existing objects. Object behavior is controlled by the currently active context that determines which roles are active at a given point in time. Contexts are reified into team instances, which may further be used to mediate between roles and maintain state of the collaboration. Modules larger than classes On the road to re-use of modules larger than classes two approaches compete: frameworks and components. For many applications white box frameworks are too fragile and black box components to rigid. Object Teams provide a middle road which balances encapsulation and adaptability. "

 As TOPCASED project leader I want to assess the usage of ours Tools in Academic and industrial projects. This assessment will help us and you to assure credibility of the Topcased projects and tools and then to insure their durability.  To do this "state of the art" could you give me back your usage of  TOPCASED Tools : which tool, for which kind of projects (evaluation, industrial, research) and all information you are able to give to us ? Specially for academics could you give me information about the usage of our tools in engineers trainees or thesis : which cursus at which level, number of student already trained, subject of thesis.  If you need some confidentiality on your information, tell me that and I will remains it for my own.   Thanks to send your Topcased usage returns to patrick.farail at airbus dot com  Thanks a lot to help us on this work I will give you back this results by mail.   Patrick Farail from Airbus TOPCASED Project leader 

"The past year I've been learning a lot of Scala and I'm currently working on a new project using Scala. I use LiquiBase, which is a database-independent library for tracking, managing and applying database changes. I'm also using the simple-build-tool (SBT) for my project. So I've put together a little SBT plug-in for running LiquiBase maintenance commands (update, rollback, …) from within SBT. For example, whenever I want to apply new database changes with LiquiBase I can now simply run sbt liquibase-update which sets up a new instance of LiquiBase and executes the LiquiBase update command which migrates my database to the latest version. At the moment the plug-in supports the following commands: liquibase-update, liquibase-drop, liquibase-tag, liquibase-rollback and liquibase-validate. What are the benefits of using the plug-in and not just the LiquiBase CLI? * no download/install of LiquiBase * classpath handled by SBT * no need to provide a big list of parameters or writing shell scripts The plug-in is called liquibase-sbt-plugin and you can find it here on GitHub. Feel free to use it or fork it and suggest changes. I'm still relatively new to Scala and especially SBT so any remarks are very welcome."

"I've had an opportunity recently to work on a product that needed an RIA web interface, and I chose my recent favorite tool for this, Vaadin. The services for this project needed to be highly scalable, and lent themselves well to functional techniques, so I selected Scala as my language of choice. I build my projects with Maven, for reasons I won't go into right now, and I do much of my JVM-language work in Intellij's excellent IDEA IDE. Given these tools, I found a way to facilitate very rapid development of web UI's, and I thought I'd pass it along. Another technique I use, which I'll expound on later, is creating "dummy" implementations of all of my backing services for my application. The "real" implementations are written as OSGi services, in separate modules from my UI. The UI is packaged as a war, but is also OSGi aware, with a bundle activator. This activator only gets called if the war is deployed into an OSGi container, and not otherwise. This allows the app to select which implementation of the services it uses - the "dummy" ones when it's deployed outside of OSGi, and the "real" ones when they're available. This means I can use the handy Maven jetty plugin to quickly spin up my application and test it on my local workstation, without needing all of the dependencies (like a data store and such) of my real services. That's good, in that I can get my "cycle time" down to a few seconds, where "cycle time" is the time between making a change and actually being able to test it in my browser. We can do better, though. I'm using Scala as my language of choice for building the UI as well, as it works just fine with Vaadin (and with everything else in the JVM ecosystem, for that matter, which is why I didn't choose a non-JVM language - but that's yet another rant). I compile my Scala with the Maven scala plugin - here's where the next handy bit comes into play. Turns out the Scala plugin has a goal cal

The aim of this paper is a brief introduction to MDA technology and a summary / comparison to the approachments to MDA of AndroMDA and Acceleo, intending to be a practical and understandable summary Introduction Model-driven architecture (MDA) is a software design approach for the development of software systems. It provides a set of guidelines for the structuring of specifications, which are expressed as models. It was launched by the Object Management Group (OMG) in 2001 The Model-Driven Architecture approach defines system functionality using a platform-independent model (PIM) using an appropriate domain-specific language (DSL). One of the main aims of the MDA is to separate design from architecture. As the concepts and technologies used to realize designs and the concepts and technologies used to realize architectures have changed at their own pace, decoupling them allows system developers to choose from the best and most fitting in both domains. The design addresses the functional (use case) requirements while architecture provides the infrastructure through which non-functional requirements like scalability, reliability and performance are realized. MDA envisages that the platform independent model (PIM), which represents a conceptual design realizing the functional requirements, will survive changes in realization technologies and software architectures.

"Developers usually have their programs write log and debug information to the standard output during coding and testing. This results in a lot of text being printed to Eclipse's console view, often more than can be easily surveyed. Since at any given time, only a small part of this information is of primary interest to the developer, a tool which highlights specific lines or words can significantly increase the readability of this output. Grep Console allows you to define a series of regular expressions which will be tested against the console output. Each expression matching a line will affect the style of either the entire line or parts of it. For example, error messages could be set to show up with a red background, or integer values showing the state of a certain variable could be rendered in bold font. "

There is no migration system in vanilla grails (although possibly in Grails 2.0 …. ?) but there do exist several plugins that provide  some migration functionality. As of this post I am aware of three: dbMigrate, Liquibase, and Autobase. Of these, I prefer Liquibase and cannot recommend it enough. While it uses XML to describe its changesets it is a mature open-source Java project that works flawlessly (and has some excellent documentation). I did not have much luck using DbMigrate and Autobase when including in an existing project… which is a shame as Autobase (which is built on Liquibase) uses a nice DSL syntax to build the migrations.

DdlUtils is a small, easy-to-use component for working with Database Definition (DDL) files. These are XML files that contain the definition of a database schema, e.g. tables and columns. These files can be fed into DdlUtils via its Ant task or programmatically in order to create the corresponding database or alter it so that it corresponds to the DDL. Likewise, DdlUtils can generate a DDL file for an existing database. DdlUtils uses the Turbine XML format, which is shared by Torque and OJB. This format expresses the database schema in a database-independent way by using JDBC datatypes instead of raw SQL datatypes which are inherently database specific. An example of such a file is:

"At this point, the only source of useful overview documentation for the Common Navigator are the excellent tutorials at Michael Elder's (the author of the CN) blog. Soon I hope to get some of this transferred into the Eclipse Plugin Developer's Guide. RCP applications can quickly and easily use the CN to show the resources in the workspace. This assumes that your RCP application uses resources (which is another discussion). The CN can also be used for non-resource RCP applications, in that case, these instructions don't apply, as the objects treated by the CN have to be created directly by the RCP application. If you are planning to use the CN in an RCP application that uses resources, there are 3 (2 of which are completely undocumented) things you must do:"

Apache XML-RPC is a Java implementation of XML-RPC, a popular protocol that uses XML over HTTP to implement remote procedure calls. Version 3 of Apache XML-RPC is still compliant to the XML-RPC specification. However, the user may enable several vendor extensions are available, that greatly extend the power of XML-RPC: All primitive Java types are supported, including long, byte, short, and double. Calendar objects are supported. In particular, timezone settings, and milliseconds may be sent. DOM nodes, or JAXB objects, can be transmitted. So are objects implementing the java.io.Serializable interface. Both server and client can operate in a streaming mode, which preserves resources much better than the default mode, which is based on large internal byte arrays.

The Java Content Repository (JCR) standard, which is based on the Java Specification Requests JSR170 (version 1.0) and JSR 283 (version 2.0), provides a Java-centric object-oriented storage API specifically targeted at content management scenarios. The JCR is not a content management system or a full-fledged content management system API, but rather a content repository API. A content repository provides a common API for all content-driven applications and CMS components, which require access to the content. It provides methods to read, write, and query content. The primary motivation of the JCR standard is to provide a standard and vendor-neutral programmatic interface for content repositories, allowing applications of multiple vendors to interact efficiently.

Java Topic / Java tutorial There are few other features of Java apart from Applets, Security, Portability and Servlets which are also important. These are also called as Java Buzzwords. Which are Simple, Object Oriented, Robust, Multi Threading, Architecture Neutral, Interpreted and High Performance, Distributed and Dynamic

Dart is an open-source, general-purpose, class-based, object-oriented language with C-style syntax which can optionally transcompile into JavaScript. It...

This business suite contains Oracle database technologies and a range of product which is acquired or developed by Oracle.

"Community Dashboard Framework (CDF) is a project that allows you to create friendly, powerful, fully featured dashboards on top of the Pentaho BI server. Former Pentaho dashboards had several drawbacks from a developer's point of view. The developing process was awkward, it required know-how of web technologies and programming languages, and basically it was time-consuming. CDF emerged as a need for a framework that overcame all those difficulties. The final result is a powerful framework featuring the following: . It is based on Open Source technologies. . It separates logic (JavaScript) of the presentation (HTML, CSS) . It features a life cycle with components interacting with each other . It uses AJAX . It is extensible, which gives the users a high level of customization: . Advanced users can extend the library of components. . They also can insert their own snippets of JavaScript and jQuery code. CDF can be used: . As part of a Pentaho solution. This is the most common scenario. . In a standalone mode as an alternative to the Pentaho User Console . Integrated with Portlets, PHP applications, intranet portals and even desktop applications. "

" OT/J: extreme modularity Whenever modularity gets tricky, OT/J provides just one more dimension for your architecture. With OT/J there's no excuse for any architectural workarounds. OT/J: extreme reuse With OT/J any existing piece of Java code is reusable. Existing components can be adapted to specific needs in full adherence to your projects requirements and without compromising a crisp modular architecture. The fabric for quality software OT/J is the fabric from which high quality software can be produced: flexible, durable, elegant. OT/J in the Wiki"

"A lot of people have asked me to document the reasons I want to migrate Hibernate from Maven to Gradle as its build tool so I enumerate those reasons here. If you are completely new to Gradle, I suggest having a look at their overview page. Up front I want to point out that this is not intended as a "Maven bash session" nor as a means to directly compare Maven and Gradle. It is just a means to describe the issues and frustrations I have seen in my 2.5+ years of using Maven for Hibernate builds; in many cases the cause is simply an assumption or concept in Maven itself which did not line up cleanly with how I wanted to do build stuff in Hibernate. Some of the list aggregated by Paul comes directly from Hibernate use-cases; I'd suggest reading through those as well. It is also a means to describe why I decided on Gradle as opposed to other related build tools out there now (Buildr, SBT, etc). Note that there is a comparison wiki between Gradle and Maven, but that it is quite old and out of date in many respects especially in regards to Gradle. The issues I had with Maven (note that these are largely chronological, not in order of "importance") are as follows:"

In this article I'll describe the setup I use to do develop Lift applications. While more heavy-weight than if an interpreted language is used, I find this setup provides fairly decent turnaround times. So, it took a little longer than expected to write this article which continues where the previous stopped. But all good things come to he who waits The software used in the previous article all had major updates in the meantime: Scala 2.8 (2.8.1 is just around the corner) Eclipse 3.6 Scale IDE for Eclipse (though a nightly build is currently needed for Eclipse 3.6) Gradle 0.9 RC1 Lift 2.1 RC2

Papyrus is aiming at providing an integrated and user-consumable environment for editing any kind of EMF model and particularly supporting UML and related modeling languages such as SysML and MARTE. Papyrus provides diagram editors for EMF-based modeling languages amongst them UML 2 and SysML and the glue required for integrating these editors (GMF-based or not) with other MBD and MDSD tools. Papyrus also offers a very advanced support of UML profiles that enables users to define editors for DSLs based on the UML 2 standard. The main feature of Papyrus regarding this latter point is a set of very powerful customization mechanisms which can be leveraged to create user-defined Papyrus perspectives and give it the same look and feel as a "pure" DSL editor.