Java Blog

Adobe Ajax Android Anwendung Apache API C++ Community Developer Eclipse Eclipse Foundation Embedded English Enterprise Entwickler Equinox Galileo Google Handy IBM IDE Individual Java Member Microsoft Mobile Modeling NetBeans News Open …

Game between Java and iphone. One of many features in Gedda-Headz Join us and be a part of the community! www.gedda-headz.com Spiel zwischen Java und iphone. Eine von vielen Handy-Funktionen in Gedda-Headz. Tritt bei und werde ein Teil …

It looks like I  am  late to find out this cool feature, but I’ll share it anyway. The reason for that is I never expected such a feature could exist. So there might be others like me who “underestimates” how the open source world addresses any problem that “can” exist and before you know, the solution is there.

As some of you know, I am not a committer on any open source project [yet].

However, I do contribute to quite a lot of them. One of the problems when you do not have write access to the original SCM repository, your patches and changes start getting outdated / conflicted / complicated and it becomes hard to keep up with the changes to the original SCM,

• of your patches, some go through as they are, some with some changes while some do not at all.
• the original repository is in continues change as well.

git Seems to tackle the issue. I have come across with Taki’s blog on CVS to GIT and back that explains how to address the problem in detail. Although the blog focuses on “CVS” it should be pretty easy apply the same for SVN and GIT (over GIT).

With these introductions you can mirror a cvs / svn repository and provide your own sub committer group to create patches, pass them to the project, get the updates back.

Even this can be very handy to fork a project.

hi also es ghet um das handy meines bruders wir wollten spiele ganz normal per usb kabel auf sein handy installieren die installation ist ok alles gut.

Last week the Eclipse Foundation published the proposal for the Remus project. In the following I will show you what the goals of the project are and how simple it is to build Eclipse based applications with this technology. We highly appreciate your feedback, suggestions, discussion at the Eclipse Community forums, see http://www.eclipse.org/forums/index.php?t=thread&frm_id=166

The goals of this project can be divided into two big parts:

1. Provide an out-of-the box set of bundles that can be installed into an Eclipse instance, for example your IDE, for daily information management. This tooling will be also available as standalone RCP application. There is already a build of a full-blown application built on Remus available, see http://www.remus-software.org.
2. The probably more relevant part is that we want to provide a framework and several APIs for building applications for viewing, editing, catgorizing, searching and synchronizing any datastructures. I’ll show you an example how to build your Hello-Remus bundle in just a few minutes.

The approach

The theoretical apporoach is that we assume that every unit of information can be described with a structure-definition. This definition holds the definition how a specific type of information is organized internally. Based on a structure-definition Remus can create business objects a navigatable information-structure, editing-ui and even a rule engine for manipulating these objects. Every structure-definition is typed, that means it can handled by the framework regarding visualization, indexing or synchronization in a different way.

Example

Ok, we’ve had enough of words, let’s start. Our “Hello World” application will be a RCP application for one single information type: A book review.

Step 1 – Creating the plugin and a structure definition.

We create a bundle using the plugin-wizard for a RCP with a single view. After the bundle was created we define our structure definition. This definition is done by a tree-based editor, but since the underlying technology is emf you can use alternative editing methods, for example with textual plugins like Xtext. A review has the following information-items

1. Title of the Review
2. Date
3. Author
4. Reviewed book
5. Review

We can create now this structure definition (see picture)

Step 2 – Navigation and first start

The first thing we have to do is to tell Remus about this new information type. We create a new extension, defining name and type of this information and point to the structure definition. Thats all for the moment. After that definition we already can add, edit and save information units. These operations are executed by default on a command-stack and can be un- or redone. The underlying data store mechanisms need no customization.

With a few lines you can create your first business objects:

As you can see we aquire an instance of a manager for setting values to an information unit. This manager checks our inputs against the underlying structure definition of this information type. A the end you’ll see that we generate a command and execute it. This command is checked for correctness and is executed on a command stack.

If we start now our RCP application we will see already a good result:

Step 3 – Editor

Remus provides some editor infrastructure to visualize and edit the given information unit. Note that these editors have already the basic functionalitites you know from other applications, like automatic refresh, close, undo-redo,…
Remus has no API for building UI elements you can use your preferred toolkit, but comes with a very handy API for binding UI elements to structure items defined by your information type. Editors are injected by a separate extension-point. For making an information type editable with an editor you have to extend 1 class and overwrite 2 methods (one for generating the ui and one for binding the ui-elements)

Due to the separation between the definition of ui elements and the binding to information structure elements you can use also third-party-tools like SWT designer.

The binding is very easy. You just have to bind a ui control to a structure element of your information type, a 2-liner:

After defining this editor you can now open this information unit from your navigation. As you can see in the screenshot the editor becomes dirty after an edit.

In addition Remus provides some additional API to forward the data of a information unit to a HTML Template Engine for pretty information visualization (if you want to browse through the data, complex forms are not appreciated) and to integrate the HTML Output into an editor.

Step 4 – Search

Integrating a search is also very easy. In general you only have to include the relevant bundles and Remus tries to index your information unit. By defining another extension point you can tell Remus which structure items need to be indexed. If you like you can use the default search view which is shipped with the framework. Also the result listing can be reused (if you like). If you use the search bundles you autmatically get a search history, a search for references, a search context with key bindings to navigate through results, …

By adding the search view to your perspective layout, you see the Search-View

Conclusion

Of course there are many other things you can use, for example linking between information units, support for files, integration of third-party-editors, data-encryption, semantical structures, synchronization with remote information pools,… I’ll post some documentation soon.

The components of Remus can be used to build RCP applications, Eclipse plugins, RAP applications or even a headless information repository running on a server for information distribution. We also provide an ODA Driver to query information structures with the Eclipse Data Tools Platform; this makes especially the BIRT integration very easy.

We are currently in the proposal phase of the Eclipse Development process and need your feedback. If you have questions about features, architecture, use cases, etc don’t hestitate to post your thoughts at the Newsgroup or the Eclipse Community Forums; and if you want to see what we’ve already done with this framework take a look at http://remus-software.org, the projects current home. We’re looking forward hearing from you.

Für welche Handy software werden fürs H1 benötigt??????????ß Klar ist das es sich um eine Linux Software handelt aber im Web gibt es keine Anwendungen.

TV Handy von FLY YING, Modell F006 mit WLAN, Dual-SIM, 3,2 Zoll Touchscreen Display und 9 MP Kamera.

Almost two years passed since the Memory Analyzer tool (MAT) was published at Eclipse. Since then we have collected a lot of feedback, questions and comments by people using it, and we also gathered experience in using the tool ourselves. Most of the people find their way to solve memory problems using MAT relatively easy, but I am convinced there are also a lot of unexplored features and concepts within the tool, which can be very handy if properly understood and used. Therefore I decided to start a series of blog posts dedicated to memory analysis (with MAT) – starting from the basics and covering the different topics in detail. I would try to answer there some of the questions which pop-up most often, give some (hopefully useful) hints, explain the benefit of certain “unpopular” queries, and (please, please, please…) collect your feedback.

As the Memory Analyzer is a tool working with heap dumps, I will start with a detailed look at heap dumps – what they are, which formats MAT can read, what can be found inside, how one can get them, etc… If you are interested in the topic, read further.

What Is a Heap Dump?

A heap dump is a snapshot of the memory of a Java process at a certain point of time. There are different formats for persisting this data, and depending on the format it may contain different pieces of information, but in general the snapshot contains information about the java objects and classes in the heap at the moment the snapshot was triggered. As it is just a snapshot at a given moment, a heap dump does not contain information such as when and where (in which method) an object was allocated.

What Are Heap Dumps Good for?

