|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Uses of Resource in com.ontotext.gate.gazetteer |
|---|
| Classes in com.ontotext.gate.gazetteer that implement Resource | |
|---|---|
class |
HashGazetteer
|
| Methods in com.ontotext.gate.gazetteer that return Resource | |
|---|---|
Resource |
HashGazetteer.init()
|
| Uses of Resource in com.ontotext.gate.vr |
|---|
| Classes in com.ontotext.gate.vr that implement Resource | |
|---|---|
class |
Gaze
Gaze is a Gazetteer VR capable of viewing and editing gazetteer lists, linear definitions (lists.def files), and mapping definitions (mappings between ontology classes and gazetteer lists). |
| Methods in com.ontotext.gate.vr that return Resource | |
|---|---|
Resource |
Gaze.init()
|
| Uses of Resource in gate |
|---|
| Subinterfaces of Resource in gate | |
|---|---|
interface |
Controller
Models the execution of groups of ProcessingResources. |
interface |
Corpus
Corpora are lists of Document. |
interface |
CorpusController
Models the execution of groups of ProcessingResources on a given corpus. |
interface |
Document
Represents the commonalities between all sorts of documents. |
interface |
LanguageAnalyser
A special type of ProcessingResource that processes Document s |
interface |
LanguageResource
Models all sorts of language resources. |
interface |
ProcessingResource
Models all sorts of processing resources. |
interface |
SimpleCorpus
Corpora are lists of Document. |
interface |
SimpleDocument
Represents the commonalities between all sorts of documents. |
interface |
TextualDocument
Top interface for all types of textual documents (transient or persistent). |
interface |
VisualResource
Models all sorts of visual resources. |
| Classes in gate that implement Resource | |
|---|---|
class |
DocumentFormat
The format of Documents. |
| Fields in gate with type parameters of type Resource | |
|---|---|
(package private) IdentityHashMap<Resource,Resource> |
Factory.DuplicationContext.knownResources
|
(package private) IdentityHashMap<Resource,Resource> |
Factory.DuplicationContext.knownResources
|
| Methods in gate that return Resource | |
|---|---|
static Resource |
Factory.createResource(String resourceClassName)
Create an instance of a resource using default parameter values. |
static Resource |
Factory.createResource(String resourceClassName,
FeatureMap parameterValues)
Create an instance of a resource, and return it. |
static Resource |
Factory.createResource(String resourceClassName,
FeatureMap parameterValues,
FeatureMap features)
Create an instance of a resource, and return it. |
static Resource |
Factory.createResource(String resourceClassName,
FeatureMap parameterValues,
FeatureMap features,
String resourceName)
Create an instance of a resource, and return it. |
static Resource |
Factory.defaultDuplicate(Resource res,
Factory.DuplicationContext ctx)
Implementation of the default duplication algorithm described in the comment for Factory.duplicate(Resource) . |
static Resource |
Factory.duplicate(Resource res)
Create a duplicate of the given resource. |
static Resource |
Factory.duplicate(Resource res,
Factory.DuplicationContext ctx)
Create a duplicate of the given resource, using the provided context. |
Resource |
Resource.init()
Initialise this resource, and return it. |
| Methods in gate that return types with arguments of type Resource | |
|---|---|
List<Resource> |
CreoleRegister.getAllInstances(String type)
Get a list of all the known Resource instances in the register that are of the specified (class or interface) type or one of its sub-types. |
| Methods in gate with parameters of type Resource | |
|---|---|
static Resource |
Factory.defaultDuplicate(Resource res,
Factory.DuplicationContext ctx)
Implementation of the default duplication algorithm described in the comment for Factory.duplicate(Resource) . |
static void |
Factory.deleteResource(Resource resource)
Delete an instance of a resource. |
static Resource |
Factory.duplicate(Resource res)
Create a duplicate of the given resource. |
static Resource |
Factory.duplicate(Resource res,
Factory.DuplicationContext ctx)
Create a duplicate of the given resource, using the provided context. |
void |
CreoleRegister.setResourceName(Resource res,
String newName)
Renames an existing resource. |
| Method parameters in gate with type arguments of type Resource | |
|---|---|
void |
CreoleRegister.registerComponent(Class<? extends Resource> clazz)
Given the class object for a class with CreoleResource
annotations, register that class is if it was found in a scanned jar
file with no additional creole.xml information. |
| Uses of Resource in gate.annotation |
|---|
| Classes in gate.annotation that implement Resource | |
|---|---|
class |
CorpusAnnotationDiff
This class compare two annotation sets on annotation type given by the AnnotationSchema object. |
| Methods in gate.annotation that return Resource | |
|---|---|
Resource |
CorpusAnnotationDiff.init()
This method does the diff, Precision,Recall,FalsePositive calculation and so on. |
| Uses of Resource in gate.corpora |
|---|
| Classes in gate.corpora that implement Resource | |
|---|---|
class |
ConllDocumentFormat
Document format for handling CoNLL/IOB documents: He PRP B-NP accepted VBD B-VP the DT B-NP position NN I-NP ... |
class |
CorpusImpl
Corpora are sets of Document. |
class |
DocumentImpl
Represents the commonalities between all sorts of documents. |
class |
EmailDocumentFormat
The format of Documents. |
class |
NekoHtmlDocumentFormat
DocumentFormat that uses Andy Clark's NekoHTML parser to parse HTML documents. |
class |
SerialCorpusImpl
|
class |
SgmlDocumentFormat
The format of Documents. |
class |
TextualDocumentFormat
The format of Documents. |
class |
TikaFormat
|
class |
UimaDocumentFormat
UIMA XCAS and XMICAS document formats. |
class |
XmlDocumentFormat
The format of Documents. |
| Methods in gate.corpora that return Resource | |
|---|---|
Resource |
CorpusImpl.duplicate(Factory.DuplicationContext ctx)
Custom duplication for a corpus - duplicate this corpus in the usual way, then duplicate the documents in this corpus and add them to the duplicate. |
Resource |
SerialCorpusImpl.duplicate(Factory.DuplicationContext ctx)
SerialCorpusImpl does not support duplication. |
Resource |
ConllDocumentFormat.init()
Initialise this resource, and return it. |
Resource |
CorpusImpl.init()
Initialise this resource, and return it. |
Resource |
DocumentImpl.init()
Initialise this resource, and return it. |
Resource |
EmailDocumentFormat.init()
Initialise this resource, and return it. |
Resource |
NekoHtmlDocumentFormat.init()
Initialise this resource, and return it. |
Resource |
SerialCorpusImpl.init()
|
Resource |
SgmlDocumentFormat.init()
Initialise this resource, and return it. |
Resource |
TextualDocumentFormat.init()
Initialise this resource, and return it. |
Resource |
TikaFormat.init()
|
Resource |
UimaDocumentFormat.init()
|
Resource |
XmlDocumentFormat.init()
Initialise this resource, and return it. |
| Methods in gate.corpora with parameters of type Resource | |
|---|---|
void |
CorpusImpl.resourceRenamed(Resource resource,
String oldName,
String newName)
|
void |
DocumentImpl.resourceRenamed(Resource resource,
String oldName,
String newName)
|
void |
SerialCorpusImpl.resourceRenamed(Resource resource,
String oldName,
String newName)
|
| Uses of Resource in gate.creole |
|---|
| Classes in gate.creole with type parameters of type Resource | |
|---|---|
private static class |
CreoleRegisterImpl.TypedResourceList<T extends Resource>
Type-safe read-only list used by getLrInstances, getPrInstances, etc. |
| Subinterfaces of Resource in gate.creole | |
|---|---|
interface |
AnnotationVisualResource
Visual Resources that display and/or edit annotations. |
interface |
ConditionalController
A Conditional controller is a controller that keeps a running strategy for each PR contained. |
interface |
ControllerAwarePR
This interface should be implemented by processing resources that need to know when any containing controller starts and ends its execution, for example to initialise internal data structures or to do some aggregate processing of data gathered from a whole corpus. |
| Classes in gate.creole that implement Resource | |
|---|---|
class |
AbstractController
|
class |
AbstractLanguageAnalyser
A parent implementation of language analysers with some default code. |
class |
AbstractLanguageResource
A convenience implementation of LanguageResource with some default code. |
class |
AbstractProcessingResource
A convenience implementation of ProcessingResource with some default code. |
class |
AbstractResource
A convenience implementation of Resource with some default code. |
class |
AbstractVisualResource
A convenience implementation of VisualResource with some default code. |
class |
ANNIETransducer
The ANNIE named entity transducer. |
class |
AnnotationSchema
This class handles annotation schemas.An annotation schema is a representation of an annotation, together with its types and their attributes, values and types. |
class |
ConditionalSerialAnalyserController
This class implements a SerialController that only contains LanguageAnalyser s. |
class |
ConditionalSerialController
Execute a list of PRs serially. |
class |
GazetteerListsCollector
|
class |
OntologyAwareTransducer
Deprecated. Ontology related functionality is now implemented in the standard JAPE Transducer Transducer . |
class |
PackagedController
|
class |
POSTagger
This class is a wrapper for HepTag, Mark Hepple's POS tagger. |
class |
RealtimeCorpusController
A custom GATE controller that interrupts the execution over a document when a specified amount of time has elapsed. |
class |
SerialAnalyserController
This class implements a SerialController that only contains LanguageAnalyser s. |
class |
SerialController
Execute a list of PRs serially. |
class |
Transducer
A cascaded multi-phase transducer using the Jape language which is a variant of the CPSL language. |
class |
VPChunker
ANNIE VP Chunker module. |
| Fields in gate.creole with type parameters of type Resource | |
|---|---|
private List<Resource> |
CreoleRegisterImpl.TypedResourceList.backingList
|
private static Map<Class<? extends Resource>,BeanInfo> |
AbstractResource.beanInfoCache
|
protected List<Resource> |
ResourceData.instantiationStack
The stack of instantiations |
protected List<Resource> |
ResourceData.persistantInstantiationList
Deprecated. No longer necessary as we don't use weak references for the instantiations. |
protected Class<? extends Resource> |
ResourceData.resourceClass
The class of the resource |
protected List<Resource> |
ResourceData.unmodifiableInstantiationStack
Unmodifiable view of the instantiation stack, returned by getInstantiations to ensure that the only way to modify the list is through the add/removeInstantiation methods of this class. |
| Methods in gate.creole that return Resource | |
|---|---|
Resource |
ConditionalSerialController.duplicate(Factory.DuplicationContext ctx)
Custom duplication method for conditional controllers to handle duplicating the running strategies. |
Resource |
CustomDuplication.duplicate(Factory.DuplicationContext ctx)
Create a duplicate of this resource. |
Resource |
SerialController.duplicate(Factory.DuplicationContext ctx)
Duplicate this controller. |
Resource |
AbstractController.init()
Initialise this resource, and return it. |
Resource |
AbstractProcessingResource.init()
Initialise this resource, and return it. |
Resource |
AbstractResource.init()
Initialise this resource, and return it. |
Resource |
AbstractVisualResource.init()
Initialise this resource, and return it. |
Resource |
AnnotationSchema.init()
Initialise this resource, and return it. |
Resource |
OntologyAwareTransducer.init()
Deprecated. |
Resource |
POSTagger.init()
|
Resource |
RealtimeCorpusController.init()
|
Resource |
Transducer.init()
This method is the one responsible for initialising the transducer. |
| Methods in gate.creole that return types with arguments of type Resource | |
|---|---|
List<Resource> |
CreoleRegisterImpl.getAllInstances(String type)
|
List<Resource> |
CreoleRegisterImpl.getAllInstances(String type,
boolean includeHidden)
|
List<Resource> |
ResourceData.getInstantiations()
Get the list of instantiations of resources |
Class<? extends Resource> |
ResourceData.getResourceClass()
Get method for the resource class. |
| Methods in gate.creole with parameters of type Resource | |
|---|---|
void |
ResourceData.addInstantiation(Resource resource)
Add an instantiation of the resource to the register of these |
void |
ResourceData.bumpInstantiation(Resource resource)
Deprecated. This operation is no longer supported, and does nothing. |
static boolean |
AbstractResource.checkParameterValues(Resource resource,
List parameters)
Checks whether the provided Resource has values for all the
required parameters from the provided list of parameters. |
protected void |
CreoleRegisterImpl.fireResourceRenamed(Resource res,
String oldName,
String newName)
|
static FeatureMap |
AbstractResource.getInitParameterValues(Resource res)
Get the current values for all of a specified resource's registered init-time parameters. |
static Object |
AbstractResource.getParameterValue(Resource resource,
String paramaterName)
Gets the value of a parameter for a resource. |
static FeatureMap |
AbstractResource.getParameterValues(Resource res,
List<List<Parameter>> params)
Get the current values of the given parameters from the given resource. |
static FeatureMap |
AbstractProcessingResource.getRuntimeParameterValues(Resource res)
Get the current values for all of a specified resource's registered runtime parameters. |
void |
ResourceData.makeInstantiationPersistant(Resource resource)
Deprecated. No longer needed as we don't use weak references in the instantiations stack. Left for compatibility as a no-op. |
boolean |
ResourceData.removeInstantiation(Resource resource)
Remove an instantiation of the resource from the register of these. |
static void |
AbstractResource.removeResourceListeners(Resource resource,
Map listeners)
Removes listeners from a resource. |
void |
CreoleRegisterImpl.resourceRenamed(Resource resource,
String oldName,
String newName)
|
void |
SerialController.resourceRenamed(Resource resource,
String oldName,
String newName)
|
static void |
AbstractResource.setParameterValue(Resource resource,
BeanInfo resBeanInf,
String paramaterName,
Object parameterValue)
Sets the value for a specified parameter for a resource. |
static void |
AbstractResource.setParameterValues(Resource resource,
FeatureMap parameters)
Sets the values for more parameters for a resource in one step. |
static void |
AbstractResource.setResourceListeners(Resource resource,
Map listeners)
Adds listeners to a resource. |
void |
CreoleRegisterImpl.setResourceName(Resource res,
String newName)
Renames an existing resource. |
| Method parameters in gate.creole with type arguments of type Resource | |
|---|---|
static BeanInfo |
AbstractResource.getBeanInfo(Class<? extends Resource> c)
|
void |
CreoleRegisterImpl.registerComponent(Class<? extends Resource> resourceClass)
|
void |
ResourceData.setResourceClass(Class<? extends Resource> resourceClass)
Set method for the resource class |
| Constructor parameters in gate.creole with type arguments of type Resource | |
|---|---|
CreoleRegisterImpl.TypedResourceList(List<Resource> backingList,
Class<T> realType)
|
| Uses of Resource in gate.creole.annotdelete |
|---|
| Classes in gate.creole.annotdelete that implement Resource | |
|---|---|
class |
AnnotationDeletePR
This class is the implementation of a processing resource which deletes all annotations and sets other than 'original markups'. |
| Methods in gate.creole.annotdelete that return Resource | |
|---|---|
Resource |
AnnotationDeletePR.init()
Initialise this resource, and return it. |
| Uses of Resource in gate.creole.annotransfer |
|---|
| Classes in gate.creole.annotransfer that implement Resource | |
|---|---|
class |
AnnotationSetTransfer
This plugin allows the names of annotations and features to be changed as well as transfered from one annotation set to another. |
| Methods in gate.creole.annotransfer that return Resource | |
|---|---|
Resource |
AnnotationSetTransfer.init()
|
| Uses of Resource in gate.creole.coref |
|---|
| Classes in gate.creole.coref that implement Resource | |
|---|---|
class |
AbstractCoreferencer
|
class |
Coreferencer
|
class |
NominalCoref
|
class |
PronominalCoref
|
| Methods in gate.creole.coref that return Resource | |
|---|---|
Resource |
AbstractCoreferencer.init()
Initialise this resource, and return it. |
Resource |
Coreferencer.init()
Initialise this resource, and return it. |
Resource |
NominalCoref.init()
Initialise this resource, and return it. |
Resource |
PronominalCoref.init()
Initialise this resource, and return it. |
| Uses of Resource in gate.creole.dumpingPR |
|---|
| Classes in gate.creole.dumpingPR that implement Resource | |
|---|---|
class |
DumpingPR
This class implements a DumpingPR which exports a given set of annotation types + the original markup, back into the document's native format. |
| Methods in gate.creole.dumpingPR that return Resource | |
|---|---|
Resource |
DumpingPR.init()
Initialise this resource, and return it. |
| Uses of Resource in gate.creole.gazetteer |
|---|
| Subinterfaces of Resource in gate.creole.gazetteer | |
|---|---|
interface |
Gazetteer
The Gazetteer interface defines the mandatory methods of a gazetteer PR. |
interface |
OntoGazetteer
OntoGazetteer A gazetter that exploits a linear gazetter to generate annotations according to a mapping definition between lists and ontology classes |
| Classes in gate.creole.gazetteer that implement Resource | |
|---|---|
class |
AbstractGazetteer
AbstractGazetteer This class implements the common-for-all methods of the Gazetteer interface |
class |
AbstractOntoGazetteer
AbstratOntoGazetteer This class implements the methods common for all ontology-aware gazetteers. |
class |
DefaultGazetteer
This component is responsible for doing lists lookup. |
class |
FlexibleGazetteer
Title: Flexible Gazetteer The Flexible Gazetteer provides users with the flexibility to choose their own customised input and an external Gazetteer. |
class |
GazetteerList
Gazetteer List provides the means for uploading, managing and storing the data in the gazetteer list files. |
class |
LinearDefinition
Represents a Linear Definition [lists.def] file The normal usage of the class will be * construct it * setURL * load * change * store |
class |
MappingDefinition
Represents a mapping definition which maps gazetteer lists to ontology classes |
class |
OntoGazetteerImpl
OntoGazetteerImpl An ontology-aware gazetteer, producing additional annotations with features [class] and [ontology]. |
class |
SharedDefaultGazetteer
Provides a way to efficiently multi-thread a DefaultGazetteer. |
| Methods in gate.creole.gazetteer that return Resource | |
|---|---|
Resource |
DefaultGazetteer.duplicate(Factory.DuplicationContext ctx)
Use a SharedDefaultGazetteer to duplicate this gazetteer
by sharing the internal FSM rather than re-loading the lists. |
Resource |
DefaultGazetteer.init()
Does the actual loading and parsing of the lists. |
Resource |
FlexibleGazetteer.init()
Does the actual loading and parsing of the lists. |
Resource |
OntoGazetteerImpl.init()
Initialize this onto gazetteer |
Resource |
SharedDefaultGazetteer.init()
Copy the references to the shareable state (i.e. the FSM) from the existing gazetteer. |
| Uses of Resource in gate.creole.ir |
|---|
| Subinterfaces of Resource in gate.creole.ir | |
|---|---|
interface |
IndexedCorpus
|
| Classes in gate.creole.ir that implement Resource | |
|---|---|
class |
SearchPR
|
| Methods in gate.creole.ir that return Resource | |
|---|---|
Resource |
SearchPR.init()
Initialise this resource, and return it. |
| Uses of Resource in gate.creole.metadata.test |
|---|
| Classes in gate.creole.metadata.test that implement Resource | |
|---|---|
class |
TestAnnotatedProcessingResource
Example resource class which is annotated with a CreoleResource annotation. |
class |
TestSubclassProcessingResource
|
class |
TestSuperclassProcessingResource
|
class |
TestUnannotatedProcessingResource
Example resource class which is not annotated with a CreoleResource annotation. |
| Uses of Resource in gate.creole.morph |
|---|
| Classes in gate.creole.morph that implement Resource | |
|---|---|
class |
Morph
Description: This class is a wrapper for Interpret ,
the Morphological Analyzer. |
| Methods in gate.creole.morph that return Resource | |
|---|---|
Resource |
Morph.duplicate(Factory.DuplicationContext ctx)
Duplicate this morpher, sharing the compiled regular expression patterns and finite state machine with the duplicate. |
Resource |
Morph.init()
This method creates the instance of the BaseWord - English Morpher and returns the instance of current class with different attributes and the instance of BaseWord class wrapped into it. |
| Uses of Resource in gate.creole.ontology |
|---|
| Subinterfaces of Resource in gate.creole.ontology | |
|---|---|
interface |
Ontology
Interface for ontology language resources. |
| Uses of Resource in gate.creole.orthomatcher |
|---|
| Classes in gate.creole.orthomatcher that implement Resource | |
|---|---|
class |
OrthoMatcher
|
| Methods in gate.creole.orthomatcher that return Resource | |
|---|---|
Resource |
OrthoMatcher.init()
Initialise this resource, and return it. |
| Uses of Resource in gate.creole.orthomatcher.SampleOrthoMatcher |
|---|
| Classes in gate.creole.orthomatcher.SampleOrthoMatcher that implement Resource | |
|---|---|
class |
SampleOrthoMatcher
|
| Methods in gate.creole.orthomatcher.SampleOrthoMatcher that return Resource | |
|---|---|
Resource |
SampleOrthoMatcher.init()
|
| Uses of Resource in gate.creole.splitter |
|---|
| Classes in gate.creole.splitter that implement Resource | |
|---|---|
class |
RegexSentenceSplitter
A fast sentence splitter replacement based on regular expressions. |
class |
SentenceSplitter
A sentence splitter. |
| Methods in gate.creole.splitter that return Resource | |
|---|---|
Resource |
RegexSentenceSplitter.init()
|
Resource |
SentenceSplitter.init()
|
| Uses of Resource in gate.creole.test |
|---|
| Classes in gate.creole.test that implement Resource | |
|---|---|
static class |
DynamicRegistrationTest.TestResource
|
| Uses of Resource in gate.creole.tokeniser |
|---|
| Classes in gate.creole.tokeniser that implement Resource | |
|---|---|
class |
DefaultTokeniser
A composed tokeniser containing a SimpleTokeniser and a
Transducer . |
class |
SimpleTokeniser
Implementation of a Unicode rule based tokeniser. |
| Methods in gate.creole.tokeniser that return Resource | |
|---|---|
Resource |
DefaultTokeniser.init()
Initialise this resource, and return it. |
Resource |
SimpleTokeniser.init()
Initialises this tokeniser by reading the rules from an external source (provided through an URL) and building the finite state machine at the core of the tokeniser. |
| Uses of Resource in gate.event |
|---|
| Fields in gate.event declared as Resource | |
|---|---|
private Resource |
CreoleEvent.resource
|
protected Resource |
DatastoreEvent.resource
|
| Methods in gate.event that return Resource | |
|---|---|
Resource |
CreoleEvent.getResource()
Gets the resource that has been (un)loaded. |
Resource |
DatastoreEvent.getResource()
Gets the resource involved in this event |
| Methods in gate.event with parameters of type Resource | |
|---|---|
void |
CreoleListener.resourceRenamed(Resource resource,
String oldName,
String newName)
Called when the creole register has renamed a resource.1 |
| Constructors in gate.event with parameters of type Resource | |
|---|---|
CreoleEvent(Resource res,
int type)
Constructor |
|
DatastoreEvent(DataStore source,
int type,
Resource res,
Object resourceID)
Constructor. |
| Uses of Resource in gate.gui |
|---|
| Subinterfaces of Resource in gate.gui | |
|---|---|
interface |
ResizableVisualResource
This interface denotes visual resources that can be resized. |
| Classes in gate.gui that implement Resource | |
|---|---|
class |
ControllerMetadataViewer
This viewer displays metadata associated with a GATE Controller. |
class |
CorpusEditor
A simple viewer/editor for corpora. |
class |
CorpusQualityAssurance
Quality assurance corpus view. |
class |
FeaturesSchemaEditor
|
class |
GazetteerEditor
Editor for ANNIE Gazetteer . |
class |
LuceneDataStoreSearchGUI
GUI allowing to write a query with a JAPE derived syntax for querying a Lucene Datastore and display the results with a stacked view of the annotations and their values. |
class |
PRViewer
|
class |
SearchPRViewer
Shows the results of a IR query. |
class |
SerialControllerEditor
|
class |
SerialDatastoreViewer
|
class |
SyntaxTreeViewer
The SyntaxTreeViewer is capable of showing and editing utterances (fancy name for sentences) and the attached syntax trees. |
| Fields in gate.gui declared as Resource | |
|---|---|
(package private) Resource |
NewResourceDialog.resource
|
(package private) Resource |
ParameterDisjunction.resource
|
(package private) Resource |
ResourceParametersEditor.resource
|
| Fields in gate.gui with type parameters of type Resource | |
|---|---|
protected List<Resource> |
AnnotationDiffGUI.documents
|
protected IdentityHashMap<Resource,List<JMenuItem>> |
MainFrame.ToolsMenu.itemsByResource
|
| Methods in gate.gui that return Resource | |
|---|---|
Resource |
ResourceParametersEditor.getResource()
Does this GUI component allow editing? |
Resource |
ControllerMetadataViewer.init()
|
Resource |
CorpusEditor.init()
|
Resource |
CorpusQualityAssurance.init()
|
Resource |
FeaturesSchemaEditor.init()
Initialise this resource, and return it. |
Resource |
GazetteerEditor.init()
|
Resource |
LuceneDataStoreSearchGUI.init()
Called when a View is loaded in GATE. |
Resource |
PRViewer.init()
|
Resource |
SearchPRViewer.init()
|
Resource |
SerialControllerEditor.init()
|
Resource |
SerialDatastoreViewer.init()
Initialise this resource, and return it. |
| Methods in gate.gui with parameters of type Resource | |
|---|---|
protected Handle |
MainFrame.findHandleForResource(Resource res)
Locates the handle for a given resource. |
void |
ResourceParametersEditor.init(Resource resource,
List parameters)
Initialises this GUI component. |
void |
MainFrame.resourceRenamed(Resource resource,
String oldName,
String newName)
|
void |
MainFrame.ToolsMenu.resourceRenamed(Resource resource,
String oldName,
String newName)
|
void |
NameBearerHandle.resourceRenamed(Resource resource,
String oldName,
String newName)
|
void |
ParameterDisjunction.resourceRenamed(Resource resource,
String oldName,
String newName)
|
void |
ResourceParametersEditor.resourceRenamed(Resource resource,
String oldName,
String newName)
|
void |
SerialControllerEditor.resourceRenamed(Resource resource,
String oldName,
String newName)
|
Handle |
MainFrame.select(Resource res)
Selects a resource if loaded in the system and not invisible. |
protected void |
MainFrame.ToolsMenu.toolLoaded(Resource res)
Add the actions published by the given tool to their appropriate places on the Tools menu. |
protected void |
ParameterDisjunction.updateValues(Resource res)
Called when a resource has been unloaded from the system; If any of the parameters has this resource as value then the value will be deleted. |
| Constructors in gate.gui with parameters of type Resource | |
|---|---|
ParameterDisjunction(Resource resource,
List parameters)
Creation from a resources and a list of names. |
| Uses of Resource in gate.gui.annedit |
|---|
| Subinterfaces of Resource in gate.gui.annedit | |
|---|---|
interface |
OwnedAnnotationEditor
Interface for all annotation editor components |
| Classes in gate.gui.annedit that implement Resource | |
|---|---|
class |
SchemaAnnotationEditor
An annotation editor that enforces the annotation schemas currently loaded in the system. |
| Methods in gate.gui.annedit that return Resource | |
|---|---|
Resource |
SchemaAnnotationEditor.init()
|
| Uses of Resource in gate.gui.docview |
|---|
| Subinterfaces of Resource in gate.gui.docview | |
|---|---|
interface |
AnnotationList
Interface for document views showing a list of annotations. |
interface |
DocumentView
A document viewer is composed out of several views (like the one showing the text, the one showing the annotation sets, the on showing the annotations table, etc.). |
| Classes in gate.gui.docview that implement Resource | |
|---|---|
class |
AbstractDocumentView
A convenience implementation of DocumentView that
can be extended by implementers of document views. |
class |
AnnotationEditor
A generic annotation editor, which uses the known annotation schemas to help speed up the annotation process (e.g. by pre-populating sets of choices) but does not enforce the schemas, allowing the user full control. |
class |
AnnotationListView
A tabular view for a list of annotations. |
class |
AnnotationSetsView
Display document annotation sets and types in a tree view like with a table. |
class |
AnnotationStackView
Show a stack view of highlighted annotations in the document centred on the document caret. |
class |
CorefEditor
Display a tree that contains the co-references type of the document, highlight co-references in the document, allow creating co-references from existing annotations, editing and deleting co-references. |
class |
DocumentEditor
This is the GATE Document viewer/editor. |
class |
OntologyClassView
Document view that displays an ontology class tree to annotate a document. |
class |
OntologyInstanceView
Document view that shows two tables: one instances and one for properties. |
class |
TextualDocumentView
This class provides a central view for a textual document. |
| Methods in gate.gui.docview that return Resource | |
|---|---|
Resource |
AnnotationEditor.init()
|
Resource |
DocumentEditor.init()
|
| Methods in gate.gui.docview with parameters of type Resource | |
|---|---|
void |
OntologyClassView.resourceRenamed(Resource resource,
String oldName,
String newName)
|
| Uses of Resource in gate.gui.jape |
|---|
| Classes in gate.gui.jape that implement Resource | |
|---|---|
class |
JapeViewer
A JAPE viewer that allows access to all phases of the grammar and provides syntax highlighting. |
| Methods in gate.gui.jape that return Resource | |
|---|---|
Resource |
JapeViewer.init()
|
| Uses of Resource in gate.gui.ontology |
|---|
| Classes in gate.gui.ontology that implement Resource | |
|---|---|
class |
OntologyEditor
The GUI for the Ontology Editor |
| Methods in gate.gui.ontology that return Resource | |
|---|---|
Resource |
OntologyEditor.init()
Init method, that creates this object and returns this object as a resource |
| Uses of Resource in gate.gui.wordnet |
|---|
| Classes in gate.gui.wordnet that implement Resource | |
|---|---|
class |
WordNetViewer
|
| Uses of Resource in gate.jape.functest |
|---|
| Methods in gate.jape.functest that return Resource | |
|---|---|
private static Resource |
BaseJapeTests.createOntology(String ontologyURL)
|
| Uses of Resource in gate.persist |
|---|
| Methods in gate.persist with parameters of type Resource | |
|---|---|
void |
LuceneDataStoreImpl.resourceRenamed(Resource resource,
String oldName,
String newName)
|
| Uses of Resource in gate.util.spring |
|---|
| Fields in gate.util.spring declared as Resource | |
|---|---|
private Resource |
GateResourceFactoryBean.object
|
private Resource |
DuplicateResourceFactoryBean.templateResource
The template resource which we will duplicate. |
| Fields in gate.util.spring with type parameters of type Resource | |
|---|---|
private List<WeakReference<Resource>> |
DuplicateResourceFactoryBean.resourcesReturned
A list of weak references to the duplicates that have been returned, so they can be freed when this factory bean is disposed. |
| Methods in gate.util.spring with parameters of type Resource | |
|---|---|
void |
AddPRResourceCustomiser.customiseResource(Resource res)
|
void |
ResourceCustomiser.customiseResource(Resource res)
|
void |
SetParameterResourceCustomiser.customiseResource(Resource res)
|
void |
DuplicateResourceFactoryBean.setTemplate(Resource template)
Set the template resource that this factory bean will duplicate. |
| Uses of Resource in gate.wordnet |
|---|
| Subinterfaces of Resource in gate.wordnet | |
|---|---|
interface |
WordNet
Represents WordNet LKB. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


