--- layout: page title: Ecosystem date: 2014-02-27 05:16:30.000000000 +08:00 permalink: /ecosystem/ ---
| 1C:Enterprise built-in OData service | 1C:Enterprise, leading platform for business automnation in Russia and CIS (more than 1M installations and 300k developers) now provides an OData service for access its data. |
| Acumatica | Acumatica is a cloud- and browser-based enterprise resource planning (ERP) solution. Business data and lists created in generic inquiries can be exposed as OData endpoints. |
| BrightstarDB | A native, .NET, NoSQL semantic web database with code first Entity Framework, LINQ and OData support. |
| Cloud Drivers | The CData Cloud Drivers create bidirectional OData entrypoints to SaaS & on-premise data sources. Supports the creation of OData feeds for a variety of popular data sources, including: QuickBooks, Salesforce, SharePoint, NetSuite CRM & ERP, Dynamics CRM, Twitter, MySQL, Oracle DB, SQLite, Excel Files, and more. |
| GeoREST | GeoREST is a web-centric framework for distributing geospatial data. It allows RESTful feature-based access to spatial data sources, including full editing capabilities, through a MapGuide server or directly via FDO. |
| Gizur OData server | Open source OData server that exposes an OData API from any MySQL database. The server also extends the OData API with functions for managing users and privileges. In addition there is support for BLOBs. The server is currently in beta status. |
| JBoss Data Virtualization | JBoss Data Virtualization exposes an OData service out-of-the-box from any exposed relational objects (tables and procedures). |
| IBM DB2 & Infomix | DB2 & Informix can expose OData via Microsoft Visual Studio. |
| IBM WebSphere eXtreme Scale | WebSphere eXtreme Scale can expose OData enabling access from a variety of clients. |
| Lightswitch | Microsoft Visual Studio LightSwitch is a development environment designed to simplify and shorten the development of data-driven businesses applications. Regardless of your development skills—whether you’re a beginner or an experienced developer—LightSwitch enables you to quickly create professional-quality business applications and data services. |
| Microsoft Dynamics CRM 2011 | The latest version allows you to query using OData |
| Microsoft Dynamics NAV 2013 | Business data in Dynamics NAV 2013 ERP solutions can be accessed as OData feeds. You can create “Self-service BI” solutions using PowerPivot for Excel to consume these feeds. |
| Progress DataDirect Cloud | Progress DataDirect Cloud is a data connectivity service that exposes SaaS application data (e.g. Salesforce.com), on-premise relational data (e.g. Oracle), Big Data (e.g. Hadoop), and NewSQL/NoSQL data (e.g. MongoDB) as an OData feed. |
| RemObjects Data Abstract | A full multi-tier database application framework that supports publishing data for insert, select, update and delete via OData. Server libraries for .NET, Mono (Linux & OS X) and Delphi |
| SAP NetWeaver Gateway | SAP NetWeaver Gateway (formerly called “Project Gateway”) is a technology that provides a simple way to connect devices, environments and platforms to SAP software based on market standards. It offers connectivity to SAP applications using any programming language or model without the need for SAP knowledge by leveraging OData-based REST services. |
| Savigent Software Catalyst xM | The Open Data Protocol provides easy access to Catalyst xM™ workflow execution history from a variety of off-the-shelf data mining and business intelligence tools and is an ideal choice to expose manufacturing intelligence from Catalyst xM™ to browser-based and mobile clients. The Catalyst xM Server Manager provides a Data Source Builder which allows users to configure virtual tables that are created dynamically to provide data access via the Open Data Protocol. |
| ScanJour WorkZone Content Server | ScanJour WorkZone is a Case and Document Management System which implements OData API for full manipulation of all data, cases and documents. |
| SDL Tridion 2011 | SDL Tridion is a Web Content Management solution, the Content Services component now supports OData |
| SharePoint | Any data you’ve got on SharePoint as of version 2010 can be manipulated via the OData protocol, which makes the SharePoint developer API considerably simpler. |
| Sitefinity CMS by Telerik | The Sitefinity CMS by Telerik is ready to host OData services. With the powerful API, any developer can expose any information from the CMS through a custom OData service. For more info, visit |
| SQL Server 2012 | Microsoft SQL Server 2012 Reporting Services can expose data from reports as OData |
| Team Foundation Server | An extension to Team Foundation Server Server 2010 and 2012 that allows you to browse TFS data using the OData protocol |
| Teiid | Teiid allows you to connect to and consume sources (odata services, relational data, web services, file, etc.) and deploy a single source that is available as an OData service out-of-the-box. |
| Telerik TeamPulse | The Telerik TeamPulse Silverlight client interacts with the database using a WCF data service, and more specifically by using the Open Data Protocol which is a popular way to expose information from a variety of sources including, but not limited to, relational databases, file systems, content management systems and traditional Web sites. |
| tm2o – OData provider for Topic Maps | TM2O – which is a generic OData provider for Topic Maps. Internally tm2o leverages OData4J |
| Webnodes CMS | Webnodes CMS is an enterprise quality ASP.NET CMS with a unique semantic content technology. Webnodes recently added OData support. Read more about it here. |
| Windows Azure Table Storage | Windows Azure Table provides scalable, available, and durable structured storage in the form of tables exposed as OData endpoints. |
| (Unofficial) SSIS import script | A SQL Server Integration Services script for importing OData into SQL Server. |
| ADO.NET Driver | Read, Write, and Update OData services through ADO.NET. The OData Data Provider makes OData Services look like SQL tables in your applications. With the ADO.NET Provider developers can simply DataBind to data, just like using SQL Server. |
| BOARD | Board (www.board.com) is a platform for Business Intelligence, Performance Management and Predictive Analytics. It comprises an in-Memory multidimensional database which can be populated with OData feeds from on-premise and cloud based data sources. |
| Browsers | Most modern browsers allow you to browse Atom based feeds. Simply point your browser at one of the OData Producers. |
| Client Libraries | Client libraries are programming libraries that make it easy to consume OData services. We already have libraries that target: Javascript, PHP, Java, Windows Phone 7 Series, iPhone (Objective C) and .NET. For a complete list visit the OData SDK. |
| combit | combit supports OData consumtion both for their reporting component List & Label and their self service BI tool Report Server. |
| Database .NET v3 | Database .NET v3 – A free, easy-to-use and intuitive database management tool, supports OData |
| DataPublic | DataPublic provides a complete cloud-ready open data portal solution for citizen engagement using OGDI DataLab, Windows Azure and Drupal 7. |
| DevExpress DataExplorer | DataExplorer is a code-free way to create native, data-enabled apps for the iPad. With its straightforward design, you or members of your team can deliver data-driven apps for today’s most popular tablet without writing a single line of Objective-C code. |
| DotNetNuke HTML Module Calling Visual Studio LightSwitch Using OData | Visual Studio LightSwitch provides the fastest and easiest way to create Line-Of-Business, Forms-Over-Data applications. |
| Drupal | |
| Excel Add-In | Connect with live OData services directly from Microsoft Excel. Use Excel to directly search, aggregate, read, write, and update live OData feeds. Perfect for mass imports / exports / updates, data cleansing & de-duplication, Excel based data analysis, and more! |
| JBoss Data Virtualization | JBoss Data Virtualization allows you to import OData services and converts them to relational objects (tables and procedures) allowing you to federate your OData based sources with other disparate sources for a single view of all your data. |
| Informatica OData Connector | Informatica Connector for OData helps customers to integrate OData compliant systems with other on-premise or cloud Applications. |
| JDBC Driver | Connect-to live OData Services services from all kinds of BI, Reporting, ETL, Database, and Analytics tools. With the JDBC Driver users can access OData Services the same way that they would connect to any other JDBC data source. |
| Joomla | The OData Component for Joomla supports reading and parsing data from OData feeds from within content pages like Articles and Basic Pages. Users can include data from any OData publishers. |
| Lightning Connect | Lightning Connect leverages the OData protocol to connect with external data without copying or storing that data inside Salesforce. Data retrieved via OData 2.0 protocol will manifest as Salesforce external (virtual) objects so that it can be tightly integrated into the Salesforce1 Platform. |
| LINQPad | LINQPad is a tool for building OData queries interactively. |
| Nucleon Database Manager supports OData | Nucleon Database Manager 6 supports now OData protocol for database management. Database Manager simplifies managing, querying, editing, visualizing, designing and reporting relational and NoSQL database systems. |
| OData Client Library for Tcl/Tk | OData Client Library for Tcl/Tk. |
| OData Helper for WebMatrix | The OData Helper for WebMatrix and ASP.NET Web Pages allows you to easily retrieve and update data from any service that exposes its data using the OData Protocol. |
| OData Native Client for BlackBerry 10 | Open Data Protocol (OData version 4.0) library for BlackBerry 10 (BB10) Cascades/C++ apps. This library makes it easy to build native BB10 apps that consume OData services. |
| OData Powershell Explorer | An ‘OData Explorer’ PowerShell application designed to allow ad-hoc browsing of OData Services using the command line or GUI using WPK from the Microsoft PowerShell Pack. |
| ODBC Driver | Read, Write, and Update OData services through ODBC. Access OData services like you would any standard database - read, write, and update etc. through a standard ODBC Driver interface. |
| Pebble Reports | Pebble Reports lets you create reports consisting of tables, charts and crosstabs. Reports can be exported to Word, Excel and PDF formats, or emailed via Outlook. |
| PowerPivot for Excel | PowerPivot for Excel 2010 is a plugin to Excel 2010 that has OData support built-in. |
| PowerQuery for Excel | Now supporting both OData V3 and OData V4, Microsoft Power Query for Excel is a free Excel add-in that enhances the self-service Business Intelligence experience in Excel by simplifying data discovery, access and collaboration. |
| Sesame - OData Browser | A preview version of Fabrice Marguerie’s OData Browser |
| Tableau | Tableau – an excellent client-side analytics tool – can now consume OData feeds |
| Teiid | Teiid allows you to import OData services and converts them to relational objects (tables and procedures) that can then be exposed as an OData service, allowing you to federate your OData based sources with other disparate sources for a single view of all your data. |
| Telerik | Telerik, always being a pioneer in supporting new technologies, not only provides native support for the OData protocol in its products, but also offers several applications and services which expose their data using the OData protocol. |
| Telerik RadControls for Silverlight and WPF | Being built on a naturally rich UI technology, the Telerik Silverlight and WPF controls will display the data in nifty styles and custom-tailored filters. Hierarchy, sorting, filtering, grouping, etc. are performed directly on the service with no extra development effort. |
| Telerik RadGrid for ASP.NET Ajax | RadGrid for ASP.NET Ajax supports automatic client-side databinding for OData services, even at remote URLs (through JSONP), where you get automatic binding, paging, filtering and sorting of the data with Telerik Ajax Grid. |
| Telerik Reporting | Telerik Reporting can connect and consume an existing OData feed with the help of WCF Data Services. |
| XOData | XOData is a generic web-based OData Service visualization & exploration tool that will assist in rapid design, prototype, verification, testing and documentation of OData Services. The online version of the tool is free. It provides direct service or metadata URL access option for visualization and exploration of publicly accessible OData services, and metadata XML File upload option for offline visualization of metadata (entity relationship). A presentation of it can be found here. |
| Cambridge Weather; Pyslet demo service | Exposes data from the University of Cambridge DTG group's weather station (operational since 1995) via OData. Also serves as a demo feed for the Pyslet Python package's OData server module. |
| City of Medicine Hat Open Data Portal | The open data portal of the City of Medicine Hat, Alberta, Canada running on OGDI DataLab and Windows Azure. |
| City of Regina Open Data Portal | The open data portal of the City of Regina, Saskatchewan, Canada, running on OGDI DataLab and Windows Azure. |
| Colombia Government Open Data Portal | Colombia Government open data portal running on OGDI DataLab and Windows Azure. |
| DataLab | DataLab (formerly known as Open Government Data Initiative) provides a customizable API for publishing government open data. The OGDI project has been superseded by the DataLab project hosted on GitHub. DataLab provides a RESTful Web service for data, accessible and visualized via a native DataBrowser (ASP.NET MVC), web and mobile apps (HTML/JavaScript, PHP, Ruby, etc), Excel, SharePoint, Drupal 7 and others. |
| DBpedia | A community effort to extract structured information from Wikipedia and to make this information available on the Web, with full support for OData interactions on the live query services. (Powered by OpenLink Virtuoso.) |
| Dev Express | OData Provider for XPO – Using Server Mode to handle Huge Datasets |
| INETA Live | INETA Live has an OData feed providing access to their vast library of User Group Presentations. |
| Italy Ministry of Health Open Data Portal | Open data portal of the Italian Ministry of Health running on OGDI DataLab and Windows Azure. |
| Linked Open Data Cloud Cache | Mirrors and interlinks dozens of data sets including all of data.gov, with full support for OData interactions. (Powered by OpenLink Virtuoso.) |
| LogMyTime | |
| Nerd Dinner | Nerd Dinner is a website that helps nerds to meet and talk, not surprisingly it has adopted OData. |
| Nuget | Nuget is a Visual Studio extension that makes it easy to install and update open source libraries and tools in Visual Studio. |
| Datawatch | With Datawatch, you can also easily access the growing number of OData sources worldwide. Connect your analysts with data producers more effectively. Pull in data from a huge number of sources to dramatically increase the depth and breadth of your business intelligence. And visualize vast amounts of information in treemaps, heatmaps and scatter plots to spot trends and anomalies that others can’t see. |
| Portugal Government Open Data Portal | Portugal Government open data portal running on OGDI DataLab and Windows Azure. |
| Public Transit Data Community | Collection of mass transit data from a variety of transportation agencies across the United States. See developer documentation for more details. |
| RemObjects | Data Abstract servers and Relativity Server let you expose your regular Data Abstract services with all associated business logic as OData services, giving you and your customers a cross platform way of accessing its data from non-Data Abstract applications and from platforms not (yet) directly supported by Data Abstract. |
| Research.microsoft.com [RMC] OData | RMC OData is a queryable version of metadata about assets published on research.microsoft.com; such as publications, videos, projects, and downloads. |
| TechEd 2013 | Microsoft TechEd 2010 conference session data. |
| Telerik | Telerik, always being a pioneer in supporting new technologies, not only provides native support for the OData protocol in its products, but also offers several applications and services which expose their data using the OData protocol. |
| Telerik TV | Telerik’s catalog of libraries, videos, Tags and Series |
| Versailles Open Data Portal | The open data portal of Versailles, France, running with a lightweight data browser using OGDI DataLab and Windows Azure. |
| webnodes | Webnodes CMS has a custom OData provider built-in that exposes the content in the system as OData feeds. This opens up a lot of opportunities! |
| Windows Azure Marketplace DataMarket | Windows Azure Marketplace DataMarket allows producers to sell premier data to consumers, using OData. |
| Windows Live | You can now use an OData client to talk to your Windows Live resources (Photos, Contacts, Status, etc) whose REST endpoints are now OData endpoints. |
| OData Powershell Explorer | An ‘OData Explorer’ PowerShell application designed to allow ad-hoc browsing of OData Services using the command line or GUI using WPK from the Microsoft PowerShell Pack. | Download |
| OData Provider Toolkit | A series of samples that show you how to write a custom Data Service Provider for ADO.NET Data Services or WCF Data Services. | Download |
| OData Validation Toolkit | A code sample that shows how to generate tests specific to your OData Service using T4 test templates. | Download |
| Sample Services | A copy of the code used in the sample services above. | Download |
| Agility CMS | Creating Streamlined DataServiceContext Proxy Class to interact with your UGC OData Feed |
| EastBanc Technologies Case Study | Firm Uses Cloud Services to Unify Data from Transit Systems, Improve Access to Schedules |
| FlatMerge | |
| IdeaBlade DevForce | Enabling OData for a DevForce model allows for non-.NET clients to access the same back-end as your DevForce .NET clients. |
| JayData | JayData |
| Open Data for Open Science 2011 | Setting up the Deployer and the oData Web Service |
| SAP Netweaver Gateway | How to set up oData service in SAP Netweaver Gateway using SEGW transaction |
| Securing OData API | In this tutorial we’re going to look at how the Layer 7 Gateway can be used to secure and constrain an OData API. |
| Socrata | This tutorial walks through analyzing Socrata data in Microsoft Excel® via OData |
| Tableau | This example discusses how to connect Tableau to an OData data source |
| Visual Fusion Enterprise | Connecting to an OData source |
| Xceed |