So what are heap dumps good for? Well, for a lot of things
If there is a system which is crashing sporadically with an OutOfMemoryError, then analyzing an automatically written heap dump with MAT can be a very easy way to find the root cause of the problem (read more here).
If you wan to analyze what the footprint into memory of your application is, then MAT and heap dumps are again a good choice. This combination can also help you to find which are your biggest structures, to find redundant data structures, to find space wasted in unused collections, and much more. Such topics will be covered later in this blog series.
If you however are trying to find out why too many garbage objects are produced during a certain operation, or want to see which methods allocate most of the objects, then you would need to use a profiler which is collecting data over time from the VM. Leak detecting techniques relying on analysis of the objects behaviour (allocation / garbage collection) are difficult to inplement using heap dumps (see object identity below).

Types of Heap Dumps

Currently the Memory Analyzer is able to work with HPROF binary heap dumps (produced by Sun, HP, SAP, etc… JVMs), IBM system dumps (after preprocessing them), and IBM portable heap dumps (PHD) from a variaty of IBM platforms. Let’s have a closer look at each of the types.

HPROF Binary Heap Dumps

A detailed specification of the content of an HPROF file can be found here.

Below are summarized some of the important pieces of the information used within MAT:

IBM System Dumps

On IBM platforms one can preprocess a system dump (core file) from a Java process with the jxtract tool, and analyze the result with Memory Analyzer on an arbitrary other box (DTFJ libraries have to be additionally installed, see details below in the “How to get heap dump” section). As the core file contains the whole process memory, this kind of dump also provides all the details seen in an hprof heap dump (including the field names, primitive fields’ values, stacktraces, etc…). There is even more information (e.g. process related information), but at the moment it is not used in Memory Analyzer.

IBM Portable Heap Dumps (PHD)

The PHD files are much smaller in size than the corresponding system dumps. However, they contain less information.
The major difference between the HPROF dumps (or the IBM system dumps) and PHD dumps is that a PHD dump does not contain the values of the primitive fields. Only the non-null references from an object are provided. The second important difference is that the field names are not present, i.e. one can’t distinguish from which field a reference is made, and because of this the presented reference chains (paths) are not as concrete as with the other dumps. Using just the object graph is still enough for the analysis of many memory-related problems, but when the content of some fields is needed to get an idea why an object is too big then one has to use the system dumps.
Usually when a PHD dump is generated there is also a corresponding javacore file. If they are put together in the same directory when the PHD dump is opened with MAT, then some of the data in the javacore file will also be used.

So, having less information has both advantages and disadvantages – the PHD dumps are ways easier to transport from a customer (smaller size), can be used to find the biggest objects in the heap. And as they are usually written by default they are a good place to start the analysis. However, in some cases the information is enough to analyze in details the root cause of a problem.

A Common API for Them All?

Having different formats for the heap dumps is definitely easier for the VM providers, as they can provide very efficiently the specific data they have. This however doesn’t hold true for the tools, which are faced with the different formats, have to understand each of them, and possibly optimize for every format separately.
An attempt to solve this problem and make the life of tool writers easier is made under the Apache Kato project and the related JSR 326. They put efforts to provide a common API for accessing data from vendor specific snapshots and thus give tools a standard way to extract the data needed for post-mortem diagnostics (including memory related problems).

How To Get a Heap Dump

How to obtain a heap dump depends on the platform and the used JVM. In general all VMs provide the possibility to request a heap dump manually, or to get one written from the VM when an OutOfMemoryError occurs. The second option is very convenient for the analysis of problems happening on production systems, or happening only sporadically, as one does not have to observe the system and wait for the problem to reoccur.
A detailed description how a heap dump can be obtained depending on the JVM is provided here.

Object Identity

One of the questions which we are asked very often is if MAT can recognize the same objects in two or more heap dumps from the same process. The answer is unfortunately still no. Object IDs which are provided in the known to us heap dumps are just the addresses at which the objects are located. As objects are often moved and reordered by the JVM during a GC these addressed change. Therefore they cannot be used to compare the objects. Tagging the objects while they are allocated is something a profiler could do (usually at a relatively high cost), but in the standard heap dumps described above such information is missing. Some ideas how to guess identical objects were discussed in this bugzilla entry.

