Of course! The owls!
Throughout all of the historical documents we've found there's one common thread - their society embraced animal companions as if they were members of their own family. The eternals we're no exception to this, and it
appears they have also had a significant number of companions in their time together. Two in particular stand out - the bonds they shared with these animals appear to have truly left an impact on their lives. While the
first companion appears to have passed away at some point in history - the records show he was loved dearly and the eternals showered him with love and affection for their all too brief time together. It left a large hole
in their hearts, but they were able to mend those wounds and give that love to another companion. However, we aren't really sure what kind of animal the new companion is as he doesn't match the description of other
creatures within his species. What a puzzling discovery!
Maybe we should investigate where the new companion was obtained? Before he joined the eternal's family he was kept in a local business as a performer for the customers. After the eternal's met him they were smitten
by his charm and energy - despite his poor attitude and frequency to lash out when upset. The records show that the store had a slogan displayed proudly on a banner outside - but alas, it has been lost to time. What is that slogan?!


The datasource object for use as an interface for a datasource
- Source:
Members
-
<static> this.client
-
- Source:
Properties:
Name Type Description client
object The client for use in the DataSource
-
<static> this.collection
-
- Source:
Properties:
Name Type Description collection
object The collection for use in the DataSource
-
<static> this.db
-
- Source:
Properties:
Name Type Description db
object The database (or simular) for the datasource (if applicable)
-
<static> this.url
-
- Source:
Properties:
Name Type Description url
string The url for the datasource (if applicable)
Methods
-
<static> closeConnection Close a connection to the DataSource ()
-
- Source:
Returns:
Returns true if a connection is established
- Type
- boolean
-
<static> getCollection Get the collection()
-
- Source:
Returns:
Returns the collection
- Type
- object
-
<static> getConnection Get a connection to the DataSource()
-
- Source:
Returns:
Returns true if a connection is established
- Type
- boolean
-
<static> insert Insert data(data)
-
Parameters:
Name Type Description data
object Data to insert
- Source:
-
<static> query Query data(query, callback)
-
Parameters:
Name Type Description query
object The query object
callback
function A callback to execute during the query
- Source:
Returns:
Returns a value from the query or response code
- Type
- object
-
<static> remove Remove data(data)
-
Parameters:
Name Type Description data
object Data to remove
- Source:
-
<static> setCollection Set the collection by name(name)
-
Parameters:
Name Type Description name
string The name of the collection
- Source:
-
<static> update Update data(data)
-
Parameters:
Name Type Description data
object Data to update
- Source:


The eight puzzle is often used as a bench mark or first test for search algorithms because its search space is small
enough to be exhaustively explored but large enough to provide a reaasonably complex test space to test out different
search algorithms on. The puzzle consists of numbered tiles, 1 to 8, arranged in a 3 by 3 grid with one square empty.
Tiles may only move by sliding into the empty square. The aim is to arrange the tiles like this:
Another popular variation of the goal state is:
Two heuristics used to guide the search are the number of tiles out of place and the total manhattan distance of the out
of place tiles to their goal locations. The manhattan distance is the total number of horizontal and vertical moves a tile
must make to arrive in its place. A manhattan distnace heuristic is supplied in this package. It can compute the total
distance from scratch or incrementally from a previous board position with a move applied to it. This technique of
incremental heuristics is possible because search node to calculate a hearustic for is always passed along with the
actual state to calculate it for. The search node can be used to obtain its parent state and the operation applied
to get to it, making incremental calculation possible. This can often be a very significant time saver.


The library of UI components used for Terminus applications.
Table of Contents
This document covers documentation for building and maintaining the terminus-ui library. For documentation on all components and styles, visit GetTerminus.github.io/terminus-ui.
docs/
)docs/typescript/
)coverage/
)
- :x: not started
- :hammer: started
- :white_check_mark: available
- :hankey: deprecated
| Feature | Notes | Status | Demo | Docs | Usage |
|---|---|---|---|---|---|
| alert | :x: | ||||
| autocomplete | :white_check_mark: | Demo | Docs | Usage | |
| autofocus | Focus a focusable element on load | :white_check_mark: | Demo | Docs | Usage |
| badge | :x: | ||||
| button | :white_check_mark: | Demo | Docs | ||
| breadcrumbs | :x: | ||||
| card | :white_check_mark: | Demo | Docs | Usage | |
| chip | :x: | ||||
| checkbox | :white_check_mark: | Demo | Docs | Usage | |
| copy | :white_check_mark: | Demo | Docs | ||
| datavis | :x: | ||||
| datepicker | :white_check_mark: | Demo | Docs | Usage | |
| date-range | :white_check_mark: | Demo | Docs | Usage | |
| dialog | :x: | ||||
| divider | :x: | ||||
| expansion | :x: | ||||
| file-picker | :x: | ||||
| input-masking | :x: | ||||
| input-messages | Used by input to display validation messages |
:white_check_mark: | (see input demo) | ||
| icon | Valid icon names: https://material.io/icons | :white_check_mark: | Demo | Docs | Usage |
| icon-button | :white_check_mark: | Demo | Docs | Usage | |
| input | :white_check_mark: | Demo | Docs | ||
| link | :white_check_mark: | Demo | Docs | ||
| loading overlay | :white_check_mark: | Demo | Docs | ||
| login form | :white_check_mark: | Demo | Docs | ||
| menu | :white_check_mark: | Demo | Docs | ||
| navigation | :white_check_mark: | Demo | Docs | ||
| paginator | :white_check_mark: | Demo | Docs | ||
| progress | :x: | ||||
| progression | :x: | ||||
| radio-group | :white_check_mark: | Demo | Docs | Usage | |
| search | :white_check_mark: | Demo | Docs | ||
| select | :white_check_mark: | Demo | Docs | ||
| spacing | Helpers for consistent spacing | :white_check_mark: | Demo | Docs | |
| sort | Used by table to manage column sorting |
:white_check_mark: | (see table demo) | Docs | Usage |
| table | :white_check_mark: | Demo | Docs | Usage | |
| tabs | :x: | ||||
| toggle | :white_check_mark: | Demo | Docs | ||
| tooltip | :white_check_mark: | Demo | Docs |
| Pipe | Notes | Status | Demo |
|---|---|---|---|
tsDate |
short , medium , extended , timestamp |
:white_check_mark: | Demo |
tsTimeAgo |
a human-readable time span | :white_check_mark: | Demo |
| Feature | Notes | Status |
|---|---|---|
| Document | :warning:DEPRECATED:warning: Provide access to the native document object | :hankey: |
| Spacing | Expose custom spacing sizes via a service | :white_check_mark: |
| Validators | Expose custom validation methods for reactive forms | :white_check_mark: |
| Window | :warning:DEPRECATED:warning: Provide access to the native window object | :hankey: |
| Feature | Notes | Status |
|---|---|---|
| Interfaces | Provide TypeScript interfaces for various objects | :white_check_mark: |
| Types | Provide TypeScript types for various parameters | :white_check_mark: |
| Feature | Notes | Status | Docs |
|---|---|---|---|
| animation | :hammer: | ||
| assets | :hammer: | ||
| breakpoints | :white_check_mark: | Docs | |
| colors | :white_check_mark: | Docs | |
| cursors | :white_check_mark: | Docs | |
| layout | :white_check_mark: | Docs | |
| shadows | :white_check_mark: | Docs | |
| spacing | :white_check_mark: | Docs | |
| typography | :white_check_mark: | Docs | |
| z-index | :white_check_mark: | Docs |
Install the library and all required dependencies:
$ yarn add @terminus/ui @terminus/ui @angular/forms @angular/animations @angular/material hammerjs --exact
To use the global styles, import the CSS file into your stylesheets:
@import<EMAIL_ADDRESS>To use the provided SCSS helper methods/variables/mixins, import the helpers file from @terminus/ui
:
@import '~@terminus/ui/helpers'
View the wiki page.
Thanks goes to these wonderful people (emoji key):
Benjamin Charity 💻 📖 ⚠ 🎨 🤔 👀 🔧 |
coreyterminator 💻 |
Wendy 🐛 |
Brian Malinconico 🐛 🤔 |
David Harkness 💻 |
kal93 🐛 |
|---|---|---|---|---|---|
This project follows the all-contributors specification. Contributions of any kind welcome!


{{title}}
Navigation
Home
About
Workshops
Get in touch
Articles
{{content}}
James Brooks
e:
<EMAIL_ADDRESS>t:
+44 (0)<PHONE_NUMBER>


All {{dataSource.paginator.pageSize}} students on this page are selected. Select all {{dataSource.data.length}} All {{dataSource.data.length}} enrolled students are selected. Clear selection


Skip to main content
Accessible Star Rating Options
View the full library of accessibility solutions.
Control
How would you rate your appetizer?
Option 1: Radio Buttons
How would you rate your meal?
Option 2: ARIA Solution
How would you rate your dessert?


--- layout: post title: The new iPad's retina display is super crisp date: 2012-03-16 15:36:52.000000000 -07:00 type: post published: true status: publish categories: [] tags: [] meta: {} author: ---
New vs iPad 2
Sent from my iPhone


