OpenOffice.org spell checker problem
If your OOo doesn’t not find any spelling error try:
Format > character > Language, and then change it to English or French…
If your OOo doesn’t not find any spelling error try:
Format > character > Language, and then change it to English or French…
I was wondering why the package org.eclipse.core.internal.watson has this name, I found the answer in the ElementTree class java doc:
/*******************************************************************************
* Copyright (c) 2000, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation – initial API and implementation
*******************************************************************************/
package org.eclipse.core.internal.watson;
import java.util.HashMap;
import org.eclipse.core.internal.dtree.*;
import org.eclipse.core.internal.utils.Messages;
import org.eclipse.core.internal.utils.StringPool;
import org.eclipse.core.runtime.*;
import org.eclipse.osgi.util.NLS;
/**
* An ElementTree can be viewed as a generic rooted tree that stores
* a hierarchy of elements. An element in the tree consists of a
* (name, data, children) 3-tuple. The name can be any String, and
* the data can be any Object. The children are a collection of zero
* or more elements that logically fall below their parent in the tree.
* The implementation makes no guarantees about the ordering of children.
*
* Elements in the tree are referenced by a key that consists of the names
* of all elements on the path from the root to that element in the tree.
* For example, if root node “a” has child “b”, which has child “c”, element
* “c” can be referenced in the tree using the key (/a/b/c). Keys are represented
* using IPath objects, where the Paths are relative to the root element of the
* tree.
* @see IPath
*
* Each ElementTree has a single root element that is created implicitly and
* is always present in any tree. This root corresponds to the key (/),
* or the singleton Path.ROOT. The root element cannot be created
* or deleted, and its data and name cannot be set. The root element’s children
* however can be modified (added, deleted, etc). The root path can be obtained
* using the getRoot() method.
*
* ElementTrees are modified in generations. The method newEmptyDelta()
* returns a new tree generation that can be modified arbitrarily by the user.
* For the purpose of explanation, we call such a tree “active”.
* When the method immutable() is called, that tree generation is
* frozen, and can never again be modified. A tree must be immutable before
* a new tree generation can start. Since all ancestor trees are immutable,
* different active trees can have ancestors in common without fear of
* thread corruption problems.
*
* Internally, any single tree generation is simply stored as the
* set of changes between itself and its most recent ancestor (its parent).
* This compact delta representation allows chains of element trees to
* be created at relatively low cost. Clients of the ElementTree can
* instantaneously “undo” sets of changes by navigating up to the parent
* tree using the getParent() method.
*
* Although the delta representation is compact, extremely long delta
* chains make for a large structure that is potentially slow to query.
* For this reason, the client is encouraged to minimize delta chain
* lengths using the collapsing(int) and makeComplete()
* methods. The getDeltaDepth() method can be used to
* discover the length of the delta chain. The entire delta chain can
* also be re-oriented in terms of the current element tree using the
* reroot() operation.
*
* Classes are also available for tree serialization and navigation.
* @see ElementTreeReader
* @see ElementTreeWriter
* @see ElementTreeIterator
*
* Finally, why are ElementTrees in a package called “watson”?
* – “It’s ElementTree my dear Watson, ElementTree.”
*/
public class ElementTree {
…
Sometimes the update from “Help -> Install New Software…” is not working due to the following error:
An error occurred while collecting items to be installed session context was:(profile=epp.package.modeling, phase=org.eclipse.equinox.internal.p2.engine.phases.Collect, operand=, action=). No repository found containing: osgi.bundle,org.eclipse.team.cvs.ssh
etc…
To solve it, simply uncheck “Contact all update sites during install to find required software” in the first page of the installaton wizard
An easy to use wiki based on javascript: http://www.tiddlywiki.com/
It holds in only one file and here are some examples:
An excellent simultation (java applet) help you understanding the different sorting algorithms.
the simulation applet: http://math.hws.edu/TMCM/java/xSortLab/
A good exercice could be to implement those sorting algorithms in both imperative and functionnal style to see the power of Scala…
See:
https://github.com/tomsontom/e4demo/raw/master/tutorial.pdf
Today I have discovered a Maven plugins for automating the Eclipse plugins development, it’s called:
http://tycho.sonatype.org/
I’ve discovered the Job Trends service from indeed.com, and I’ve tried it with MDE, MDA, UML and DSL: http://www.indeed.com/jobtrends?q=model+driven+development%2C+MDA%2C+UML%2C+DSL&l=
This is suggesting that: UML was succesful and will continue to have success…especially with the MDA (marketing) approach, that’s why the UML and MDA curves are behaving the same way.
But if you zoom on the graph (by removing the ‘UML’ keyword ) you’ll see that the MDE is becoming more and more a job trend: http://www.indeed.com/jobtrends?q=model+driven+development%2C+MDA%2C+DSL&l=