---
layout: default
title: Meet the Orchestra
group: about
group-weight: 3
permalink: /about/orchestra/
---
Meet the Orchestra
{% assign members = site.members | where: 'weight', 1 | sort: 'name' %}
{% for member in members %}
{% include member.html %}
{% endfor %}
{% assign members = site.members | where: 'weight', 2 | sort: 'name' %}
{% for member in members %}
{% include member.html %}
{% endfor %}
{% assign members = site.members | where: 'weight', 3 | sort: 'name' %}
{% for member in members %}
{% include member.html %}
{% endfor %}


class GenoPheno(object):
Genotype-phenotype transformation.
Method pheno
provides the transformation from geno- to phenotype,
that is from the internal representation to the representation used
in the objective function. Method geno
provides the "inverse" pheno-
to genotype transformation. The geno-phenotype transformation comprises,
in this order:
- insert fixed variables (with the phenotypic values)
- affine linear transformation (first scaling then shift)
- user-defined transformation
- repair (e.g. into feasible domain due to boundaries)
- re-assign fixed variables their original phenotypic value
By default all transformations are the identity. The repair is only
applied, if the transformation is given as argument to the method
pheno
.
geno
is only necessary, if solutions have been injected.
| Method | __init__ |
return GenoPheno instance with phenotypic dimension dim . |
| Method | geno |
maps the phenotypic input argument into the genotypic space, that is, computes essentially the inverse of pheno. |
| Method | pheno |
maps the genotypic input argument into the phenotypic space, see help for class GenoPheno |
| Instance Variable | fixed |
Undocumented |
| Instance Variable | isidentity |
Undocumented |
| Instance Variable | islinear |
Undocumented |
| Instance Variable | N |
Undocumented |
| Instance Variable | repaired |
Undocumented |
| Instance Variable | scales |
Undocumented |
| Instance Variable | tf |
Undocumented |
| Instance Variable | tf |
Undocumented |
| Instance Variable | typical |
Undocumented |
return GenoPheno
instance with phenotypic dimension dim
.
Keyword Arguments
scaling
- the diagonal of a scaling transformation matrix, multipliers in the genotyp-phenotyp transformation, see
typical_x
typical_x
- pheno = scaling*geno + typical_x
fixed_values
- a dictionary of variable indices and values, like {0:2.0, 2:1.1}, that are not subject to change, negative indices are ignored (they act like incommenting the index), values are phenotypic values.
tf
list of two user-defined transformation functions, or
None
.tf[0] is a function that transforms the internal representation as used by the optimizer into a solution as used by the objective function. tf[1] does the back-transformation. For example:
tf_0 = lambda x: [xi**2 for xi in x] tf_1 = lambda x: [abs(xi)**0.5 fox xi in x]or "equivalently" without the
lambda
construct:def tf_0(x): return [xi**2 for xi in x] def tf_1(x): return [abs(xi)**0.5 fox xi in x]tf=[tf_0, tf_1] is a reasonable way to guaranty that only positive values are used in the objective function.
Details
If tf_0 is not the identity and tf_1 is ommitted, the genotype of x0 cannot be computed consistently and "injection" of phenotypic solutions is likely to lead to unexpected results.
maps the phenotypic input argument into the genotypic space, that is, computes essentially the inverse of pheno.
By default a copy is made only to prevent to modify y.
The inverse of the user-defined transformation (if any) is only needed if external solutions are injected, it is not applied to the initial solution x0.
Details
geno searches first in archive for the genotype of y and returns the found value, typically unrepaired. Otherwise, first from_bounds is applied, to revert a projection into the bound domain (if necessary) and pheno is reverted. repair is applied last, and is usually the method CMAEvolutionStrategy.repair_genotype that limits the Mahalanobis norm of geno(y) - mean.
maps the genotypic input argument into the phenotypic space,
see help for class GenoPheno
Details
If copy, values from x are copied if changed under the transformation.