Most of the GET requests you can issue to the HTTP API return JSON objects with a large number of keys. While a few of these keys represent things you set yourself in a PUT request or AMQP command (e.g. queue durability or arguments), most of them represent statistics to do with the object in question. This page attempts to document them.
It should be read in conjunction with the manual page
for rabbitmqctl
(see your installation if on Unix / Linux,
or the
RabbitMQ website for the latest version). Any field which can
be returned by a command of the form rabbitmqctl
list_something
will also be returned in the
equivalent part of the HTTP API, so all those keys are not
documented here. However, the HTTP API also adds a lot of extra
fields which are not available in rabbitmqctl
.
Many fields represent a count of some kind: queue length,
messages acknowledged, bytes received and so on. Such absolute
counts returned by the HTTP API will often have a
corresponding _details
object which offers
information on how this count has changed. So for example, from
a queue:
"messages": 123619, "messages_details": { "avg": 41206.333333333336, "avg_rate": 1030.1583333333333, "rate": 24723.8, "samples": [ { "sample": 123619, "timestamp":<PHONE_NUMBER>000 }, { "sample": 0, "timestamp":<PHONE_NUMBER>000 }, { "sample": 0, "timestamp":<PHONE_NUMBER>000 } ] }
Here we have a messages
count (the total messages
in the queue), with some additional data:
avg |
The average value for the requested time period (see below). |
avg_rate |
The average rate for the requested time period. |
rate |
How much the count has changed per second in the most recent sampling interval. |
samples |
Snapshots showing how the value has changed over the requested time period. |
avg
, avg_rate
and samples
will only appear if you request a specific time period by
appending query parameters to the URL. To do this you need to
set an age and an increment for the samples you want. The end of
the range returned will always correspond to the present.
Different types of data take different query parameters to return samples, as in the following table. You can specify more than one set of parameters if the resource you are requesting can generate more than one type of sample (for example, queues can return message rates and queue lengths).
| Messages sent and received | msg_rates_age / msg_rates_incr |
| Bytes sent and received | data_rates_age / data_rates_incr
|
| Queue lengths | lengths_age / lengths_incr |
| Node statistics (e.g. file descriptors, disk space free) | node_stats_age / node_stats_incr |
For example,
appending ?lengths_age=3600&lengths_incr=60
will
return the last hour's data on queue lengths, with a sample for
every minute.
Many objects (including queues, exchanges and channels) will
return counts of messages passing through them. These are
included in a message_stats
object (which in turn
will contain _details
objects for each count, as
described above).
These can contain:
publish |
Count of messages published. |
publish_in |
Count of messages published "in" to an exchange, i.e. not taking account of routing. |
publish_out |
Count of messages published "out" of an exchange, i.e. taking account of routing. |
confirm |
Count of messages confirmed. |
deliver |
Count of messages delivered in acknowledgement mode to consumers. |
deliver_noack |
Count of messages delivered in no-acknowledgement mode to consumers. |
get |
Count of messages delivered in acknowledgement mode in response to basic.get. |
get_noack |
Count of messages delivered in no-acknowledgement mode in response to basic.get. |
deliver_get |
Sum of all four of the above. |
redeliver |
Count of subset of messages in deliver_get
which had the redelivered flag set.
|
return |
Count of messages returned to publisher as unroutable. |
Only fields for which some activity has taken place will appear.
In addition, queues, exchanges and channels can return a
breakdown of message stats for each of their neighbours
(i.e. adjacent objects in the chain: channel -> exchange ->
queue -> channel). This will only happen if
the rates_mode
configuration item has been switched
to detailed
from its default of basic
.
As this possibly constitutes a large quantity of data, it is also only returned when querying a single channel, queue or exchange rather than a list. Note also that the default sample retention policy means that these detailed message stats do not retain historical data for more than a few seconds.
The detailed message stats objects have different names
depending on where they are (documented below). Each set of
detailed stats consists of a list of objects with two fields,
one identifying the partner object and one stats
which is a message_stats object as described above.
For example, from a queue:
"incoming": [ { "stats": { "publish": 352593, "publish_details": { "rate": 100.2 } }, "exchange": { "name": "my-exchange", "vhost": "/" } } { "stats": { "publish": 543784, "publish_details": { "rate": 54.6 } }, "exchange": { "name": "amq.topic", "vhost": "/" } } ],
This queue is currently receiving messages from two exchanges: 100.2 msg/s from "my-exchange" and 54.6 msg/s from "amq.topic".
This has the following fields:
cluster_name |
The name of the entire cluster, as set with rabbitmqctl
set_cluster_name .
|
contexts |
A list of web application contexts in the cluster. |
erlang_full_version |
A string with extended detail about the Erlang VM and how it was compiled, for the node connected to. |
erlang_version |
A string with the Erlang version of the node connected to. As clusters should all run the same version this can be taken as representing the cluster. |
exchange_types |
A list of all exchange types available. |
listeners |
All (non-HTTP) network listeners for all nodes in the
cluster. (See contexts
in /api/nodes for HTTP).
|
management_version |
Version of the management plugin in use. |
message_stats |
A message_stats object for everything the user can see - for
all vhosts regardless of permissions in the case
of monitoring and administrator
users, and for all vhosts the user has access to for other
users.
|
node |
The name of the cluster node this management plugin instance is running on. |
object_totals |
An object containing global counts of all connections,
channels, exchanges, queues and consumers, subject to the
same visibility rules as for message_stats .
|
queue_totals |
An object containing sums of
the messages , messages_ready
and messages_unacknowledged fields for all
queues, again subject to the same visibility rules as
for message_stats .
|
rabbitmq_version |
Version of RabbitMQ on the node which processed this request. |
rates_mode |
'none', 'basic' or 'detailed'. |
statistics_db_event_queue |
Number of outstanding statistics events yet to be processed by the database. |
statistics_db_node |
Name of the cluster node hosting the management statistics database. |
This has the following fields:
applications |
List of all Erlang applications running on the node. |
auth_mechanisms |
List of all SASL authentication mechanisms installed on the node. |
cluster_links |
A list of the other nodes in the cluster. For each node, there are details of the TCP connection used to connect to it and statistics on data that has been transferred. |
config_files |
List of config files read by the node. |
contexts |
List of all HTTP listeners on the node. |
db_dir |
Location of the persistent storage used by the node. |
disk_free |
Disk free space in bytes. |
disk_free_alarm |
Whether the disk alarm has gone off. |
disk_free_limit |
Point at which the disk alarm will go off. |
enabled_plugins |
List of plugins which are both explicitly enabled and running. |
exchange_types |
Exchange types available on the node. |
fd_total |
File descriptors available. |
fd_used |
Used file descriptors. |
io_read_avg_time |
Average wall time (milliseconds) for each disk read operation in the last statistics interval. |
io_read_bytes |
Total number of bytes read from disk by the persister. |
io_read_count |
Total number of read operations by the persister. |
io_reopen_count |
Total number of times the persister has needed to recycle file handles between queues. In an ideal world this number will be zero; if the number is large, performance might be improved by increasing the number of file handles available to RabbitMQ. |
io_seek_avg_time |
Average wall time (milliseconds) for each seek operation in the last statistics interval. |
io_seek_count |
Total number of seek operations by the persister. |
io_sync_avg_time |
Average wall time (milliseconds) for each fsync() operation in the last statistics interval. |
io_sync_count |
Total number of fsync() operations by the persister. |
io_write_avg_time |
Average wall time (milliseconds) for each disk write operation in the last statistics interval. |
io_write_bytes |
Total number of bytes written to disk by the persister. |
io_write_count |
Total number of write operations by the persister. |
log_files |
List of log files used by the node. If the node also sends
messages to stdout, "<stdout> " is also
reported in the list.
|
mem_used |
Memory used in bytes. |
mem_alarm |
Whether the memory alarm has gone off. |
mem_limit |
Point at which the memory alarm will go off. |
mnesia_disk_tx_count |
Number of Mnesia transactions which have been performed that required writes to disk. (e.g. creating a durable queue). Only transactions which originated on this node are included. |
mnesia_ram_tx_count |
Number of Mnesia transactions which have been performed that did not require writes to disk. (e.g. creating a transient queue). Only transactions which originated on this node are included. |
msg_store_read_count |
Number of messages which have been read from the message store. |
msg_store_write_count |
Number of messages which have been written to the message store. |
name |
Node name. |
net_ticktime |
Current kernel net_ticktime setting for the node. |
os_pid |
Process identifier for the Operating System under which this node is running. |
partitions |
List of network partitions this node is seeing. |
proc_total |
Maximum number of Erlang processes. |
proc_used |
Number of Erlang processes in use. |
processors |
Number of cores detected and usable by Erlang. |
queue_index_journal_write_count |
Number of records written to the queue index journal. Each record represents a message being published to a queue, being delivered from a queue, and being acknowledged in a queue. |
queue_index_read_count |
Number of records read from the queue index. |
queue_index_write_count |
Number of records written to the queue index. |
rates_mode |
'none', 'basic' or 'detailed'. |
run_queue |
Average number of Erlang processes waiting to run. |
running |
Boolean for whether this node is up. Obviously if this is false, most other stats will be missing. |
sasl_log_file |
Location of sasl log file. |
sockets_total |
File descriptors available for use as sockets. |
sockets_used |
File descriptors used as sockets. |
type |
'disc' or 'ram'. |
uptime |
Time since the Erlang VM started, in milliseconds. |
All of the above, plus:
memory |
Detailed memory use statistics. Only appears
if ?memory=true is appended to the URL.
|
binary |
Detailed breakdown of the owners of binary memory. Only
appears if ?binary=true is appended to the
URL. Note that this can be an expensive query if there are
many small binaries in the system.
|
See documentation for rabbitmqctl
list_connections
. No additional fields,
although pid
is replaced by node
.
Note also that while non-AMQP connections will appear in this
list (unlike rabbitmqctl list_connections
), they
will omit many of the connection-level statistics.
See documentation for rabbitmqctl list_channels
,
with pid
replaced by node
, plus:
connection_details |
Some basic details about the owning connection. |
message_stats |
See the section on message_stats above. |
All the above, plus
publishes |
Detailed message stats (see section above) for publishes to exchanges. |
deliveries |
Detailed message stats for deliveries from queues. |
consumer_details |
List of consumers on this channel, with some details on each. |
See documentation for rabbitmqctl list_exchanges
, plus:
message_stats |
See the section on message_stats above. |
All the above, plus:
incoming |
Detailed message stats (see section above) for publishes from channels into this exchange. |
outgoing |
Detailed message stats for publishes from this exchange into queues. |
See documentation for rabbitmqctl list_queues
, with
all references to pid
s replaced by node
s
plus:
message_stats |
See the section on message_stats above. |
All the above, plus:
incoming |
Detailed message stats (see section above) for publishes from exchanges into this queue. |
deliveries |
Detailed message stats for deliveries from this queue into channels. |
consumer_details |
List of consumers on this channel, with some details on each. |
All the fields from rabbitmqctl list_vhosts
(i.e. name
and tracing
) plus:
message_stats |
Global message_stats for this vhost. Note that activity for
other users in this vhost is shown, even for users
without the monitoring tag.
|
messages messages_ready messages_acknowledged |
Sum of these fields for all queues in the vhost. |
recv_oct send_oct |
Sum of these fields for all connections to the vhost. |


