New Version Available: OWL 2 (Document Status Update, 12 November 2009)
The OWL Working Group has produced a W3C Recommendation for a new version of OWL which adds features to this 2004 version, while remaining compatible. Please see OWL 2 Document Overview for an introduction to OWL 2 and a guide to the OWL 2 document set.
Please refer to the errata for this document, which may include some normative corrections.
See also translations.
Copyright © 2004 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
This document specifies usage scenarios, goals and requirements for a web ontology language. An ontology formally defines a common set of terms that are used to describe and represent a domain. Ontologies can be used by automated tools to power advanced services such as more accurate web search, intelligent software agents and knowledge management.
This document has been reviewed by W3C Members and other interested parties, and it has been endorsed by the Director as a W3C Recommendation. W3C's role in making the Recommendation is to draw attention to the specification and to promote its widespread deployment. This enhances the functionality and interoperability of the Web.
This is one of six parts of the W3C Recommendation for OWL, the Web Ontology Language. It has been developed by the Web Ontology Working Group as part of the W3C Semantic Web Activity (Activity Statement, Group Charter) for publication on 10 February 2004.
The design of OWL expressed in earlier versions of these documents has been widely reviewed and satisfies the Working Group's technical requirements. The Working Group has addressed all comments received, making changes as necessary. Changes to this document since the Proposed Recommendation version are detailed in the change log.
Comments are welcome at<EMAIL_ADDRESS>(archive) and general discussion of related technology is welcome at<EMAIL_ADDRESS>(archive).
A list of implementations is available.
The W3C maintains a list of any patent disclosures related to this work.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
The Semantic Web is a vision for the future of the Web in which information is given explicit meaning, making it easier for machines to automatically process and integrate information available on the Web. The Semantic Web will build on XML's ability to define customized tagging schemes [XML] and RDF's flexible approach to representing data [RDF Concepts]. The next element required for the Semantic Web is a web ontology language which can formally describe the semantics of classes and properties used in web documents. In order for machines to perform useful reasoning tasks on these documents, the language must go beyond the basic semantics of RDF Schema [RDF Vocabulary].
This document is one part of the specification of OWL, the Web Ontology Language. The Document Roadmap section of the OWL Overview document describes each of the other documents. This document enumerates the requirements of a web ontology language as perceived by the working group. However, it is expected that future languages will extend OWL, adding, among other things, greater logical capabilities and the ability to establish trust on the Semantic Web.
We motivate the need for a web ontology language by describing six use cases. Some of these use cases are based on efforts currently underway in industry and academia, others demonstrate more long-term possibilities. The use cases are followed by design goals that describe high-level objectives and guidelines for the development of the language. These design goals will be considered when evaluating proposed features. The section on Requirements presents a set of features that should be in the language and gives motivations for those features. The Objectives section describes a list of features that might be useful for many use cases but may not necessarily be addressed by the working group.
The Web Ontology Working Group charter tasks the group to produce this more expressive semantics and to specify mechanisms by which the language can provide "more complex relationships between entities including: means to limit the properties of classes with respect to number and type, means to infer that items with various properties are members of a particular class, a well-defined model of property inheritance, and similar semantic extensions to the base languages." The detailed specification of the web ontology language will take into consideration:
An ontology defines the terms used to describe and represent an area of knowledge. Ontologies are used by people, databases, and applications that need to share domain information (a domain is just a specific subject area or area of knowledge, like medicine, tool manufacturing, real estate, automobile repair, financial management, etc.). Ontologies include computer-usable definitions of basic concepts in the domain and the relationships among them (note that here and throughout this document, definition is not used in the technical sense understood by logicians). They encode knowledge in a domain and also knowledge that spans domains. In this way, they make that knowledge reusable.
The word ontology has been used to describe artifacts with different degrees of structure. These range from simple taxonomies (such as the Yahoo hierarchy), to metadata schemes (such as the Dublin Core), to logical theories. The Semantic Web needs ontologies with a significant degree of structure. These need to specify descriptions for the following kinds of concepts:
Ontologies are usually expressed in a logic-based language, so that detailed, accurate, consistent, sound, and meaningful distinctions can be made among the classes, properties, and relations. Some ontology tools can perform automated reasoning using the ontologies, and thus provide advanced services to intelligent applications such as: conceptual/semantic search and retrieval, software agents, decision support, speech and natural language understanding, knowledge management, intelligent databases, and electronic commerce.
Ontologies figure prominently in the emerging Semantic Web as a way of representing the semantics of documents and enabling the semantics to be used by web applications and intelligent agents. Ontologies can prove very useful for a community as a way of structuring and defining the meaning of the metadata terms that are currently being collected and standardized. Using ontologies, tomorrow's applications can be "intelligent," in the sense that they can more accurately work at the human conceptual level.
Ontologies are critical for applications that want to search across or merge information from diverse communities. Although XML DTDs and XML Schemas are sufficient for exchanging data between parties who have agreed to definitions beforehand, their lack of semantics prevent machines from reliably performing this task given new XML vocabularies. The same term may be used with (sometimes subtle) different meaning in different contexts, and different terms may be used for items that have the same meaning. RDF and RDF Schema begin to approach this problem by allowing simple semantics to be associated with identifiers. With RDF Schema, one can define classes that may have multiple subclasses and super classes, and can define properties, which may have sub properties, domains, and ranges. In this sense, RDF Schema is a simple ontology language. However, in order to achieve interoperation between numerous, autonomously developed and managed schemas, richer semantics are needed. For example, RDF Schema cannot specify that the Person and Car classes are disjoint, or that a string quartet has exactly four musicians as members.
One of the goals of this document is to specify what is needed in a web ontology language. These requirements will be motivated by potential use cases and general design objectives that take into account the difficulties in applying the standard notion of ontologies to the unique environment of the Web.
Ontologies can be used to improve existing Web-based applications and may enable new uses of the Web. In this section we describe six representative use cases of web ontologies. Note that this is not an exhaustive list, but instead a cross-section of interesting use cases. These use cases served as a guideline in choosing requirements for the OWL language (see Section 4). The requirements were chosen based on the aspects of the use cases that the working group considered most important, while considering the scope of the OWL charter and other design constraints. As such, one should not assume that OWL will directly support every aspect of the use cases.
A web portal is a web site that provides information content on a common topic, for example a specific city or domain of interest. A web portal allows individuals that are interested in the topic to receive news, find and talk to one another, build a community, and find links to other web resources of common interest.
In order for a portal to be successful, it must be a starting place for locating interesting content. Typically this content is submitted by members of the community, who often index it under some subtopic. Another means of collecting content relies on the content providers tagging the content with information that can be used in syndicating it. Typically, this takes the form of simple metatags that identify the topic of the content, etc.
However, a simple index of subject areas may not provide the community with sufficient ability to search for the content that its members require. In order to allow more intelligent syndication, web portals can define an ontology for the community. This ontology can provide a terminology for describing content and axioms that define terms using other terms from the ontology. For example, an ontology might include terminology such as "journal paper," "publication," "person," and "author." This ontology could include definitions that state things such as "all journal papers are publications" or "the authors of all publications are people." When combined with facts, these definitions allow other facts that are necessarily true to be inferred. These inferences can, in turn, allow users to obtain search results from the portal that are impossible to obtain from conventional retrieval systems. Such a technique relies on content providers using the web ontology language to capture high-quality ontology relationships, and an objective of OWL is to enable sufficiently rich and useful metadata content to motivate the necessary effort. It is a separate challenge to minimize this effort and an ontology language will likely have a greater impact if it can facilitate metadata capture as an nonintrusive part of any information creation process.
One example of an ontology based portal is OntoWeb. This portal serves the academic and industry community that is interested in ontology research. Another example of a portal that uses Semantic Web technologies and could benefit from an ontology language is The Open Directory Project; a large, comprehensive human-edited directory of the Web. It is constructed and maintained by a vast, global community of volunteer editors. RDF dumps of the Open Directory database are available for download.
Ontologies can be used to provide semantic annotations for collections of images, audio, or other non-textual objects. It is even more difficult for machines to extract meaningful semantics from multimedia than it is to extract semantics from natural language text. Thus, these types of resources are typically indexed by captions or metatags. However, since different people can describe these non-textual objects in different ways, it is important that the search facilities go beyond simple keyword matching. Ideally, the ontologies would capture additional knowledge about the domain that can be used to improve retrieval of images.
Multimedia ontologies can be of two types: media-specific and content-specific. Media specific ontologies could have taxonomies of different media types and describe properties of different media. For example, video may include properties to identify length of the clip and scene breaks. Content-specific ontologies could describe the subject of the resource, such as the setting or participants. Since such ontologies are not specific to the media, they could be reused by other documents that deal with the same domain. Such reuse would enhance search that was simply looking for information on a particular subject, regardless of the format of the resource. Searches where media type was important could combine the media-specific and content-specific ontologies.
As an example of a multimedia collection, consider an archive of images of antique furniture. An ontology of antique furniture would be of great use in searching such an archive. A taxonomy can be used to classify the different types of furniture. It would also be useful if the ontology could express definitional knowledge. For example, if an indexer selects the value "Late Georgian" for the style/period of (say) an antique chest of drawers, it should be possible to infer that the data element "date.created" should have a value between 1760 and 1811 A.D. and that the "culture" is British. Availability of this type of background knowledge significantly increases the support that can be given for indexing as well as for search. Another feature that could be useful is support for the representation of default knowledge. An example of such knowledge would be that a "Late Georgian chest of drawers," in the absence of other information, would be assumed to be made of mahogany. This knowledge is crucial for real semantic queries, e.g. a user query for "antique mahogany storage furniture" could match with images of Late Georgian chests of drawers, even if nothing is said about wood type in the image annotation.
Large corporations typically have numerous web pages concerning things like press releases, product offerings and case studies, corporate procedures, internal product briefings and comparisons, white papers, and process descriptions. Ontologies can be used to index these documents and provide better means of retrieval. Although many large organizations have a taxonomy for organizing their information, this is often insufficient. A single ontology is often limiting because the constituent categories are likely constrained to those representing one view and one granularity of a domain; the ability to simultaneously work with multiple ontologies would increase the richness of description. Furthermore, the ability to search on values for different parameters is often more useful than a keyword search with taxonomies.
An ontology-enabled web site may be used by:
A typical problem for each of these types of users is that they may not share terminology with the authors of the desired content. The salesperson may not know the technical name for a desired feature or technical people in different fields might use different terms for the same concept. For such problems, it would be useful for each class of user to have different ontologies of terms, but have each ontology interrelated so translations can be performed automatically.
Another problem is framing queries at the right level of abstraction. A project leader looking for someone with expertise in operating systems should be able to locate an employee who is an expert with both Unix and Windows.
One aspect of a large service organization is that it may have a very broad set of capabilities. But when pursuing large contracts these capabilities sometimes need to be assembled in new ways. There will often be no previous single matching project. A challenge is to reason about how past templates and documents can be reassembled in new configurations, while satisfying a diverse set of preconditions.
This use case is for a large body of engineering documentation, such as that used by the aerospace industry. This documentation can be of several different types, including design documentation, manufacturing documentation, and testing documentation. These document sets each have a hierarchical structure, but the structures differ between the sets. There is also a set of implied axes which cross-link the documentation sets: for example, in aerospace design documents, an item such as a wing spar might appear in each.
Ontologies can be used to build an information model which allows the exploration of the information space in terms of the items which are represented, the associations between the items, the properties of the items, and the links to documentation which describes and defines them (i.e., the external justification for the existence of the item in the model). That is to say that the ontology and taxonomy are not independent of the physical items they represent, but may be developed/explored in tandem.
A concrete example of this use case is design documentation for the aerospace domain, where typical users include:
To support this kind of usage, it is important that constraints can be defined. These constraints may be used to enhance search or check consistency. An example of a constraint might be:
biplane(X) => CardinalityOf(wing(X)) = 2 wingspar(X) AND wing(Y) AND isComponentOf(X,Y) => length(X) < length(Y)
Another common use of this kind of ontology is to support the visualization and editing of charts which show snapshots of the information space centered on a particular concept (e.g., a class or instance). These are typically activity/rule diagrams or entity-relationship diagrams.
The Semantic Web can provide agents with the capability to understand and integrate diverse information resources. A specific example is that of a social activities planner, which can take the preferences of a user (such as what kinds of films they like, what kind of food they like to eat, etc.) and use this information to plan the user's activities for an evening. The task of planning these activities will depend upon the richness of the service environment being offered and the needs of the user. During the service determination / matching process, ratings and review services may also be consulted to find closer matches to user preferences (for example, consulting reviews and rating of films and restaurants to find the "best").
This type of agent requires domain ontologies that represent the terms for restaurants, hotels, etc. and service ontologies to represent the terms used in the actual services. These ontologies will enable the capture of information necessary for applications to discriminate and balance among user preferences. Such information may be provided by a number of sources, such as portals, service-specific sites, reservation sites and the general Web.
Agentcities is an example of an initiative that is exploring the use of agents in a distributed service environment across the Internet. This will involve building a network of agent platforms that represent real or virtual cities, such as San Francisco or the Bay Area, and populating them with the services of those cities. Initially, these services will be oriented towards business to consumer services, such as hotels, restaurants, entertainment, etc., but eventually, they will be expanded to include business to business services, such as payroll, and business to enterprise services.This will require a number of different domain and service ontologies: Key issues include:
Ubiquitous computing is an emerging paradigm of personal computing, characterized by the shift from dedicated computing machinery to pervasive computing capabilities embedded in our everyday environments. Characteristic to ubiquitous computing are small, handheld, wireless computing devices. The pervasiveness and the wireless nature of devices require network architectures to support automatic, ad hoc configuration. An additional reason for development of automatic configuration is that this technology is aimed at ordinary consumers.
A key technology of true ad hoc networks is service discovery, functionality by which "services" (i.e., functions offered by various devices such as cell phones, printers, sensors, etc.) can be described, advertised, and discovered by others. All of the current service discovery and capability description mechanisms (e.g., Sun's JINI, Microsoft's UPnP) are based on ad hoc representation schemes and rely heavily on standardization (i.e., on a priori identification of all those things one would want to communicate or discuss).
The key issue (and goal) of ubiquitous computing is "serendipitous interoperability," interoperability under "unchoreographed" conditions, i.e., devices which weren't necessarily designed to work together (such as ones built for different purposes, by different manufacturers, at a different time, etc.) should be able to discover each others' functionality and be able to take advantage of it. Being able to "understand" other devices, and reason about their services/functionality is necessary, since full-blown ubiquitous computing scenarios will involve dozens if not hundreds of devices, and a priori standardizing the usage scenarios is an unmanageable task.
The interoperation scenarios are dynamic in nature (i.e., devices appear and disappear at any moment as their owners carry them from one room or building to another) and do not involve humans in the loop as far as (re-)configuration is concerned. The tasks involved in the utilization of services involve discovery, contracting, and composition. The contracting of services may involve representing information about security, privacy and trust, as well as about compensation-related details (the provider of a service may have to be compensated for services rendered). In particular, it is a goal that corporate or organizational security policies be expressed in application-neutral form, thus enabling constraint representation across the diversity of enforcement mechanisms (e.g., firewalls, filters/scanners, traffic monitors, application-level routers and load-balancers).
Thus, an ontology language will be used to describe the characteristics of devices, the means of access to such devices, the policy established by the owner for use of a device, and other technical constraints and requirements that affect incorporating a device into a ubiquitous computing network. The needs established for DAML-S (particularly the issues surrounding the expressiveness of the language) and the RDF-based schemes for representing information about device characteristics (namely, W3C's Composite Capability/Preference Profile (CC/PP) and WAP Forum's User Agent Profile or UAProf) directly relate to this use case and the resource infrastructure which will support applications which will negotiate and dynamically configure ad hoc networks.
Design goals describe general motivations for the language that do not necessarily result from any single use case. Along with the Use Cases, these motivate the Requirements and Objectives in Sections 4 and 5. In this section, we describe eight design goals for the web ontology language, in particular those dealing with:
For each goal, we describe the tasks it supports and explain the rationale for the goal. We also describe the degree to which RDF and RDF Schema supports the goal.
Ontologies should be publicly available and different data sources should be able to commit to the same ontology for shared meaning. Also, ontologies should be able to extend other ontologies in order to provide additional definitions.
Supported Tasks:
Any use case in which distributed data sources use shared
terminology.
Justification:
Interoperability requires agreements on the definitions of
identifiers. Ontologies can provide standard sets of identifiers and formal
descriptions of those identifiers. Data sources that commit to the same
ontology explicitly agree to use the same identifiers with the same
meanings.
Often, shared ontologies are not sufficient. An organization may find that an existing ontology provides 90% of what it needs, but the remaining 10% is critical. In such cases, the organization should not have to create a new ontology from scratch, but instead be able to create an ontology which extends an existing ontology and adds any desired identifiers and definitions.
RDF(S) Support:
In RDF, each schema has its own namespace identified by a URI.
Each resource in the schema has an ID, and a globally unique
identifier can be created by combining the ID with the
URI of the namespace. Any resource that uses this URI
references the term as defined in that schema. However, RDF is
unclear on the definition of a term that has partial definitions
in multiple schemas. The specification appears to assume that the
definition is the union of all descriptions that use the same
identifier, regardless of source. However, this may lead to
problems in a distributed environment, where some schemas may
contain incorrect or false definitions. There is no way in RDF
for a resource to indicate which set of definitions it agrees
to.
An ontology may change during its lifetime. A data source should specify the version of an ontology to which it commits.
An important issue is whether or not documents that commit to one version of an ontology are compatible with those that commit to another. Both compatible and incompatible revisions should be allowed, but it should be possible to distinguish between the two. Note that since formal descriptions only provide approximations for the meanings of most identifiers, it is possible for a revision to change the intended meaning of an identifier without changing its formal description. Thus determining semantic backwards-compatibility requires more than a simple comparison of term descriptions. As such, the ontology author needs to be able to indicate such changes explicitly.
Supported Tasks:
Any use case in which the ontology could potentially change,
and in particular those in which the owner of the ontology is
different from the data providers.
Justification:
Since the Web is constantly growing and changing, we must
expect ontologies to change as well. Ontologies may need to
change because there were errors in prior versions, because a new
way of modeling the domain is preferred, or because
new terminology has been created (e.g.,
as the result of the invention of new technology). A web ontology
language must be able to accommodate ontology revision. Note that
ontology evolution is different from ontology extension, which
does not change the original ontology.
RDF(S) Support:
The RDF Schema Specification recommends that each version of a
schema should be a separate resource with its own URI. The
rdfs:subClassOf and rdfs:subPropertyOf properties can be used to
relate new versions of classes and properties to older versions.
However, this has the drawback that incorrect definitions cannot
be retracted. For example, assume that in schema v1, v1:Dolphin
is a rdfs:subClassOf v1:Fish. When this mistake is noticed, the
new version of the schema, v2, says that v2:Dolphin is a
rdfs:subClassOf v2:Mammal. However, if we make v2:Dolphin a
rdfs:subClassOf v1:Dolphin, then we also say that v2:Dolphin is
an rdfs:subClassOf v1:Fish which perpetuates the error.
Different ontologies may model the same concepts in different ways. The language should provide primitives for relating different representations, thus allowing data to be converted to different ontologies and enabling a "web of ontologies."
Supported Tasks:
Any use case in which data from different providers with
different terminologies must be integrated.
Justification:
Although shared ontologies and ontology extension allow a
certain degree of interoperability between different
organizations and domains, there are often cases where there are
multiple ways to model the same information. This may be due to
differences in the perspectives of different organizations,
different professions, different nationalities, etc. In order for
machines to be able to integrate information that commits to
heterogeneous ontologies, there need to be primitives that allow
ontologies to map concepts to their equivalents in other ontologies.
RDF(S) Support:
RDF provides minimal support for interoperability by means of
the rdfs:subClassOf and rdfs:subPropertyOf properties.
Different ontologies or data sources may be contradictory. It should be possible to detect these inconsistencies.
Supported Tasks:
Any use cases in which decentralization of data and lack of
controlling authority can lead to conflicts in the data. Any
ontology extension task that may result in incoherent
descriptions (possibly by extending an ontology in a way that
generated an over constrained concept).
Justification:
The Web is decentralized, allowing anyone to say anything. As
a result, different viewpoints may be contradictory, or even
false information may be provided. In order to prevent agents
from combining incompatible data or from taking consistent data
and evolving it into an inconsistent state, it is important that
inconsistencies can be detected automatically.
RDF(S) Support:
RDF and RDFS do not allow inconsistencies to be expressed.
The language should be able to express a wide variety of knowledge, but should also provide for efficient means to reason with it. Since these two requirements are typically at odds, the goal of the web ontology language is to find a balance that supports the ability to express the most important kinds of knowledge.
Supported Tasks:
Any use case that uses large ontologies or large data sets and
requires the representation of diverse knowledge.
Justification:
There are over one billion pages on the Web, and the potential
application of the Semantic Web to embedded devices and agents
poses even larger amounts of information that must be handled.
The web ontology language should support reasoning systems that scale
well. However, the language should also be as expressive
as possible, so that users can state the kinds of knowledge that
is important to their applications.
Expressivity determines what can be said in the language, and thus determines its inferential power and what reasoning capabilities should be expected in systems that fully implement it. An expressive language contains a rich set of primitives that allow a wide variety of knowledge to be formalized. A language with too little expressivity will provide too few reasoning opportunities to be of much use and may not provide any contribution over existing languages.
RDF(S) Support:
RDF is very scalable (with the exception of the XML syntax
being extremely verbose) but is not very expressive.
The language should provide a low learning barrier and have clear concepts and meaning. The concepts should be independent from syntax.
Supported Tasks:
Markup and querying of semantic web documents by users, either
directly or indirectly.
Justification:
Although ideally most users will be isolated from the language
by front end tools, the basic philosophy of the language must be
natural and easy to learn. Furthermore, early adopters, tool
developers, and power users may work directly with the syntax,
meaning human readable (and writable) syntax is desirable.
RDF(S) Support:
RDF is fairly easy to use, but RDF Schema is more complex. The
syntax appears to be a major barrier for many.
The language should be compatible with other commonly used Web and industry standards. In particular, this includes XML and related standards (such as XML Schema and RDF), and possibly other modeling standards such as UML.
Supported Tasks:
Exchange of ontologies and data in a standard format.
Justification:
Compatibility with other standards eases tool
development and deployment of the language.
RDF(S) Support:
RDF has an XML serialization syntax [RDF Syntax].
The language should support the development of multilingual ontologies, and potentially provide different views of ontologies that are appropriate for different cultures.
Supported Tasks:
Tasks where the same ontology is used by multiple countries or
cultures.
Justification:
The Web is an international tool. The Semantic Web should aid
in the exchange of ideas and information between different
cultures, and should thus make it easy for members of different
nations to use the same ontologies.
RDF(S) Support:
To the extent that XML supports internationalization, so does
RDF.
The use cases and design goals motivate a number of requirements for a web ontology language. The Working Group currently feels that the requirements described below are essential to the language. Each requirement includes a short description and is motivated by one or more design goals from the previous section.
Ontologies must be resources that have their own unique identifiers, such as a URI reference.
Motivation: Shared ontologies
Two concepts in different ontologies must have distinct absolute identifiers (although they may have identical relative identifiers). It must be possible to uniquely identify a concept in an ontology using a URI reference.
Motivation: Shared ontologies, Ontology interoperability
Ontologies must be able to explicitly extend other ontologies in order to reuse concepts while adding new classes and properties. Ontology extension must be a transitive relation; if ontology A extends ontology B, and ontology B extends ontology C, then ontology A implicitly extends ontology C as well.
Motivation: Shared ontologies
Resources must be able to explicitly commit to specific ontologies, indicating precisely which set of definitions and assumptions are made.
Motivation: Shared ontologies
It must be possible to provide meta-data for each ontology, such as author, publish-date, etc. These properties may or may not be borrowed from the Dublin Core element set.
Motivation: Shared ontologies
The language must provide features for comparing and relating different versions of the same ontology. This should include features for relating revisions to prior versions, explicit statements of backwards-compatibility, and the ability to deprecate identifiers (i.e., to state they are available for backwards-compatibility only, and should not be used in new applications/documents.)
Motivation: Ontology evolution
The language must be able to express complex definitions of classes. This includes, but is not limited to, sub classing and Boolean combinations of class expressions (i.e., intersection, union, and complement).
Motivation: Balance of expressivity and scalability, Ontology interoperability, Inconsistency detection
The language must be able to express the definitions of properties. This includes, but is not limited to, sub properties, domain and range constraints, transitivity, and inverse properties.
Motivation: Balance of expressivity and scalability, Ontology interoperability, Inconsistency detection
The language must provide a set of standard data types. These data types may be based on XML Schema data types [XML-SCHEMA2].
Motivation: Compatibility with other standards, Ease of use
The language must include features for stating that two classes or properties are equivalent.
Motivation: Ontology interoperability
The language must include features for stating that pairs of identifiers represent the same individual (note that consistent with the terminology used in other OWL documents, an individual here is any instance of an OWL class, and does not necessarily mean a person). Due to the distributed nature of the Web, it is likely that different identifiers will be assigned to the same individual. The use of a standard URL does not solve this problem, because some individuals may have multiple URLs, such as a person who has home and work web pages or e-mail addresses.
Motivation: Ontology interoperability
The language must provide a way to allow statements to be "tagged" with additional information such as source, timestamp, confidence level, etc. The language need not provide a standard set of properties that can be used in this way, but should instead provide a general mechanism for users to attach such information. RDF reification may be one possible way to accommodate the requirement, although reification is a somewhat controversial feature.
Motivation: Shared ontologies, Ontology interoperability
The language must support the ability to treat classes as instances. This is because the same concept can often be seen as a class or an individual, depending on the perspective of the user. For example, in a biological ontology, the class Orangutan may have individual animals as its instances. However, the class Orangutan may itself be an instance of the class Species. Note, that Orangutan is not a subclass of Species, because then that would say that each instance of Orangutan (an animal) is an instance of Species.
Motivation: Ontology interoperability
The language must support the specification of cardinality restrictions on properties. These restrictions set minimum and maximum numbers of individuals that any single individual can be related to via the specified property.
Motivation: Balance of expressivity and scalability goal,, Inconsistency detection
The language should have an XML serialization syntax. XML has become widely accepted by industry and numerous tools for processing XML have been developed. If the web ontology language has an XML syntax, then these tools can be extended and reused.
Motivation: Compatibility with other standards
The language should support the specification of multiple alternative user-displayable labels for the resources specified by an ontology. This can be used, for example, to view the ontology in different natural languages.
Motivation: Internationalization, Ease of use
The language should support the use of multilingual character sets.
Motivation: Internationalization, Compatibility with other standards
In some character encodings, e.g. Unicode based encodings, there are some cases where two different character sequences look the same and are expected, by most users, to compare equal. An example is one using a pre-composed form (just one c-cedilla character) and another using a decomposed form (a 'c' character followed by a cedilla accent character). Given that the W3C I18N WG has decided that early uniform normalization (to Unicode Normal Form C) as the usual approach to solving this problem, any other solution needs to be justified.
Motivation: Internationalization, Compatibility with other standards
In addition to the set of features that should be in the language (as defined in the previous section), there are other features that would be useful for many use cases. These features will be addressed by the working group if possible, but the group may decide that there are good reasons for excluding them from the language or for leaving them to be implemented by a later working group. Some of these objectives are not fully defined, and as such need further clarification if they are to be addressed by the language. Note that the order of the objectives below does not imply relative priority or degree of consensus.
The language may support different levels of complexity for defining ontologies. Applications can conform to a particular layer without supporting the entire language. A guideline for identifying layers may be based on functionality found in different types of database and knowledge base systems.
Motivation: Balance of expressivity and scalability
The language should support the specification of default values for properties. Such values could be used to make inferences about typical members of classes. However, true default values (such as those used in defeasible inheritance reasoning) are nonmonotonic, which can be problematic on the Web where new information is constantly being discovered or added. Furthermore, there is no commonly accepted method for dealing with defaults. An alternative is for the language specification to recommend to users how they can create their own default mechanisms.
Motivation: Balance of expressivity and scalability
Due to the size and rate of change on the Web, the closed-world assumption (which states that anything that cannot be inferred is assumed to be false) is inappropriate. However, there are many situations where closed-world information would be useful. Therefore, the language must be able to state that a given ontology can be regarded as complete. This would then sanction additional inferences to be drawn from that ontology. The precise semantics of such a statement (and the corresponding set of inferences) remains to be defined, but examples might include assuming complete property information about individuals, assuming completeness of class-membership, and assuming exhaustiveness of subclasses.
Motivation: Shared ontologies, Inconsistency detection
The language should support the ability to specify ranges of values for properties. This mechanism may borrow from XML Schema data types [XML-SCHEMA2].
Motivation: Inconsistency detection
The language may support the composition of properties in statements about classes and properties. An example of the use of property composition would be the assertion that a property called uncleOf is the same as the composition of the fatherOf and brotherOf properties.
Motivation: Balance of expressivity and scalability
The language should be decidable.
Motivation: Balance of expressivity and scalability
The language should support the ability to commit to portions of an ontology, as well as committing to an entire ontology. However, it is unclear what granularity should be used here. Possible choices are to choose a subset of concepts with their entire definitions, or to choose individual pieces of definitions. Note that borrowing partial definitions of concepts must address the potential interoperability problems that can arise since different applications will be using the same identifier to mean different things.
Motivation: Shared ontologies
The language should support the ability to create ontology views, in which subsets of an ontology can be specified or concepts can be assigned alternate names. This is particularly useful in developing multicultural versions of an ontology. Note that this requirement may be satisfied by having multiple ontologies and using an ontology mapping mechanism.
Motivation: Internationalization, Ontology interoperability
The W3C XML Digital Signature specification is an important building block for communication among untrusted properties, which is important for many ontology applications. The web ontology language should be designed in a way that makes it straightforward to use XML Signatures.
Motivation: Compatibility with other standards
The language should support the use of arithmetic functions. These can be used in translating between different units of measure.
Motivation: Ontology interoperability
The language should support string concatenation and simple pattern matching. These features can be used to establish interoperability between ontologies that treat complex information as a formatted string and those that have separate properties for each component. For example, one ontology may represent an e-mail address as a single string, while another may divide it into a string for user name and a string for server name. To integrate the two ontologies, one would need to specify that the concatenation of the user name, the '@' character, and the server name is equivalent to the single value used in the first ontology.
Motivation: Ontology interoperability
The language should support the ability to aggregate information in a way similar to SQL's GROUP BY clause. It should allow counts, sums, and other operations to be computed for each group. This would allow interoperability between ontologies that represented information at different levels of granularity, and could relate things such as budget category totals to budget line item amounts, or the number of personnel to individual data on employees.
Motivation: Ontology interoperability
The language should support the use of executable code to evaluate complex criteria. Procedural attachments greatly extend the expressivity of the language, but are not well-suited to formal semantics. A procedural attachment mechanism for web ontologies should specify how to locate and execute the procedure. One potential candidate language would be Java, which is already well-suited to intra-platform sharing on the Web.
Motivation: Ontology interoperability
In general, the language will not make a unique names assumption. That is, distinct identifiers are not assumed to refer to different individuals (see Requirement R11). However, there are many applications where the unique names assumption would be useful. Users should have the option of specifying that all of the names in a particular namespace or document refer to distinct individuals.
Motivation: Inconsistency detection
The language should support the definition and use of complex / structured data types. These may be used to specify dates, coordinate pairs, addresses, etc.
Motivation: Compatibility with other standards, Ease of use
Changes since Proposed Recommendation are listed in reverse chronological order.
Raphael Volz and Jonathan Dale made significant authorial contributions to this document, and along with the current editor, were co-editors of the initial working drafts. The initial effort to identify design goals and requirements was co-led by Deborah McGuinness and the editor. Some of the requirements were directly contributed by Dr. McGuinness [DWM] based upon over a decade of work in building ontology-based systems. Other requirements were identified as part of the editor's Ph.D. thesis work in building a prototype Semantic Web system [Hef]. A draft version of the Corporate Web Site Management section was written by Michael Smith.
The content of this document is the result of extensive discussions within the Web Ontology Working Group as a whole. The participants in this working group included: Yasser alSafadi, Jean-François Baget, James Barnette, Sean Bechhofer, Jonathan Borden, Stephen Buswell, Jeremy Carroll, Dan Connolly, Peter Crowther, Jonathan Dale, Jos De Roo, David De Roure, Mike Dean, Larry Eshelman, Jérôme Euzenat, Tim Finin, Nicholas Gibbins, Sandro Hawke, Patrick Hayes, Jeff Heflin, Ziv Hellman, James Hendler, Bernard Horan, Masahiro Hori, Ian Horrocks, Jane Hunter, Ruediger Klein, Natasha Kravtsova, Ora Lassila, Deborah McGuinness, Enrico Motta, Leo Obrst, Mehrdad Omidvari, Martin Pike, Marwan Sabbouh, Guus Schreiber, Noboru Shimizu, Michael K. Smith, John Stanton, Lynn Andrea Stein, Herman ter Horst, David Trastour, Frank van Harmelen, Bernard Vatant, Raphael Volz, Evan Wallace, Christopher Welty, Charles White, Frederik Brysse, Francesco Iannuzzelli, Massimo Marchiori, Michael Sintek and John Yanosy.