Watch this video to get a feel for Susan's design contributions.
Watch this video to get a feel for Ingrid's artistic contributions.


Please consider uploading a square image
Okay I am a newbie!
Hmm! I'm up for a challange
This looks too easy! Apparantly
Who am I kidding?
I admit! I'm insane
No Comments!
start
reset


Before Change
Convert snake casing where present to camel casing
s = "".join(word.capitalize() for word in string.split("_"))
for c in ascii_lowercase:
s = s.replace("-" + c, c.upper())
return s
def calculate_genfiles(path, source):
with open(path, "r") as protobuf:
After Change
def camelcase(string):
Convert snake casing where present to camel casing
return "".join(word.capitalize() for word in re.split("[-_]", string))
def calculate_genfiles(path, source):
with open(path, "r") as protobuf:
lines = protobuf.readlines()


FAQ's
Contact me
*This will open whatever mailing application is built into your operating system. If you would rather send me an email using an internet application, just send it to nfelch@smith.edu


I am a front-end website developer based out of the metro-Detroit area.
I get a lot of enjoyment out of taking an idea and bringing it to life on
the screen in front of me! When I am not working on developing websites,
I like to travel, spend time on the water, fight for those who don't have a voice,
and dabble in photography. I am a proponent of the Oxford comma! :)
My focus is on writing clean, well-formatted, semantic HTML5 to
make sure that the content is easy to read, easy to collaborate on,
easy to trouble-shoot, and is accessible to all users.
I pride myself on writing CSS that is easy to read and build on.
I focus on keeping my CSS lean and fast to load, and I try
to stay up to date on current best practices.
I look forward to taking your ideas and/or PSD and quickly & accurately
converting them into a webpage that is a pixel-perfect match, and something you are proud of.


Install instructions:
download and unzip the file
move extracted file to your IntelliJ project directory
right-click and select open the first time
A new
"submission.zip"
was created!
download
Handmade by
C.Wong