{% extends 'commercialoperator/emails/base_email.html' %}
{% block content %}
Your document to complete a requirement {{ compliance.reference }} of your licence has been submitted.
You will receive a confirmation email, and it will show up on your account if the document meets the requirement.
You will receive a notification email if there is any incomplete information or documents missing.
{% endblock %}


public class Satellite extends java.lang.Object implements ISatellite
| Modifier and Type | Field and Description |
|---|---|
private java.util.List<INetworkAgent> |
myAgents |
static org.jgrapht.graph.DirectedWeightedMultigraph<Vertex,Link> |
myGraph |
private static org.slf4j.Logger |
myLogger |
private controllers.networking.ITopologyDiscoverer |
myTopologyDiscoverer |
private static java.lang.String |
rootElementIP |
private static java.lang.String |
rootElementPassword |
private static java.lang.String |
rootElementUserName |
private static java.lang.String |
satelliteIP |
private static java.lang.String |
satelliteName |
private static int |
satellitePort |
private static java.lang.String |
topologyDiscovererIP |
private static int |
topologyDiscovererPort |
| Constructor and Description |
|---|
Satellite(java.lang.String satelliteName,
java.lang.String satelliteIP,
int satellitePort,
java.lang.String myTopologyDiscovererIP,
int myTopologyDiscovererPort)
Setup RMI-Server and connect to the TopologyDiscoverer via Java RMI.
|
| Modifier and Type | Method and Description |
|---|---|
void |
addNetworkAgent(INetworkAgent agent)
Adds an Network Agent to the ArrayList 'myAgents'.
|
void |
disconnect()
Call remote disconnect() method to remove Satellite from the
TopologyDiscoverer's ArrayList.
|
private static org.slf4j.Logger |
getLogger() |
java.lang.String |
getSatelliteName() |
controllers.networking.ITopologyDiscoverer |
getServer() |
org.jgrapht.graph.DirectedWeightedMultigraph<Vertex,Link> |
getTopology()
Get the site's network topology by asking all available Network Agents
to discover the LAN.
|
boolean |
isAlive()
The TopologyDiscoverer will use this remote method to check whether or
not a Satellite is still reachable.
|
static void |
main(java.lang.String[] args)
Create objects, add CiscoAgent to ArrayList 'myAgents' and setup the
shutdown hook.
|
static void |
parseCommandLine(java.lang.String[] args)
Parse the command line options.
|
static boolean |
readProperties()
Read the connection properties - Satellite name, Satellite IP-Address,
Satellite port number, TopologyDiscoverer IP-Address, TopologyDiscoverer
port number, root element IP-Address, root element username and password
- from a file named 'connection.properties' that is a resource on the
classpath.
|
void |
sendEvent(java.lang.String satelliteName,
java.lang.String message)
Call remote receiveEvent() method to send an event.
|
boolean |
setRoute(Vertex source,
Vertex next,
Vertex secondToLast,
Vertex destination)
Set a static route on a network element.
|
private static java.lang.String satelliteName
private static java.lang.String satelliteIP
private static int satellitePort
private controllers.networking.ITopologyDiscoverer myTopologyDiscoverer
private static java.lang.String topologyDiscovererIP
private static int topologyDiscovererPort
private static java.lang.String rootElementUserName
private static java.lang.String rootElementPassword
private static java.lang.String rootElementIP
private java.util.List<INetworkAgent> myAgents
private static org.slf4j.Logger myLogger
public Satellite(java.lang.String satelliteName, java.lang.String satelliteIP, int satellitePort, java.lang.String myTopologyDiscovererIP, int myTopologyDiscovererPort)
satelliteName
- - The Satellite's name.satelliteIP
- - The local IP-Address to setup the RMI-Server.satellitePort
- - The local port number to setup the RMI-Server.myTopologyDiscovererIP
- - Destination IP-Address to connect to TopoDis via Java RMI.myTopologyDiscovererPort
- - Destination port number to connect to TopoDis via RMI.public void sendEvent(java.lang.String satelliteName, java.lang.String message) throws java.rmi.RemoteException
satelliteName
- - The Satellite's name who sends the message.message
- - The actual message, e.g. 'Link XY on device Z is down'.java.rmi.RemoteException
- A RemoteException is the common superclass for a number of
communication-related exceptions that may occur during the
execution of a remote method call.public void disconnect() throws java.rmi.RemoteException
java.rmi.RemoteException
- A RemoteException is the common superclass for a number of
communication-related exceptions that may occur during the
execution of a remote method call.public boolean setRoute(Vertex source, Vertex next, Vertex secondToLast, Vertex destination) throws java.rmi.RemoteException
ISatellite
setRoute
in interface ISatellite
source
- - The source network element where to configure the route.next
- - The neighbor network element for getting the next-hop
IP-Address.secondToLast
- - The second to last network element for calculating the
destination network.destination
- - The destination network element for calculating the
destination network.java.rmi.RemoteException
- A RemoteException is the common superclass for a number of
communication-related exceptions that may occur during the
execution of a remote method call.public boolean isAlive() throws java.rmi.RemoteException
ISatellite
isAlive
in interface ISatellite
java.rmi.RemoteException
- A RemoteException is the common superclass for a number of
communication-related exceptions that may occur during the
execution of a remote method call.public controllers.networking.ITopologyDiscoverer getServer()
public void addNetworkAgent(INetworkAgent agent)
agent
- - The Network Agent that needs to be added to the ArrayList
'myAgents'.public org.jgrapht.graph.DirectedWeightedMultigraph<Vertex,Link> getTopology() throws java.rmi.RemoteException
ISatellite
getTopology
in interface ISatellite
java.rmi.RemoteException
- A RemoteException is the common superclass for a number of
communication-related exceptions that may occur during the
execution of a remote method call.private static org.slf4j.Logger getLogger()
public static void parseCommandLine(java.lang.String[] args)
args
- The args string passed into the method.public static boolean readProperties()
public java.lang.String getSatelliteName()
public static void main(java.lang.String[] args)
args
- The args string passed into the main method.