public static interface SoyTofu.Renderer
Important: If you're a user of Soy, you should use the methods here (on a Renderer object created by Soy), but should not create your own implementations of this interface.
| Modifier and Type | Method and Description |
|---|---|
String |
render()
Renders the template using the data, injected data, and message bundle previously set.
|
void |
render(Appendable out)
Renders the template using the data, injected data, and message bundle previously set
into the given Appendable.
|
SanitizedContent |
renderStrict()
Renders the strict-mode template as a SanitizedContent object, which can be used as an input
to another Soy template, or used to verify that the output type is correct.
|
SoyTofu.Renderer |
setActiveDelegatePackageNames(Set<String> activeDelegatePackageNames)
Sets the set of active delegate package names.
|
SoyTofu.Renderer |
setContentKind(SanitizedContent.ContentKind contentKind)
Sets the expected content kind.
|
SoyTofu.Renderer |
setCssRenamingMap(SoyCssRenamingMap cssRenamingMap)
Sets the CSS renaming map.
|
SoyTofu.Renderer |
setData(Map<String,?> data)
Sets the data to call the template with.
|
SoyTofu.Renderer |
setData(SoyRecord data)
Sets the data to call the template with.
|
SoyTofu.Renderer |
setDontAddToCache(boolean dontAddToCache)
If set to true, indicates that we should not add the current combination of
SoyMsgBundle and SoyCssRenamingMap to the cache if it's not already there. |
SoyTofu.Renderer |
setIdRenamingMap(SoyIdRenamingMap idRenamingMap)
Sets the ID renaming map.
|
SoyTofu.Renderer |
setIjData(Map<String,?> ijData)
Sets the injected data to call the template with.
|
SoyTofu.Renderer |
setIjData(SoyRecord ijData)
Sets the injected data to call the template with.
|
SoyTofu.Renderer |
setMsgBundle(SoyMsgBundle msgBundle)
Sets the bundle of translated messages, or null to use the messages from the Soy source.
|
SoyTofu.Renderer setData(Map<String,?> data)
Note: If you call this method instead of setData(SoyRecord)
, your template data
will be converted to a SoyMapData
object on each call. This may not be a big deal if
you only need to use the data object once. But if you need to reuse the same data object for
multiple calls, it's more efficient to build your own SoyRecord
object and reuse it
with setData(SoyRecord)
.
SoyTofu.Renderer setData(SoyRecord data)
SoyTofu.Renderer setIjData(Map<String,?> ijData)
Note: If you call this method instead of setIjData(SoyRecord)
, the data
will be converted to a SoyRecord
object on each call. This may not be a big deal if
you only need to use the data object once. But if you need to reuse the same data object for
multiple calls, it's more efficient to build your own SoyRecord
object and reuse it
with setIjData(SoyRecord)
.
SoyTofu.Renderer setIjData(SoyRecord ijData)
SoyTofu.Renderer setActiveDelegatePackageNames(Set<String> activeDelegatePackageNames)
SoyTofu.Renderer setMsgBundle(SoyMsgBundle msgBundle)
SoyTofu.Renderer setIdRenamingMap(SoyIdRenamingMap idRenamingMap)
SoyTofu.Renderer setCssRenamingMap(SoyCssRenamingMap cssRenamingMap)
SoyTofu.Renderer setDontAddToCache(boolean dontAddToCache)
SoyMsgBundle
and SoyCssRenamingMap
to the cache if it's not already there.
Only applicable when the associated SoyTofu
instance uses caching. Default value is
false, i.e. by default we always add to cache when not already present.
Specifically, if dontAddToCache
is set to true, then after checking the cache for
the current combination of SoyMsgBundle
and SoyCssRenamingMap
:
(a) if found in cache, we will use the cached intermediate results for faster rendering,
(b) if not found in cache, we will fall back to the no-caching method of rendering.
If your app uses many different SoyMsgBundle
s or SoyCssRenamingMap
s and
you're finding that the caching mode of SoyTofu
is using too much memory, one
strategy may be to first prime the cache with the most common combinations by calling
SoyTofu.addToCache(com.google.template.soy.msgs.SoyMsgBundle, com.google.template.soy.shared.SoyCssRenamingMap)
, and then when rendering, always setDontAddToCache(true)
.
This way, most of your renders will use the cached results, yet your cache will never grow
beyond the size that you initially primed it to be.
SoyTofu.Renderer setContentKind(SanitizedContent.ContentKind contentKind)
An attempt to render a non-strict template or a strict template with a different kind will fail if this has been called.
String render()
Checks the content kind of the template. Non-strict and kind="html" templates are allowed, unless setContentKind was called. The goal is to prevent accidental rendering of unescaped kind="text" in contexts where that could XSS.
SanitizedContent renderStrict()
This returns a SanitizedContent object corresponding to the kind="..." attribute of the template. The expected content kind must be set beforehand, unless HTML is expected, to avoid an exception.
IllegalArgumentException
- If the template is non-strict, or the kind doesn't match
the expected kind (from setContentKind, or the default of HTML).void render(Appendable out)
Checks the content kind of the template. Non-strict and kind="html" templates are allowed, unless setContentKind was called. The goal is to prevent accidental rendering of unescaped kind="text" in contexts where that could XSS.