This section focus on the Component-based paradigm. It presents a precise definition which is complemented after by a list of characteristics that a component should fulfill. Since middleware plays an important role in components, a short overview of CORBA is also done. Finally, Bonobo is used as an example.
There isn't much consensus in what constitutes a component. A good yet still incomplete definition is Clemens Szyperski's list of characteristic properties of a component:
A component is an indivisible unit of independent deployment.
A component is a unit of third-party composition.
A component has no persistent state.
An illustration of the use of components
This definition may seem too general but basically constitutes the core on what consists a component and has several implications. This list will be complemented in the next section.
Imagine a big, complex and heterogeneous project divided in different parts, each with its particular function and interacting with other parts of the project, being developed by different teams. The final product may even be located in different platforms and locations. This is a good example in how component-based technology can be used. Basically, each part constitutes a component. An interface contract for each component is established and interaction is done through these interfaces. Each part shouldn't have to worry about the other parts, in particular, their location and platform.
Another example can be found in desktop environments. Imagine a user writing a document or a web page where he wants to integrate a graphic. Putting graphics functionality in the word processor or web page editor would be overloading them (how about audio, movie, barcharts...?). Doing it outside and importing as an image is also not the best solution. But if there is already a mechanism for handling that functionality why not reuse it? Basically, the idea is to "embed" the graphics mechanism in the word processor or web page editor (something like: "when handling this data use this particular mechanism"). But to have a good interaction between mechanisms we need independence, interface contracts and again components appear as a good solution for this.
First, let's refer to the aimed key aspects in component-based development.
Standardized parts and services (both through the standardization of components and the environment in which they operate.)
Minimal or no contact between entities designing components; decoupling of development efforts.
Access to practical (re)use both internal and external through standardized interoperability, configurability, and deployment.
Independent variability through documentation of components 'seams' (the interfaces used and exposed).
Source code for custom needs; binary components for standard needs.
A strict emphasis on component assembly first; manual coding second.
A robust mechanism for the delivery of architectures, frameworks, and services.
But this implies several questions:
How "loose" do we want a component to be? Could it be dependent from other components or context-based? At first glance this doesn't seem desirable since it will minimize reuse which is one of the main aspects desired.
But then how do we minimize problems occurring from deployment and reuse? These problems involve dependencies both from the environment and other components.
How to minimize communication between parts and dependencies on the developments of the several parts?
How to handle third-party interoperability? In order to avoid problems with versioning it is necessary a "black-box" view of the component but that is not enough. The third-party still has to have a guarantee on the services provided by the component.
How to handle heterogeneity between parts (for example, different languages, different platforms,...)?
What happens if the component has persistent state? Having persistent state would make two copies of a component different: is that desirable?
The key aspects and these questions leads us to some discussion on the three points presented above.
As a component is an unit of independent deployment it needs to be well-separated from the environment and even from other components. In other words, the component needs to encapsulate its constituent features. Also, it has to be totally deployed.
The second point relates to the composition with other components by a party exterior to at least one component. To couple with that, the component has to be self-contained and specify exactly what it provides and requires by means of well-defined interfaces and implementation hiding.
The reason for the third point has to do with the fact that a component should be indistinguishable from its copies. By complying to this it is then possible that there is, at most, one copy of each component loaded in each process.
Dion Hinchcliffe and Michael J. Gaffney complemented the three points above with nine other points (see Links and further information). These twelve items constitute what they believe are the "unequivocal requirements a software entity must meet in order to claim to be, dare we say it, a 'true' component".
These nine added items are:
A component must be loosely coupled with other components via interface definitions and implementation separation.
A component must explicitly identify both the interfaces it uses and exposes, and/or the service categories it uses and exposes.
A component has an unbreakable contract with all of its clients by virtue of the services its interface promises to deliver (design by contract).
A component must be deliverable in binary form (black box).
A component must use and expose services through standardized middleware services (DCOM, CORBA, JavaBeans, etc.)
A component must be configurable at design-time/run-time through a standardized interface (such as ActiveX and JavaBeans property sheets or standard configuration files).
A component must be interoperable with other components across processes, machines, networks, languages, operating systems, transaction environments, and tools.
A component should make use of standardized infrastructure services such as security, licensing, versioning, life-cycle management, visual assembly, event notification, configuration, scripting, metadata, introspection, persistence, relationships, administration, management, debugging, and installation.
A component should be able to wire itself into a collaboration with other components solely via design-time/run-time configuration.
The last two items are desirable but not absolutely necessary as well as they are difficult to satisfy. The other seven plus the three described in the beginning enable the realization of the key aspects of component-based development presented above.
Very roughly, the keywords are: interface contracts, middleware, configurability and independent, "black-box"-view unit.
But why comply with all these requirements? For example, why use strategies like CORBA when it doesn't seem to be necessary? Because if we want to make use of the benefits that this technology enables, not complying with just one of the 10 points (the other two, as was said are not necessary but are very desirable) will make the component less reusable and adaptable to the situation. In this case, if later on there would be a need to have different platforms, for example, wrappers would have to be written to do the work this technology is responsible for.
A final note regarding components Vs objects.
Components and objects, at first glance, are very similar concepts. There exists the image of entities, independent units that interact with each other, associated with both and, both are paradigms of development. But there are, however, some fundamental differences.
Here is a table showing the main differences between both concepts:
| Components | Objects |
|---|---|
| all copies are equal | it has a unique identity (instantiation) |
| it has no persistent state | it can have persistent state |
| it encapsulates its features but not its state | it encapsulates its state and behavior |
A request passing from client to object implementation (from the OMG documentation)
Middleware is now a very popular term and is basically used to refer to software "that sits in the middle, connecting diverse (and usually preexisting) programs together". In other words, a separate product that acts as a glue between two applications.
The necessity for middleware strategies appeared with distributed computing. Database systems have been one of the most important areas in this field (see Links and further information). The complexity involved in the communication between software parts residing in different machines (for example, a database server, an application server and the clients) made it necessary that some extra software was added to handle this communication.
Distributed computing is now very widely used. There is a need for strategies that simplify the developer's work (for example, handling the message passing protocol) but provide good flexibility. Using object-oriented principles, Microsoft developed DCOM, Java developed JavaBeans and OMG, the CORBA architecture.
But these are not always the best solutions for a project. There are several strategies and the following list presents the main ones except for CORBA which is described in the following section.
the communication between the application components is done using sockets directly;
the API is very low level, making the overhead associated very low, thus, resulting in more efficient applications;
it is not well suited to handle complex data types especially regarding different types of machine and/or programming languages and so is unsuitable for developing complex applications
function-oriented interface to socket-level communications;
and so is easier to use than raw socket programming;
it is powerful enough to be the basis for many client/server applications;
a standard RPC protocol exists, although there are some incompatible implementations;
capabilities similar to CORBA
there is a good support on Microsoft Operating Systems but this support is sparse outside;
thus making it very good for projects over Microsoft products but not well-suited for cross-platform;
CORBA-like architecture
supports the passing of objects by value (CORBA, for example, only passes references to objects);
but is a Java-only solution and, so, is not the best solution if different languages are used;
XML is also playing an important role in middleware. It is an easily parsed, human readable, simple and, most important, standard and independent format. These characteristics are very useful to connect heterogeneous programs together, both for data representation and communication protocol.
Middleware is what handles the communication between components. The complexity and flexibility required by component designing but still the desire that it is simple to use and implement leads to a middleware solution that:
can handle complex data types and communication
enables connecting different platforms, in particular, different operating systems, hardware and software
enables the communication between different languages
provides all the above in a standard way
hides from the developer the complexity of communication (for examples, the message passing passing protocol) and of complying with the items above
Probably, the product that fulfills best the items above is CORBA since DCOM is very bounded to the platform and JavaBeans to the language.
CORBA, or Common Object Request Broker Architecture, is defined by OMG (Object Management Group). It is a popular architecture and specification for creating software components. Its purpose is to handle interoperability between different hardware and software products, in a standard and transparent way, thus making it possible for two different applications from different vendors, in different computers, operating systems, programming languages and networks to communicate with each other.
It's an object-oriented architecture and its building blocks are:
Basically, is used to specify interfaces between CORBA objects.
Moreover, defines mappings for a variety of different languages and which purpose is to abstract from the languages being used to implement the components so that they all speak a common language.
It's not an implementation language; its sole purpose is to define interfaces.
A software component whose purpose is to facilitate communications between objects by, for example, providing capabilities like:
to locate a remote object, given an object reference
marshaling of parameters and return values to and from remote method invocations
So, basically, ORBs handle requests between applications enabling abstraction of where the program that receives the request and the one sending are.
Provides a standard communication between different ORBs above TCP/IP. Other protocols exist, and not only over TCP/IP, but this one is the most popular.
To facilitate the communication between objects, Object References are used (in the IIOP case, these are called Interoperable Object References, IOR): when a component of an application wants to access a CORBA object, it first obtains an OR for that object. Using the OR, the component can then invoke methods on the object.
CORBA provides, with these building blocks, independence of language - CORBA objects and clients can be implemented in any language that exists IDL for it, which is a big set, and need not know which language was used to implement other CORBA objects that they talk to - and independence of platform - CORBA objects can be used on any platform for which there is a CORBA ORB implementation.
It is said that a component is a server if it contains CORBA objects whose services are accessible to other objects. And, naturally, it is said to be a client if it accesses services from some other CORBA object. Of course, a component can act both as a client and a server.
Related with these terms are the stubs and skeletons:
a small piece of code that allows a client component to access a server component
pieces of code that one "fills in" when implementing a server
Finally, the Object Management Group established the Object Management Architecture (OMA) of which CORBA is a part. OMA consists of:
ORB function[1]
CORBAservices - object services
CORBAfacilities - common facilities
domain interfaces
application objects
It is important to note that these include a set standard services, compliant with CORBA, containing directory and naming services and transaction services.
Part of one of the screenshots at GNOME's webpage. It shows miscellaneous embedding (for example, playing GnoMines on the spreadsheet...).
"BONOBO is the GNOME architecture for creating reusable software components and compound documents."
GNOME implemented BONOBO in order to comply with interoperability between different applications in the desktop (e.g., embed a graphics object in a word processor document).
BONOBO is basically a set of CORBA interfaces and an implementation in GNOME/GTK+ of these interfaces that are designed to be simple to use and hide CORBA and between-components protocol used. An application uses these interfaces to export its functionality or integrate other components functionality making it possible to edit a graphic or even play GnoMines in a spreadsheet.
BONOBO is targeted both at the developer and the user.
The GNOME project is very large and consists of multiple applications. This applications are developed by several people, in particular, hobbyists whose contribution can disappear at any point.
Component software helps reduce the complexity of applications by reducing the amount of information a programmer needs to know about the system.
The component software also enables the developer to build larger, more complex applications by gluing different components together.
UNIX provides very powerful mechanisms to a user with small programs like sed, awk, cat and sort and pipes that enables this programs to be chained, where the output from the first is used as the input for the second. This enables the user to do very powerful actions in a simple command line.
BONOBO uses this as an image and applies it to desktop environments. Instead of building applications more and more complex and with every possible functionality, simply reuse what is already built and "give to Caesar what belongs to Caesar". For example, writing a document in a word processor and adding data from a spreadsheet program. What is meant with the above is that, instead of having to leave the word processor, launch the spreadsheet, copy the data and paste it to the text, being able to insert data directly from the word processor. The word processor will include the data from the spreadsheet and launch the program. Furthermore, the user would be able to edit the data included from the spreadsheet directly from the word processor or could have the data refreshed when it was changed in the spreadsheet (imagine, for example, daily reports).
The term for this is Document-Centric world.
BONOBO is similar to the OLE strategy in Microsoft.
All BONOBO components must implement the Bonobo::Unknown interface. This interface consists of a function query_interface() and the pair ref()/unref(). The first is used to check if an interface is implemented and to obtain the required interface. The pair is described in the next point. It is by these interfaces that the component states if it is embedable (for example, it is embedable if it provides the Bonobo::Embedable interface), if it is storable, if it can be edit in place, etc.
Components keep track on if their services are being used by the ref()/unref() functions, the first incrementing the counter when a request is received, the second decrementing when the request has been fulfilled.
Documents containing heterogeneous data can still be stored by using compound documents and requesting that the components responsible for that type of data do the storage (by providing the respective interfaces)
There are two types of "components": the ones that provide services (the containee/component) and the ones that use it (the containers). Looking at the example mentioned before, the word processor is a container and the spreadsheet program is the containee/component. A program can act as both parts.
It is the most common way for components to be registered and, thus, being found by others.
BONOBO addresses the requirements for:
creating compound documents
object linking
object embedding
service activation
storage facilities
menu and toolbar negotiation (merging)
printing
Cetus links is a site devoted to providing links and information on Objects and Components. At the time of this writing, they stated having 18873 links related with these subjects. Among this were the following:
Components and Objects Together by Clemens Szperski who also wrote a popular book on components.
Components: Where Are They? by Dion Hinchcliffe and Michael J. Gaffney that presents a very concrete study on components and from where the requirements and characteristics presented in this document where most based.
CDBi FORUM stands for Component-Based Development and Integration Forum and provides several interesting and useful informations about components.
Lesson 134: Middleware by Jonathan Angel provides a good overview of middleware. It focuses on the evolution of this software starting from the appearance of distributed computing to distributed objects with CORBA, JavaBeans and DCOM. It also makes a short reference to XML.
As for CORBA, there is a good number of documentation on CORBA. A good place to start is the OMG homepage.
| [1] | CORBA's role is to implement this |