Mushrooms - P. semilanceata & Cannabis
To Start off I'm 18 and have only used marijuana before. I read a lot of trip reports to prepare myself. I packed my marijuana smoking gear, warm clothing, and drinks (cola and water). I've been trying to get shrooms for weeks, everyone is always out, but today, a dealer I know comes up to me and says man I heard you want some shrooms.  He picks out 'about 4-5 grams' of liberty caps. I buy them for 40$ canadian. A few hours later I'm heading with my buddy oz to another friends place. We get off the bus and he says 'Yo man, break out the shrooms already.' I whip em out and this is roughly 5:50ish I commence to start eating shrooms with oz, sharing about 2 grams with him.
I get to my friend B's place and already a few people are there. I finish off the shrooms which taste very woody and dry at first, but with a bitter/sour aftertaste. Cola cures this aftertaste rather quickly. We sit in the kitchen after we finish, I get dizzy and nauseated. We head to my friends room, a small room with foam on the ground, posters on the wall and a yellow light. By this time 6:30 I'm already starting to trip. Everythings pushing in on me, like the air got really heavy, and I'm getting increasingly sick feeling.
I decide this is already really edgy and I feel nervous, I need to smoke a bowl of weed to calm myself, so I do. Instantly it takes the edge off, but it also throws me into overgear making the trip stronger. I start rummaging through my backpack in search of pen and paper to write down everything I'm starting to see. My buddy gives me a plank of wood to act as a surface to write on. I start writing and it seems the ink is really sticky, and just drags over the paper. I write down some illegible things and lose my train of thought blaming it on my friend. The plank of wood explodes, litterally taking over the entire room, then shrinking again. I whip out my favorite book and open it up.  I then think I may be cold so I pull my sweater towards me, it flows with my hand like oil, and I put it on.
Then this kid goes 'Hey man you're bleeding all over the place man' I wasn't he was just tripping me out and man was I scared, I realized I couldn't feel anything and that physical harm was a real fear.  I get back to the house and already everything's a little bit too crazy. I start to question everything, something I can't help but do for some reason. I become afraid and slightly paniced about the strength of this drug. Next thing I know I'm lieing on the floor in the living room, its 7:12, I'm so messed up that I forget what my body looks like. I hear shouting (people actually fighting in the house) and man that's a terrible thing to hear stoned.
I look around and everything explodes into grains of sand, I'm flying through this ridiculous duststorm and I can't focus or understand. I suddenly am back in the room, then I seem to melt and fly to another part of the room.  It's my legs! All splayed out in front of me. I realize I have arms and hands to. I look at my palms and can see the blood running underneath the skin, I wonder if I were to slice myself with my knife what would happen, because obviously a mind such as this cannot die, I'd live forever in this state, floating around without a body. Quickly I change my track of thought, before I get too many ideas.
The drug is proving impossible to control, I decide to go with it. I look at the carpet, one of those half shag ones with strings poking up. The rug starts growing and shrinking then flys around my head and I get sucked in again, flying through some other kind of kaleidoscope storm.  I'm afraid of vomiting because I'm tripping so hard I can barely feel my body, I could choke and die but I walk to the bathroom and do vomit, luckily into the toilet.
I pull my mind away and miraculously figure out how to work the sink, my subconcious seems to be bored of my antics and is working on some sort of basic comfort instinct. I look into the mirror and think 'Wow you look sick, red eyes, sweating, sort of depressed looking.' I run into my friends brother and claim 'I'm never doing this again this is not my drug!' He yells to his wife that I'm having a bad trip and to make sure I don't do anything crazy.
I lay down for another 15 mins and its around 8:00 now, I'm shocked to see so little time has passed. I become aware of who I am and drink some water, then I sit down and start pieceing my mind back together. I start to see that talent and skill is just the ability people have to will themselves a universe, and that nothing is really there until you force it to be. I realize that people in life just try to show me how to better master my surroundings, and that we are all little balls of light floating around trying to understand everything. I gain more respect for schooling and teachers, only to lose it again when I'm sober. I also grasp some concept that things I don't like are things that invade my mind, things that get to my mind. I like my surroundings and if someone ruins them I don't like that person for making me uncomfortable.
I stop my mad philosophical ranting and stare at the wall. The young children who live in the house have drawn lines with crayons of all sorts of color. I watch these lines and try to figure out what they really are, but they keep moving. They form roman soldiers marching to a town. They walk into the town and speak to someone.  This was the most entertaining thing I have ever seen, my friends looked at me as I continued to look all over the wall watching this portrayal of history play out in front of me. I start to chat with a 6 year old girl who is awake and in the same room as me, we start playing with simple toys and arguing over the spelling of the word dog. I seemed to relate very well with this child.
The next 2 hours or so I am coming down and it's just a smooth ride of colors and patterns, and things moving. I enjoy the crazy rug, it's just, well crazy. I come back to reality and realize that shrooms are truely amazing. After I came down I shared my experience with J (B's sister) and G (B's brother in law). The whole trip went 0-40mins coming up. 40mins-2hours was the peak until I vomited. 2-5hours was coming down.
Luckily the whole time I was freaking out at the peak of it a part of me was sitting there observing saying 'Don't worry you'll come down soon, is there any person that can speed up this come down? Your dad can he help? a doctor?
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


--- title: "BULB FORCING WORKSHOP" date: "2000-01-01 21:02:06 -06:00" categories: - adult subtitle: "" layout: "events" event-image: "bulb-forcing.jpg" event-dates: "WEDNESDAY, OCTOBER 17" event-location: "Online" button-type: "register" tickets-link: "" registration-info: "" instructor-info: "Scott Mower" member-cost: "$43" public-cost: "$55" event-notes: "" tickets-button: "" published: false ---
REGISTRATION REQUIRED
THURSDAY, FEB 4, 6:30 - 8PM
Brighten the winter blues by planting spring bulbs in pots for winter forcing. We will share the secrets of successful bulb forcing as participants plant a combination of bulbs into containers to take home which will grow into small potted spring gardens. Participants will be provided with all the necessary materials including pots, soil, selected bulbs and instructions for forcing.


In its most basic form, R can be used as a simple calculator. Consider the following arithmetic operators:
+
-
*
/
^
%%
The last two might need some explaining:
^
operator raises the number to its left to the power of the number to its right: for example 3^2
is 9.5 %% 3
is 2.With this knowledge, follow the instructions below to complete the exercise.
2^5
in the editor to calculate 2 to the power 5.28 %% 6
to calculate 28 modulo 6.#
symbol is used to add comments on the R code.
# An addition
5 + 5
# A subtraction
5 - 5
# A multiplication
3 * 5
# A division
(5 + 5) / 2
# Exponentiation
# Modulo
# An addition
5 + 5
# A subtraction
5 - 5
# A multiplication
3 * 5
# A division
(5 + 5) / 2
# Exponentiation
2 ^ 5
# Modulo
28 %% 6
msg = "Do not remove the other arithmetic examples!"
test_output_contains("2^5", incorrect_msg = "The exponentiation example is not correct. Write `2 ^ 5` on a new line.")
test_output_contains("28 %% 6", incorrect_msg = "There seems to be an issue with the modulo example. Write `28 %% 6` on a new line.")
success_msg("Great! Head over to the next exercise.")