- NAME
- expr - Evaluate an expression
- SYNOPSIS
- expr arg ?arg arg ...?
- DESCRIPTION
- OPERANDS
- OPERATORS
- - + ~ !
- * / %
- + -
- << >>
- < > <= >=
- == !=
- eq ne
- &
- ^
- |
- &&
- ||
- x?y:z
- MATH FUNCTIONS
- abs(arg)
- acos(arg)
- asin(arg)
- atan(arg)
- atan2(y, x)
- ceil(arg)
- cos(arg)
- cosh(arg)
- double(arg)
- exp(arg)
- floor(arg)
- fmod(x, y)
- hypot(x, y)
- int(arg)
- log(arg)
- log10(arg)
- pow(x, y)
- rand()
- round(arg)
- sin(arg)
- sinh(arg)
- sqrt(arg)
- srand(arg)
- tan(arg)
- tanh(arg)
- wide(arg)
- TYPES, OVERFLOW, AND PRECISION
- STRING OPERATIONS
- PERFORMANCE CONSIDERATIONS
- EXAMPLES
- SEE ALSO
- KEYWORDS
expr - Evaluate an expression
expr arg ?arg arg ...?
Concatenates args (adding separator spaces between them),
evaluates the result as a Tcl expression, and returns the value.
The operators permitted in Tcl expressions are a subset of
the operators permitted in C expressions, and they have the
same meaning and precedence as the corresponding C operators.
Expressions almost always yield numeric results
(integer or floating-point values).
For example, the expression
expr 8.2 + 6
evaluates to 14.2.
Tcl expressions differ from C expressions in the way that
operands are specified. Also, Tcl expressions support
non-numeric operands and string comparisons.
A Tcl expression consists of a combination of operands, operators,
and parentheses.
White space may be used between the operands and operators and
parentheses; it is ignored by the expression's instructions.
Where possible, operands are interpreted as integer values.
Integer values may be specified in decimal (the normal case), in octal (if the
first character of the operand is 0), or in hexadecimal (if the first
two characters of the operand are 0x).
If an operand does not have one of the integer formats given
above, then it is treated as a floating-point number if that is
possible. Floating-point numbers may be specified in any of the
ways accepted by an ANSI-compliant C compiler (except that the
f, F, l, and L suffixes will not be permitted in
most installations). For example, all of the
following are valid floating-point numbers: 2.1, 3., 6e4, 7.91e+16.
If no numeric interpretation is possible (note that all literal
operands that are not numeric or boolean must be quoted with either
braces or with double quotes), then an operand is left as a string
(and only a limited set of operators may be applied to it).
On 32-bit systems, integer values MAX_INT (0x7FFFFFFF) and MIN_INT
(-0x80000000) will be represented as 32-bit values, and integer values
outside that range will be represented as 64-bit values (if that is
possible at all.)
Operands may be specified in any of the following ways:
- [1]
-
As a numeric value, either integer or floating-point.
- [2]
-
As a boolean value, using any form understood by string is boolean.
- [3]
-
As a Tcl variable, using standard $ notation.
The variable's value will be used as the operand.
- [4]
-
As a string enclosed in double-quotes.
The expression parser will perform backslash, variable, and
command substitutions on the information between the quotes,
and use the resulting value as the operand
- [5]
-
As a string enclosed in braces.
The characters between the open brace and matching close brace
will be used as the operand without any substitutions.
- [6]
-
As a Tcl command enclosed in brackets.
The command will be executed and its result will be used as
the operand.
- [7]
-
As a mathematical function whose arguments have any of the above
forms for operands, such as sin($x). See below for a list of defined
functions.
Where the above substitutions occur (e.g. inside quoted strings), they
are performed by the expression's instructions.
However, the command parser may already have performed one round of
substitution before the expression processor was called.
As discussed below, it is usually best to enclose expressions
in braces to prevent the command parser from performing substitutions
on the contents.
For some examples of simple expressions, suppose the variable
a has the value 3 and
the variable b has the value 6.
Then the command on the left side of each of the lines below
will produce the value on the right side of the line:
expr 3.1 + $a 6.1
expr 2 + "$a.$b" 5.6
expr 4*[llength "6 2"] 8
expr {{word one} < "word $a"} 0
The valid operators are listed below, grouped in decreasing order
of precedence:
- - + ~ !
-
Unary minus, unary plus, bit-wise NOT, logical NOT. None of these operators
may be applied to string operands, and bit-wise NOT may be
applied only to integers.
- * / %
-
Multiply, divide, remainder. None of these operators may be
applied to string operands, and remainder may be applied only
to integers.
The remainder will always have the same sign as the divisor and
an absolute value smaller than the divisor.
- + -
-
Add and subtract. Valid for any numeric operands.
- << >>
-
Left and right shift. Valid for integer operands only.
A right shift always propagates the sign bit.
- < > <= >=
-
Boolean less, greater, less than or equal, and greater than or equal.
Each operator produces 1 if the condition is true, 0 otherwise.
These operators may be applied to strings as well as numeric operands,
in which case string comparison is used.
- == !=
-
Boolean equal and not equal. Each operator produces a zero/one result.
Valid for all operand types.
- eq ne
-
Boolean string equal and string not equal. Each operator produces a
zero/one result. The operand types are interpreted only as strings.
- &
-
Bit-wise AND. Valid for integer operands only.
- ^
-
Bit-wise exclusive OR. Valid for integer operands only.
- |
-
Bit-wise OR. Valid for integer operands only.
- &&
-
Logical AND. Produces a 1 result if both operands are non-zero,
0 otherwise.
Valid for boolean and numeric (integers or floating-point) operands only.
- ||
-
Logical OR. Produces a 0 result if both operands are zero, 1 otherwise.
Valid for boolean and numeric (integers or floating-point) operands only.
- x?y:z
-
If-then-else, as in C. If x
evaluates to non-zero, then the result is the value of y.
Otherwise the result is the value of z.
The x operand must have a boolean or numeric value.
See the C manual for more details on the results
produced by each operator.
All of the binary operators group left-to-right within the same
precedence level. For example, the command
expr 4*2 < 7
returns 0.
The &&, ||, and ?: operators have ``lazy
evaluation'', just as in C,
which means that operands are not evaluated if they are
not needed to determine the outcome. For example, in the command
expr {$v ? [a] : [b]}
only one of [a] or [b] will actually be evaluated,
depending on the value of $v. Note, however, that this is
only true if the entire expression is enclosed in braces; otherwise
the Tcl parser will evaluate both [a] and [b] before
invoking the expr command.
Tcl supports the following mathematical functions in expressions, all
of which work solely with floating-point numbers unless otherwise noted:
abs cosh log sqrt
acos double log10 srand
asin exp pow tan
atan floor rand tanh
atan2 fmod round wide
ceil hypot sin
cos int sinh
- abs(arg)
-
Returns the absolute value of arg. Arg may be either
integer or floating-point, and the result is returned in the same form.
- acos(arg)
-
Returns the arc cosine of arg, in the range [0,pi]
radians. Arg should be in the range [-1,1].
- asin(arg)
-
Returns the arc sine of arg, in the range [-pi/2,pi/2]
radians. Arg should be in the range [-1,1].
- atan(arg)
-
Returns the arc tangent of arg, in the range [-pi/2,pi/2]
radians.
- atan2(y, x)
-
Returns the arc tangent of y/x, in the range [-pi,pi]
radians. x and y cannot both be 0. If x is greater
than 0, this is equivalent to atan(y/x).
- ceil(arg)
-
Returns the smallest integral floating-point value (i.e. with a zero
fractional part) not less than arg.
- cos(arg)
-
Returns the cosine of arg, measured in radians.
- cosh(arg)
-
Returns the hyperbolic cosine of arg. If the result would cause
an overflow, an error is returned.
- double(arg)
-
If arg is a floating-point value, returns arg, otherwise converts
arg to floating-point and returns the converted value.
- exp(arg)
-
Returns the exponential of arg, defined as e**arg.
If the result would cause an overflow, an error is returned.
- floor(arg)
-
Returns the largest integral floating-point value (i.e. with a zero
fractional part) not greater than arg.
- fmod(x, y)
-
Returns the floating-point remainder of the division of x by
y. If y is 0, an error is returned.
- hypot(x, y)
-
Computes the length of the hypotenuse of a right-angled triangle
sqrt(x*x+y*y).
- int(arg)
-
If arg is an integer value of the same width as the machine
word, returns arg, otherwise
converts arg to an integer (of the same size as a machine word,
i.e. 32-bits on 32-bit systems, and 64-bits on 64-bit systems) by
truncation and returns the converted value.
- log(arg)
-
Returns the natural logarithm of arg. Arg must be a
positive value.
- log10(arg)
-
Returns the base 10 logarithm of arg. Arg must be a
positive value.
- pow(x, y)
-
Computes the value of x raised to the power y. If x
is negative, y must be an integer value.
- rand()
-
Returns a pseudo-random floating-point value in the range (0,1).
The generator algorithm is a simple linear congruential generator that
is not cryptographically secure. Each result from rand completely
determines all future results from subsequent calls to rand, so
rand should not be used to generate a sequence of secrets, such as
one-time passwords. The seed of the generator is initialized from the
internal clock of the machine or may be set with the srand function.
- round(arg)
-
If arg is an integer value, returns arg, otherwise converts
arg to integer by rounding and returns the converted value.
- sin(arg)
-
Returns the sine of arg, measured in radians.
- sinh(arg)
-
Returns the hyperbolic sine of arg. If the result would cause
an overflow, an error is returned.
- sqrt(arg)
-
Returns the square root of arg. Arg must be non-negative.
- srand(arg)
-
The arg, which must be an integer, is used to reset the seed for
the random number generator of rand. Returns the first random
number (see rand()) from that seed. Each interpreter has its own seed.
- tan(arg)
-
Returns the tangent of arg, measured in radians.
- tanh(arg)
-
Returns the hyperbolic tangent of arg.
- wide(arg)
-
Converts arg to an integer value at least 64-bits wide (by sign-extension
if arg is a 32-bit number) if it is not one already.
In addition to these predefined functions, applications may
define additional functions using Tcl_CreateMathFunc().
All internal computations involving integers are done with the C type
long, and all internal computations involving floating-point are
done with the C type double.
When converting a string to floating-point, exponent overflow is
detected and results in a Tcl error.
For conversion to integer from string, detection of overflow depends
on the behavior of some routines in the local C library, so it should
be regarded as unreliable.
In any case, integer overflow and underflow are generally not detected
reliably for intermediate results. Floating-point overflow and underflow
are detected to the degree supported by the hardware, which is generally
pretty reliable.
Conversion among internal representations for integer, floating-point,
and string operands is done automatically as needed.
For arithmetic computations, integers are used until some
floating-point number is introduced, after which floating-point is used.
For example,
expr 5 / 4
returns 1, while
expr 5 / 4.0
expr 5 / ( [string length "abcd"] + 0.0 )
both return 1.25.
Floating-point values are always returned with a ``.''
or an e so that they will not look like integer values. For
example,
expr 20.0/5.0
returns 4.0, not 4.
String values may be used as operands of the comparison operators,
although the expression evaluator tries to do comparisons as integer
or floating-point when it can,
except in the case of the eq and ne operators.
If one of the operands of a comparison is a string and the other
has a numeric value, the numeric operand is converted back to
a string using the C sprintf format specifier
%d for integers and %g for floating-point values.
For example, the commands
expr {"0x03" > "2"}
expr {"0y" < "0x12"}
both return 1. The first comparison is done using integer
comparison, and the second is done using string comparison after
the second operand is converted to the string 18.
Because of Tcl's tendency to treat values as numbers whenever
possible, it isn't generally a good idea to use operators like ==
when you really want string comparison and the values of the
operands could be arbitrary; it's better in these cases to use
the eq or ne operators, or
the string command instead.
Enclose expressions in braces for the best speed and the smallest
storage requirements.
This allows the Tcl bytecode compiler to generate the best code.
As mentioned above, expressions are substituted twice:
once by the Tcl parser and once by the expr command.
For example, the commands
set a 3
set b {$a + 2}
expr $b*4
return 11, not a multiple of 4.
This is because the Tcl parser will first substitute $a + 2 for
the variable b,
then the expr command will evaluate the expression $a + 2*4.
Most expressions do not require a second round of substitutions.
Either they are enclosed in braces or, if not,
their variable and command substitutions yield numbers or strings
that don't themselves require substitutions.
However, because a few unbraced expressions
need two rounds of substitutions,
the bytecode compiler must emit
additional instructions to handle this situation.
The most expensive code is required for
unbraced expressions that contain command substitutions.
These expressions must be implemented by generating new code
each time the expression is executed.
Define a procedure that computes an "interesting" mathematical
function:
proc calc {x y} {
expr { ($x*$x - $y*$y) / exp($x*$x + $y*$y) }
}
Convert polar coordinates into cartesian coordinates:
# convert from ($radius,$angle)
set x [expr { $radius * cos($angle) }]
set y [expr { $radius * sin($angle) }]
Convert cartesian coordinates into polar coordinates:
# convert from ($x,$y)
set radius [expr { hypot($y, $x) }]
set angle [expr { atan2($y, $x) }]
Print a message describing the relationship of two string values to
each other:
puts "a and b are [expr {$a eq $b ? {equal} : {different}}]"
Set a variable to whether an environment variable is both defined at
all and also set to a true boolean value:
set isTrue [expr {
[info exists ::env(SOME_ENV_VAR)] &&
[string is true -strict $::env(SOME_ENV_VAR)]
}]
Generate a random integer in the range 0..99 inclusive:
set randNum [expr { int(100 * rand()) }]
array, for, if, string, Tcl, while
arithmetic, boolean, compare, expression, fuzzy comparison
Copyright © 1993 The Regents of the University of California.
Copyright © 1994-2000 Sun Microsystems, Inc.
Copyright © 1995-1997 Roger E. Critchlow Jr.