1. Introduction
Groovy supports multiple ways to generate text dynamically including GStrings
, printf
and MarkupBuilder just to name a few. In addition to these, there is a dedicated template framework which is well-suited to applications where the text to be generated follows the form of a static template.
2. Template framework
The template framework in Groovy consists of a TemplateEngine
abstract base class that engines must implement and a Template
interface that the resulting templates they generate must implement.
Included with Groovy are several template engines:
-
SimpleTemplateEngine
- for basic templates -
StreamingTemplateEngine
- functionally equivalent toSimpleTemplateEngine
, but can handle strings larger than 64k -
GStringTemplateEngine
- stores the template as writeable closures (useful for streaming scenarios) -
XmlTemplateEngine
- works well when the template and output are valid XML -
MarkupTemplateEngine
- a very complete, optimized, template engine
3. SimpleTemplateEngine
Shown here is the SimpleTemplateEngine
that allows you to use JSP-like scriptlets (see example below), script, and EL expressions in your template in order to generate parametrized text. Here is an example of using the system:
def text = 'Dear "$firstname $lastname",\nSo nice to meet you in <% print city %>.\nSee you in ${month},\n${signed}'
def binding = ["firstname":"Sam", "lastname":"Pullara", "city":"San Francisco", "month":"December", "signed":"Groovy-Dev"]
def engine = new groovy.text.SimpleTemplateEngine()
def template = engine.createTemplate(text).make(binding)
def result = 'Dear "Sam Pullara",\nSo nice to meet you in San Francisco.\nSee you in December,\nGroovy-Dev'
assert result == template.toString()
While it is generally not deemed good practice to mix processing logic in your template (or view), sometimes very simple logic can be useful. E.g. in the example above, we could change this:
$firstname
to this (assuming we have set up a static import for capitalize inside the template):
${firstname.capitalize()}
or this:
<% print city %>
to this:
<% print city == "New York" ? "The Big Apple" : city %>
3.1. Advanced Usage Note
If you happen to be embedding your template directly in your script (as we did above) you have to be careful about backslash escaping. Because the template string itself will be parsed by Groovy before it is passed to the the templating framework, you have to escape any backslashes inside GString expressions or scriptlet 'code' that are entered as part of a Groovy program. E.g. if we wanted quotes around The Big Apple above, we would use:
<% print city == "New York" ? "\\"The Big Apple\\"" : city %>
Similarly, if we wanted a newline, we would use:
\\n
in any GString expression or scriptlet 'code' that appears inside a Groovy script. A normal “\n” is fine within the static template text itself or if the entire template itself is in an external template file. Similarly, to represent an actual backslash in your text you would need
\\\\
in an external file or
\\\\
in any GString expression or scriptlet 'code'. (Note: the necessity to have this extra slash may go away in a future version of Groovy if we can find an easy way to support such a change.)
4. StreamingTemplateEngine
The StreamingTemplateEngine
engine is functionally equivalent to the SimpleTemplateEngine
, but creates the template using writeable closures making it more scalable for large templates. Specifically this template engine can handle strings larger than 64k.
It uses JSP style <% %> script and <%= %> expression syntax or GString style expressions. The variable 'out' is bound to the writer that the template is being written to.
Frequently, the template source will be a file but here we show a simple example providing the template as a string:
def text = '''\
Dear <% out.print firstname %> ${lastname},
We <% if (accepted) out.print 'are pleased' else out.print 'regret' %> \
to inform you that your paper entitled
'$title' was ${ accepted ? 'accepted' : 'rejected' }.
The conference committee.'''
def template = new groovy.text.StreamingTemplateEngine().createTemplate(text)
def binding = [
firstname : "Grace",
lastname : "Hopper",
accepted : true,
title : 'Groovy for COBOL programmers'
]
String response = template.make(binding)
assert response == '''Dear Grace Hopper,
We are pleased to inform you that your paper entitled
'Groovy for COBOL programmers' was accepted.
The conference committee.'''
5. GStringTemplateEngine
As an example of using the GStringTemplateEngine
, here is the example above done again (with a few changes to show some other options). First we will store the template in a file this time:
Dear "$firstname $lastname",
So nice to meet you in <% out << (city == "New York" ? "\\"The Big Apple\\"" : city) %>.
See you in ${month},
${signed}
Note that we used out
instead of print
to support the streaming nature of GStringTemplateEngine
. Because we have the template in a separate file, there is no need to escape the backslashes. Here is how we call it:
def f = new File('test.template')
def engine = new groovy.text.GStringTemplateEngine()
def template = engine.createTemplate(f).make(binding)
println template.toString()
and here is the output:
Dear "Sam Pullara", So nice to meet you in "The Big Apple". See you in December, Groovy-Dev
6. XmlTemplateEngine
XmlTemplateEngine
for use in templating scenarios where both the template source and the expected output are intended to be XML. Templates may use the normal ${expression}
and $variable
notations to insert an arbitrary expression into the template. In addition, support is also provided for special tags: <gsp:scriptlet>
(for inserting code fragments) and <gsp:expression>
(for code fragments which produce output).
Comments and processing instructions will be removed as part of processing and special XML characters such as <
, >
, "
and '
will be escaped using the respective XML notation. The output will also be indented using standard XML pretty printing.
The xmlns namespace definition for gsp: tags will be removed but other namespace definitions will be preserved (but may change to an equivalent position within the XML tree).
Normally, the template source will be in a file but here is a simple example providing the XML template as a string:
def binding = [firstname: 'Jochen', lastname: 'Theodorou', nickname: 'blackdrag', salutation: 'Dear']
def engine = new groovy.text.XmlTemplateEngine()
def text = '''\
<document xmlns:gsp='http://groovy.codehaus.org/2005/gsp' xmlns:foo='baz' type='letter'>
<gsp:scriptlet>def greeting = "${salutation}est"</gsp:scriptlet>
<gsp:expression>greeting</gsp:expression>
<foo:to>$firstname "$nickname" $lastname</foo:to>
How are you today?
</document>
'''
def template = engine.createTemplate(text).make(binding)
println template.toString()
This example will produce this output:
<document type='letter'>
Dearest
<foo:to xmlns:foo='baz'>
Jochen "blackdrag" Theodorou
</foo:to>
How are you today?
</document>
7. The MarkupTemplateEngine
This template engine is a template engine primarily aimed at generating XML-like markup (XML, XHTML, HTML5, …), but that can be used to generate any text based content. Unlike traditional template engines, this one relies on a DSL that uses the builder syntax. Here is a sample template:
xmlDeclaration()
cars {
cars.each {
car(make: it.make, model: it.model)
}
}
If you feed it with the following model:
model = [cars: [new Car(make: 'Peugeot', model: '508'), new Car(make: 'Toyota', model: 'Prius')]]
It would be rendered as:
<?xml version='1.0'?>
<cars><car make='Peugeot' model='508'/><car make='Toyota' model='Prius'/></cars>
The key features of this template engine are:
-
a markup builder like syntax
-
templates are compiled into bytecode
-
fast rendering
-
optional type checking of the model
-
includes
-
internationalization support
-
fragments/layouts
7.1. The template format
7.1.1. Basics
Templates consist of Groovy code. Let’s explore the first example more thoroughly:
xmlDeclaration() (1)
cars { (2)
cars.each { (3)
car(make: it.make, model: it.model) (4)
} (5)
}
| 1 | renders the XML declaration string. |
| 2 | opens a cars tag |
| 3 | cars is a variable found in the template model, which is a list of Car instances |
| 4 | for each item, we create a car tag with the attributes from the Car instance |
| 5 | closes the cars tag |
As you can see, regular Groovy code can be used in the template. Here, we are calling each
on a list (retrieved from the model), allowing us to
render one car
tag per entry.
In a similar fashion, rendering HTML code is as simple as this:
yieldUnescaped '<!DOCTYPE html>' (1)
html(lang:'en') { (2)
head { (3)
meta('http-equiv':'"Content-Type" content="text/html; charset=utf-8"') (4)
title('My page') (5)
} (6)
body { (7)
p('This is an example of HTML contents') (8)
} (9)
} (10)
| 1 | renders the HTML doctype special tag |
| 2 | opens the html tag with an attribute |
| 3 | opens the head tag |
| 4 | renders a meta tag with one http-equiv attribute |
| 5 | renders the title tag |
| 6 | closes the head tag |
| 7 | opens the body tag |
| 8 | renders a p tag |
| 9 | closes the body tag |
| 10 | closes the html tag |
The output is straightforward:
<!DOCTYPE html><meta http-equiv='"Content-Type" content="text/html; charset=utf-8"'/><title>My page</title>
This is an example of HTML contents

| With some configuration, you can have the output pretty printed, with newlines and indent automatically added. |
7.1.2. Support methods
In the previous example, the doctype declaration was rendered using the yieldUnescaped
method. We have also seen the xmlDeclaration
method.
The template engine provides several support methods that will help you render contents appropriately:
| Method | Description | Example |
|---|---|---|
yield |
Renders contents, but escapes it before rendering |
Template:
Output:
|
yieldUnescaped |
Renders raw contents. The argument is rendered as is, without escaping. |
Template:
Output:
|
xmlDeclaration |
Renders an XML declaration String. If the encoding is specified in the configuration, it is written in the declaration. |
Template:
Output:
If Output:
|
comment |
Renders raw contents inside an XML comment |
Template:
Output:
|
newLine |
Renders a new line. See also |
Template:
Output:
|
pi |
Renders an XML processing instruction. |
Template:
Output:
|
tryEscape |
Returns an escaped string for an object, if it is a |
Template:
Output:
|
7.1.3. Includes
The MarkupTemplateEngine
supports inclusion of contents from another file. Included contents may be:
-
another template
-
raw contents
-
contents to be escaped
Including another template can be done using:
include template: 'other_template.tpl'
Including a file as raw contents, without escaping it, can be done like this:
include unescaped: 'raw.txt'
Eventually, inclusion of text that should be escaped before rendering can be done using:
include escaped: 'to_be_escaped.txt'
Alternatively, you can use the following helper methods instead:
-
includeGroovy(<name>)
to include another template -
includeEscaped(<name>)
to include another file with escaping -
includeUnescaped(<name>)
to include another file without escaping
Calling those methods instead of the include xxx:
syntax can be useful if the name of the file to be included is dynamic (stored in a variable for example).
Files to be included (independently of their type, template or text) are found on classpath. This is one of the reasons why the MarkupTemplateEngine
takes
an optional ClassLoader
as constructor argument (the other reason being that you can include code referencing other classes in a template).
If you don’t want your templates to be on classpath, the MarkupTemplateEngine
accepts a convenient constructor that lets you define the directory where
templates are to be found.
7.1.4. Fragments
Fragments are nested templates. They can be used to provide improved composition in a single template. A fragment consists of a string, the inner template, and a model, used to render this template. Consider the following template:
ul {
pages.each {
fragment "li(line)", line:it
}
}
The fragment
element creates a nested template, and renders it with a model which is specific to this template. Here,
we have the li(line)
fragment, where line
is bound to it
. Since it
corresponds to the iteration of pages
,
we will generate a single li
element for each page in our model:

Page 1

Page 2

Fragments are interesting to factorize template elements. They come at the price of the compilation of a fragment per template, and they cannot be externalized.
7.1.5. Layouts
Layouts, unlike fragments, refer to other templates. They can be used to compose templates and share common structures. This is often interesting if you have, for example, a common HTML page setup, and that you only want to replace the body. This can be done easily with a layout. First of all, you need to create a layout template:
html {
head {
title(title) (1)
}
body {
bodyContents() (2)
}
}
| 1 | the title variable (inside the title tag) is a layout variable |
| 2 | the bodyContents call will render the body |
Then what you need is a template that includes the layout:
layout 'layout-main.tpl', (1)
title: 'Layout example', (2)
bodyContents: contents { p('This is the body') } (3)
| 1 | use the main-layout.tpl layout file |
| 2 | set the title variable |
| 3 | set the bodyContents |
As you can see, bodyContents
will be rendered inside the layout, thanks to the bodyContents()
call in the layout file. As
a result, the template will be rendered as this:
<title>Layout example</title>
This is the body

The call to the contents
method is used to tell the template engine that the block of code is in fact a specification of a
template, instead of a helper function to be rendered directly. If you don’t add contents
before your specification, then
the contents would be rendered, but you would also see a random string generated, corresponding to the result value of the block.
Layouts are a powerful way to share common elements across multiple templates, without having to rewrite everything or use includes.
Layouts use, by default, a model which is independent from the model of the page where they are used. It is however possible to make them inherit from the parent model. Imagine that the model is defined like this:
model = new HashMap<String,Object>();
model.put('title','Title from main model');
and the following template:
layout 'layout-main.tpl', true, (1)
bodyContents: contents { p('This is the body') }
| 1 | note the use of true to enable model inheritance |
then it is not necessary to pass the title
value to the layout as in the previous example. The result will be:
<title>Title from main model</title>
This is the body