| Contents | Previous | Next |
The Java 2D API enhances the graphics, text, and imaging capabilities of the Abstract Windowing Toolkit (AWT), enabling the development of richer user interfaces and new types of Java applications.
Along with these richer graphics, font, and image APIs, the Java 2D API supports enhanced color definition and composition, hit detection on arbitrary geometric shapes and text, and a uniform rendering model for printers and display devices.
The Java 2D API also enables the creation of advanced graphics libraries, such as CAD-CAM libraries and graphics or imaging special effects libraries, as well as the creation of image and graphic file read/write filters.
When used in conjunction with the Java Media Framework and other Java Media APIs, the Java 2D APIs can be used to create and display animations and other multimedia presentations. The Java Animation and Java Media Framework APIs rely on the Java 2D API for rendering support.
Early versions of the AWT provided a simple rendering package suitable for rendering common HTML pages, but not full-featured enough for complex graphics, text, or imaging. As a simplified rendering package, the early AWT embodied specific cases of more general rendering concepts. The Java 2D API provides a more flexible, full-featured rendering package by expanding the AWT to support more general graphics and rendering operations.
For example, through the Graphics
class you can draw rectangles, ovals, and
polygons. Graphics2D
enhances the
concept of geometric rendering by providing a mechanism for
rendering virtually any geometric shape. Similarly, with the Java
2D API you can draw styled lines of any width and fill geometric
shapes with virtually any texture.
Geometric shapes are provided through
implementations of the Shape
interface,
for example Rectangle2D
and Ellipse2D
. Curves and arcs are also specific
implementations of Shape
.
Fill and pen styles are provided through
implementations of the Paint
and
Stroke
interfaces, for example
BasicStroke
, GradientPaint
, TexturePaint
, and Color
.
AffineTransform
defines
linear transformations of 2D coordinates, including scale,
translate, rotate, and shear.
Clip regions are defined by the same
implementations of the Shape
interface
that are used to define general clipping regions, for example
Rectangle2D
and GeneralPath
.
Color composition is provided by implementations
of the Composite
interface, for example
AlphaComposite
.
A Font
is defined by
collections of Glyphs
, which are in turn
defined by individual Shapes
.
The basic graphics rendering model has not changed
with the addition of the Java 2D APIs. To render a graphic,
you set up the graphics context and invoke a rendering method on
the Graphics
object.
The Java 2D API class Graphics2D
extends Graphics
to support more graphics attributes and
provide new rendering methods. Setting up a Graphics2D
context is described in “Rendering with Graphics2D”.
The Java 2D API automatically compensates for differences in rendering devices and provides a uniform rendering model across different types of devices. At the application level, the rendering process is the same whether the target rendering device is a display or a printer.
The Java 2D API provides support for multi-screen environments. See Section 1.2.1, “Coordinate Systems” and “Rendering in a Multi-Screen Environment” for more information.
The Java 2D API maintains two coordinate systems:
The Java 2D system automatically performs the necessary conversions between user space and the device space of the target rendering device. Although the coordinate system for a monitor is very different from the coordinate system for a printer, these differences are invisible to applications.
As shown in Figure 1-1, the user space origin is located in the upper-left corner of the space, with x values increasing to the right and y values increasing downward.
User space represents a uniform abstraction of all possible device coordinate systems. The device space for a particular device might have the same origin and direction as user space, or it might be different. Regardless, user space coordinates are automatically transformed into the appropriate device space when a graphic object is rendered. Often, the underlying platform device drivers are used to perform this conversion.
The Java 2D API defines three levels of configuration information that are maintained to support the conversion from user space to device space. This information is encapsulated by three classes:
GraphicsEnvironment
GraphicsDevice
GraphicsConfiguration
Between them, the GraphicsEnvironment
, GraphicsDevice
, and GraphicsConfiguration
represent all of the
information necessary for locating a rendering device or font on
the Java platform and for converting coordinates from user space to
device space. An application can access this information, but does
not need to perform any transformations between user space and
device space.
The GraphicsEnvironment
describes the collection of rendering devices visible to a Java
application on a particular platform. Rendering devices include
screens, printers, and image buffers. The GraphicsEnvironment
also includes a list of all of
the available fonts on the platform.
A GraphicsDevice
describes an application-visible rendering device, such as a screen
or printer. Each possible configuration of the device is
represented by a GraphicsConfiguration
.
For example, an SVGA display device can operate in several modes:
640x480x16 colors, 640x480x256 colors, and 800x600x256 colors. The
SVGA screen is represented by a GraphicsDevice
object and each of the modes is
represented by a GraphicsConfiguration
object.
A GraphicsEnvironment
can contain one or more GraphicsDevices
;
in turn, each GraphicsDevice
can have
one or more GraphicsConfigurations
.
The Java 2D API has a unified coordinate
transformation model. All coordinate transformations, including
transformations from user to device space, are represented by
AffineTransform
objects. AffineTransform
defines the rules for manipulating
coordinates using matrices.
You can add an AffineTransform
to the graphics context to rotate,
scale, translate, or shear a geometric shape, text, or image when
it is rendered. The added transform is applied to any graphic
object rendered in that context. The transform is performed when
user space coordinates are converted to device space
coordinates.
A string is commonly thought of in terms of the characters that comprise the string. When a string is drawn, its appearance is determined by the font that is selected. However, the shapes that the font uses to display the string don’t always correspond to individual characters. For example, in professional publishing, certain combinations of two or more characters are often replaced by a single shape called a ligature.
The shapes that a font uses to represent the
characters in the string are called glyphs. A font might represent a character such as
a lowercase a acute using multiple
glyphs, or represent certain character combinations such as the
fi in final with a single glyph. In the
Java 2D API, a glyph is simply a Shape
that can be manipulated and rendered in the same way as any other
Shape
.
A font can be thought
of as a collection of glyphs. A single font might have many
versions, such as heavy, medium, oblique, gothic, and regular.
These different versions are called faces. All of the faces in a font have a similar
typographic design and can be recognized as members of the same
family.
In the Java 2D API, fonts are specified by a name that describes a particular font face—for example, Helvetica Bold.
Using the Java 2D API, you can compose and render
strings that contain multiple fonts of different families, faces,
sizes, and even languages. The appearance of the text is kept
logically separate from the layout of the text. Font
objects are used to describe the appearance,
and the layout information is stored in TextLayout
and TextAttributeSet
objects. Keeping the font and
layout information separate makes it easier to use the same fonts
in different layout configurations.
Images are collections of pixels organized spatially. A pixel defines the appearance of an image at a single display location. A two-dimensional array of pixels is called a raster.
The pixel’s appearance can be defined directly or as an index into a color table for the image.
In images that contain many colors (more than 256), the pixels usually directly represent the color, alpha, and other display characteristics for each screen location. Such images tend to be much larger than indexed-color images, but they look more realistic.
In an indexed-color image, the colors in the image are limited to the colors specified in the color table, often resulting in fewer colors that can be used in the image. However, an index typically requires less storage space than a color value, so images stored as a set of indexed colors are usually smaller. This pixel format is popular for images that contain only 16 or 256 colors.
Images in the Java 2D API have two primary components:
The rules for interpreting the pixel are
encapsulated by a ColorModel
object—for example, whether the values should be interpreted
as direct or indexed colors. For a pixel to be displayed, it must
be paired with a color model.
A band is one component of the color space for an image. For example, the Red, Green, and Blue components are the bands in an RGB image. A pixel in a direct color model image can be thought of as a collection of band values for a single screen location.
The java.awt.image
package contains several ColorModel
implementations, including those for packed and component pixel
representations.
A ColorSpace
object
encapsulates the rules that govern how a set of numeric
measurements corresponds to a particular color. The ColorSpace
implementations in the java.awt.color
represent the most popular color
spaces, including RGB and gray scale. Note that a color space is
not a collection of colors—it defines the rules for how to
interpret individual color values.
Separating the color space from the color model provides greater flexibility in how colors are represented and converted from one color representation to another.
With the Java 2D API, you can render Shapes
using different pen styles and fill patterns.
Because text is ultimately represented by a set of glyphs, text
strings can also be stroked and filled.
Pen styles are defined by objects that implement
the Stroke
interface. Strokes enable you
to specify different widths and dashing patterns for lines and
curves.
Fill patterns are defined by objects that
implement the Paint
interface. The
Color
class, which was available in
earlier versions of the AWT, is a simple type of Paint
object used to define solid-color fills. The
Java 2D API provides two additional Paint
implementations, TexturePaint
and GradientPaint
. TexturePaint
defines a fill pattern using a simple
image fragment that is repeated uniformly. GradientPaint
defines a fill pattern as a gradient
between two colors.
In Java 2D, rendering a shape’s outline and filling the shape with a pattern are two separate operations:
draw
methods
renders the shape’s contour or outline using the pen style
specified by the Stroke
attribute and
the fill pattern specified by the Paint
attribute.fill
method fills the
interior of the shape with the pattern specified by the
Paint
attribute.When a text string is rendered, the current
Paint
attribute is applied to the glyphs
that form the string. Note, however, that drawString
actually fills the glyphs that are
rendered. To stroke the outlines of the glyphs in a text string,
you need to get the outlines and render them as shapes using the
draw
method.
When you render an object that overlaps an
existing object, you need to determine how to combine the colors of
the new object with the colors that already occupy the area where
you are going to draw. The Java 2D API encapsulates rules for how
to combine colors in a Composite
object.
Primitive rendering systems provide only basic Boolean operators for combining colors. For example, a Boolean compositing rule might allow the source and destination color values to be ANDed, ORed, or XORed. There are several problems with this approach
The Java 2D API avoids these pitfalls by
implementing alpha-blending1 rules that take color model
information into account when compositing colors. An AlphaComposite
object includes the color model of
both the source and destination colors.
The Java 2D API classes are organized into the following packages:
java.awt
java.awt.geom
java.awt.font
java.awt.color
java.awt.image
java.awt.image.renderable
java.awt.print
Package java.awt
contains those Java 2D API classes and
interfaces that are general in nature or that enhance legacy
classes. (Obviously, not all of the classes in java.awt
are Java 2D classes.)
Package java.awt.geom
contains classes and interfaces
related to the definition of geometric primitives.
Many of the geometric primitives have
corresponding .Float
and .Double
implementations. This was done to enable
both floating single- and double-precision implementations.
Double-precision implementations provide greater rendering
precision at the expense of performance on some platforms.
Package java.awt.font
contains classes and interfaces
used for text layout and the definition of fonts.
Packagejava.awt.color
contains classes and interfaces
for the definition of color spaces and color profiles.
The java.awt.image
and >java.awt.image.renderable
packages
contain classes and interfaces for the definition and rendering of
images.
Package java.awt.print
contains classes and interfaces
that enable printing of all Java 2D–based text, graphics, and
images.
| Contents | Previous | Next |


Start Bootstrap
Home
(current)
About
Services
Contact
JavaScript 1
Nombre:
Mensaje
You've reached the end!


NebliDex BlockHelper is a program designed to index the Neblio blockchain through its interaction with Nebliod or Neblio-Qt. Once indexed, the BlockHelper runs its own RPC (Remote Procedure Call) server that applications can use to obtain Neblio blockchain related transaction and address information. BlockHelper will continue to sync with a synced Nebliod/Neblio-Qt. BlockHelper is designed to be used with NebliDex Critical Nodes but can be used with other applications simultaneously. BlockHelper will only connect to applications on the same computer.
Getting Started
First grab the latest version of Nebliod or Neblio-Qt from the Neblio alpha builds repository:
https://neblio-build-staging.ams3.digitaloceanspaces.com/index.html
*If using Neblio-Qt, you must activate the RPC server (not on by default) by setting up a neblio.conf file in your Neblio data folder with an rpcuser, an rpcpass, an rpcport of 6326 (which is default) and server=1.
Next, wait for Nebliod/Neblio-Qt to completely sync to the Blockchain before running BlockHelper otherwise BlockHelper will tell you to wait till Nebliod is fully synced. Once Nebliod is synced, start BlockHelper and it will begin to index the Blockchain. The indexing process should be quicker than Nebliod indexing but it will still take several hours to complete. The blockchain index file will be a few gigabytes in size (at height 660,000) and will be stored in the blockdata subfolder.
Once BlockHelper is synced, if using with a NebliDex CN, when you Activate as a CN, it will automatically
detect the BlockHelper and show "BlockHelper Active" in the status bar of the NebliDex client if connected.
Building NebliDex BlockHelper
NebliDex BlockHelper is built in C# using managed code from the .NET Library on Windows and Mono Framework on Mac and Linux.
Mac
- Download Visual Studio for Mac
- Install Mono Framework (if not already included)
- Open Solution
- Build and Run in Terminal
*If you want to create a bundle using mkbundle (see the build script inside the bin folder)
Linux
Depending on the exact version of Linux you are running the steps can vary.
- Install Mono Develop following these steps: MonoDevelop
- Run code: sudo apt-get install monodevelop
- Open Solution
- Build and Run in Terminal
Windows
- Make sure at least .NET Framework 4.5 is installed on your system
- Find your favorite C# code editor (Visual Studio, SharpDevelop,MonoDevelop)
- Open Solution
- Build and Run in Terminal
Querying BlockHelper
The NebliDex BlockHelper accepts messages sent to it from a local computer with the following format:
Message Length - JSON Encoded Message
Message Length = Unsigned Little Endian Int32 (4 bytes) that represents the length of the JSON Encoded Message.
JSON Encoded Message = String that represents the request sent to the BlockHelper.
RPC Commands
Request
Response
rpc.method:rpc.serverversion
rpc.response:0
rpc.method:rpc.serverversion
rpc.response:1
rpc.result:(server version)
OR
rpc.error:(error)
rpc.method:rpc.gettransactioninfo
rpc.response:0
rpc.txhash:(transaction hash)
rpc.method:rpc.gettransactioninfo
rpc.response:1
rpc.result:(JSON object of transaction)
OR
rpc.error:(error)
rpc.method:rpc.getaddressinfo
rpc.response:0
rpc.neb_address:(neblio address)
rpc.method:rpc.getaddressinfo
rpc.response:1
rpc.result:(JSON Array of UTXOs)
OR
rpc.error:(error)
rpc.method:rpc.broadcasttx
rpc.response:0
rpc.tx_hex:(transaction raw hex)
rpc.method:rpc.broadcasttx
rpc.response:1
rpc.result:(transaction hash)
OR
rpc.error:(error)
rpc.method:rpc.getspentaddressinfo
rpc.response:0
rpc.neb_address:(neblio address)
rpc.max_utxo:(max number of spent TXOs to query, max is 1000)
rpc.method:rpc.getspentaddressinfo
rpc.response:1
rpc.result:(JSON Array of UTXOs)
OR
rpc.error:(error)
rpc.method:rpc.createntp1transaction
rpc.response:0
rpc.source_address:(neblio address source)
rpc.to_addresses:(JSON Array that represents all the target addresses, similar to API)
rpc.method:rpc.createntp1transaction
rpc.response:1
rpc.result:(JSON object with information on how to create a transaction)
OR
rpc.error:(error)
rpc.method:rpc.getblockheight
rpc.response:0
rpc.method:rpc.getblockheight
rpc.response:1
rpc.result:(BlockHelper current block height)
OR
rpc.error:(error)