SweetFreeStuff.com
///////////////////////////////////////////
Free Systane Ultra Lubricant Eye Drops Sample
Posted: 22 Sep 2014 11:09 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Systane Ultra Lubricant Eye Drops Sample
The post Free Systane Ultra Lubricant Eye Drops Sample appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Tropico 3 PC Game Download
Posted: 22 Sep 2014 01:17 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Redeem a Steam Key for a free Tropico 3 PC game download.
The post Free Tropico 3 PC Game Download appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Subscription to Guitar Player Magazine
Posted: 22 Sep 2014 12:41 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
The post Free Subscription to Guitar Player Magazine appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Redbox DVD Rental
Posted: 22 Sep 2014 12:34 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free, one-night DVD rental - Enter code: SEPT22 Valid today (9/22) only.
The post Free Redbox DVD Rental appeared first on SweetFreeStuff.com.
///////////////////////////////////////////
Free Sample BioTrue Multi Purpose Solution
Posted: 22 Sep 2014 12:01 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
State that you have never tried it for a free sample.
The post Free Sample BioTrue Multi Purpose Solution appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Bag of Monkey Loco Gummy Bears at Stripes Stores
Posted: 21 Sep 2014 11:19 PM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Coupon good for free bag of Monkey Loco Gummy Bears at Stripes Stores.
Expires 9/23. Check locations.
The post Free Bag of Monkey Loco Gummy Bears at Stripes Stores appeared
first on SweetFreeStuff.com.
///////////////////////////////////////////
Free Cinnamon Oatmeal Raisin Meta Health Bar Sample
Posted: 21 Sep 2014 11:13 PM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Cinnamon Oatmeal Raisin Meta Health Bar Sample
The post Free Cinnamon Oatmeal Raisin Meta Health Bar Sample appeared first
on SweetFreeStuff.com.
///////////////////////////////////////////
Free Abercrombie & Fitch Fierce Confidence Fragrance Sample
Posted: 21 Sep 2014 10:30 PM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Abercrombie Fitch Fierce Confidence Fragrance Sample
The post Free Abercrombie Fitch Fierce Confidence Fragrance Sample
appeared first on SweetFreeStuff.com.
///////////////////////////////////////////
10 FREE Pampers Gifts to Grow Points
Posted: 21 Sep 2014 10:08 PM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
To login please click here and enter the code: FBCAT989C09EA14 for 10 more
points. (If you need to register, click here to sign up and receive 100
points!) The Pampers Gifts to Grow Rewards Program rewards you for choosing
Pampers diapers, training pants and wipes for your growing baby. To start,
simply collect the codes from all []
The post 10 FREE Pampers Gifts to Grow Points appeared first on
SweetFreeStuff.com.