Definition
Average maturity date estimated for barley using the Biophotothemal Time Scale (BPTS) (calendar day)
Method of calculation
The stop date for barley is estimated using the Biophotothemal Time Scale (BPTS), which uses relationships between the rate of development in barley and temperature and photoperiod (Williams, 1974). If the stop date is later than GDD2Stop (indicating that maturity is not reached before frost), then ‘STOPBarley’ is set to ‘-99’


Issues:
Spatnav can't put focus inside iframe (TODO: why?)
Once focus is inside (via e.g. 'tab' key), cannot move around due to preventDefault


Please type the word shown
Type Words
This is a word type game
Click Start When you are ready
Please type the word shown
START
0


WITNESS LIST Regulated Industries Committee (SUBCOMMITTEE ON Renewable Energy) March 16, 2005-12:00A HB 1565 For: Colburn, Kenneth (Primary Energy Holdings, LLC) Trucksess, Jeff (Fuel Cell Texas) Against: Oldham, Phillip (Texas Coalition for Competitive Electricity) Stansell, Wade (Association of Electric Companies of Texas) Williams, Mike (Texas Electric Cooperatives) Registering, but not testifying: For: Smith, Tom (Public Citizen) Against: Zion, Mark (Texas Public Power Association) On: Rabago, Karl (Texas Renewable EnergyIndustries Assoc.) HB 1671 For: Carrillo, Victor (Texas Energy Planning Council) Neff, Shirley (Americans for Solar Power) Smith, Kari (Powerlight Corporation) Williams, Mike (Texas Electric Cooperatives) Zion, Mark (Texas Public Power Association) Against: Oldham, Phillip (Texas Coalition for Competitive Electricity) On: Griffey, Charles (Reliant Energy) Parsley, Julie (Public Utility Commission) Saathoff, Kent (Electric Reliability Council of Texas) Smitherman, Barry (Public Utility Commission) Stansell, Wade (Association of Electric Companies of Texas) Registering, but not testifying: For: Mayberry, Warren (Texas Farm Bureau) On: Rabago, Karl (Texas Renewable Energy Industries Assoc.) HB 1693 On: Waddill, Duane (Texas Residential Construction Commission) Registering, but not testifying: For: Reed, Cyrus (Lone Star Chapter of Sierra Club) HB 1798 For: Anderson, Scott (Environmental Defense) Neff, Shirley (Americans for Solar Power) Sloan, Mike (The Wind Coalition) Smith, Kari (Powerlight Corporation) Against: Oldham, Phillip (Texas Coalition for Competitive Electricity) On: Parsley, Julie (Public Utility Commission) Rabago, Karl (Texas Renewable Energy Industries Assn.) Saathoff, Kent (Electric Reliability Council of Texas) Smitherman, Barry (Public Utility Commission) Stansell, Wade (Association of Electric Companies of Texas) Registering, but not testifying: For: Armstrong, Reed (PPM Energy, Inc.) Carroll, Judith (Self and Gamesa Energia SW) Edmondson, Eddy (Texas Nursery & Landscape Association) Hadden, Karen (Sustainable Energy and Economic Development Coalition) Houle, Thomas (Cielo Wind Power Corp.) Mayberry, Warren (Texas Farm Bureau) Metzger, Luke (Texas Public Interest Research Group) Reed, Cyrus (Lone Star Chapter of Sierra Club) Sickels, Linda (Trinity Ind., Inc.)