But it is also possible to override a value from the parent model:
layout 'layout-main.tpl', true, (1)
title: 'Overriden title', (2)
bodyContents: contents { p('This is the body') }
| 1 | true means inherit from the parent model |
| 2 | but title is overriden |
then the output will be:
<title>Overriden title</title>
This is the body

7.2. Rendering contents
7.2.1. Creation of a template engine
On the server side, rendering templates require an instance of groovy.text.markup.MarkupTemplateEngine
and a
groovy.text.markup.TemplateConfiguration
:
TemplateConfiguration config = new TemplateConfiguration(); (1)
MarkupTemplateEngine engine = new MarkupTemplateEngine(config); (2)
Template template = engine.createTemplate("p('test template')"); (3)
Map<String, Object> model = new HashMap<>(); (4)
Writable output = template.make(model); (5)
output.writeTo(writer); (6)
| 1 | creates a template configuration |
| 2 | creates a template engine with this configuration |
| 3 | creates a template instance from a String |
| 4 | creates a model to be used in the template |
| 5 | bind the model to the template instance |
| 6 | render output |
There are several possible options to parse templates:
-
from a
String
, usingcreateTemplate(String)
-
from a
Reader
, usingcreateTemplate(Reader)
-
from a
URL
, usingcreateTemplate(URL)
-
given a template name, using
createTemplateByPath(String)
The last version should in general be preferred:
Template template = engine.createTemplateByPath("main.tpl");
Writable output = template.make(model);
output.writeTo(writer);
7.2.2. Configuration options
The behavior of the engine can be tweaked with several configuration options accessible through the TemplateConfiguration
class:
| Option | Default value | Description | Example |
|---|---|---|---|
declarationEncoding |
null |
Determines the value of the encoding to be written when |
Template:
Output:
If Output:
|
expandEmptyElements |
false |
If true, empty tags are rendered in their expanded form. |
Template:
Output:
If Output:
|
useDoubleQuotes |
false |
If true, use double quotes for attributes instead of simple quotes |
Template:
Output:
If Output:
|
newLineString |
System default (system property |
Allows to choose what string is used when a new line is rendered |
Template:
If Output:
|
autoEscape |
false |
If true, variables from models are automatically escaped before rendering. |
|
autoIndent |
false |
If true, performs automatic indentation after new lines |
|
autoIndentString |
four (4) spaces |
The string to be used as indent. |
|
autoNewLine |
false |
If true, performs automatic insertion of new lines |
|
baseTemplateClass |
|
Sets the super class of compiled templates. This can be used to provide application specific templates. |
|
locale |
Default locale |
Sets the default locale for templates. |
| Once the template engine has been created, it is unsafe to change the configuration. |
7.2.3. Automatic formatting
By default, the template engine will render output without any specific formatting. Some configuration options can improve the situation:
-
autoIndent
is responsible for auto-indenting after a new line is inserted -
autoNewLine
is responsible for automatically inserting new lines based on the original formatting of the template source
In general, it is recommended to set both autoIndent
and autoNewLine
to true if you want human-readable, pretty printed, output:
config.setAutoNewLine(true);
config.setAutoIndent(true);
Using the following template:
html {
head {
title('Title')
}
}
The output will now be:

<title>Title</title>

We can slightly change the template so that the title
intruction is found on the same line as the head
one:
html {
head { title('Title')
}
}
And the output will reflect that:

<title>Title</title>

New lines are only inserted where curly braces for tags are found, and the insertion corresponds to where the nested content is found. This means that tags in the body of another tag will not trigger new lines unless they use curly braces themselves:
html {
head {
meta(attr:'value') (1)
title('Title') (2)
newLine() (3)
meta(attr:'value2') (4)
}
}
| 1 | a new line is inserted because meta is not on the same line as head |
| 2 | no new line is inserted, because we’re on the same depth as the previous tag |
| 3 | we can force rendering of a new line by explicitly calling newLine |
| 4 | and this tag will be rendered on a separate line |
This time, the output will be:

<meta attr='value'/><title>Title</title>
<meta attr='value2'/>

By default, the renderer uses four(4) spaces as indent, but you can change it by setting the TemplateConfiguration#autoIndentString
property.
7.2.4. Automatic escaping
By default, contents which is read from the model is rendered as is. If this contents comes from user input, it can be sensible, and you might
want to escape it by default, for example to avoid XSS injection. For that, the template configuration provides an option which will automatically
escape objects from the model, as long as they inherit from CharSequence
(typically, `String`s).
Let’s imagine the following setup:
config.setAutoEscape(false);
model = new HashMap<String,Object>();
model.put("unsafeContents", "I am an  hacker.");
and the following template:
html {
body {
div(unsafeContents)
}
}
Then you wouldn’t want the HTML from unsafeContents
to be rendered as is, because of potential security issues:

I am an  hacker.

Automatic escaping will fix this:
config.setAutoEscape(true);
And now the output is properly escaped:

I am an  hacker.

Note that using automatic escaping doesn’t prevent you from including unescaped contents from the model. To do this, your template should then explicitly
mention that a model variable should not be escaped by prefixing it with unescaped.
, like in this example:
html {
body {
div(unescaped.unsafeContents)
}
}
7.2.5. Common gotchas
Strings containing markup
Say that you want to generate a

tag which contains a string containing markup:
p {
yield "This is a "
a(href:'target.html', "link")
yield " to another page"
}
and generates:

This is a link to another page

Can’t this be written shorter? A naive alternative would be:
p {
yield "This is a ${a(href:'target.html', "link")} to another page"
}
but the result will not look as expected:

linkThis is a to another page

The reason is that the markup template engine is a streaming engine. In the original version, the first yield
call
generates a string which is streamed to the output, then the a
link is generated and streamed, and then the last yield
call is streamed, leading in an execution in order. But with the string version above, the order of execution is different:
-
the
yield
call requires an argument, a string -
that arguments needs to be evaluated before the yield call is generated
so evaluating the string leads to an execution of the a(href:…)
call before yield
is itself called. This is not
what you want to do. Instead, you want to generate a string which contains markup, which is then passed to the yield
call. This can be done this way:
p("This is a ${stringOf {a(href:'target.html', "link")}} to another page")
Note the stringOf
call, which basically tells the markup template engine that the underlying markup needs to be rendered
separately and exported as a string. Note that for simple expressions, stringOf
can be replaced by an alternate tag
notation that starts with a dollar sign:
p("This is a ${$a(href:'target.html', "link")} to another page")
It is worth noting that using stringOf or the special $tag notation triggers the creation of a distinct string writer
which is then used to render the markup. It is slower than using the version with calls to yield which perform direct
streaming of the markup instead.
|
7.2.6. Internationalization
The template engine has native support for internationalization. For that, when you create the TemplateConfiguration
, you can provide
a Locale
which is the default locale to be used for templates. Each template may have different versions, one for each locale. The
name of the template makes the difference:
-
file.tpl
: default template file -
file_fr_FR.tpl
: french version of the template -
file_en_US.tpl
: american english version of the template -
…
When a template is rendered or included, then:
-
if the template name or include name explicitly sets a locale, the specific version is included, or the default version if not found
-
if the template name doesn’t include a locale, the version for the
TemplateConfiguration
locale is used, or the default version if not found
For example, imagine the default locale is set to Locale.ENGLISH
and that the main template includes:
include template: 'locale_include_fr_FR.tpl'
then the template is rendered using the specific template:
Texte en français
Using an include without specifying a locale will make the template engine look for a template with the configured locale, and if not, fallback to the default, like here:
include template: 'locale_include.tpl'
Default text
However, changing the default locale of the template engine to Locale.FRANCE
will change the output, because the template engine will now look for a file
with the fr_FR
locale:
Texte en français
This strategy lets you translate your templates one by one, by relying on default templates, for which no locale is set in the file name.
7.2.7. Custom template classes
By default, templates created inherit the groovy.text.markup.BaseTemplate
class. It may be interesting for an application to provide a different
template class, for example to provide additional helper methods which are aware of the application, or customized rendering primitives (for HTML,
for example).
The template engine provides this ability by setting an alternative baseTemplateClass
in the TemplateConfiguration
:
config.setBaseTemplateClass(MyTemplate.class);
The custom base class has to extend BaseClass
like in this example:
public abstract class MyTemplate extends BaseTemplate {
private List<Module> modules
public MyTemplate(
final MarkupTemplateEngine templateEngine,
final Map model,
final Map<String, String> modelTypes,
final TemplateConfiguration configuration) {
super(templateEngine, model, modelTypes, configuration)
}
List<Module> getModules() {
return modules
}
void setModules(final List<Module> modules) {
this.modules = modules
}
boolean hasModule(String name) {
modules?.any { it.name == name }
}
}
This example shows a class which provides an additional method named hasModule
, which can then be used directly in the template:
if (hasModule('foo')) {
p 'Found module [foo]'
} else {
p 'Module [foo] not found'
}
7.3. Type checked templates
7.3.1. Optional type checking
Even if templates are not type checked, they are statically compiled. This means that once the templates are compiled, performance should be very good. For some applications, it might be good to make sure that templates are valid before they are actually rendered. This means failing template compilation, for example, if a method on a model variable doesn’t exist.
The MarkupTemplateEngine
provides such a facility. Templates can be optionally type checked. For that, the developer must provide additional information at
template creation time, which is the types of the variables found in the model. Imagine a model exposing a list of pages, where a page is defined as:
public class Page {
Long id
String title
String body
}
Then a list of pages can be exposed in the model, like this:
Page p = new Page();
p.setTitle("Sample page");
p.setBody("Page body");
List<Page> pages = new LinkedList<>();
pages.add(p);
model = new HashMap<String,Object>();
model.put("pages", pages);
A template can use it easily:
pages.each { page -> (1)
p("Page title: $page.title") (2)
p(page.text) (3)
}
| 1 | iterate on pages from the model |
| 2 | page.title is valid |
| 3 | page.text is not (should be page.body ) |
Without type checking, the compilation of the template succeeds, because the template engine doesn’t know about the model until a page is actually rendered. This means that the problem would only surface at runtime, once the page is rendered:
No such property: text
In some situations, this can be complicated to sort out or even notice. By declaring the type of the pages
to the template engine, we’re now capable of failing at compile time:
modelTypes = new HashMap<String,String>(); (1)
modelTypes.put("pages", "List<Page>"); (2)
Template template = engine.createTypeCheckedModelTemplate("main.tpl", modelTypes) (3)
| 1 | create a map which will hold the model types |
| 2 | declare the type of the pages variables (note the use of a string for the type) |
| 3 | use createTypeCheckedModelTemplate instead of createTemplate |
This time, when the template is compiled at the last line, an error occurs:
[Static type checking] - No such property: text for class: Page
This means that you don’t need to wait for the page to be rendered to see an error. The use of createTypeCheckedModelTemplate
is mandatory.
7.3.2. Alternative declaration of types
Alternatively, if the developer is also the one who writes the templates, it is possible to declare the types of the expected variables
directly in the template. In this case, even if you call createTemplate
, it will be type checked:
modelTypes = { (1)
List<Page> pages (2)
}
pages.each { page ->
p("Page title: $page.title")
p(page.text)
}
| 1 | types need to be declared in the modelTypes header |
| 2 | declare one variable per object in the model |
7.3.3. Performance of type checked templates
An additional interest of using type checked models is that performance should improve. By telling the type checker what are the expected types, you also let the compiler generate optimized code for that, so if you are looking for the best performance, consider using type checked templates.
8. Other solutions
Also, there are other templating solutions that can be used along with Groovy, such as FreeMarker, Velocity, StringTemplate and others.


{% extends "base.html" %} {% block content %}
Create email based reminders for yourself and others.
Log in or register now.


A review by John Beachem
* * * *
CAST Neve Campbell - Sidney Prescott Skeet Ulrich - Billy Loomis Matthew Lillard - Stuart Maker Jamie Kennedy - Randy Meeks David Arquette - Deputy Dwight "Dewey* Riley Courtney Cox - Gale Weathers
Twelve years ago, director Wes Craven gave audiences "A Nightmare on Elm Street", and terrified an entire generation. After an ungodly number of terrible sequels, Mr. Craven has collaborated with writer Keven Williamson on something quite new. "Scream", is a rare item indeed. A serious horror movie in which all involved seem to realize they are in a horror movie.
A serial killer, obsessed with old horror movies, is stalking a small California town. After the brutal murders of two high school students in the beginning of the film (one of the movie's most shocking and tense scenes), a group of high school students decide to figure out who the killer is. Sidney Prescott (Neve Campbell), is more or less the leader of the group, and her mother had been killed the year before. As the teens search for the killer's identity, everyone becomes a suspect. Things are made more interesting by a TV reporter, Gale Weathers (Courtney Cox), and a deputy (David Arquette) who are also trying to determine the killer's identity.
This film is not for the squeamish, be forewarned. It just barely squeaked by an NC-17 rating for exessive gore. I can't, in good conscience, give a blood splattered horror movie a higher rating than four stars, but this is truly one of the best I've seen. The only weak point in this film seems to be Neve Campbell's acting at times. It's not that she does a bad job, she simply isn't as convincing as the rest of the cast. In particular, Skeet Ulrich and Matthew Lillard are quite good. Lillard plays Campbell's boyfriend, and Lillard is a goofy member of the group. Jamie Kennedy is a riot as the horror movie expert of the gang, spending a good deal of time spouting off lines from horror films and quoting the rules for how to survive a horror flick.
Another excellent member of the cast, though she isn't in it for too long, is Drew Barrymore. Playing a terrified student, home alone one night at the beginning of the film, she does a marvelous job. One last thing I must point out, is how much I enjoyed the mystery aspect to the story. The majority of horror films make it quite clear who the killer is. Not here.
This movie is a lot of fun for those who have strong stomachs. If you don't normally enjoy slasher flicks, stay far away from this one. Watch for two rather surprising actors in here too. Henry Winkler, as the high school principal, and Robert Englund (Freddy Kreuger) shows up very quickly as a janitor.
* * * * * - One of the greatest movies ever made, see it now. * * * * - Great flick, try and catch this one. * * * - Okay movie, hits and misses. * * - Pretty bad. See it if you've got nothing better to do. * - One of the worst movies ever. See it only if you enjoy pain.
E-mail with comments at<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Royal Enfield motorcycle configurator introduced
by Firoze IraniThe new Royal Enfield configurator allows you customise their bikes with accessories like panniers, exhausts, touring seat options and alloy wheels.
Royal Enfield recently introduced an online motorcycle configurator which allows users to customise the company's models online. The configurator also shows buyers how the customised model will end up looking if they chose to equip it with the factory-fitted accessories.
Customers can accessorise their bikes with engine guards, panniers, rear luggage rack, a touring seat and alloy wheels. The manufacturer says these genuine accessories come with a two year warranty. Royal Enfield are calling this the ‘Make Your Own’ initiative and are rolling it out in 141 stores across 6 cities - Delhi NCR, Bangalore, Chennai, Hyderabad, Mumbai and Pune.
In the initial stage, Make Your Own will only be applicable for customers who are booking the latest Classic 350 that has been launched in two new colours - Mercury SIlver and Pure Black. It will be extended to the other Royal Enfield models in a phased manner.
The accessory list for the Classic 350 is quite extensive. It includes 16 different exhaust options and over half a dozen luggage and protection options. The company has alloy wheels on offer. We spent some time on the configurator and managed to add Rs 36,000 of additional equipment on the Classic 350.
Also see:
Royal Enfield Bullet 350 prices hiked
Royal Enfield Himalayan likely to get updated in coming months


Review(c)1998 eric lurio
Primary Colors
Directed by Mike Nichols
This couldn't have come out at a more opportune time. It's silly and profound at the same time and timely as hell and tells a truth as only a fictionalization can.
Ages ago, there was a miniseries called `Washington: Behind Closed Doors' with Jason Robards, Jr. as President Richard Monckton, a thinly disguesed Nixon clone. Changing the last name, permitted Robards to dig into what he though was the inner man without doing a Tricky Dickie impression like Anthony Hopkins would do twenty years later.
Jack Stanton (John Travolta) is to Slick Willie as Monckton was to Tricky Dick. Travolta gets to delve into the inner Clinton without having to do an impression. But do we want to follow him there?
We meet Henry Burton (Adrian Lester) the grandson of a beloved civil rights leader, while he's following Governor Stanton around during a tour of an inner city school adult literacy program.
Before he knows it, Henry is recruited into Stanton's presidential campaign, thereby getting himself dumped by his radical journalist girlfriend. But that's okay, he's soon shacking up with Daisy Green (Maura Tierney), an assistant campaign manager.
This is kind of an idealized version of the ‘92 campaign. We WANT to see Hillery...um...Susan Stanton (Emma Thompson) slap her husband around when she hears about Gennifer Flow...Cashmere McLeod (Gia Carides) tapes on the tube.
We surely would have wanted to hear like Henry and Libby Holden (Kathy Bates) did, that the tapes were faked.[well I WOULD]
Elaine May's writing sparkles and Mike Nichol's direction is on the money.
Nichols has gotten himself one helluva cast here. Billy Bob Thornton is great as spinmeister Richard Jemmons, and Kathy Bates gives her best performance since `Misery,' Larry Hagman gives a truly bravura performance as rival candidate Freddy Picker
This is, more than anything, about idealism. The Stantons are portrayed as genuine idealists as are most of the campaign bigwigs.
The question is if you really believe in the principles how far would you go to put them into effect?  Or would you cheat a bit, and cover up a peccadillo or two like the Stantons?
It's a question that the last part of the movie attempts to answer to great effect. More and more it becomes apparent that Libby Holden is more central a character than Mrs. Stanton is.
Stick another one up on the provisional top-ten list. Every Republican in congress should see this film.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


1 / 5
A halloween themed picture of Jack Skellington- The Pumpkin King
2 / 5
A picture of space with a lens flare effect
3 / 5
A halloween themed picture based on Goosebumps: Attack of the Jack O' Lanterns
4 / 5
A picture of a ship escaping its framed picture
5 / 5
A picture done in the style of Bob Ross on black canvas
❮
❯


Extensions
The following extensions are available globally.
-
GKGridGraph extension to offer convenience methods for working with Locateables
See moreDeclaration
Swift
class GKGridGraph : GKGraph
CitySimCoreiOS Docs (85% documented)
The following extensions are available globally.
GKGridGraph extension to offer convenience methods for working with Locateables
See moreSwift
class GKGridGraph : GKGraph


Simulate Logged? ({{simulateLogged}})
State 1
State 2
State 3 (Redirect no permission)
State 4 (Redirect if logged to google - global setting)
State 5 (Redirect if logged to custom route specific setting)


| close_abs/1 | Close a stream. |
| foldl/3 | Fold a fun over a file of terms. |
| open_abs/1 | Create a stream from a file. |
| read_abs/2 | Read a term given the absolute position from a stream. |
close_abs(Stream) -> any()
Close a stream.
foldl(File, Fun, Acc0) -> any()
Fold a fun over a file of terms. The terms are stored in binary term format. Fun is of the form F(Term, Pos, Acc) -> NewAcc Terms are read one at a time from the file. Pos is an integer index into the file this can be used later as an argument to read_abs
open_abs(File) -> any()
Create a stream from a file.
read_abs(Stream, Pos) -> any()
Read a term given the absolute position from a stream.
Generated by EDoc, Dec 9 2009, 19:02:42.


There are four main types of Business Organization:
1. Sole Proprietorship 2. Partnership * A. General Partnership * B. Limited Partnership 3. Corporation 4. Limited Liability Companies
ADVANTAGES AND DISADVANTAGES OF BUSINESS ORGANIZATIONS
Sole Proprietorship
Advantages
1. Low start-up costs 2. Greatest freedom from regulations 3. Owner in direct control and asset ownership 4. Single level of taxation and both federal and state levels of taxation 5. Profits belong to owner 6. Reduced levels of annual reporting
Disadvantages
1. Unlimited liability 2. Lack of continuity 3. More difficult to raise capital 4. Limits in tax deductions of medical and group life insurance
Partnership
Advantages
1. Ease in formation 2. Low start-up costs 3. Additional sources of capital 4. Broader management base
Disadvantages
1. Unlimited personal liability 2. Lack of continuity 3. Divided authority 4. Hard to find suitable partners
Corporation
Advantages
1. Limited liability 2. Ownership is transferable 3. Continuous existence 4. Legal entity
Disadvantages
1. Closely regulated 2. Most expensive to organize 3. Difficult to liquidate investment
Corporation
Advantages
1. Tax deferral @ l5% for first $50,000 of income 2. Medical Insurance is deductible 3. Group term life insurance is deductible
Disadvantages
1. Maximum tax rate is 34% 2. Double taxation 3. Favorable liquidation tax treatment is no longer available resulting in double taxation.
S Corporation
Advantages
1. Single level of federal taxation 2. Single level of taxation upon sale or liquidation of business
Disadvantages
1. Medical and group term life insurance is not deductible
Limited Liability Companies
An LLC is a new, non-corporate entity combining the operational flexibility and tax status of partnerships with the limited liability protection traditionally associated with corporations. Profit and non-profit activities may be pursued through LLCs.
Generally, in New Jersey as well as other states that have adopted LLC legislation, an LLC expressly constitutes a separate and distinct legal person. The basic components which are derived from both corporate and partnership laws, are as follows:
* Articles of Organization * Management * Operating Agreement * Limited Liability * Membership * Limited Life
DOCUMENTS YOU MAY NEED
1. Prepare/Review lease agreements or purchase agreements 2. Prepare/Review franchise agreements 3. Prepare/Review buy-sell agreements 4. Obtain licenses, zoning variances 5. Provide specific legal advice 6. Prepare/Review and File Certificate of Incorporation and establish Registered Agent 7. Prepare/Review By-Laws 8. Prepare/Review initial meeting of shareholders documents 9. Prepare/Review and File Trade Name Certificate 10. Prepare/Review Partnership Agreement 11. Prepare/Review Agreement of Sale 12. Prepare/Review Promissory Note 13. Prepare/Review and File Annual Report 14. Suggestions on workers compensation coverage
IS THE CORPORATE STATUS UP TO DATE? IS THE CORPORATE STATUS UP TO DATE?
1. Is the minute book up to date? 2. Are the minutes signed? 3. Do the minutes reflect the following? * a. Annual shareholders meeting? * b. Annual directors meeting? * c. Special meetings? * d. Retirement plan contributions? * e. Bonuses? 4. Are stock certificate books properly up to date? 5. Are by-laws properly up to date? 6. Are proper records of expense reimbursements being kept?
You should have your accountant contact your attorney to be certain these and the following questions are taken care of:
1. Has corporate tax been estimated? 2. Have deposits on federal and state taxes been paid? 3. Are there any earnings accumulation problems? 4. Have state and federal tax returns been prepared? 5. Have all tax returns been filed on time? 6. Should a subchapter S election be made or recorded? 7. Are proper depreciation guidelines being followed?


{% extends "bootstrap_layout.html" %} {% set active_page = "handicap_form" %} {% block content %}
Enter the email your scores are associated with to view your handicap


Once configured, you can create messages and publish them to the queue. You may also create services that will automatically be fired as messages are pushed to your application.
For your convenience, a custom Provider service will be created and registered in the Container for each of your defined Queues. The container service id will be in the format of uecode_qpush.{your queue name}.
Publishing messages is simple - fetch your Provider service from the container and call the publish method, which accepts an array.
#src/My/Bundle/ExampleBundle/Controller/MyController.php
public function publishAction()
{
$message = [
'messages should be an array'.
'they can be flat arrays' => [
'or multidimensional'
]
];
$this->get('uecode_qpush.my_queue_name')->publish($message);
}
Messages are either automatically received by your application and events dispatched (setting push_notification to true), or can be picked up by Cron jobs through an included command if you are not using a Message Queue provider that supports Push notifications.
When the notifications or messages are Pushed to your application, the QPush Bundle automatically catches the request and dispatches an event which can be easily hooked into.
Once a message is received via POST from your Message Queue, a MessageEvent is dispatched which can be handled by your services. Each MessageEvent contains the name of the queue and a Uecode\Bundle\QPushBundle\Message\Message object, accessible through getters.
#src/My/Bundle/ExampleBundle/Service/ExampleService.php
use Uecode\Bundle\QPushBundle\Event\MessageEvent
public function onMessageReceived(MessageEvent $event)
{
$queue_name = $event->getQueueName();
$message = $event->getMessage();
}
The Message objects contain the provider specific message id, a message body, and a collection of provider specific metadata.
These properties are accessible through simple getters.
The message body is an array matching your original message. The metadata property is an ArrayCollection of varying fields sent with your message from your Queue Provider.
#src/My/Bundle/ExampleBundle/Service/ExampleService.php
use Uecode\Bundle\QPushBundle\Event\MessageEvent;
use Uecode\Bundle\QPushBundle\Message\Message;
public function onMessageReceived(MessageEvent $event)
{
$id = $event->getMessage()->getId();
$body = $event->getMessage()->getBody();
$metadata = $event->getMessage()->getMetadata();
// do some processing
}
For your Services to be called on QPush events, they must be tagged with the name uecode_qpush.event_listener. A complete tag is made up of the following properties:
| Tag Property | Example | Description |
|---|---|---|
| name | uecode_qpush.event_listener | The Qpush Event Listener Tag |
| event | {queue name}.message_received | The message_received event, prefixed with the Queue name |
| method | onMessageReceived | A publicly accessbile method on your service |
| priority | 100 | Priority, 1-100 to control order of services. Higher priorities are called earlier |
The priority is useful to chain services, ensuring that they fire in a certain order - the higher priorities fire earlier.
Each event fired by the Qpush Bundle is prefixed with the name of your queue, ex: my_queue_name.message_received.
This allows you to assign services to fire only on certain queues, based on the queue name. However, you may also have multiple tags on a single service, so that one service can handle events from multiple queues.
services:
my_example_service:
class: My\Example\ExampleService
tags:
- { name: uecode_qpush.event_listener, event: my_queue_name.message_received, method: onMessageReceived }
The method listed in the tag must be publicly available in your service and should take a single argument, an instance of Uecode\Bundle\QPushBundle\Event\MessageEvent.
#src/My/Bundle/ExampleBundle/Service/MyService.php
use Uecode\Bundle\QPushBundle\Event\MessageEvent;
// ...
public function onMessageReceived(MessageEvent $event)
{
$queueName = $event->getQueueName();
$message = $event->getMessage();
$metadata = $event->Message()->getMetadata();
// Process ...
}
Once all other Event Listeners have been invoked on a MessageEvent, the QPush Bundle will automatically attempt to remove the Message from your Queue for you.
If an error or exception is thrown, or event propagation is stopped earlier in the chain, the Message will not be removed automatically and may be picked up by other workers.
If you would like to remove the message inside your service, you can do so by calling the delete method on your provider and passing it the message id. However, you must also stop the event propagation to avoid other services (including the Provider service) from firing on that MessageEvent.
#src/My/Bundle/ExampleBundle/Service/MyService.php
use Uecode\Bundle\QPushBundle\Event\MessageEvent;
// ...
public function onMessageReceived(MessageEvent $event)
{
$id = $event->getMessage()->getId();
// Removes the message from the queue
$awsProvider->delete($id);
// Stops the event from propagating
$event->stopPropagation();
}
It is recommended to use your config_dev.yml file to disable the push_notifications settings on your queues. This will make the queue a simple Pull queue. You can then use the uecode:qpush:receive Console Command to receive messages from your Queue.
If you need to test the Push Queue functionality from a local stack or internal machine, it possible to use ngrok to tunnel to your development environment, so its reachable by your Queue Provider.
You would need to update your config_dev.yml configuration to use the ngrok url for your subscriber(s).


[gecode-users] python binding - Gecode does not find a solution on first run, finds a solution on consecutive runs.
Stefan Krastanov
stefan.krastanov at yale.edu
Tue Jul 14 20:23:55 CEST 2015
Hello,
I am using:
gecode-python 0.27
gecode 3.7.3
(newer versions from the debian repository do not work with gecode-python)
I have a python function `my_function` that builds a `gecode.space()`
object with around 200 000 linear IRT_NQ constraints and 3 IRT_EQ
constraints on 9 int variables with domain 1-to-10. One final
constraint is `minimize` over the sum of the variables.
My python function returns `list(space.search())` at the end.
The first call to this function usually takes ~1minute and does not
return any solutions. Consecutive calls take less than a second and
return solutions.
Why is this happening? Is the search non-deterministic?
Can the search give no solutions when there are existing solutions?
Why is the first call slow and returns no solutions while consecutive
calls are fast and return solutions? Especially so given that I
recreate the space each time? Is there some fancy caching happening?
In any case, thanks for the great software. This is the first time I
am using a constraint solver and it is quite amazing what it can do.
Best,
Stefan
More information about the users
mailing list


THINK will take place over the course of the two first days, and will outline the major role of FLOSS in the digital economy. The “Make it Happen!” baseline very concretely sums up the focus on building a successful free and open-source strategy, from a technological and commercial standpoint.
The opening day format will differ from the previous editions as talks will happen in a single-track schedule in the largest auditorium. This enables us to concentrate on having the best schedule in a unique plenary session dedicated to decision-makers in the private and public sectors. Talks will be more concise and will introduce the think tanks and workshops held on the second day.
This renewed format will support the 2013 focus: making it happen. The FLOSS industry is now at a point where we need to have IT departments take the step from intention, either from strategy or political decision, to actual use or purchase.
We will demonstrate that innovation with FLOSS is accessible to all companies and organisations. It is nowadays easier to innovate in each market because of the availability of free and innovative technologies. This demystification of practical innovation will be the major theme of this sixth edition of the Open World Forum.
All of our speakers have successfully innovated with free and open-source software and will share their experiences around its use and impact. Shared innovation and the platforms available for collaborative innovation will be represented. More practically, speakers will document the way they succeeded in bringing innovation through FLOSS in the following sectors:
- Digital economy
- Media
- Public sector
- Foundations and Communities
The opening day will be dedicated to keynotes, conferences and panels. The individual talk slot format will be shorter than previous editions, so we can have a very dynamic and interesting program. The morning will be the opportunity to approach the real impact of Open-Source in the digital economic world, as well as the impact of state policies, the governance, educational and business issues. We'll end this sequence with some industrial, organizational, community and government success stories that might inspire attendees to choose Free and Open-Source Software for their next projects.
The afternoon will focus on the innovation catalyst role that Open-Source plays in the major technological and educational projects, especially in infrastructure and Cloud, in Big Data and the Hadoop platforms, in the Web of tomorrow and in Mobility.
CIOs and major users of FLOSS will be invited to take part in the fifth edition of the Open CIO Summit, which is scheduled for the end of the day.
These topics will be explored deeper during the second day, through workshops and think tanks led by industry and community leaders. This will enable attendees to contribute to the evolution of our field, and of course provide the meeting point where the world experts will get together and talk about the present and the future.


#assign guice="active">
Create a Guice Provider that programmatically creates a EbeanServer instance.
Example provider implementation using ServerConfig
and EbeanServerFactory
.
Example provider implementation using Ebean
that implicitly creates the
default
EbeanServer using application.yml.
In the Guice module bind the provider using eager singleton so that the EbeanServer is created eagerly at startup.
```java // bind the provider as eager singleton bind(EbeanServer.class).toProvider(EbeanServerProvider.class).asEagerSingleton() ```
As long as ServerConfig.setRegister(true)
and ServerConfig.setDefaultServer(true)
are used in the Guice provider then the EbeanServer instance created is also available via the Ebean
singleton and that means both @Inject
and the active record
style can be used.


--- [ Manor Status ] ---
Current mode:
%status%
Next mode change:
%change%
--- [ Castle Info ] ---
%castleInfo%


Command Line Interface¶
groovy-hadoop is a command line tool which integrates with the hadoop jar application.
The syntax is
$ hadoop jar groovy-hadoop-0.2.0.jar [generic hadoop options] [groovy-hadoop options]
with the following rules:
- All generic hadoop options must be specified before groovy-hadoop options to be taken into account
- In case of conflicting options groovy-hadoop options override the generic hadoop ones. For example, if both -D mapred.input.dir=some/path and -input some/other/path are set, the value some/other/path will be used.
groovy-hadoop Options¶
- -help¶
prints help text with a description of both generic hadoop and groovy-hadoop options
- -input <input paths>¶
Convenience parameter. Sets the mapred.input.dir property
- -output <output paths>¶
Convenience parameter. Sets the mapred.output.dir property. The corresponding path should usually not exist.
- -map <map script>¶
Executes the script in the map phase. Available parameters: key, value, context, outKey, outValue, and logger
- -reduce <reduce script>¶
Executes the script in the reduce phase. Available parameters: key, values, context, outKey, outValue, and logger
- -combine <combine script>¶
Executes the script in the combine phase. Available parameters: key, values, context, outKey, outValue, and logger
- -outputKeyClass <class name>¶
Convenience parameter for the mapred.output.key.class property. All hadoop writables can be specified with only their simple class name, like Text for example.
- -outputValueClass <class name>¶
Convenience parameter for the mapred.output.value.class property. All hadoop writables can be specified with only their simple class name, like Text for example.
- -mapOutputKeyClass <class name>¶
Convenience parameter for the mapred.mapoutput.key.class property. All hadoop writables can be specified with only their simple class name, like Text for example.
- -mapOutputValueClass <class name>¶
Convenience parameter for the mapred.mapoutput.value.class property. All hadoop writables can be specified with only their simple class name, like Text for example.
- -combinesplits <max split size>¶
Sets the maximum split size for InputFormats extending FileInputFormat. Use 0 to prevent the applicaton from using combine splits, at all. Example values: 128M, 1G, 134217728. Default value is 512M.
- -jvmreuse <reuse value>¶
Sets the mapred.job.reuse.jvm.num.tasks property. NOTE: In contrast to generic hadoop, the default value is -1 meaning “use JVM instances as often as possible”.
- -quiet¶
Do not use verbose output.
Generic Hadoop Options¶
Just for the sake of completeness, the following list gives an overview on the generic hadoop options which are supported and trasparently delegated to the hadoop jar application. The parameter value names and options descriptions are taken from the org.apache.hadoop.util.GenericOptionsParser class.
- -archives <paths>¶
Comma separated archives to be unarchived on the compute machines.
- -conf <configuration file>¶
Specify an application configuration file.
- -D <property=value>¶
Set arbitrary property value.
- -files <paths>¶
Comma separated files to be copied to the map reduce cluster.
- -fs <local|namenode:port>¶
Sets fs.default.name property.
- -jt <local|jobtracker:port>¶
Sets mapred.job.tracker property.
- -libjars <paths>¶
Comma separated jar files to include in the classpath.