Joel 3:1
For, behold, in those days, and in that time, when I shall bring again the captivity of Judah and Jerusalem,


Professional Service
- Reviewer
World Wide Web Journal, 2011
- External Reviewer
20th Australasian Database Conference, ADC 2009
- External Reviewer
Joint 9th Asia-Pacific Web Conference, APWeb 2007 and
8th International Conference on Web-Age Information Management, WAIM 2007
Teaching
- s1, 2007: COMP1911 Computing 1, and COMP9414 Artificial Intelligence
- s2, 2006: COMP9414 Artificial Intelligence
- s1, 2006: COMP1911 Computing 1
- s2, 2005: COMP1091 Solving Problems with Software and Tools
- s1, 2005: COMP2041 Software Construction: Techniques and Tools


From:Perlingiere Debra To:Bowen Bob ; Williams Jason R (Credit) Sent:2017-01-11T04:41:12.0000000Z Subject:Re: short term gas sale and purchase agreement
I await a return call from customer message I left with same yesterday.
Debra Perlingiere
Enron North America Corp.
Legal Department
1400 Smith Street, EB 3885
Houston, Texas 77002
<EMAIL_ADDRESS>Phone<PHONE_NUMBER>
Fax<PHONE_NUMBER>
***********
EDRM Enron Email Data Set has been produced in EML, PST and NSF format by ZL Technologies, Inc. This Data Set is licensed under a Creative Commons Attribution 3.0 United States License <http://creativecommons.org/licenses/by/3.0/us/> . To provide attribution, please cite to "ZL Technologies, Inc. (http://www.zlti.com)."
***********
California


