HP and Microsoft Corp. today announced a portfolio of four new converged application appliances that fuse applications, infrastructure and productivity tools into a single system. These new microsoft solutions help organizations optimize employee productivity and decision-making, while simplifying the delivery of applications for IT.
Sharjah Pakistani Escorts
Sharjah Indian Escorts
New Indian Call Girls In Dubai
JBR Dubai Sexy Night Indian Call Girls
Al Nahda Dubai Sexy Night Pakistani Call Girls
Vip Indian Escort In Dubai
Pakistani Independent Escorts In Sharjah
Desi Call Girls In Dubai
New Indian Escort In Sharjah
Inheritance is a mechanism in which one object acquires all the properties and behaviours of parent object. The idea behind inheritance is that you can create new classes that are built upon existing classes. When you inherit from an existing class, you reuse (or inherit) methods and fields, and you add new methods and fields to adapt your new class to new situations.
"Seam 3 is collection of modules and developer tools based on the Java EE platform. The modules are portable extensions to CDI that integrate with other technologies to extend the core Java EE functionality. These modules bring you many of the beloved features and integrations from Seam 2 (security, internationalization, JSF, rules, business process management) and also branch out into new areas. IDE support is provided by the JBoss Tools Eclipse plugins.
Before diving in, get up to speed with the status and direction of Seam 3. Also be sure to check out the latest news at the bottom of the page. "
migrate4j is a database migration tool. Suppose you determine that you need a new database table for your project. If you develop alone, you could write an SQL script that adds a table and manually apply this to your development system. But if you work with other developers, or need to keep a test system in synch with your development system, this become tedious and error prone.
Migration tools make it possible to add your new table (or make any other schema changes) in an automated fashion, ensuring all your systems are always in synch. Migration tools also make it possible to quickly and easily roll back previous changes. Unlike typing commands into an interactive SQL window or storing SQL scripts, migration tools keep a detailed history of how your database schema evolved (just in case you need to go back to a previous version). Finally, migration tools minimize or eliminate the problem of having to use vendor specific syntax - you may never switch database products, but if you do, using a migration tool will make your life much easier.
The initial intent of migrate4j was to make a Java version of Ruby's db:migrate. If you've used db:migrate, you probably fell in love with it's simple syntax, easy configuration and ability to roll changes up and back effortlessly. The intent (and the challenge) of migrate4j is to bring the power and simplicity of db:migrate to Java programmers, using familiar type safety and syntax. Along the way, we're adding additional functionality that makes migrate4j more than just another Ruby tool rewritten for Java - it is a Java project intended to make other Java projects even better.
In JDBC 4.0, we no longer need to explicitly load JDBC drivers using Class.forName(). When the method getConnection is called, the DriverManager will attempt to locate a suitable driver from among the JDBC drivers that were loaded at initialization and those loaded explicitly using the same class loader as the current application.
JDBC 4.0 Enhancements in Java SE 6
Java Platform, Standard Edition (Java SE) version 6 (code name Mustang), is currently in its second beta release and is scheduled to be delivered in October of this year. Java SE 6 includes several enhancements to the Java Database Connectivity (JDBC) API. These enhancements will be released as JDBC version 4.0. The main objectives of the new JDBC features are to provide a simpler design and better developer experience. This article provides an overview of the JDBC 4.0 enhancements and what benefits they offer to enterprise Java developers. We will explore the new JDBC features with the help of a sample loan processing application using Apache Derby as the back-end database.
Aspect-oriented computing is continuing to increase in popularity. The modularity inherent in OSGi and Eclipse offers unique opportunities for managing and applying aspects by supplying them in bundles and directing their application to particular sets of bundles. This incubator work area is dedicated to delivering an integration of aspects and OSGi.
The goal is to allow developers to use the Equinox together with AspectJ by combining the benefits of both worlds. Using a load-time weaving extension you are able to add AspectJ aspects to your bundle-based system just by putting them into general OSGi bundles. It does not matter if the pointcuts you defined inside the aspects contain join points that are defined by classes within the same bundle or any other bundle in your installation. The load-time weaving extension will take care that your aspects are woven with the appropriate classes at load-time.
To illustrate this lets assume the following situation: You would like to write an aspect that traces something within the JDT plug-ins of Eclipse. Without some kind of load-time aspect weaving you would somehow need to recompile those JDT plug-ins using AJDT (for example) together with your aspect. By using the load-time aspect weaving extension all you need is to implement your aspect and add that bundle to your system. The load-time aspect weaving extension takes care of weaving your aspect with the JDT code as it is loaded. And it doesn't matter if a new JDT is installed by the user later on. The next time your application is started the load-time aspect weaving will take care of weaving your aspect into these bundles as well, if necessary.
With this technology is becomes possible to modularize crosscutting concerns across different plug-ins while keeping the idea of separate compilation for bundles.
Goals
Provide Runtime Modularity and Versioning for Crosscutting Concerns: Aspects are used to implement crosscutting concerns. However such concerns usually compr
"The NetKernel Resource Oriented Computing (ROC) platform separates architecture from code. With ROC you can compose your architectural design independently from implementation code.
By keeping the details of code separate from high-level information architecture you gain:
freedom of choice in implementation language
rapid click-fit compositional development
long-term evolvable solutions
Threading and scheduling is managed by the microkernel so your code execution is efficiently optimised with linear scaling on multi-core without the need to learn new languages.
Something brand-new also comes from separating architecture and code. NetKernel provides system-wide caching of every area of your system. For free. No configuration.
NetKernel learns what information is reusable and reuses it. This makes NetKernel systems fast. Very fast."
"JAnnocessor is a new open-source framework for powerful, flexible, yet easy processing of annotated Java code. Its main purpose is compile-time, annotation-driven source code generation in a declarative and customizable fashion. JAnnocessor is built on top of Java APT, encapsulating the Java source code model in a rich and convenient high-level domain model that serves as a good target for expressive matching and transformation. Finally, a template engine is used for customizable template-based source code generation. Having simplicity and productivity in mind, JAnnocessor has many useful features that make it enjoyable: smart imports organization, logging delegation, graphical UI for real-time debug, hot swap of processors and templates, as well as out-of-the-box common annotations, processors and templates."
Oracle provided the EC with a Java SE 7 specification request and
license that are self-contradictory, severely restrict distribution of
independent implementations of the spec, and most importantly, prohibit
the distribution of independent open source implementations of the
spec. Oracle has refused to answer any reasonable and responsible
questions from the EC regarding these problems.
In the phrase
"fail to uphold their responsibilities under the JSPA", we are referring
to Oracle's refusal to provide the ASF's Harmony project with a TCK
license for Java SE that complies with Oracle's obligations under the
JSPA as well as public promises made to the Java community by officers
of Sun Microsystems (recently acquired by Oracle.)
it should be noted that
the majority of the EC members, including Oracle, have publicly stated
that restrictions on distribution such as those found in the Java SE 7
license have no place in the JCP - and two distinguished individual
members of the EC, Doug Lea and Tim Peierls, both have resigned in
protest over the same issue.
By approving Java SE 7, the
EC has failed on both counts : the members of the EC refused to stand up
for the rights of implementers, and by accepting Oracle's TCK license
terms for Java SE 7, they let the integrity of the JCP's licensing
structure be broken.
The Apache Software Foundation concludes
that that JCP is not an open specification process
and finally, the EC is unwilling or unable to assert the basic power of
their role in the JCP governance process
In short, the EC and the Java Community Process are neither.
To
that end, our representative has informed the JCP's Program Management
Office of our resignation, effective immediately. As such, the ASF is
removing all official representatives from any and all JSRs. In
addition, we will refuse any renewal of our JCP membership and, of
course, our EC position.
Okay ! Java's privatized now...
What now ?
Thank god I moved off Java in time. Suddenly Oracle is the new Death Star, replacing Microsoft.
This is a sad, sad day in the Java community. I hoped that Oracle would back-peddle and realize the folly of their ways. Now Java will be to Oracle what .NET is to Microsoft and it will be the death of Java as we know it.
Posibly in few years we'll see Apache as a new Sun for "Java", followed by Eclipse, Google, etc... I hope this is a great movement done by Apache for the community. We'll see... The objetive of Oracle are Enterprises that cannot move from Java because of hight investments, it will earn a lot of money from them. Oracle ignores the community because is not going to pay for (expensive, as all the rest of Oracle products) licenses... We'll se...
The Apache Software Foundation has resigned its seat on the Java SE/EE Executive Committee. Apache has served on the EC for the past 10 years, winning the JCP "Member of the Year" award 4 times, and recently was ratified for another term with support from 95% of the voting community. Further, the project communities of the ASF, home to Apache Tomcat, Ant, Xerces, Geronimo, Velocity and nearly a 100 mainstay java components have implemented countless JSRs and serve on and contribute to many of the JCPs technical expert groups.
We'd like to provide some explanation to the community as to why we're taking this significant step.
"There are pros and cons for considering validation as business logic, and Spring offers a design for validation (and data binding) that does not exclude either one of them. Specifically validation should not be tied to the web tier, should be easy to localize and it should be possible to plug in any validator available. Considering the above, Spring has come up with a Validator interface that is both basic ands eminently usable in every layer of an application.
Data binding is useful for allowing user input to be dynamically bound to the domain model of an application (or whatever objects you use to process user input). Spring provides the so-called DataBinder to do exactly that. The Validator and the DataBinder make up the validation package, which is primarily used in but not limited to the MVC framework.
The BeanWrapper is a fundamental concept in the Spring Framework and is used in a lot of places. However, you probably will not have the need to use the BeanWrapper directly. Because this is reference documentation however, we felt that some explanation might be in order. We will explain the BeanWrapper in this chapter since, if you were going to use it at all, you would most likely do so when trying to bind data to objects.
Spring's DataBinder and the lower-level BeanWrapper both use PropertyEditors to parse and format property values. The PropertyEditor concept is part of the JavaBeans specification, and is also explained in this chapter. Spring 3 introduces a "core.convert" package that provides a general type conversion facility, as well as a higher-level "format" package for formatting UI field values. These new packages may be used as simpler alternatives to PropertyEditors, and will also be discussed in this chapter."
"Spring Surf is a view composition framework for Spring MVC that plugs into your existing Spring applications. It provides a scriptable and content-centric approach to building web applications.
You can drop Spring Surf right into your existing Spring web applications or you can begin building new Spring Surf applications using SpringSource Tool Suite or Spring Roo's command-line magic."
"The PrettyFaces team is currently working on an alternative way to configure URL mappings. PrettyFaces will soon allow to use annotations instead of the classic XML configuration file to declare mappings. We encourage everyone interested in PrettyFaces to take a look at this new way of configuration and share his or her opinion with us."
* Enhancements
o New plugins provide enhanced capabilities:
+ Hibernate Plugin:
# allows to generate SQL statements from Hibernate HQL statements
# shows object tree of mapped objec
With AutoPatch, an agile development process that requires a database change looks like this:
Developer alters the model, which requires a change to the database
Developer possibly consults a DBA, and develops a SQL patch against their personal database that implements the alteration
Developer commits the patch to source control at the same time as they commit their dependent code
Other developers' and environments' databases are automatically updated by AutoPatch the next time the new source is run
This represents streamlined environment maintenance, allowing developers to cheaply have their own databases and all databases to stay in synch with massively lower costs and no environment skew.
That's what AutoPatch does.
Clusters with one database? Multiple schemas? Logical migrations, instead of just DDL changes? Need to do something special/custom? Need to distribute your changes commercially? All without paying anything? No problem.
Special thanks to Piero Sartini who came up with this alternative. It is basically the same as the previous alternative, but it uses the new JEE6 Context and Dependency Injection (CDI) and session scoped beans instead of EJBs. This alternative should have better performance than using EJBs.
Instead of annotating the Vaadin application as a stateful session bean, it should be annotated using the @SessionScoped annotation, like so:
Last weekend while pondering the question "Is Scala ready for the enterprise?" I decided to write a simple Java EE 6 app entirely in Scala, without using any Java. I had three main reasons for doing this: one was just to see how easy/difficult it would be to write everything in Scala (it was easy). Another was to document the process for others journeying down the same road (the entire project is on github). Finally, I wanted to identify advantages of using Scala instead of Java that are specific to Java EE apps (I found several).
Background
The specific app I created was an adaptation of the Books example from Chapter 10 of Beginning Java™ EE 6 Platform with GlassFish™ 3. It's a simple web app that displays a list of books in a database and lets you add new books. Although it's a pretty trivial app, it does touch on several important Java EE 6 technologies: JPA 2.0, EJB 3.1 and JSF 2.0.