oship-dev team mailing list archive

[Roberto Siqueira <siqueira@xxxxxxxxxxxxxxx>]

Hi, Otavio (and all):
 Wow, this is *huge*! Have you already tried the Wikipedia 
(http://www.wikipedia.org/) and the Wiktionary 
(http://www.wiktionary.org/)? By personal experience, these are the best 
starting points to look for unknown words, acronyms, and even small 
expressions -- always clear and surprisingly accurate.

 Anyway, below you'll find my "best efforts" to help you with your 
questions. Thinking of it, it may indeed be a good idea to start a small 
"Glossary" in the FAQs: https://answers.launchpad.net/oship/+faqs , at 
least for terms strictly related to OSHIP (e.g.  dADL, cADL, AOM etc). 
What do you all think?
 Best regards,
Roberto.

Otavio Silva a écrit :
>    Hi!
>    I was reading the document "overview.pdf" and, as I am not an IT 
> professional, I have some doubts with the following terms. If anyone 
> could help me...
>  
> * UML
= Unified Modeling Language, a graphical (and standardized) way to 
represent software, using a higher level of abstraction than with a 
specific programming language. It's (kind of) a generalization of 
flowcharts to object-oriented (OO) programming. Diagrams created with a 
"UML drawing tool" (e.g. ArgoUML) are saved in the XMI format and, in 
theory, can be used to generate an equivalent program, in any OO 
language (Python, in our case). But the mechanism is overly complex and 
has compatibility issues. The openEHR UML models 
(http://www.openehr.org/releases/1.0.2/architecture/computable/UML/uml.html) 
e.g. are not fully operational yet.

> * "semi-automated and automated distributed workflows"
automated = without human intervention.
distributed = a single computing system that is "spread" among many 
physically-separated machines.
workflow = see: http://en.wikipedia.org/wiki/Healthcare_workflow

> * "legacy data purification and validation gateways"
legacy data = data stored in old formats
validation = a way to verify that your data has no inconsistencies under 
a given format, usually through a series of "good format" rules (AKA 
schema).
gateway = a machine that distributes (and sometimes filters) data that 
arrives from the outside, to a local network.

> * "runtime data"
= data newly created by a running program, which usually disappears when 
the program ends.

> * "caching"
= creation of a local copy, to optimize the access to a given chuck of 
data (that usually needs to be retrieved many times in a row). 

> * "model containing many classes" - model, object, class in Object 
> Oriented
= see: http://pt.wikipedia.org/wiki/Orienta%C3%A7%C3%A3o_a_objeto  and: 
http://en.wikipedia.org/wiki/Object-oriented_programming#Fundamental_concepts_and_features

>  * "granularity", "fine-grained" / "coarse-grained"
= level of detail

> * "namespaces"
= kind of "directories", where your "files" (i.e. your objects) live. 2 
files on the same directory cannot share the same name, but files from 
different directories can. When files from different directories 
"interact", we must use their "fully qualified names" (e.g. /dir1/file1 
and /dir2/file1), to avoid name conflicts. This is what is called 
"disambiguation" -- an ugly name for a simple concept.

> * "Dependencies"
= "chunks" of code (and data) that must be present on your system (e.g. 
python-dev, setuptools, virtualenv) when you want to run another chunk 
(e.g. grok, oship) that "reuse" (AKA "calls") them.

> * "type system"
= maybe just "external-type system"?

> * freeform legacy data
= old data, without a rigid formatting (or having an undefined one). 

> * front-end, back-end and  Non-repudiation
front-end, back-end = see: 
http://en.wikipedia.org/wiki/Front-end_and_back-end
non-repudiation = has to do with security and digital signatures. See: 
http://en.wikipedia.org/wiki/Non-repudiation

> * hard information
= probably the actual 'medical' data.

> * hashes
= in this case, cryptographic hash functions (AKA checksums). See: 
http://en.wikipedia.org/wiki/Cryptographic_hash_function .

> * inferencing attacks
= one of the many techniques to break the security of a given 
communication protocol.

> * "hash (e.g. MD5) of a canonical representation" and "digest strings"
MD5 = see "hashes" above and: http://en.wikipedia.org/wiki/Md5
canonical representation = standard (conventional?) way to format data 
or programming code.
digest strings = the hashes values that are needed to decrypt the 
encoded data (AKA "the message").

> * versioned persistence layer
= layer where old copies are stored, on a system (like Wikipedia itself, 
or Launchpad's Bazaar) that allows "undoing" changes to the stored 
documents. Access to old versions of a document is generally considered 
a security risk (e.g. in MSWord: 
http://www.salon.com/news/feature/2007/05/18/cpa_documents/index.html )

>  * instances
> * rollback
instances = versions (or copies) of a document.
to rollback = to undo a change returning to a previous version.

>  * cardinalities 
= see: http://en.wikipedia.org/wiki/Cardinality_(data_modeling)

> * proxy
= see: http://en.wiktionary.org/wiki/proxy

> * asynchronous synchronisation
= a procedure to ascertain that 2 copies (mirrors) of a database stay 
identical that takes place not at fixed times but e.g. whenever the 
workload is low (regardless it's a funny name, isn't it?)

> * "reverse internet identifier"
= sorry, I've never heard about this. But GUID and OID are probably 
similar. See here: http://en.wikipedia.org/wiki/Guid and here: 
http://en.wikipedia.org/wiki/Object_identifier .

> * scheme-space
= never heard about, either. But must be something similar to a 
"namespace" (see "namespaces", above).

> * object model
= see: http://en.wikipedia.org/wiki/Object_model . (By the way: AOM is 
the acronym for "Archetype Object Model".)

> * serialised form / abstract serialisation
serialization = to represent physically an abstract object model, using 
e.g. text strings. ADL is the serialization of the AOM.

> * keystrokes 
= characters that are entered using a keyboard.

> * "atomic internal codes"
= in this case just some sort of minimalist codes, which cannot be 
further subdivided (split).

> * middleware
= see: http://en.wiktionary.org/wiki/middleware 

> * (data) sinks
= the opposite of data sources. Something that demands data, instead of 
supplying it.  

> * relational databases
= the most popular type of database, where data is stored on 2D tables 
(i.e., tables composed of rows and columns). MySQL, PostgreSQL etc are 
all examples of relational databases. OTOH, tree-structured (or 
"nested") data like: directory trees, archetypes and XML files, is 
better handled by "hierarchic" databases.

> * flatter structures
= structures that are, by nature, more relational (un-nested) than 
tree-like (nested). Please note that nested structures (e.g. ADL files) 
*can* be stored in relational databases (and vice-versa), using well 
known transformations -- it's enough to add more columns, to store the 
hierarchic (AKA "who is your parent?") information.

> * "'full-strength' semantics", "covariant and contravariant" and "inbuilt"
'full-strength' semantics" = the flexibility of the object model in its 
"pure" form (i.e. not implemented in any specific language or technology)
covariant and contravariant = see: 
http://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)
inbuilt (types) = simple, predefined types like "integer", "boolean", 
"float" etc

> Thanks a lot!
You're (ouf!) welcome.
> Otavio