The Haskell Foundation (HF) is an independent, non-profit organization dedicated to broadening the adoption of Haskell, by supporting its ecosystem of tools, libraries, education, and research.
Driving adoption. HF seeks to foster an understanding of the benefits of using Haskell among developers who do not currently use the language, to erase barriers to entry, and to improve the Haskell ecosystem. We have many passionate and expert groups, but each is focused around a particular piece of the ecosystem, and none is dedicated to the overall user experience.
Open source. Haskell is an open source community and HF will embrace the open-source ethos wholeheartedly. HF may develop, or sponsor the development of tools and infrastructure, but it will all be open source.
Empowering the community. A major goal of HF is to augment, celebrate, and coordinate the contributions and leadership of volunteers, not to supplant or replace them.
Open, friendly, and diverse. For many of us Haskell is more a way of life than a programming language. All are welcome, all can contribute.
Transparent. All communication related to code and decision making will be publicly accessible, to enable asynchronous communication and collaboration. Only certain categories of sensitive information (e.g. financial, and matters concerning particular individuals) will be kept confidential.
True to Haskell’s principles. Haskell’s design puts principle ahead of expediency, notably by cleaving closely to the principles of purely functional programming. Success, yes, but not at all costs!
HF will have a Foundation Board (“Board” hereafter) that reflects the Haskell community and its stakeholders, including academics, commercial users, and individuals.
HF will have a staff. The size of the staff will depend on funding, but we intend to hire an Executive Director (ED), who can organize Haskell outreach, support its funding activities and oversee the rest of the staff. The staff will mostly focus on funding, marketing, and key infrastructure.
HF will work with existing and new open-source teams to channel energy into various efforts like packaging, tools, libraries, compilers, languages, documentation, user experience, and infrastructure. To reiterate, we expect that most technical contributions will be volunteer, just as it is today, but we want to position HF to fill gaps that can help adoption.
HF will establish a code of conduct and transparent decision-making that will apply to itself and any associated teams.
To the extent HF funds and pursues technical goals itself, it will pursue those goals with the same transparency as we expect from any of the teams associated with it. In this way HF will augment the community in a transparent way.
Conditions for telling this story are favorable. The days of a senior sysadmin dictating which version of Java or Python “shall be used” are dying. Containers and cloud technology have inadvertently conspired to permit engineering teams to make these decisions more often at a team level, even in larger organizations. Still, these teams need air cover and solid tools so that their decisions don’t look “rogue” to the rest of the organization.
If used correctly, Haskell can be unreasonably effective. Unfortunately, the “if” clause is not common knowledge. The HF recognizes that many of these advanced features are precisely the reason why Haskell can be successful in cases where other languages fall short. We trust that the end users will be able to make the right trade-offs that work for them. The HF will be there to help users that need to make these trade-offs by improving documentation and highlighting success stories. For example, Haskell has a great concurrency story and things like STM that are dramatically undersold in the marketplace. Some advanced features can be emphasized and taught.
The spectrum of developers is very broad: Haskell is used by both junior developers as well as long-time experts. This can cause friction, and some code may be unreadable even to other Haskell developers. This is unfortunate, because we believe that Haskell allows us to express ideas in a way that are clear and elegant. We need to delineate the common knowledge aspect of the language and tools to elevate more developers. HF should carry this banner.
Beyond that, the pesky problem of the marketplace for Haskellers remains. We often hear about fear of hiring bottlenecks and we know some engineering leaders that list this as the number one concern about Haskell. These leaders need to know one thing. You don’t have to hire a Haskell team: Haskell can make your team. Your smart Python developers can learn how to make reliable software and will love you for letting them. There is a role for HF to bridge the gap between the countless developers who want to learn and write Haskell, and the decision makers who currently believe it is hard to find these people.