I was born and raised in Nothern of Denmark, but my real roots reach to both South America and Russia. I don't know what I owe my travel bug to but it's there!
My passion: I've got several. I'm really passionate about something as sexy as... soil. And I love activities - sailing, dancing, cycling, skating, gardening, tennis.
A fun fact: I once fell asleep in a tree when I was a kid. My parents didn't take me down.


Preview of supported animations.
Icons can be loaded from json files with src attribute.
| animation | preview |
| empty |
|
| hover |
|
| click |
|
| auto |
|
| loop |
|
| morph |
|
| morph-two-way |
|


If you already know the pip
tool,
here’s how you can install:
$ pip install handroll
The rest of this documentation explains Python’s installation tools and how to deal with some common issues.
Detailed instructions
handroll is written in the Python programming language. The tool uses Python’s standard packaging and is uploaded to the primary Python repository, the Python Package Index (PyPI).
PyPI uses a standard installation tool
called pip
.
A recent version of Python should include pip
as part of the installation,
but there are a few reasons why it may not be installed.
If you run pip
and get results like:
$ pip pip: command not found
then you need to install the tool before proceeding.
Your operating system may have pip
as an available package.
On Ubuntu,
sudo apt-get install python-pip
would install pip
.
The pip
documentation includes alternative instructions
for how to get it installed.
Once pip
is installed, run:
$ pip install handroll
Troubleshooting
Sometimes things go wrong
and pip
may not give you helpful feedback.
A common problem is administrative permissions.
If you see something like:
$ pip install handroll Downloading/unpacking handroll Downloading handroll-2.0-py2.py3-none-any.whl (80kB): 80kB downloaded ... snip ... Installing collected packages: handroll, mock, blinker, textile, Pygments, werkzeug, docutils, watchdog, Markdown, argh, pathtools Cleaning up... Exception: Traceback (most recent call last): File "/usr/lib/python2.7/dist-packages/pip/basecommand.py", line 122, in main status = self.run(options, args) ... snip ... OSError: [Errno 13] Permission denied: '/usr/local/lib/python2.7/dist-packages/handroll'
then that means you are not installing with the required permissions.
There are a few options to fixing this problem:
- Install with administrative permissions (i.e., a system installation).
- Install to a user account.
- Install in a directory with a virtual environment.
System installation
The easiest option is
to run the command with elevated permissions.
On a Linux operating system,
this is commonly done with sudo
.
$ sudo pip install handroll
This should install handroll
at the system level
and put the handroll
command
in the system’s bin
directory
(i.e., a location where your terminal can find the command).
User installation
pip
can install into a user’s home directory
where permissions shouldn’t be an issue.
$ pip install handroll --user
With this option,
handroll will install in a user’s home directory
(most likely $HOME/.local
).
If this is the first time using a user installation,
you may need to add to your PATH
so your terminal can find the handroll
command.
$ export PATH="$PATH:$HOME/.local/bin"
Virtual environment installation
Virtual environments are special directories where Python code can be stored and isolated from other code. These environments are popular because they consolidate all code to a single place.
To use a virtual environment:
$ virtualenv venv $ source venv/bin/activate (venv)$ pip install handroll