Home
|
Flavors
|
About
|
Contact
Sweet Bliss
Welcome to Sweet Bliss! Have a look around at the best cupcakes in town!


A repository monitored by the Continuous Integration server has just detected a new pull request for:
The git initialization has succeeded in the local directory: "/Users/trunks/codes/ci/tests/repo", and the following unit tests have started running:
| Command | Start | End | Code |
|---|---|---|---|
| first tests/a.py | 07/14/2005 12:30 | 07/14/2005 12:31 | 0 |
| @CUSTBIN tests/scripts.py | 07/14/2005 12:30 | 07/14/2005 12:31 | 1 |
| cd @CUSTPATH; path tests/builders.py | 07/14/2005 12:30 | 07/14/2005 12:31 | 2 |
If you have any questions, please contact the owner of the repository:
Kind Regards,
CI Bot


{% extends "templates/about.html" %} {% block about_title %}:: Frequently Asked Questions (FAQs){% endblock %} {% block about_content %}
The goal of the OEC is to become an online resource for global trade. As such we would like to attract as many international visitors to the site as possible. The goal of translating the site is two-fold, part 1 being to "translate" the official esoteric HS and SITC product classification names and part 2 being to translate these cleaned up names from english to the other 15 languages supported by the site.
 If so, then you can help us improve our translations on the site. Have we mentioned that the site and all of its data are open source? By lending a hand, you can help to create a global resource for others wishing to work with international trade data.
Below you'll see headers for each language supported by the site with links to a Google Spreadsheet that holds the relevant translations. For each of the products listed in the spreadsheet there are "Name", "Description", "Keyword", "Gender", "Plural" and "Article" columns. Right-click on the cell you wish to edit and click Insert Comment.


Katrine Øgaard Jensen is a translator and writer. She is one of the founding editors of EuropeNow, a journal of political research, literature, and art at Columbia University. She previously served as editor in chief of the Columbia Journal and blog editor at Asymptote and Words Without Borders. Her translation of Ursula Andkjær Olsen’s award-winning poetry collection Third-Millennium Heart was published by Action Books and Broken Dimanche Press in 2017.
On juggling multiple writing practices
Writer, editor, and translator Katrine Øgaard Jensen discusses balancing a job with personal work, and why you need to always be protective of your time.
You’re a writer, journalist, translator, poet, and editor. Why do you work in all these forms and how do they inform each other?
My different roles inform my work in different ways. Definitely my background in journalism informs my own writing, but also my translation, because translation actually requires a lot of research. For Third Millennium Heart I ended up doing a lot more research than I thought I’d need to, because the book is such an onion. It has so many layers, and it’s all about things being inside and outside of one another. I ended up spending hours in these internet rabbit holes trying to figure out what it was that the poet I was translating was talking about. Journalism definitely has helped me a lot in terms of understanding a text and getting into the depths of whatever a writer intended with the text. In terms of my own writing, I love doing research and discovering little weird scientific facts or discovering new worlds.
I have a lot of weird books at home that inspire me. There’s one called Islands in the Sky: Bold New Ideas for Colonizing Space, which informs my poetry a lot. It opens my mind in different ways. It’s just one example of many books that I enjoy perusing when I’m trying to get new ideas. It’s not all particularly scientific, but some of it is. I have one book on angelic language that’s by some pseudoscientist. It’s called The Complete Enochian Dictionary and it’s some scientists who believed they had found the language of angels. I like delving into research of real worlds and also imaginary worlds when I do my writing.
 I’m wondering how that extensive research is folded into your final product?
When I first read Third Millennium Heart, I thought, “Oh, no big deal.” I thought it was an easier work to translate than it actually was when I really delved into the text. At first I just translated it in a pretty straightforward way, but then halfway through the book I realized that there’s a lot more to this text than what I first thought, because there are some phrases that are odd, and places with very subtle differences in the Danish language that made me look it up, and then I realized it was a reference to something. Then I had to go back and find all these places where the language sounded a little bit off, and realized it was because it was referencing Kierkegaard or Nietzsche or Hegel. There’re also tons of references to the bible and a lot of scientific body language.
As a translator, I’m supposed to make it sound similar to the original, not awkward, and barely noticeable that it’s a translation. But at the same time I have to hit exactly the right vocabulary in order for the reader to pick up on these references the same way that I did. So it was a matter of going into these works by these philosophers, or finding translations of the bible online to figure out what was the exact phrasing that she’s referring to, and how do I insert it in English in a way so that if people are curious about the text, they can Google this specific phrase and figure out, “Oh, that’s a reference to Nietzsche.” Or the bible or whatever it is.
In that way I like how it reads seamlessly. And at the same time, if the reader knows that there are these references, maybe they’ll be curious and will start looking up some of the lines and actually find out that it is an onion full of layers in terms of literature, but also in regards to society. I like how the whole book sort of starts within the body. Then it moves out into society, and then it moves out into the universe with planets, and planets as spiderwebs and all that stuff. It is just such a multi-faceted work. It is my hope that people read it and will barely notice the references, but then when they do they’ll get really excited like I did.
But I did have some challenges with her references to children’s songs, because some of these songs aren’t necessarily translated into English. For instance, there’s this one Danish children’s song that just sort of keeps going. Like you keep building on this song. The title of the song means “the mountain lies far out in the wood.” I had a really hard time finding an English equivalent to it. I ended up with “The Green Grass Grows All Around” because that actually has the same form. In some cases I had to swap out the references so that you would understand the idea behind the song more than the song itself. That’s, again, just one example of how I had to deal with research and translating that research into the English work.
Let’s talk about process and the rabbit holes you fall into while translating. We’re in this hyper-informational age where you can get on your phone and Google something and actually even translate a line, which one assumes could make this kind of work easier or more complicated.
I don’t know how other people do this, but for me I actually do research pretty much line by line.  It’s more like I start a poem, and then whenever I hit something that sounds like a reference, I’ll Google it. And then I’ll figure out what the reference is, and then I’ll start researching how to translate it into English.
I can tell you my favorite rabbit hole that I encountered. There’s this one poem I translated where it references a couple of songs. And in one of them, there’s a simple line that goes: “I dreamt a dream last night.” And I was just thinking oh, this is kind of weird that you have this fragment that just says, “I dreamt a dream last night.” I was thinking, why did she put it in there? And then I Googled it, and it turns out that it was actually a reference to the oldest known secular song in the Nordic country, which was written around 1300. It’s an old East Norse song that’s included in the Codex Runicus, which is a transcript of Scanian law. Just like this old Norse song written in runes. That’s an obvious rabbit hole to go down because I was obsessed with trying to figure out what it meant.
How long is a really long time for you?
From when I got the book deal for translating Third Millennium Heart until it was done took me two years. But I also have, as you pointed out, a million other jobs. So, of course, it didn’t take me two whole years to translate this book. But with all the extensive research, it did take a long time.
Since you’re translating and editing and working on all these things at the same time, how do you switch modes?
It’s one of my favorite things, actually, because I feel like I never grow sick of one of those things because I keep switching between them. I have a pretty short attention span. I can only stay excited about one thing for a couple of hours and then I need to switch to something else. Translation is such an amazing writing exercise for me. It really helps me get excited about my own writing.
I translate a lot of stuff just for fun that I don’t necessarily plan to get published. Whenever I read a great poet, I just feel the urge to translate them into another language so I can practice getting that beautiful writing into my veins, or get it through my fingertips by rewriting it in another language. To me translation is very much a writing exercise that gets me into writing my own stuff. I did my MFA at Columbia University and there I had this great teacher, Alice Quinn. She’s the Director of Poetry Society America and worked at The New Yorker for a long time. She taught this class called something like “The Beauty and the Power of the Sentence,” where she told all of us that we should, as a writing exercise, take a book that we love and then type it out. Like, basically type the entire book into our computers. And then just sort of let the sentences flow through our fingertips.
To me, translation is taking that a step further. Not just typing in a text that I love, but actually rewriting it in another language. It’s like reinventing it. It makes you feel like you have decoded how it was done, in a way.
Editing is also a really important component of everything I do because, first of all, I spend a lot of time scouting for new writers from all over the world. When I worked at Asymptote, the journal for literary translation, I was so inspired by all the submissions we received. I was really excited about finding new voices all over the world that were translated into English, many of them for the first time. Discovering these voices also informed my own writing in many ways.
It’s my job to go and find these new voices. It’s incredibly inspiring to me, and a privilege, that I get to sit and look for writers from all kinds of countries and cultures for a living—writers who are major in their own countries, but who I’d never heard of because I don’t speak the language they write in.
Editing and solicitation plays a major part in my creative process, too. Just reading all these different poets and prose writers inspires me a lot. Then there’s of course the line-editing aspect of it, which is another component that I couldn’t live without because every time I pay really close attention to another writer and their sentences when I edit them, I also become very aware of my own writing in a different way. I try to edit myself as carefully as I edit others.
It’s very difficult, but it does help a lot. In editing others, I learn how to spot my own mistakes. When you see awkwardness in other people’s writing, you can sometimes also be like, “Oh, wait. That’s also what I did. I need to go back and fix that, because it’s actually really annoying.” It is all connected.
When I talk to people about what I do they sometimes say, “Yeah, but wouldn’t you really like to just be a full-time writer? Isn’t that the dream?” But it really isn’t, because I can’t see myself not doing all of these things at once. There’s some kind of network there that I don’t want to break, you know? I have my own little ecosystem of different things that I love to do. I think I would go insane if I did just one of those things.
Because of all the multifaceted things that inform your work, do you ever get over-stimulated and have a hard time focusing?
Yes, always. It’s a constant struggle. And that’s, of course, also the danger of doing this many things. It is really difficult to delve in and stay with one thing for long enough to get to the next level. It’s a lot easier for me to just sit down and edit, or to translate, than it is for me to get into the writing zone. The writing zone is a constant struggle in my life. Getting to the point where I feel like I can really focus on my own writing is something I’m still trying to figure out how to do.
Describe your daily process and how you balance these different parts of yourself.
For now, I have three days a week where I edit for my day job, and then I have four consecutive days where I either sit down to translate, or I write my own stuff. I try to say, “Okay. This is my writing weekend.” Or, “This is my translation weekend.” And weekend means four days for me, which is a pleasure. That’s how I try to switch between those things. But I do need several days in a row where I can focus. It’s the same with emails. I read this great article by a writer who asked, “Would you rather be known for your actual writing or your swift email response?”
I know exactly what you’re talking about. I read it. I was like, “This is perfect.”
That was a really good article for me to read because for so long I’ve been obsessed with emailing people back right away. When I was out for a walk and an email ticked in on my iPhone I would immediately reply to them. I’d get some kind of gratification out of, you know, “Oh, I did a good job. I replied to this person immediately.” But it took me out of that meditative state that I was in. So now I try to really stick with only replying to emails on the days where I’m working.
On those three days where I’m in the office, I try to reply to all the emails then. I’ll still read them over the weekend, but I’ll try to decide if I really need to reply to them or not. So, I really try to just say that my weekends are holy. I need to be in a completely different world on those days. That’s how I try to balance the different things that I do.
I feel like many people don’t understand people who work in a lot of forms. When your work is blurring several lines, you can easily fall through the cracks because you’re not easily quantifiable.
Absolutely. And I’ll also say it’s the same with my personal life. Actually, I try to also plan out little blocks of personal engagement. I try to always plan my dinner dates with friends, or drinks or whatever, within the days I’m working in the office in Manhattan so that it won’t interfere with my writing or creative time. I think I do that pretty well, even though I do get a lot of flak from my friends for not going out on the weekends. It’s very helpful for me.
I struggle with that, too. When do I have enough time for my brain to open up those channels that allow me to create something I can be happy with? It’s hard.
Exactly. I have a lot of friends who say they wake up in the morning and then do their writing early before they do anything else. I’m so jealous of that because I need full blocks of time. I need full days. I need to feel like I have an infinite amount of time ahead of me in order to do anything. And I’m happy to say that apparently David Lynch feels the same way. I just read his book on meditation and catching the big fish. It was really inspiring to me. The book was about his struggles with creativity and how to create things. He was talking about his youth as a painter, saying, “You know, in order to get one good hour in of painting, you have to have at least four hours.”
Katrine Øgaard Jensen recommends:
Adapted from On juggling multiple writing practices interview with Katrine Øgaard Jensen on The Creative Independent.