Mushrooms, the key to unlocking myself and new perspectives on life. Before I start I just want to say, mushrooms made my life better. They made me see the silver lining, the truth. About 3 years ago, a few of my friends and I decided to take shrooms. They have done them a couple times before, and I had tried it once, with little to no effect.
We each bought 2 grams in brownie form (mmm) and ingested them sometime around 8 pm. After the initial hour or so waiting period, we finally decided to leave my friends basement and walk around, and let whatever was going to happen, happen. Around 9 pm we arrived on foot at a local park. We sat on the bleachers and let the shrooms take hold of us. I remember quite vividly the onset, the shift from this perspective to the next. This perspective, or life that we all live and exist in everyday was finally slipping away. I was now entering the real existance. The existance we all once knew, but for whatever reason forgot, and chose to block out.
The first signs of the shifting perspective was my vision. We were sitting on the bleachers at the park, in front of us was a huge chain link fence that was for the baseball diamond. I remember just gazing at the chain links, slowly but surely, they were all melting downwards, almost dripping to the ground. I remember looking at the wooden planks of the seat we were sitting on. I glanced at it and noticed 3 knots in the wood. They took the form of 3 felines. One a tiger, one a panther, and one a lion. Iím fond of cats so I donít know if this had any impact on what I saw, but I definitely saw these images of 3 large cats in the wood, as knots. I did not tell anyone of my friends what I was seeing.
We sat there for about an hour talking about everything we could think of. Namely, my friend S, told me he could not picture himself as me. He thinks I donít talk much, but rather I only speak when its needed - I donít gossip, Iím not that type of person, although I do like engrossing conversations, just hate gossip and the like. I told him I couldnít picture myself as him either, for whatever reason. I donít think anyone can picture themselves as anyone else. Different mindset, ideas, etc...
After about an hour or so we got up and started walking towards my friends house again, the field of grass surrounding us felt like a jungle. The grass felt so soft when I stepped on it (I had shoes on) that it was undescribable. Once we got on the pavement is where things really got weird. On the street near my friends house there is long lines of concrete that the city patched up with asphalt or whatever to fill the cracks in. I stopped in disbelief to see these lines flowing. Almost matrix like. Everything was flowing, everything was moving. Tree's, bushes, grass, everything related to nature was breathing or moving in some way or another. It was a great feeling, everything was alive.
I felt that this was the true nature of things. This is how we were meant to see things. This is how things were meant to be. I had so many ideas flowing through my head. Things I've done in the past that I regretted, things I wish I would do in the future.
Every thought came with crystal clarity. It all made sense, sort of. Why we have certain habits? Why we treat people a certain way. Why we act certain ways in different situations. How predictable we all are.
For the first time in my life, I was truly happy and astonished by this existance we call life. It was almost as if all along I was just skimming along the surface, not breaking through and really experiencing anything. I felt sad but happy at the same time knowing what I've found and that I could use this information and new perspective to live a better life and treat people better. After about 3 or 4 hours of hanging out with my friends, they decided they wanted to smoke a joint in their car. I decided against it. I didnít see a point in smoking weed to 'try and get more high' - I was more high than I could ever be. I was high on life and didnít need anything else. So I started walking home, it would only take me about 25 minutes.
As I started the walk back home, the same thoughts of what am I doing here, how can I make my life better, etc, continually went through my head. I passed my hand through a bush on the sidewalk, it felt surreal. My sense of touch was magnified 100 times. I neared my house and as I was walking up my driveway, I noticed one of our cats was outside in the front yard. It started walking towards me as I neared my door. I pet its back and I can still remember to this day how soft it felt. It meowed at me as if it were talking to me. I meowed back. It was awesome. I then realized there's beauty in everything, sometimes you just need to stop and take a look at what it is. Beauty is all around us. We have just become so used to it that it's nothing to us now. For most people at least, I think. The cat seemed so innocent and happy. I was happy that it was happy.
I walked inside and everything had a 'new' space age type feel to it. Bathrooms were weird, computers were weird. Especially my keyboard. I tried playing a computer game and talking to my friends on MSN, the keyboard seemed flat and different, and it took me a while to get my typing skills back, as weird as that may sound. Later that night when I was still high, but coming down - I wanted to walk into the living room to tell my parents that I was on mushrooms, and I wanted to tell them everything that I've discovered about myself and life in general... but I couldn't. I didnít think, no, I knew they wouldnít understand, and they would most likely get angry more than anything for me being under the influence of shrooms. Even though shrooms are the key to unlocking the door to real existance. The way to make our ignorant minds sober again. To really see things, the way they were, and are meant to be seen.
To this day, I have not changed all my habits. I still somehow conform to society's standards even though I know I shouldnít have to, nor do I want to. But it's so hard, we're all conditioned this way, but why? What's the reason? Why canít we all live in this existance, all on the same plane?
I still donít know. Maybe our minds can only take so much of the 'truth'. The truth to what really is, and what isnít. Our minds are the most powerful tools on this planet, yet we still fail to master it. It's the human condition. We're all in this existance together whether we like it or not. Why canít we just all get a long and make this paradise we call earth a better place? Why? Because of ego. People need to feed their ego and live for the materialistic things in life. And not living for a real reason.
But who am I to say whatís to live for? Who am I to say whatís right and whatís wrong? Iím just a simple man that has seen the right way of things.  The only difference is Iíve seen the truth. Iím only human.
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.


SceneJS
- extending - creating a new node type
In this example we create a new scene node type, which sets a random material color for its child nodes.
Learn more about creating new node types in
this tutorial


File Organizer
Hey! you are all setup.
Keep an eye on your Downloads directory, chrome's default.
all the changes will be made to the directory selected for the download.
Open Downloads
Click here to save the list of your courses


Uncle Tom's Cabin (Told to the Children)
by Harriet Beecher Stowe
Chapter 16: Eva and Topsy
Additional Information
- Year Published: 1852
- Language: English
- Country of Origin: United States of America
- Source: Stowe, H. B. (1852). Uncle Tom's Cabin (Told to the Children). H. E. Marshall, (Ed.).
-
Readability:
- Flesch–Kincaid Level: 3.7
- Word Count: 1,315
- Genre: Historical Fiction
- Keywords: 19th century literature, american literature
- ✎ Cite This
Downloads
Two or three years passed. Uncle Tom was still with Mr. St. Clare, far away from his home. He was not really unhappy. But always in his heart was the aching longing to see his dear ones again.
Now he began to have a new sorrow. He loved his little mistress Eva very tenderly, and she was ill.
He saw that she was growing white and thin. She no longer ran and played in the garden for hours together as she used to do. She was always tired now.
Miss Ophelia noticed it too, and tried to make Mr. St. Clare see it. But he would not. He loved his little Eva so much, that he did not want to believe that anything could be the matter with her.
Mrs. St. Clare never thought that any one, except herself, could be ill. So Eva grew daily thinner and weaker, and Uncle Tom and Aunt Ophelia more and more sad and anxious.
But at last she became so unwell, that even Mr. St. Clare had to own that something was wrong, and the doctor was sent for.
In a week or two she was very much better. Once more she ran about playing and laughing, and her father was delighted. Only Miss Ophelia and the doctor sighed and shook their heads. And little Eva herself knew; but she was not troubled. She knew she was going to God.
'Papa,' she said one day, 'there are some things I want to say to you. I want to say them now while I am able.'
She seated herself on his knee, and laid her head on his shoulder.
'It is all no use, papa, to keep it to myself any longer. The time is coming when I am going to leave you. I am going, never to come back,' and Eva sobbed.
'Eva, darling, don't say such things; you are better you know.'
'No, papa, I am not any better. I know it quite well, and I am going soon.'
'And I want to go,' she went on, 'only I don't want to leave you—it almost breaks my heart.'
'Don't, Eva, don't talk so. What makes you so sad?'
'I feel sad for our poor people. I wish, papa, they were all free. Isn't there any way to have all slaves made free?'
'That is a difficult question, dearest. There is no doubt that this way is a very bad one. A great many people think so. I do myself. I wish there was not a slave in the land. But then, I don't know what is to be done about it.'
'Papa, you are such a good man, and so noble and kind.  When I am dead, papa, then you will think of me; and do it for my sake.'
'When you are dead, Eva! Oh, child, don't talk to me so.'
'Promise me at least, father, that Tom shall have his freedom, as soon as I am gone.'
'Yes, dear, I will do anything you wish. Only don't talk so.'
Miss Ophelia and Eva had been to church together.
Suddenly Mr. St. Clare and his little girl heard a great noise coming from Miss Ophelia's room. A minute later she appeared, dragging Topsy behind her.
'Come out here,' she was saying. 'I will tell your master.'
'What is the matter now?' asked Mr. St. Clare.
'The matter is that I cannot be plagued with this child any longer' said Miss Ophelia. 'It is past all bearing. Here, I locked her up, and gave her a hymn to learn. What does she do, but spy out where I put my key. She has gone to my wardrobe, taken a bonnet–trimming, and cut it all to pieces to make dolls' jackets! I never saw anything like it in my life.
'I don't know what to do,' she went on; 'I have taught and taught. I have talked till I'm tired. I've whipped her. I've punished her in every way I can think of, and still she is as naughty as she was at first.'
'Come here, Topsy, you monkey,' said Mr. St. Clare.
Topsy came, her hard, round eyes glittering and blinking, half in fear, half in mischief.
'What makes you behave so?' said Mr. St. Clare, who could not help being amused at her funny expression.
'Spects it's my wicked heart; Miss Feely says so.'
'Don't you see how much Miss Ophelia has done for you? She says she has done everything she can think of.'
'Lor', yes, mas'r! Old missis used to say so, too.  But it didn't do me no good. I 'specs if they is to pull every hair out o' my head it wouldn't do no good neither. I's so wicked. Laws!  'I can't have that trouble any longer.'
Eva had stood silent, listening. Now she took Topsy by the hand, and led her into a little room close by.
'What makes you so naughty, Topsy?' she said, with tears in her eyes. 'Why don't you try to be good? Don't you love anybody, Topsy?'
'Dunno nothin' 'bout love. I love candy, that's all.'
'But you love your father and mother?'
'Never had none, ye know. I telled ye that, Miss Eva.'
'Oh, I forgot,' said Eva sadly. 'But hadn't you any brother, or sister, or aunt, or—'
'No, none on 'em. Never had nothin' nor nobody.'
'But, Topsy, if you would only try to be good you might—'
'Couldn't never be nothin' but a nigger, if I was ever so good,' said Topsy. 'If I could be skinned, and come white, I'd try then.'
'But people can love you, if you are black, Topsy. Miss Ophelia would love you if you were good.'
Topsy laughed scornfully.
'Don't you think so?' said Eva.
'No.  She'd as soon have a toad touch her. There can't nobody love niggers, and niggers can't do nothin'. I don't care,' and Topsy began whistling to show that she didn't.
'Oh, Topsy! I love you,' said Eva, laying her little, thin hand on Topsy's shoulder. 'I love you, because you haven't had any mother, or father, or friends; because you have been a poor, ill–used child. I love you, and I want you to be good. It makes me sorry to have you so naughty.  I shan't be here very long.'
Topsy's round, bright eyes grew suddenly dim with tears. She did believe at last that it was possible for some one to love her.
'Poor Topsy, said Eva gently.
 I never did care nothin' about it before.'