Quick Overview
Cards (3)
Bank Accounts (2)
Latest Transactions
+$250,00
xxx-485 Account
From Company Inc at June 10, 2018 - 10:06
-$540,00
xxx-7898 VISA
From Company Inc at June 5, 2018 - 08:46
+$120,00
xxx-485 Account
From Company Inc at May 25, 2018 - 12:25
+$698,00
xxx-796 Account
From Company Inc at May 23, 2018 - 14:23


cell death AtNRP stress Arabidopsis expression AtNRP, BiP soybean signaling response osmotic plant protein atnrp ANAC file (Fig. GmNRP– GmNAC lines pathway using PEG induced induction stress–induced Plant components leaves VPE tolerance NRP–mediated phenotype plants Additional genes proteins transgenic pS: tunicamycin water {border-style DCD/NRP–mediated gene leaf analysis control px;} seedlings sequences #ffffff;} function described drought endoplasmic reticulum root signal tobacco used (Additional Col– NAC activity chlorophyll downstream results sequence stress, transcription DNA Fontes RNA Total conservation endogenous promoter transformed Fig. GmNAC, Sci displayed loss overexpression performed Reis conserved control. functional growth homologs levels lines. soyBiPD transcript treated Biol UPR acid based extent fraction indicate microsomal monitored selected shown Arabidopsis. AtBiP BiPDox EPB LINK Phylogenetic accumulation agroinfiltrated bZIP days determined domain indicated isolated kb) method module orthologs protoplasts quantified regulatory sectors species Cell NRP PAB Silva activate amino biological content genes. involved knockout line lower unfolded (TIF Arabidopsis, BiP–overexpressing Gene Tunicamycin assay conditions, enhanced gVPE high kingdom linked peroxidation px; qRT–PCR. related transduction trees {font-family BMC Expression GUS NRPs PCD activated addition attenuated attenuates b). blue calculated compared conditions factor family font-size inducer lipid medium molecular null obtained programmed responses serum signaling, soybean. taken transferred vector μg/mL) (w/v) ANAC, BiP–GFP–HDEL Carvalho Col–, Furthermore, Glycine Howell Mendes Protein Solanum UBQ attenuation bars binding cDNAs cells component confidence confirmed d). days–old demonstrated development different double; enzyme examined harbor higher identified independently inhibition interval membrane monocotyledonous overexpressing plant–specific previously putative recovered replicates reverse share similar specific stress-induced stress–and total treatment type wild–type (Invitrogen) Acad Bayesian BiPD BiP–mediated Costa DCD Evans Fwd GmNRP- Likewise, Liu Phytozome RT–PCR TAIR Transient Wang abiotic adaptive aligned alleles amplified anti–GFP associated benthamiana border-color border-width carried cause clustered constructed containing data dicotyledonous domain–containing drought. entry expressed expression. functions genes, genome individually. mannitol, mechanisms mixed multiple phylogenetic placed plant-specific primers processing p < ,, recombination response. revealed separated solid; soybean, stress. thaliana transformation treatment. t–test validated {font-style {font-weight (in -ΔΔCt ./pnas. AtBiP–GFP–HDEL AtNRP–overexpressing BiP, BiPox Cascardo Collectively, DCD/NRP DMSO GmNRP–B Like MES, MUSCLE. NRP–A NRP–B Natl N–rich Oryza Overexpression Photography Physiol Proc Soybean Stress Sun Tunicamycin. VPE. Values activation analyses analysis. assays bold c). clade cluster complemented contains courier; crops. cytosolic databases days. developed differences distinct em; extensive formed function. fusion generations genomes germinated green increases leaves. line. localized member modulation negative n = ). order pDONR participated pathway. plants. plants: positive probed program promote promotes pt;} quantitative regulator relative respectively. response, sativa senescence showed silico similarity stained staining stresses stresses. studies supported transient upstream vectors w/v) wild withholding yield


This is a legal agreement
This agreement is a type of contract. It’s important you are happy with the details before you sign.
If you are unsure about any part of this agreement get advice from people you know or an organisation like Citizens Advice.


If selected, then default report file names and paths are used.
The default paths are:
${WORKSPACE}/neoload-report/report.html
${WORKSPACE}/neoload-report/report.xml
${WORKSPACE}/neoload-report/junit-sla-results.xml
Note that if the necessary report files are not archived then
they are not found by the plugin and some functionality will not work.


Overview
Hi, and welcome! My name is Diem, and one of my favorite past time is crocheting. I find it relaxing and rewarding when I am working on a project. I call myself an amateur, thus I'm not here to teach you how to crochet. The purpose to convince you to give it a try and provide you with some helpful resources through your journey.
The best way to learn is to just start. I learned by watching YouTube videos. Simply search what you want to crochet; however, I recommend starting with the common stitches listed in the table below. Once you get a hang of them, search for the crochet projects you want to do. I started with hats, and I am currently into Amigurumi projects. Check out my gallery for some inspo!
To get started, you will only need a few items.


About
Docs
Code
Who
Lists
Bugs
$ git clone https://camlistore.googlesource.com/camlistore
Want to
contribute
?


2020 Grammy nominations: See the full list of nominees | Honolulu Star-Advertiser
Lizzo, a charismatic new pop and R&B star, has been nominated for eight prizes at the 62nd annual Grammy Awards, leading a class dominated by fresh faces like Billie Eilish and Lil Nas X.
Lizzo spent much of the last decade as a struggling rapper and singer, but broke through this year with hits like “Juice” and “Truth Hurts,” and a bold, body-positive persona. Little known to mainstream audiences a year ago, she is now up for every major award at the Grammys, including album of the year for the deluxe version of “Cuz I Love You,” record and song of the year for “Truth Hurts,” and best new artist, the Recording Academy announced Wednesday.
Not so long ago, the Grammys were routinely criticized for rewarding journeyman stars and rock elders at the expense of pop’s younger and more vital ranks. No longer. Continuing a trend that has been building for several years, the latest crop of nominees are young, diverse and largely reflective of the forefront of pop.
Lizzo’s competition includes two artists with six nominations each: Eilish, a 17-year-old alternative auteur who has built a wildly devoted following, and Lil Nas X, a 20-year-old rapper and master of internet memes whose “country-trap” hybrid “Old Town Road” became an all-pervasive cultural phenomenon this year, breaking Billboard’s singles chart record with 19 weeks at No. 1.
Eilish’s “When We All Fall Asleep, Where Do We Go?” is up for album of the year; “Bad Guy” is up for record and song of the year; and Eilish is a contender for best new artist. She is the youngest person to be nominated for all four top categories. Finneas O’Connell, her brother and primary collaborator, received five nods for his work with her as a producer and songwriter.
Lil Nas X was nominated for record of the year for the remix of “Old Town Road” (which features country star Billy Ray Cyrus) and album of the year for “7,” an eight-song EP. He is also up for best new artist, in what may be seen as a challenge to the academy’s more conservative voting ranks, who have often been reluctant to reward artists they view as untested.
But Lil Nas X has also come to stand for many of the changes now sweeping pop music. “Old Town Road” first exploded as a hit on TikTok, the video app, and his blithe combination of rap and country highlighted the increasing blurring of genre. At first, Nashville struggled to accept him; last week, “Old Town Road” won best musical event at the Country Music Association Awards.
Even so, Lil Nas X was not nominated in any of the Grammys’ country categories. The nominees for country album of the year are Eric Church’s “Desperate Man,” Reba McEntire’s “Stronger Than the Truth,” Pistol Annies’ “Interstate Gospel,” Thomas Rhett’s “Center Point Road” and Tanya Tucker’s “While I’m Livin’.”
The awards ceremony will be held Jan. 26 in Los Angeles and broadcast by CBS.
Among this year’s other top nominees, Ariana Grande received five nods, including record of the year for “7 Rings” — a recasting of Rodgers and Hammerstein’s “My Favorite Things” — and album of the year for “Thank U, Next.” The young R&B singer H.E.R., who took home two awards at the most recent Grammys, is also up for five, including album of the year for “I Used to Know Her” and record and song of the year for “Hard Place.” (Record of the year is for performers and producers, while the song category recognizes songwriters.)
In a conspicuous rebuffing of a major star, Taylor Swift — a 10-time winner and onetime darling of the academy — received three nods, but only one in a major category: “Lover,” the title track of her latest album, is up for song of the year. Swift’s song “You Need to Calm Down” is up for best pop solo performance, and “Lover” for best pop vocal album.
Last year, the Grammys expanded the top categories to eight nominees, from five. That has helped the academy put forth a more diverse group, after it came under sharp criticism for an underrepresentation of women among the winners.
In the most prestigious categories, the nominations largely went to a mixture of new faces in pop and R&B, and midcareer, alt-leaning rock artists. For album of the year, the contestants also include “i,i” by Bon Iver, the project of the experimental singer-songwriter Justin Vernon; Vampire Weekend’s “Father of the Bride”; and Lana Del Rey’s “Norman ———— Rockwell!”
The crop for record of the year also includes Bon Iver’s “Hey, Ma”; “Talk,” a radio hit by the young R&B-pop singer Khalid; and “Sunflower” by Post Malone and Swae Lee. Song of the year includes “Always Remember Us This Way,” as performed by Lady Gaga in the film “A Star Is Born”; “Bring My Flowers Now,” as performed by Tucker; “Norman ———— Rockwell” by Del Rey; and “Someone You Loved,” a breakout hit by 23-year-old Scottish crooner Lewis Capaldi.
Among the rest of this year’s 84 categories, Michelle Obama is up for best spoken word album for “Becoming” — she will compete against the Beastie Boys and John Waters — and “Homecoming,” Beyoncé’s Coachella concert movie, is up for best music film. Beyoncé also received three nominations connected to her music for the remake of “The Lion King.”
The awards are not without some industry drama. Lizzo’s “Truth Hurts” has been the subject of a harsh dispute over songwriting credits — two writers said their work in an early writing session was used without their permission; Lizzo sued them and another songwriter last month, asking a judge to deny their claims. The song was released two years ago but is eligible for the 2020 Grammys because it was included on the expanded version of Lizzo’s new album and had not been submitted before.
And there was much grumbling behind the scenes over this year’s eligibility window. To accommodate the Winter Olympics, the show is being held a few weeks earlier than usual, which shortened the period for new music that could be submitted. Only music released between Oct. 1, 2018 and Aug. 31, 2019 — an 11-month stretch — is eligible this year. Swift and Del Rey’s albums came in right under the wire.
The awards are also being viewed as a coming-out for a new management era at the Recording Academy after several years of complaints and controversies over its treatment of women and artists of color.
The academy’s former chief executive, Neil Portnow, had helped stabilize the institution but came under fire when he said after the 2018 awards that women should “step up” to advance their careers and be recognized at the Grammys. Under pressure, Portnow approved a task force to evaluate the academy and its procedures.
A new chief, Deborah Dugan, took over this summer after leading Bono’s Red charity campaign. So far she has said little of her plans, but suggested that more changes for the institution are in store.
“Today’s announcement reflects a new era for the Recording Academy,” Dugan said in a statement, “an army of engaged members that welcomes diversity, embraces creativity and champions young musicians on the rise.”
Winners will be chosen by the academy’s 11,000 voting members.
—
Grammy Nominations 2020
Record of the Year
“Hey, Ma” — Bon Iver
“Bad Guy” — Billie Eilish
“7 Rings” — Ariana Grande
“Hard Place” — H.E.R.
“Talk” — Khalid
“Old Town Road” — Lil Nas X featuring Billy Ray Cyrus
“Truth Hurts” — Lizzo
“Sunflower” — Post Malone and Swae Lee
Album of the Year
“i,i” — Bon Iver
“Norman —————— Rockwell!” — Lana Del Rey
“When We All Fall Asleep, Where Do We Go?” — Billie Eilish
“Thank U, Next” — Ariana Grande
“I Used To Know Her” — H.E.R.
“7” — Lil Nas X
“Cuz I Love You (Deluxe)” — Lizzo
“Father of the Bride” — Vampire Weekend
Song of the Year
“Always Remember Us This Way” — Natalie Hemby, Lady Gaga, Hillary Lindsey and Lori McKenna, songwriters (Lady Gaga)
“Bad Guy” — Billie Eilish O’Connell & Finneas O’Connell, songwriters (Billie Eilish)
“Bring My Flowers Now” — Brandi Carlile, Phil Hanseroth, Tim Hanseroth and Tanya Tucker, songwriters (Tanya Tucker)
“Hard Place” — Ruby Amanfu, Sam Ashworth, D. Arcelious Harris. H.E.R. and Rodney Jerkins, songwriters (H.E.R.)
“Lover” — Taylor Swift, songwriter (Taylor Swift)
“Norman —————— Rockwell” — Jack Antonoff and Lana Del Rey, songwriters (Lana Del Rey)
“Someone You Loved” — Tom Barnes, Lewis Capaldi, Pere Kelleher, Benjamin Kohn and Sam Roman, songwriters (Lewis Capaldi)
“Truth Hurts” — Steven Cheung, Eric Frederic, Melissa Jefferson and Jesse Saint John, songwriters (Lizzo)
Best New Artist
Black Pumas
Billie Eilish
Lil Nas X
Lizzo
Maggie Rogers
Rosalía
Tank and the Bangas
Yola
Best Pop Solo Performance
“Spirit” — Beyoncé
“Bad Guy” — Billie Eilish
“7 Rings” — Ariana Grande
“Truth Hurts” — Lizzo
“You Need to Calm Down” — Taylor Swift
Best Pop Duo/Group Performance
“Boyfriend” — Ariana Grande and Social House
“Sucker” — Jonas Brothers
“Old Town Road” — Lil Nas X featuring Billy Ray Cyrus
“Sunflower” — Post Malone and Swae Lee
“Señorita” — Shawn Mendes and Camila Cabello
Best Pop Vocal Album
“The Lion King: The Gift” — Beyoncé
“When We All Fall Asleep, Where Do We Go?” — Billie Eilish
“Thank U, Next” — Ariana Grande
“No.6 Collaborations Project” — Ed Sheeran
“Lover” — Taylor Swift
Best Rock Performance
“Pretty Waste” — Bones UK
“This Land” — Gary Clark Jr.
“History Repeats” — Brittany Howard
“Woman” — Karen O and Danger Mouse
“Too Bad” — Rival Sons
Best Alternative Music Album
“U.F.O.F.” — Big Thief
“Assume Form” — James Blake
“i,i” — Bon Iver
“Father of the Bride” — Vampire Weekend
“Anima” — Thom Yorke
Best R&B Performance
“Love Again” — Daniel Caesar and Brandy
“Could’ve Been” — H.E.R. featuring Bryson Tiller
“Exactly How I Feel” — Lizzo featuring Gucci Mane
“Roll Some Mo” — Lucky Daye
“Come Home” — Anderson .Paak Featuring André 3000
Best R&B Album
“1123” — BJ the Chicago Kid
“Painted” — Lucky Daye
“Ella Mai” — Ella Mai
“Paul” — PJ Morton
“Ventura” — Anderson .Paak
Best Rap Performance
“Middle Child” — J. Cole
“Suge” — DaBaby
“Down Bad” — Dreamville featuring J.I.D, Bas, J. Cole, EARTHGANG and Young Nudy
“Racks in the Middle” — Nipsey Hussle featuring Roddy Ricch and Hit-Boy
“Clout” — Offset featuring Cardi B
Best Rap/Sung Performance
“Higher” — DJ Khaled Featuring Nipsey Hussle and John Legend
“Drip Too Hard” — Lil Baby and Gunna
“Panini” — Lil Nas X
“Ballin” — Mustard featuring Roddy Ricch
“The London” — Young Thug featuring J. Cole and Travis Scott
Best Rap Album
“Revenge of the Dreamers III” — Dreamville
“Championships” — Meek Mill
“I Am > I Was” — 21 Savage
“Igor” — Tyler, the Creator
“The Lost Boy” — YBN Cordae
Best Country Song
“Bring My Flowers Now” — Brandi Carlile, Phil Hanseroth, Tim Hanseroth and Tanya Tucker, songwriters (Tanya Tucker)
“Girl Goin’ Nowhere” — Jeremy Bussey and Ashley McBryde, songwriters (Ashley McBryde)
“It All Comes Out in the Wash” — Miranda Lambert, Hillary Lindsey, Lori McKenna and Liz Rose, songwriters (Miranda Lambert)
“Some of It” — Eric Church, Clint Daniels, Jeff Hyde and Bobby Pinson, songwriters (Eric Church)
“Speechless” — Shay Mooney, Jordan Reynolds, Dan Smyers and Laura Veltz, songwriters (Dan + Shay)
Best Country Album
“Desperate Man” — Eric Church
“Stronger Than the Truth” — Reba McEntire
“Interstate Gospel” — Pistol Annies
“Center Point Road” — Thomas Rhett
“While I’m Livin’” — Tanya Tucker
Best Jazz Instrumental Album
“In the Key of the Universe” — Joey DeFrancesco
“The Secret Between the Shadow and the Soul” — Branford Marsalis Quartet
“Christian McBride’s New Jawn” — Christian McBride
“Finding Gabriel” — Brad Mehldau
“Come What May” — Joshua Redman Quartet
Best Latin Rock, Urban or Alternative Album
“X 100PRE” — Bad Bunny
“Oasis” — J Balvin and Bad Bunny
“Indestructible” — Flor De Toloache
“Almadura” — iLe
“El Mal Querer” — Rosalía
Best Compilation Soundtrack for Visual Media
“The Lion King: The Songs” — Various Artists
“Quentin Tarantino’s Once Upon a Time in Hollywood” — Various Artists
“Rocketman” — Taron Egerton
“Spider-Man: Into the Spider-Verse” — Various Artists
“A Star Is Born” — Lady Gaga and Bradley Cooper
Producer of the Year, Non c lassical
Jack Antonoff
Dan Auerbach
John Hill
Finneas
Ricky Reed


We seek to improve and maintain optimal mental well-being of the society
1 in 7 people are suffering from mental illness. However only 40% seek help
Mental health education & awareness, workshops & training, medical support
All of us have mental health just like our physical health and yet it remains a taboo subject that is susciptible to age-old stigmas, prejudices and fears.
This results in some people suffering from unidentified prolong mental illness. Hence, we wish to educate and spread awareness on the importance of mental health which would further encourage people to seek help at the right time.
→Programs for the educational sector
Relive-India's school/college programmes focus on early recognition, mental health promotion and raising awareness about available treatement methods.
Programs for the corporate/ industrial sector
Relive-India's corporate programmes have been designed to focus on spreading awareness regarding mental illness and their treatement.
Programs for specific communities
Relive-India's community programmes aim to address different aspects of mental health among all sects of people and it is adaptable to cater to any particular community
For further detailed information about our programs
Our programs→Mental health betterment/ mental illness is often followed by denial and hesitation to seek help. We understand that it can become really overwhelming to seek help. Our aim is to encourage and provide maximum support for you to find the best clinically qualified person to suit your needs.
Seek help now →


Helped Professor grade students' assignments and presentations
Assisted Students' with their class presentations and exams
Conducted Labs for explaining prototyping and testing tools
Tools Used: Axure RP8, Moqup, Balsamiq, Selenium IDE
Web Design and User Experience Engineering
Assisted Students' with their class assignments and exams
Performed code reviews for Students' assignments
Created online class quizzes and exams using Hackeerrank
Technologies Used: HTML5, CSS3, Bootstrap CSS, AngularJS, NodeJS, PHP, MySQL
Data Management and Database Design
Assisted course instructor in grading assignments, exams, conduct office hours
Worked with other Teaching Assistants in coordinating the lectures in class
Provided guidance to 40+ students in class assignments and project presentations
Technologies Used: MySQL
Web Developer Intern
Clean Harbors
Roles and Responsibilities:
Developed fully functional internal corporate Card application from gathering and analysis of business requirements to getting code into production environment using .NET and MySQL
Tested the company’s billing website, which generates $30,00,000 invoices a year, in multiple browsers to ensure cross-browser compatibility thereby correcting the minor design flaws
Verified the accuracy of Company’s reports by running Queries in Microsoft SQL Server prior to approving for release into production environment thereby reducing the manual effort of verifying data by 50%
Systems Engineer
Tata Consultancy Services Ltd.
Roles and Responsibilities:
Global Ecommerce Application – STAPLES.COM:
Provided production support for Staples.com website and maintained 100% availability of the site by constantly monitoring the site using Omniture, Soasta and Splunk
Developed Linux scripts for migration of large scale production data to server which lessened the manual intervention of running jobs separately
Automated migration report generation by querying the database to obtain the data using MySQL, thereby eliminating 20 hours of manual data entry a week for the team
Social Networking Application – TATA INNOVERSE(TI):
Developed and supported Tata Innoverse(TI) Application, an ideation platform for the TATA group of companies, using Ruby on Rails and PostgreSQL
Validated the form errors and accuracy of the output data by creating and executing RSpec test cases for the application, thereby reducing the production defects by 30%
Created and implemented a reporting module using MySQL and BIRT with Eclipse for the TI application which displays the employees’ Key Performance Indicators, thereby providing accurate data during audits
Redesigning Yelp Website
Restructured the existing Yelp website by redefining the design of the various planes of UX design and UX best practices
Created mockups for the restricted website using Axure and Balsamiq tools
Optimization of Opportunistic Networks using Particle Swarm Optimization(PSO)
Opportunistic Network
Opportunistic mobile social networks are a form of mobile ad hoc networks that exploit the human social characteristics, such as similarities, daily routines, mobility patterns, and interests to perform the message routing and data sharing.
The oppnets differ from traditional networks, in which the nodes of a single network are all deployed together, with the size of the network and locations of its nodes pre-designed.
Particle Swarm Optimization
Particle swarm optimization (PSO) is a method that optimizes a problem by trying to improve a candidate solution with regard to a given measure of quality.
This solves a problem by having a swarm of particles and moving these particles around in the search-space according to the fitness function over the particle's position and velocity.
Proposed Solution
Particle Swarm Optimization(PSO) algorithm used to establish the communication among the messages(packets) that are transferred from the mobile devices at the time of crisis. The messages are considered as particles and the particles are scattered in two dimensional space. The particles are said to move in the direction of the intermediate node, which is denoted as a target particle. With the help of PSO, the particles get an optimized route to move closer to the intermediate node.