The instanceof
operator allows to check whether an object belongs to a certain class. It also takes inheritance into account.
Such a check may be necessary in many cases. For example, it can be used for building a polymorphic function, the one that treats arguments differently depending on their type.
The syntax is:
It returns true
if obj
belongs to the Class
or a class inheriting from it.
For instance:
```js run class Rabbit {} let rabbit = new Rabbit();
// is it an object of Rabbit class? ! alert( rabbit instanceof Rabbit ); // true /! ```
It also works with constructor functions:
```js run ! // instead of class function Rabbit() {} /!
alert( new Rabbit() instanceof Rabbit ); // true ```
…And with built-in classes like Array
:
js run let arr = [1, 2, 3]; alert( arr instanceof Array ); // true alert( arr instanceof Object ); // true
Please note that arr
also belongs to the Object
class. That’s because Array
prototypically inherits from Object
.
Normally, instanceof
examines the prototype chain for the check. We can also set a custom logic in the static method Symbol.hasInstance
.
The algorithm of obj instanceof Class
works roughly as follows:
If there’s a static method Symbol.hasInstance
, then just call it: Class[Symbol.hasInstance](obj)
. It should return either true
or false
, and we’re done. That’s how we can customize the behavior of instanceof
.
For example:
```js run // setup instanceOf check that assumes that // anything with canEat property is an animal class Animal { static Symbol.hasInstance { if (obj.canEat) return true; } }
let obj = { canEat: true };
alert(obj instanceof Animal); // true: AnimalSymbol.hasInstance is called ```
Most classes do not have Symbol.hasInstance
. In that case, the standard logic is used: obj instanceOf Class
checks whether Class.prototype
is equal to one of the prototypes in the obj
prototype chain.
In other words, compare one after another: js obj.__proto__ === Class.prototype? obj.__proto__.__proto__ === Class.prototype? obj.__proto__.__proto__.__proto__ === Class.prototype? ... // if any answer is true, return true // otherwise, if we reached the end of the chain, return false
In the example above rabbit.__proto__ === Rabbit.prototype
, so that gives the answer immediately.
In the case of an inheritance, the match will be at the second step:
```js run class Animal {} class Rabbit extends Animal {}
let rabbit = new Rabbit(); ! alert(rabbit instanceof Animal); // true /!
// rabbit.__proto__ === Rabbit.prototype ! // rabbit.__proto__.__proto__ === Animal.prototype (match!) /! ```
Here’s the illustration of what rabbit instanceof Animal
compares with Animal.prototype
:
By the way, there’s also a method objA.isPrototypeOf(objB), that returns true
if objA
is somewhere in the chain of prototypes for objB
. So the test of obj instanceof Class
can be rephrased as Class.prototype.isPrototypeOf(obj)
.
It’s funny, but the Class
constructor itself does not participate in the check! Only the chain of prototypes and Class.prototype
matters.
That can lead to interesting consequences when a prototype
property is changed after the object is created.
Like here:
```js run function Rabbit() {} let rabbit = new Rabbit();
// changed the prototype Rabbit.prototype = {};
// …not a rabbit any more! ! alert( rabbit instanceof Rabbit ); // false /! ```
We already know that plain objects are converted to string as [object Object]
:
```js run let obj = {};
alert(obj); // [object Object] alert(obj.toString()); // the same ```
That’s their implementation of toString
. But there’s a hidden feature that makes toString
actually much more powerful than that. We can use it as an extended typeof
and an alternative for instanceof
.
Sounds strange? Indeed. Let’s demystify.
By specification, the built-in toString
can be extracted from the object and executed in the context of any other value. And its result depends on that value.
[object Number]
[object Boolean]
null
: [object Null]
undefined
: [object Undefined]
[object Array]
Let’s demonstrate:
```js run // copy toString method into a variable for convenience let objectToString = Object.prototype.toString;
// what type is this? let arr = [];
alert( objectToString.call(arr) ); // [object !Array/!] ```
Here we used call as described in the chapter to execute the function objectToString
in the context this=arr
.
Internally, the toString
algorithm examines this
and returns the corresponding result. More examples:
```js run let s = Object.prototype.toString;
alert( s.call(123) ); // [object Number] alert( s.call(null) ); // [object Null] alert( s.call(alert) ); // [object Function] ```
The behavior of Object toString
can be customized using a special object property Symbol.toStringTag
.
For instance:
```js run let user = { Symbol.toStringTag: “User” };
alert( {}.toString.call(user) ); // [object User] ```
For most environment-specific objects, there is such a property. Here are some browser specific examples:
```js run // toStringTag for the environment-specific object and class: alert( windowSymbol.toStringTag); // Window alert( XMLHttpRequest.prototypeSymbol.toStringTag ); // XMLHttpRequest
alert( {}.toString.call(window) ); // [object Window] alert( {}.toString.call(new XMLHttpRequest()) ); // [object XMLHttpRequest] ```
As you can see, the result is exactly Symbol.toStringTag
(if exists), wrapped into [object ...]
.
At the end we have “typeof on steroids” that not only works for primitive data types, but also for built-in objects and even can be customized.
We can use {}.toString.call
instead of instanceof
for built-in objects when we want to get the type as a string rather than just to check.
Let’s summarize the type-checking methods that we know:
| works for | returns | |
|---|---|---|
typeof |
primitives | string |
{}.toString |
primitives, built-in objects, objects with Symbol.toStringTag |
string |
instanceof |
objects | true/false |
As we can see, {}.toString
is technically a “more advanced” typeof
.
And instanceof
operator really shines when we are working with a class hierarchy and want to check for the class taking into account inheritance.