| MPI_ERRHANDLER_FREE( errhandler ) | |
| INOUT errhandler | MPI error handler (handle) |
int MPI_Errhandler_free(MPI_Errhandler *errhandler)
MPI_Errhandler_free(errhandler, ierror)
TYPE(MPI_Errhandler), INTENT(INOUT) :: errhandler
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
MPI_ERRHANDLER_FREE(ERRHANDLER, IERROR)
INTEGER ERRHANDLER, IERROR
Marks the error handler associated with errhandler for
deallocation and sets errhandler to
MPI_ERRHANDLER_NULL.
The error handler will be deallocated after
all
the objects
associated with it
(communicator, window, or file)
have been deallocated.
| MPI_ERROR_STRING( errorcode, string, resultlen ) | |
| IN errorcode | Error code returned by an MPI routine |
| OUT string | Text that corresponds to the errorcode |
| OUT resultlen | Length (in printable characters) of the result returned in string |
int MPI_Error_string(int errorcode, char *string, int *resultlen)
MPI_Error_string(errorcode, string, resultlen, ierror)
INTEGER, INTENT(IN) :: errorcode
CHARACTER(LEN=MPI_MAX_ERROR_STRING), INTENT(OUT) :: string
INTEGER, INTENT(OUT) :: resultlen
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
MPI_ERROR_STRING(ERRORCODE, STRING, RESULTLEN, IERROR)
INTEGER ERRORCODE, RESULTLEN, IERROR
CHARACTER*(*) STRING
Returns the error string associated with an error code or class. The argument string must represent storage that is at least MPI_MAX_ERROR_STRING characters long.
The number of characters actually written is returned in the output argument, resultlen.
Rationale.
The form of this function was chosen to make the Fortran and C
bindings similar. A version that returns a pointer to a string has two
difficulties. First, the return string must be statically allocated and
different for each error message (allowing the pointers returned by
successive calls to MPI_ERROR_STRING to point to the correct
message). Second, in Fortran, a function declared as returning
CHARACTER*(*) can not be referenced in, for example, a
PRINT statement.
( End of rationale.)


Reduction indices in tensorflow
30 Oct 2016TensorFlow provides many handy functions for performing reductions on tensors. I was trying to compute max-pooling over some tensor. I did not understand the idea of reduction indices correctly, and hence ended up writing for loops within the tensorflow computation graph. As expected the code ran poorly.
It was clear that using tf.reduce_max
appropriately would be the key
to rectify the issue. Note that similar ideas apply to numpy arrays. I hope that
this write-up will be useful for future reference.
The reduction index is essentially that index on which the operation runs. Also, note that the dimensions are indexed starting from 0. Therefore, for a 2-D tensor, the rows are indexed as the 0 dimension and columns are indexed as dimension 1.
Say we are given a 2-D tensor (a
) and we want a tensor which contains the
sum of entries along the column. (rows are indexed by i
and columns are indexed by j
). If we were to write this down as
a summation operation we would have a summation that runs over i
.
Therefore, our sum would be given by
tf.reduce_sum(a, reduction_indices=[0])
Let us try to write up some code to understand this.
import tensorflow as tf
import numpy as np
t1 = tf.Variable(np.reshape(np.arange(1,13), (4,3)))
# t1 is a tensor [[1, 2, 3],
# [4, 5, 6],
# [7, 8, 9],
# [10, 11, 12]]
t2 = tf.reduce_max(t1, reduction_indices=[0])
# t2 is the tensor [10, 11, 12]
t3 = tf.reduce_max(t1, reduction_indices=[1])
# t3 is the tensor [3, 6, 9, 12]
with tf.Session() as sess:
tf.initialize_all_variables().run()
print(sess.run(t2))
# [10 11 12]
print(sess.run(t3))
# [3 6 9 12]
These ideas generalize to higher order tensors. It is worthwhile to think about the right reshaping of the tensor and reduction along appropriate dimension(s).


--- layout: default bodyclass: about --- {% include img-banner.html %} {% include main-content.html %}
Our apprentices come from St. Louis City and County schools and beyond. We also have apprentices who have already graduated high school, and are building their skill sets for the next opportunity!
We seek to create opportunities for teens in the city of STL. We also make room for inclusion in the workplace, acknowledging that there are many diverse young creatives in STL. Apprenticeships are open to youth of any ethnicity, creed, gender identity, and/or sexual orientation.
Our program has always been nearly a 50/50 ratio of males to females.


Responsive Images quiz by Cameron Pittman
Taking advantage of sizes
alongside srcset
gives you a very powerful combination for responsive images. This quiz is here to help you practice giving the browser the ability to decide which image it should download based on media queries and image width.
Modify this page using DevTools. When it meets all the requirements listed in the Udacity Feedback, a code will appear. Type that code into the Udacity classroom to continue.
sizes
and srcset
That coffee looks delicious. You know what's even more delicious? Responsive images based on media queries :) Help the browser determine the right image to download using srcset
to specify images with different natural resolutions and sizes
to tell the browser how wide the image will be on the page using media queries.
For this quiz, I want you to tell the browser to download that it has the option of using Coffee_1280w.jpg
and Coffee_640w.jpg
, which have widths of 1280px and 640px respectively. Tell the browser that the image will display at 50vw if the page is 960px wide or smaller, otherwise the image displays at 100vw.
Make your changes with DevTools!


Provides fast, reliable and extensible starter for the development of Angular 2 projects.
angular2-seed
provides the following features:
Note that this seed project requires node v4.x.x or higher and npm 2.14.7.
Here is how to speedup the build on Windows.
In order to start the seed use:
git clone --depth 1 https://github.com/mgechev/angular2-seed.git
cd angular2-seed
# install the project's dependencies
npm install
# watches your files and uses livereload by default
npm start
# api document for the app
npm run build.docs
# dev build
npm run build.dev
# prod build
npm run build.prod
Does not rely on any global dependencies.
Default application server configuration
var PORT = 5555;
var LIVE_RELOAD_PORT = 4002;
var DOCS_PORT = 4003;
var APP_BASE = '/';
Configure at runtime
npm start -- --port 8080 --reload-port 4000 --base /my-app/
Visit the Wiki page of the project.
npm test
# Debug - In two different shell windows
npm run build.test.watch # 1st window
npm run karma.start # 2nd window
# code coverage (istanbul)
# auto-generated at the end of `npm test`
# view coverage report:
npm run serve.coverage
# e2e (aka. end-to-end, integration) - In three different shell windows
# Make sure you don't have a global instance of Protractor
# npm run webdriver-update <- You will need to run this the first time
npm run webdriver-start
npm run serve.e2e
npm run e2e
# e2e live mode - Protractor interactive mode
# Instead of last command above, you can use:
npm run e2e.live
You can learn more about Protractor Interactive Mode here
angular2-seed
supports progressive web apps with angular/progressive.
The seed can generate a file manifest.appcache
which lists all files included in a project's output, along with SHA1 hashes of all file contents. This file can be used directly as an AppCache manifest (for now, index.html
must be manually edited to set this up).
The manifest is also annotated for use with angular2-service-worker
. Some manual operations are currently required to enable this usage. The package must be installed, and worker.js
manually copied into the project src directory:
cp node_modules/angular2-service-worker/dist/worker.js src/client
In order to generate the manifest file run:
# ENV can be both prod or dev
npm run generate.manifest -- --env ENV
Then, the commented snippet in main.ts
must be uncommented to register the worker script as a service worker.
Please see the CONTRIBUTING file for guidelines.
An advanced option to this seed exists here which mirrors the latest changes here but adds core support for:
You may use it to learn how to extend this seed for your own use cases or use the advanced seed if your project needs those features.
Forks of this project demonstrate how to extend and integrate with other libraries:
.
├── LICENSE
├── README.md
├── gulpfile.ts <- configuration of the gulp tasks
├── karma.conf.js <- configuration of the test runner
├── package.json <- dependencies of the project
├── protractor.conf.js <- e2e tests configuration
├── src <- source code of the application
│ ├── home
│ │ └── components
│ ├── index.html
│ ├── main.ts
│ ├── shared
│ │ └── services
│ │ ├── name-list...
│ │ └── name-list...
│ └── sw.js <- sample service worker
├── test-main.js <- testing configuration
├── tools
│ ├── README.md <- build documentation
│ ├── config
│ │ ├── project.config.ts <- configuration of the specific project
│ │ ├── seed.config....
│ │ └── seed.config.ts <- generic configuration of the seed project
│ ├── config.ts <- exported configuration (merge both seed.config and project.config, project.config overrides seed.config)
│ ├── debug.ts
│ ├── manual_typings
│ │ ├── project <- manual ambient typings for the project
│ │ │ └── sample.pac...
│ │ └── seed <- seed manual ambient typings
│ │ ├── merge-stre..
│ │ └── slash.d.ts
│ ├── tasks <- gulp tasks
│ │ ├── project <- project specific gulp tasks
│ │ │ └── sample.tas...
│ │ └── seed <- seed generic gulp tasks. They can be overriden by the project specific gulp tasks
│ ├── utils <- build utils
│ │ ├── project <- project specific gulp utils
│ │ │ └── sample_util...
│ │ ├── project.utils.ts
│ │ ├── seed <- seed specific gulp utils
│ │ │ ├── clean.ts
│ │ │ ├── code_change...
│ │ │ ├── server.ts
│ │ │ ├── tasks_tools.ts
│ │ │ ├── template_loc...
│ │ │ ├── tsproject.ts
│ │ │ └── watch.ts
│ │ └── seed.utils.ts
│ └── utils.ts
├── tsconfig.json <- configuration of the typescript project (ts-node, which runs the tasks defined in gulpfile.ts)
├── tslint.json <- tslint configuration
├── typings <- typings directory. Contains all the external typing definitions defined with typings
├── typings.json
└── appveyor.yml
| mgechev | ludohenin | d3viant0ne | tarlepp | NathanWalker | nareshbhatia |
| jesperronn | the-ult | aboeglin | gkalpak | ryzy | Shyam-Chen |
| pgrzeszczak | natarajanmca11 | TheDonDope | njs50 | larsthorup | jerryorta-dev |
| e-oz | ouq77 | JakePartusch | LuxDie | tsm91 | JohnCashmore |
| domfarolino | evanplaice | hAWKdv | c-ice | markharding | devanp92 |
| ojacquemart | TuiKiken | juristr | ip512 | Yonet | Nightapes |
| Brooooooklyn | allenhwkim | brendanbenson | briantopping | cadriel | dszymczuk |
| dstockhammer | dwido | koodikindral | philipooo | alexweber | hpinsley |
| jeffbcross | johnjelinek | justindujardin | lihaibh | nulldev07 | tandu |
| inkidotcom | mjwwit | ocombe | gdi2290 | typekpb | Green-Cat |
| tapas4java | redian | robbatt | robertpenner | sclausen | Bigous |
| butterfieldcons | jgolla | ultrasonicsoft | yassirh |
You can follow the Angular 2 change log here.
MIT
Generated using TypeDoc


{% extends "base.html" %} {% block content %} {% if not chat.finished %} {% if host %}
You are the host of this chat a guest will connect soon.
{% endif %}Remember to play nice. If you offend the other person they may report you. And you may report them. You only get one report an hour.
{% endif %}{{line.split(':')[0]}}{{line.split(':')[1]}}