Are Dead Objects Present In the Heap Dump?

Another question which often pops up is if garbage objects are included in the heap dump. This again depends on the heap dump, but usually a GC is done before the heap dump is written. Nevertheless there are always some objects which are unreachable from the GC roots, i.e. should be thrown away. The Memory Analyzer removes such objects during the initial parsing of a heap dump in order to simplify the analysis. If you want to have a look at the “garbage” or even want the objects to remain, then find here what to do.

In Closing …
This was my attempt to give a detailed explanation of the different heap dump formats which the Memory Analyzer understands, and also give the answers to some of the questions which we frequently get. I’m sure there are still questions to be answered, and the MAT team will be very happy to get them from you, be it as comments here, in our fourm, or in bugzilla.

Just found a very good write up about maven vs ant builds –
http://www.iternum.com/knowhow/guidelines/maven-vs-ant/. A very interesting read for everybody who need to build Java applications.

P.S.

Interestingly, I see that there are not much changes since the last time I was heavily involved in the maven configuration nightmare on a big J2EE application (this was at 2006). Right now I’m in a good position – we are using ant build files generated automatically from the Eclipse plugin projects by the PDE. All what we need then is to integrate them via Makefile.local to our overall (custom) build process which also manages to compile and build our C/C++/Java/Eclipse code to handy rpm files of ~300MB size

Its due for a long time Ever since I purchased this domain, I wanted to create a site as a resource for Eclipse Plug-in developers. With little bit of hacking over the two weekends, the website is up and running with bare minimum content. I’ll be adding more content from this blog and elsewhere, meanwhile you can check out the layout and other stuff.

Coolest and most useful thing for the visitors would be Eclipse Search. Even though the results portion occupies a significant space in the prime area, I decided to have it because its very handy if you want to search for something. And the whole interface is very nice (courtesy: Google Ajax APIs) Whether you want to search for a particular class in the repository or search for an xml editor plugin or a blog entry about Tray Item, its available in  few clicks.

Every article has a pdf & print icon. So if you need an offline copy, its available. This was not possible earlier with this blog.

And last, but not the least, for international visitors, the translate option is available in the bottom bar. With just two clicks you can translate to a language of your choice – without reloading the page. Again, done thru Google Ajax APIs. (you got to love this web stuff – esp when you can implement a feature without writing a single line of code )

Mail me/leave a comment if you have any comments/suggestions

Christian Stöcker spricht mir aus der Seele: Der App-Wahn ist eine Zwangsjacke für das Internet. Darum hatte ich mich in der letzten Zeit ein wenig mit Java ME beschäftigt. Und mein nächstes Handy ist eines, das ich selber programmieren und betanken kann — ohne beim Hersteller meine Kreditkartennummer ange­ben und um Aufnahme betteln zu müssen. [...]

Hi suche ein Java Programm fürs Jet womit ich meinen PC fernsteuern kann bitte ne fullversion oder ne freeware danke.

Guten Abend zusammen. Ich habe mir Java-Box auf mein Handy geschmissen. Und da dann die Opera mini beta 5 drin installiert. Und ich muß sagen das ist.

ich möchte mir das Mh702 DualSim Handy JAVA 2GB Unlocked i68 MP3 3.0 TOUCHSCREEN bei eFox-Shop kaufen und ich möchte gerne wissen ob man darauf apps.

Der kostenlose Mobile Downloader ist ein Downloadmanager, der Downloads nach einer Unterbrechung wieder fortsetzen kann usw. Er ist einfach zu.

Schon im Jahr 2004 berichtete Spiegel-online über die ersten Handy-Viren . Die logische Schlussfolgerung aus dem Bericht lautete seinerzeit, dass “auch Handys langfristig nur mit Virenschutzsoftware vor Angriffen geschützt werden können.” Java-Programme wählen teure Nummern Forscher haben Malware im Umlauf gefunden, die Smartphones infiziert und anschließend Premium-SMS verschickt. Die…