2007 Enterprise Search Engine Vendors Roundup
Last Updated Mar 2009
By Mark Bennett, New Idea engineering Inc. - Volume 4 Number 1 - Spring 2007
Another year has come and gone since we last prognosticated about the key Enterprise Search players, see Transatlantic Titans Square Off in 2006. In this issue we take an updated look at the past year and what 2007 may hold; not too many fancy predictions -- that's not our style -- but at least a preview of what you'll be seeing.
Key Players Still In Front
FAST and Autonomy Still Tier 1
Autonomy and FAST Search continue to be the dominating players, with many other players large and small nipping at their heels. Both companies have done well according to both their PR departments and most of their customers. Autonomy was still working through the merging of the Verity products and staff retention issues from their acquisition of Verity in late 2005, so it felt like FAST had a bit of a "smoother" year, but both companies remain the two 800 pound gorillas in the room.
Both FAST and Autonomy have moved favorably in "Gartner's Magic Quadrants", in the past few years, with FAST now essentially tied with Autonomy after FAST's rapid ascent. The "At Verity" represents Autonomy, which acquired Verity in late 2005, and has therefore subsumed Verity's spot the 2006 data point. Endeca is a dotted-line only because our focus here is on Enterprise search. We wonder if Gartner will move Google and IBM into the top right quadrant this year as well.
FAST: Still the "Bring It On!" Guys
As a company, FAST Search and Transfer has shown no fear of any potential search application, no matter how large, no matter how complex, no matter how unusual the market or requirements; if you have the money they can build it, period. FAST takes the approach that search is a highly flexible platform on which other corporate applications can be built.
Of particular note, FAST has had traction with their eCommerce solution called FAST ImPulse, a direct response to Endeca's core product offering.
FAST also provides a number of customizable vertical applications they call "Search Derivative Applications" (SDAs) in widespread fields such as law enforcement, newspaper and media management, as well as directory and yellow pages software. However, for extensions not directly tied to search, FAST has taken the approach to partner with companies that provide best-of-breed technologies in audio and video search, compliance, and other specialty areas.
FAST Forward '07, which just finished up in San Diego, continued to showcase this with lots of new ideas and demos. They are establishing their annual user group meeting as a bona fide industry event, with speakers like Andrew McAfee, John Battelle, Tim O'Reilly and others. We look forward to the introduction of ESP 5.1 later this year.
Autonomy: the "Ain't it Cool!?" Guys
Autonomy has had some positive traction with their "K2 v7" product, a hybrid of their core IDOL product and the Verity K2 API. As a reminder, Autonomy now has 3 different search engines via acquisition: its own IDOL core, the Verity K2 wrapper around IDOL, and Ultraseek.
K2 and Ultraseek are both contributing to the evolution of the IDOL product line; Ultraseek donated some excellent spider technology, and K2 provided a more robust API, toolset, user, and integration layer. IDOL already had "whiz-bang" core search and was already quite scalable.
Ultraseek, the third code-base in Autonomy's repertoire, is still beloved by customers, but starting to show its age. It's still a great product for "search dial-tone", we still love it, but we don't expect many "Enterprise Search 2.0" enhancements for it. While two of its core engineers have left, three still remain and the product is still being actively maintained and incrementally enhanced.
If you're still using K2 v6 we do encourage you to start plotting your migration path forward. Many generic K2 users will probably migrate directly to the core IDOL product. However, if you are a K2 user and have invested heavily in scripts and management processes, you might find that K2V7, also based on the IDOL kernel, will help protect the investment.
Autonomy has also taken the approach of offering "total solutions" in search: aungate provides Email scanning for compliance, Virage includes multimedia search for audio and video content, etalk for CRM, and Cardiff for Business Process management.
The Challengers
Two of the four US Behemoths from last year's roundup have started to cross over, trying to compete with Tier 1 players. Google and IBM have both made great strides; we still consider Oracle and Microsoft to be Tier 2 players.
A Mixed Year for Google
If you look at the numbers, Google had a good year. Business Week had reported a doubling in sales and certainly every client we've talked to has taken a peek. However, they failed to meet the functional requirement at a number of test installations. By our tracking, Google has lost business to our Tier 1 companies much more often then they succeeded. Many clients have tried the GSA with high hopes, only to later abandon it and then buy yet-another engine; this is not universal and they certainly do have some happy enterprise clients. Certainly every company we've talked to has had a high-level executive ask "Why don't we just use Google?" somewhere along the process; they then try it and have an answer.
Google has released new versions of their product and are fighting back really hard - every VP in America expects them to "fix" enterprise search and they know it. They've also tried to address integration problems by announcing high-visibility partnerships with companies like Bearing Point, but apparently not an exclusive deal given the amount of spooning Bearing Point has been doing with FAST and potentially other vendors. Google's curse may be their own brand name. Folks have such high expectations: "Finally our enterprise search will be wonderful!" But inside the firewall, deprived of their link ranking data, they perform on a par with many other "search 1.0" engines, enabling competent "search dial-tone", but not the magic relevancy that folks expect. Meanwhile Ultraseek and IBM's new low-end offering with Yahoo, often provide comparable performance at a lower price.
IBM: The Biggest Positive Surprise of 2006
By far the biggest surprise this year was from IBM, with their OmniFind Discovery Edition engine. As you recall, last year we had counted them as one of the four US behemoths that was still not in a leadership position.
However, in 2005 IBM acquired iPhrase and in 2006 re-released that product as IBM OmniFind Discovery Edition. It is also available in a reduced feature set version as the Yahoo! Edition we'll talk about shortly. We're impressed with this new commercial offering, and we see it as a direct threat to Autonomy and FAST in the mid to long term.
IBM's new commercial offering now is a solid Enterprise Search 2.0 product, with full results list navigation, advanced linguistics, excellent business logic, and of course the ultimate blue chip brand name. It still faces some technical and marketing challenges. The current version may not scale as easily, or integrate with other systems as completely as FAST or Autonomy, but IBM certainly realizes this and is busily working to address all of these issues.
Of note, Discovery Edition offers a powerful platform for custom business logic to handle specific searches. For example, employee searches related to vacation and sick time could automatically include a custom applet, embedded within the results list along with the organic results, to help them schedule their leave. Sure all engines are capable of this at the application layer, but IBM has thought this through much more thoroughly than anyone else we've seen, and the framework will make this a much more refined and common practice. IBM has other interesting tools up its sleeve that are tangential to search and, if fully integrated, could make for an even more compelling solution.
And of course clouding up the low end of the market was the release of their other search product, the free "IBM OmniFind Yahoo! Edition", which supports up to 500,000 documents, and includes an admin GUI and support for custom synonyms. Look for a review in an upcoming issue. Don't be confused -- the Yahoo! Edition is not a same as the high end OmniFind Discover Edition, but it is a direct shot at Google's lower end appliances, and many of the Tier 2 / Tier 3 players.
Endeca tops in eCommerce, but now an Enterprise Solution?
We are impressed with Endeca's technology and dominance in the eCommerce space. They were one of the early leaders in faceted navigation, and the first to tie dynamic business logic to search relevancy. If you are designing an eCommerce solution, then we believe Endeca and FAST's ImPulse should be on your short list. And of course they are now the only US-lead company in Gartner's "magic quadrant".
But in 2006 we saw Endeca talking more about enterprise search, and we're not sold on it yet.
Forrester helped to validate this claim with a favorable evaluation of their enterprise search administrative tools, an area that is lacking in some other vendors' offerings.
But we can't help wonder, since they dominate the eCommerce space, why not be happy with that and continue to grow the lead? We imagine the answer is that, to sustain growth they want to expand into other markets; but is the eCommerce market now flat? Even if the eCommerce markets in the US and Europe were assumed to be saturated, there's still the rapidly expanding economies of Kramer's "BRIC" (Brazil, Russia, India and China)
We think they are very late to the enterprise game; they are very rarely mentioned by clients outside of the eCommerce space. Many other larger players are already well established or are spending big to get there, so we are skeptical of them in this market. Do they seriously want to take on Autonomy, FAST, Google, IBM, Microsoft and Oracle? We think their energy would be better spent localizing and marketing their excellent products in countries that are still at that start of their eCommerce "boom".
Still Not There, but still trying!
US Behemoths in General
As we mentioned last year, if you compare the market cap of the European Tier 1 players, compared to the 4 US behemoths trying unseat them, it really seems like a David and Goliath battle. If you compare Google, IBM, Microsoft and Oracle to FAST and Autonomy, it's on the order of a 300 to 1 market cap ratio. But for those large players, enterprise search is not their main focus. If any of them stopped selling enterprise search tomorrow, it wouldn't have too much of an impact on their bottom line.
Even for Google, which has evolved into an advertising company that happens to have a famous public search engine and portal, enterprise search just isn't a "must win" segment for them. To be fair, it is believed that Google's GSA business is the largest non-public-portal revenue generating product line they have, though still not "core" to their bottom line.
Microsoft Planning a Big Push
Microsoft continues to promote search within the enterprise, but we still list them as a Tier 2 player. Vista has shipped with search that is more deeply embedded, but we still see this as "desktop search", competing with the Google Toolbar and Apple's Spot Light.
Microsoft has gained some traction with SharePoint, and the search that goes along with it; but in our minds this is still "search dial-tone" / search 1.0 level search tied directly to SharePoint. We'll wait to see if SharePoint 2007 for Enterprise Search starts "fanning out" to other repositories and applications. Microsoft also offers search in many of their other server products, including SQL Server. But like the other US behemoths, full-text search is not their primary product, so by definition is not their top priority.
Oracle taking aim at Microsoft via Acquisition
Oracle already had a search product, their Oracle Text. But in 2006 they acquired Stellent, taking direct aim at Microsoft SharePoint.
We're still not seeing heavy traction for Oracle in the full-text search space. Adding Stellent will help with the CMS market, but that is still a somewhat large niche.
All the other Players
The Tier 3 players are a very heterogeneous group, with some players that were former leaders who have not kept up with technology; relative newcomers with solid technologies like DieselPoint, iSYS, and YourAmigo; giants with long established reputations that seem to maintain a low profile like Open Text; and may others with more vertical focus like X1 and Recommind. We've briefly mentioned these in a sidebar above, and will be following up in future issues focusing on each of these vendors.