Design Principles
10 principles for designing user centred public services.
Start with user needs
Service design starts with identifying user needs.  Do research, analyse data, talk to users. Don’t make assumptions. Have empathy for users, and remember that what they ask for isn't always what they need.
-
What we mean when we say “service transformation”
by Mike Bracken -
Most of government is mostly service design most of the time
by Matt Edgar -
Vertical campfires: our user research walls
by Kate Towsey
Do less
Government should only do what only government can do. If we’ve found a way of doing something that works, we should make it reusable and shareable instead of reinventing the wheel every time. This means building platforms and registers others can build upon, providing resources (like APIs) that others can use, and linking to the work of others. We should concentrate on the irreducible core.
-
Building digital civic infrastructure from the ground up
by Mike Bracken -
What we’ve learned about scaling agile
by Jamie Arnold
Design with data
In most cases, we can learn from real world behaviour by looking at how existing services are used. Let data drive decision-making, not hunches or guesswork. Keep doing that after taking your service live, prototyping and testing with users then iterating in response. Analytics should be built-in, always on and easy to read. They’re an essential tool.
-
Retiring our icons
by Guy Moorhouse -
Combining user research and analytics to improve the user experience
by Lana Gibson and Charlotte Clancy - Performance data for government services
Do the hard work to make it simple
Making something look simple is easy. Making something simple to use is much harder — especially when the underlying systems are complex — but that’s what we should be doing. Don’t take “It’s always been that way” for an answer. It’s usually more and harder work to make things simple, but it’s the right thing to do.
-
Doing the hard work to make things simple
by Mike Bracken -
I fought the law and the users won
by Pete Herlihy -
This is what we mean when we say “service transformation”
by Mike Bracken
Iterate - then iterate again
The best way to build good services is to start small and iterate wildly. Release Minimum Viable Products early, test them with actual users, move from Alpha to Beta to Live adding features, deleting things that don’t work and making refinements based on feedback. Iteration reduces risk. It makes big failures unlikely and turns small failures into lessons. If a prototype isn’t working, don’t be afraid to scrap it and start again.
-
Discovering discovery
by Sarah Prag -
6 case studies using research and data to improve a live service
by Ben Holliday -
Exemplars making examples of themselves
by Mike Bracken
This is for everyone
Accessible design is good design. Everything we build should be as inclusive, legible and readable as possible. If we have to sacrifice elegance — so be it. We’re building for needs, not audiences. We’re designing for the whole country, not just the ones who are used to using the web. The people who most need our services are often the people who find them hardest to use. Let’s think about those people from the start.
-
Building for inclusion
by Léonie Watson -
What are we doing about accessibility?
by Joshua Marshall -
Here’s what we mean by “building for inclusion”
by Mike Bracken
Understand context
We’re not designing for a screen, we’re designing for people. We need to think hard about the context in which they’re using our services. Are they in a library? Are they on a phone? Are they only really familiar with Facebook? Have they never used the web before?
-
How we recruited people with low/no digital skills on Carer's Allowance
by Simon Hurst -
The right place to do rural research
by Emily Ball
Build digital services, not websites
A service is something that helps people to do something. Our job is to uncover user needs, and build the service that meets those needs. Of course much of that will be pages on the web, but we’re not here to build websites. The digital world has to connect to the real world, so we have to think about all aspects of a service, and make sure they add up to something that meets user needs.
-
Digital leadership
by Kit Collingwood-Richardson -
Revealing the hidden side of transformation
by Mike Bracken -
Not the HMRC of old
by Mike Bracken
Be consistent, not uniform
We should use the same language and the same design patterns wherever possible. This helps people get familiar with our services, but when this isn’t possible we should make sure our approach is consistent.
This isn’t a straitjacket or a rule book. Every circumstance is different. When we find patterns that work we should share them, and talk about why we use them. But that shouldn’t stop us from improving or changing them in the future when we find better ways of doing things or the needs of users change.
Make things open: it makes things better
We should share what we’re doing whenever we can. With colleagues, with users, with the world. Share code, share designs, share ideas, share intentions, share failures. The more eyes there are on a service the better it gets — howlers are spotted, better alternatives are pointed out, the bar is raised.
Much of what we’re doing is only possible because of open source code and the generosity of the web design community. We should pay that back.
-
GDS, USDS, and sharing expertise
by Mike Bracken -
How sharing helps us improve digital services
by Mike Bracken


Working around WebForms Event Validation
WebForms Event Validation feature means that the form will only postback if the controls havent been tampered with (e.g.: someone setting malicious input via JavaScript).
On a more technical level, its basically a hash of all the trusted control values, which is then compared prior to postback.
The problem comes when you change to data after the page load, which is “outside” the values webforms trusts.
Example
A common use-case is changing dropdown options after page load.
MyPage.aspx.cs:
Dropdown.DataSource = new List<int> { 1 };
<asp:DropDownList ID="Dropdown" runat="server">
</asp:DropDownList>
Fine so far. And now lets change the dropdown options.
<script>
var option = $('<option/>', { value: 2 });
$('#<%: Dropdown.ClientID %>').add(option);
</script>
This new selectable value “2” is “outside” the values webforms trusts.
So when you post 1, its all good. But then post back 2, and webforms will shout at the top of its lungs, saying event validation failed.
Workaround
The main issue is that we dont want event validation.
But WebForms only allows us to change that at the site-wide and page level.
Cant change it at component-level, like for our dropdown (e.g.: some asp web control attribute like EnableEventValidation=False).
Unofficial workaround?
Well, theres 3 options.
1. Flick off page-level event validation
Not recommended, its there to keep us safe
2. Add a class
Event validation is declared through SupportsEventValidation class attribute.
The attribute does not apply to children.
So you can just make your own Dropdown class that inherits from ASP’s dropdown, then use that.
Creating a class that shouldnt be necessary seems messy.
3. Dont postback the control
By this, i mean putting the asp web control OUTSIDE the form that asp renders.
Usually you can shove it between the closing <form/> tag, and the closing <body/> tag.
This effectively mimicks 2, but in a cleaner fashion.


We enhance tables!
- generate holistic technologies
- orchestrate intuitive functionalities
- incentivize dynamic e-commerce
- matrix granular experiences
- transition global web services
- target value-added supply-chains
- harness innovative technologies
- incentivize customized ROI
- synthesize open-source channels
- monetize killer partnerships
- aggregate holistic infomediaries


{% include 'header.html' %}
Main campus parking
Open air parking
Health and safety department parking
Health and safety Department complex
Underground Car Park
Previous
Next


Robert C. Litchfield
"idea generation typically produces a high ratio of bad ideas to good ones, and idea selection mechanisms often function poorly"
"Brainstorming (Osborn, 1957) is an intervention in which individuals, groups, and organizations adhere to a set of four rules while working in sessions designated to generate ideas. The rules are (1) to generate as many ideas as possible, (2) to avoid criticizing any of the ideas, (3) to attempt to combine and improve on previously articulated ideas, and (4) to encourage the generation of “wild” ideas."
Osborn, 1957


Clubber floored man after being told off for taking drink outside
The incident was captured on CCTV
by Rod MalcolmA clubber caused bother after "a comedy moment" when he stood outside a bar with his outstretched right arm holding a drink just inside.
Jordan Marshall, 31, came up with the trick when told it was against licensing rules to take booze out of the Atrium bar in Newark, a court heard.
When door staff pushed him out of the way, he "lashed out" and floored one man who ended up with tiny fractures around an eye socket.
Marshall admitted wounding and was ordered to pay £1,500 compensation to the doorman, who was left with numbness and "a strange feeling" when he smiles. The father-of-five said that his children were "scared to cuddle him" when the injury was at its worst.
Sitting at Nottingham Crown Court, Judge Sally Hancox told him: "People don't like being pushed but a door person is entitled to do that with your behaviour.
"You are standing there in a comedy moment with the glass inside the night club. Then you get arsey with the door staff," she added.
The incident was captured on CCTV which was played in court before sentence was passed on Marshall of Clumber Avenue, Newark. He was given a 20-month prison term, suspended for two years, and must do 100 hours community work.
Kevin Jones, prosecuting, said that the doorman is a single parent who had to take 11 weeks off work and needed surgery.
"That made it difficult for him to support his family," added Mr Jones.
Mark Nicholls, mitigating, said that Marshall had "access to £2,000" for compensation. He added: "He is working full-time as a funeral parlour sales person."


This plugin adds buttons to show only assignments/weapons/awards/weapon unlocks from specific DLC/base game. It's a new version of the old plugin, which worked only with assignments.
Feedback and translations to other languages will be appreciated.
Changelog
1.6 - added Final Stand to the list of premium DLCs
1.5.5 - fixed a bug
1.5.4 - it really works now, promise
1.5.3 - really really fixed the bug
1.5.2 - really fixed the bug
1.5.1 - fixed a bug
1.5 - the plugin now detects owned DLCs/Premium automatically, you don't have to set them anymore
incorrect counts of items are hidden from now on
added an option to hide items from unowned DLCs from the ALL view (on by default)
added an option to show menu items for unowned DLCs (off by default)
1.0.1 - added Portugal (thanks to ArnoldLayne) and German (thanks to Brady_The) translations
1.0 - initial version
Screenshots
assignments.png
weapons.png
awards.png
weapon_unlocks.png
You can install this plugin from the plugin gallery:
P.S. - Base game in russian is "Базовая игра", but "Основная игра" (Main game) sounds way better for me.
Topicstarter
dapil
Plugin Developer
Thank you, added!
Wolf68k
Need to update and enable the Dragon's Teeth buttons.
Krayziesoldier
it works, you need to enable them in the settings.
Nano
Global Moderator
Krayziesoldier wrote:
it works, you need to enable them in the settings.
For me, plugin just show "All" and "Base game". I have Premium and in options i have uncheckeed "Hide items from unowned DLCs" (in stats, assignments, awards and unlocks too)
http://i.imgur.com/r9LlFu9.png
Post edited 2 x times, last by
dapil
Plugin Developer
Topicstarter
dapil
Plugin Developer
I updated the plugin few hours ago and changed it to detect the DLCs automatically so that probably caused it, I'll look into it.
EDIT: The plugin should work correctly now.
Post edited 2 x times, last by
dapil
Plugin Developer
Topicstarter
dapil
Plugin Developer
There was a major update! Check out the first post for a changelog! Big thanks to ezek1el3000 for help with debugging the plugin.
Nano
Global Moderator
Works like a charm. :)
Topicstarter
dapil
Plugin Developer
Awesome :)
Post edited 1 x times, last by
Nano
Global Moderator
Nano
Global Moderator
Dapil, Final Stand filters isn't showing. You need to update manually or it's a bug?
Post edited 1 x times, last by
Krayziesoldier
Krayziesoldier
line 100 change the last false to true and its fixed.
xpowned = [true,true,true,true,false];
to
xpowned = [true,true,true,true,true];