Writing QML Extensions with C++
The Qt QML module provides a set of APIs for extending QML through C++ extensions. You can write extensions to add your own QML types, extend existing Qt types, or call C/C++ functions that are not accessible from ordinary QML code.
This tutorial shows how to write a QML extension using C++ that includes core QML features, including properties, signals and bindings. It also shows how extensions can be deployed through plugins.
Many of the topics covered in this tutorial are documented in further detail in Integrating QML and C++ and its documentation sub-topics. In particular, you may be interested in the sub-topics Exposing Attributes of C++ Classes to QML and Defining QML Types from C++.
Running the Tutorial Examples
The code in this tutorial is available as an example project with subprojects associated with each tutorial chapter. In Qt Creator, open the Welcome mode and select the tutorial from Examples. In Edit mode, expand the extending-qml project, right-click on the subproject (chapter) you want to run and select Run.
Chapter 1: Creating a New Type
extending-qml/chapter1-basics
A common task when extending QML is to provide a new QML type that supports some custom functionality beyond what is provided by the built-in Qt Quick types. For example, this could be done to implement particular data models, or provide types with custom painting and drawing capabilities, or access system features like network programming that are not accessible through built-in QML features.
In this tutorial, we will show how to use the C++ classes in the Qt Quick module to extend QML. The end result will be a simple Pie Chart display implemented by several custom QML types connected together through QML features like bindings and signals, and made available to the QML runtime through a plugin.
To begin with, let's create a new QML type called "PieChart" that has two properties: a name and a color. We will make it available in an importable type namespace called "Charts", with a version of 1.0.
We want this PieChart
type to be usable from QML like this:
import Charts 1.0 PieChart { width: 100; height: 100 name: "A simple pie chart" color: "red" }
To do this, we need a C++ class that encapsulates this PieChart
type and its two properties. Since QML makes extensive use of Qt's meta object system, this new class must:
- Inherit from QObject
- Declare its properties using the Q_PROPERTY macro
Here is our PieChart
class, defined in piechart.h
:
#include <QtQuick/QQuickPaintedItem> #include <QColor> class PieChart : public QQuickPaintedItem { Q_OBJECT Q_PROPERTY(QString name READ name WRITE setName) Q_PROPERTY(QColor color READ color WRITE setColor) public: PieChart(QQuickItem *parent = 0); QString name() const; void setName(const QString &name); QColor color() const; void setColor(const QColor &color); void paint(QPainter *painter); private: QString m_name; QColor m_color; };
The class inherits from QQuickPaintedItem because we want to override QQuickPaintedItem::paint() in perform drawing operations with the QPainter API. If the class just represented some data type and was not an item that actually needed to be displayed, it could simply inherit from QObject. Or, if we want to extend the functionality of an existing QObject-based class, it could inherit from that class instead. Alternatively, if we want to create a visual item that doesn't need to perform drawing operations with the QPainter API, we can just subclass QQuickItem.
The PieChart
class defines the two properties, name
and color
, with the Q_PROPERTY macro, and overrides QQuickPaintedItem::paint(). The class implementation in piechart.cpp
simply sets and returns the m_name
and m_color
values as appropriate, and implements paint()
to draw a simple pie chart. It also turns off the QGraphicsItem::ItemHasNoContents flag to enable painting:
PieChart::PieChart(QQuickItem *parent) : QQuickPaintedItem(parent) { } ... void PieChart::paint(QPainter *painter) { QPen pen(m_color, 2); painter->setPen(pen); painter->setRenderHints(QPainter::Antialiasing, true); painter->drawPie(boundingRect().adjusted(1, 1, -1, -1), 90 * 16, 290 * 16); }
Now that we have defined the PieChart
type, we will use it from QML. The app.qml
file creates a PieChart
item and display the pie chart's details using a standard QML Text item:
import Charts 1.0 import QtQuick 2.0 Item { width: 300; height: 200 PieChart { id: aPieChart anchors.centerIn: parent width: 100; height: 100 name: "A simple pie chart" color: "red" } Text { anchors { bottom: parent.bottom; horizontalCenter: parent.horizontalCenter; bottomMargin: 20 } text: aPieChart.name } }
Notice that although the color is specified as a string in QML, it is automatically converted to a QColor object for the PieChart color
property. Automatic conversions are provided for various other basic types; for example, a string like "640x480" can be automatically converted to a QSize value.
We'll also create a C++ application that uses a QQuickView to run and display app.qml
. The application must register the PieChart
type using the qmlRegisterType() function, to allow it to be used from QML. If you don't register the type, app.qml
won't be able to create a PieChart
.
Here is the application main.cpp
:
#include "piechart.h" #include <QtQuick/QQuickView> #include <QGuiApplication> int main(int argc, char *argv[]) { QGuiApplication app(argc, argv); qmlRegisterType<PieChart>("Charts", 1, 0, "PieChart"); QQuickView view; view.setResizeMode(QQuickView::SizeRootObjectToView); view.setSource(QUrl("qrc:///app.qml")); view.show(); return app.exec(); }
This call to qmlRegisterType() registers the PieChart
type as a type called "PieChart", in a type namespace called "Charts", with a version of 1.0.
Lastly, we write a .pro
project file that includes the files and the declarative
library:
QT += qml quick HEADERS += piechart.h SOURCES += piechart.cpp \ main.cpp RESOURCES += chapter1-basics.qrc DESTPATH = $$[QT_INSTALL_EXAMPLES]/qml/tutorials/extending-qml/chapter1-basics target.path = $$DESTPATH qml.files = *.qml qml.path = $$DESTPATH INSTALLS += target qml
Now we can build and run the application:
Note: You may see a warning Expression ... depends on non-NOTIFYable properties: PieChart::name. This happens because we add a binding to the writable name
property, but haven't yet defined a notify signal for it. The QML engine therefore cannot update the binding if the name
value changes. This is addressed in the following chapters.
Chapter 2: Connecting to C++ Methods and Signals
extending-qml/chapter2-methods
Suppose we want PieChart
to have a "clearChart()" method that erases the chart and then emits a "chartCleared" signal. Our app.qml
would be able to call clearChart()
and receive chartCleared()
signals like this:
import Charts 1.0 import QtQuick 2.0 Item { width: 300; height: 200 PieChart { id: aPieChart anchors.centerIn: parent width: 100; height: 100 color: "red" onChartCleared: console.log("The chart has been cleared") } MouseArea { anchors.fill: parent onClicked: aPieChart.clearChart() } Text { anchors { bottom: parent.bottom; horizontalCenter: parent.horizontalCenter; bottomMargin: 20 } text: "Click anywhere to clear the chart" } }
To do this, we add a clearChart()
method and a chartCleared()
signal to our C++ class:
class PieChart : public QQuickPaintedItem { ... public: ... Q_INVOKABLE void clearChart(); signals: void chartCleared(); ... };
The use of Q_INVOKABLE makes the clearChart()
method available to the Qt Meta-Object system, and in turn, to QML. Note that it could have been declared as a Qt slot instead of using Q_INVOKABLE, as slots are also callable from QML. Both of these approaches are valid.
The clearChart()
method simply changes the color to Qt::transparent, repaints the chart, then emits the chartCleared()
signal:
void PieChart::clearChart() { setColor(QColor(Qt::transparent)); update(); emit chartCleared(); }
Now when we run the application and click the window, the pie chart disappears, and the application outputs:
qml: The chart has been cleared
Chapter 3: Adding Property Bindings
extending-qml/chapter3-bindings
Property binding is a powerful feature of QML that allows values of different types to be synchronized automatically. It uses signals to notify and update other types' values when property values are changed.
Let's enable property bindings for the color
property. That means if we have code like this:
import Charts 1.0 import QtQuick 2.0 Item { width: 300; height: 200 Row { anchors.centerIn: parent spacing: 20 PieChart { id: chartA width: 100; height: 100 color: "red" } PieChart { id: chartB width: 100; height: 100 color: chartA.color } } MouseArea { anchors.fill: parent onClicked: { chartA.color = "blue" } } Text { anchors { bottom: parent.bottom; horizontalCenter: parent.horizontalCenter; bottomMargin: 20 } text: "Click anywhere to change the chart color" } }
The "color: chartA.color" statement binds the color
value of chartB
to the color
of chartA
. Whenever chartA
's color
value changes, chartB
's color
value updates to the same value. When the window is clicked, the onClicked
handler in the MouseArea changes the color of chartA
, thereby changing both charts to the color blue.
It's easy to enable property binding for the color
property. We add a NOTIFY feature to its Q_PROPERTY() declaration to indicate that a "colorChanged" signal is emitted whenever the value changes.
class PieChart : public QQuickPaintedItem { ... Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged) public: ... signals: void colorChanged(); ... };
Then, we emit this signal in setPieSlice()
:
void PieChart::setColor(const QColor &color) { if (color != m_color) { m_color = color; update(); // repaint with the new color emit colorChanged(); } }
It's important for setColor()
to check that the color value has actually changed before emitting colorChanged()
. This ensures the signal is not emitted unnecessarily and also prevents loops when other types respond to the value change.
The use of bindings is essential to QML. You should always add NOTIFY signals for properties if they are able to be implemented, so that your properties can be used in bindings. Properties that cannot be bound cannot be automatically updated and cannot be used as flexibly in QML. Also, since bindings are invoked so often and relied upon in QML usage, users of your custom QML types may see unexpected behavior if bindings are not implemented.
Chapter 4: Using Custom Property Types
extending-qml/chapter4-customPropertyTypes
The PieChart
type currently has a string-type property and a color-type property. It could have many other types of properties. For example, it could have an int-type property to store an identifier for each chart:
// C++ class PieChart : public QQuickPaintedItem { Q_PROPERTY(int chartId READ chartId WRITE setChartId NOTIFY chartIdChanged) ... public: void setChartId(int chartId); int chartId() const; ... signals: void chartIdChanged(); }; // QML PieChart { ... chartId: 100 }
Aside from int
, we could use various other property types. Many of the Qt data types such as QColor, QSize and QRect are automatically supported from QML. (See Data Type Conversion Between QML and C++ documentation for a full list.)
If we want to create a property whose type is not supported by QML by default, we need to register the type with the QML engine.
For example, let's replace the use of the property
with a type called "PieSlice" that has a color
property. Instead of assigning a color, we assign an PieSlice
value which itself contains a color
:
import Charts 1.0 import QtQuick 2.0 Item { width: 300; height: 200 PieChart { id: chart anchors.centerIn: parent width: 100; height: 100 pieSlice: PieSlice { anchors.fill: parent color: "red" } } Component.onCompleted: console.log("The pie is colored " + chart.pieSlice.color) }
Like PieChart
, this new PieSlice
type inherits from QQuickPaintedItem and declares its properties with Q_PROPERTY():
class PieSlice : public QQuickPaintedItem { Q_OBJECT Q_PROPERTY(QColor color READ color WRITE setColor) public: PieSlice(QQuickItem *parent = 0); QColor color() const; void setColor(const QColor &color); void paint(QPainter *painter); private: QColor m_color; };
To use it in PieChart
, we modify the color
property declaration and associated method signatures:
class PieChart : public QQuickItem { Q_OBJECT Q_PROPERTY(PieSlice* pieSlice READ pieSlice WRITE setPieSlice) ... public: ... PieSlice *pieSlice() const; void setPieSlice(PieSlice *pieSlice); ... };
There is one thing to be aware of when implementing setPieSlice()
. The PieSlice
is a visual item, so it must be set as a child of the PieChart
using QQuickItem::setParentItem() so that the PieChart
knows to paint this child item when its contents are drawn:
void PieChart::setPieSlice(PieSlice *pieSlice) { m_pieSlice = pieSlice; pieSlice->setParentItem(this); }
Like the PieChart
type, the PieSlice
type has to be registered using qmlRegisterType() to be used from QML. As with PieChart
, we'll add the type to the "Charts" type namespace, version 1.0:
int main(int argc, char *argv[]) { ... qmlRegisterType<PieSlice>("Charts", 1, 0, "PieSlice"); ... }
Chapter 5: Using List Property Types
extending-qml/chapter5-listproperties
Right now, a PieChart
can only have one PieSlice
. Ideally a chart would have multiple slices, with different colors and sizes. To do this, we could have a slices
property that accepts a list of PieSlice
items:
import Charts 1.0 import QtQuick 2.0 Item { width: 300; height: 200 PieChart { anchors.centerIn: parent width: 100; height: 100 slices: [ PieSlice { anchors.fill: parent color: "red" fromAngle: 0; angleSpan: 110 }, PieSlice { anchors.fill: parent color: "black" fromAngle: 110; angleSpan: 50 }, PieSlice { anchors.fill: parent color: "blue" fromAngle: 160; angleSpan: 100 } ] } }
To do this, we replace the pieSlice
property in PieChart
with a slices
property, declared as a QQmlListProperty type. The QQmlListProperty class enables the creation of list properties in QML extensions. We replace the pieSlice()
function with a slices()
function that returns a list of slices, and add an internal append_slice()
function (discussed below). We also use a QList to store the internal list of slices as m_slices
:
class PieChart : public QQuickItem { Q_OBJECT Q_PROPERTY(QQmlListProperty<PieSlice> slices READ slices) ... public: ... QQmlListProperty<PieSlice> slices(); private: static void append_slice(QQmlListProperty<PieSlice> *list, PieSlice *slice); QString m_name; QList<PieSlice *> m_slices; };
Although the slices
property does not have an associated WRITE
function, it is still modifiable because of the way QQmlListProperty works. In the PieChart
implementation, we implement PieChart::slices()
to return a QQmlListProperty value and indicate that the internal PieChart::append_slice()
function is to be called whenever a request is made from QML to add items to the list:
QQmlListProperty<PieSlice> PieChart::slices() { return QQmlListProperty<PieSlice>(this, 0, &PieChart::append_slice, 0, 0, 0); } void PieChart::append_slice(QQmlListProperty<PieSlice> *list, PieSlice *slice) { PieChart *chart = qobject_cast<PieChart *>(list->object); if (chart) { slice->setParentItem(chart); chart->m_slices.append(slice); } }
The append_slice()
function simply sets the parent item as before, and adds the new item to the m_slices
list. As you can see, the append function for a QQmlListProperty is called with two arguments: the list property, and the item that is to be appended.
The PieSlice
class has also been modified to include fromAngle
and angleSpan
properties and to draw the slice according to these values. This is a straightforward modification if you have read the previous pages in this tutorial, so the code is not shown here.
Chapter 6: Writing an Extension Plugin
extending-qml/chapter6-plugins
Currently the PieChart
and PieSlice
types are used by app.qml
, which is displayed using a QQuickView in a C++ application. An alternative way to use our QML extension is to create a plugin library to make it available to the QML engine as a new QML import module. This allows the PieChart
and PieSlice
types to be registered into a type namespace which can be imported by any QML application, instead of restricting these types to be only used by the one application.
The steps for creating a plugin are described in Creating C++ Plugins for QML. To start with, we create a plugin class named ChartsPlugin
. It subclasses QQmlExtensionPlugin and registers our QML types in the inherited registerTypes() method.
Here is the ChartsPlugin
definition in chartsplugin.h
:
#include <QQmlExtensionPlugin> class ChartsPlugin : public QQmlExtensionPlugin { Q_OBJECT Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid) public: void registerTypes(const char *uri); };
And its implementation in chartsplugin.cpp
:
#include "piechart.h" #include "pieslice.h" #include <qqml.h> void ChartsPlugin::registerTypes(const char *uri) { qmlRegisterType<PieChart>(uri, 1, 0, "PieChart"); qmlRegisterType<PieSlice>(uri, 1, 0, "PieSlice"); }
Then, we write a .pro
project file that defines the project as a plugin library and specifies with DESTDIR that library files should be built into a ../Charts
directory.
TEMPLATE = lib CONFIG += plugin QT += qml quick DESTDIR = ../Charts TARGET = $$qtLibraryTarget(chartsplugin) HEADERS += piechart.h \ pieslice.h \ chartsplugin.h SOURCES += piechart.cpp \ pieslice.cpp \ chartsplugin.cpp DESTPATH=$$[QT_INSTALL_EXAMPLES]/qml/tutorials/extending-qml/chapter6-plugins/Charts target.path=$$DESTPATH qmldir.files=$$PWD/qmldir qmldir.path=$$DESTPATH INSTALLS += target qmldir CONFIG += install_ok # Do not cargo-cult this! OTHER_FILES += qmldir # Copy the qmldir file to the same folder as the plugin binary cpqmldir.files = qmldir cpqmldir.path = $$DESTDIR COPIES += cpqmldir
When building this example on Windows or Linux, the Charts
directory will be located at the same level as the application that uses our new import module. This way, the QML engine will find our module as the default search path for QML imports includes the directory of the application executable. On macOS, the plugin binary is copied to Contents/PlugIns
in the the application bundle; this path is set in chapter6-plugins/app.pro:
osx { charts.files = $$OUT_PWD/Charts charts.path = Contents/PlugIns QMAKE_BUNDLE_DATA += charts }
To account for this, we also need to add this location as a QML import path in main.cpp
:
QQuickView view; #ifdef Q_OS_OSX view.engine()->addImportPath(app.applicationDirPath() + "/../PlugIns"); #endif ...
Defining custom import paths is useful also when there are multiple applications using the same QML imports.
The .pro
file also contains additional magic to ensure that the module definition qmldir file is always copied to the same location as the plugin binary.
The qmldir
file declares the module name and the plugin that is made available by the module:
module Charts plugin chartsplugin
Now we have a QML module that can be imported to any application, provided that the QML engine knows where to find it. The example contains an executable that loads app.qml
, which uses the import Charts 1.0
statement. Alternatively, you can load the QML file using the qmlscene tool, setting the import path to the current directory so that it finds the qmldir
file:
qmlscene -I . app.qml
The module "Charts" will be loaded by the QML engine, and the types provided by that module will be available for use in any QML document which imports it.
Chapter 7: Summary
In this tutorial, we've shown the basic steps for creating a QML extension:
- Define new QML types by subclassing QObject and registering them with qmlRegisterType()
- Add callable methods using Q_INVOKABLE or Qt slots, and connect to Qt signals with an
onSignal
syntax - Add property bindings by defining NOTIFY signals
- Define custom property types if the built-in types are not sufficient
- Define list property types using QQmlListProperty
- Create a plugin library by defining a Qt plugin and writing a qmldir file
The Integrating QML and C++ documentation shows other useful features that can be added to QML extensions. For example, we could use default properties to allow slices to be added without using the slices
property:
PieChart { PieSlice { ... } PieSlice { ... } PieSlice { ... } }
Or randomly add and remove slices from time to time using property value sources:
PieChart { PieSliceRandomizer on slices {} }
Files:
- tutorials/extending-qml/chapter1-basics/app.qml
- tutorials/extending-qml/chapter1-basics/piechart.cpp
- tutorials/extending-qml/chapter1-basics/piechart.h
- tutorials/extending-qml/chapter2-methods/app.qml
- tutorials/extending-qml/chapter2-methods/piechart.cpp
- tutorials/extending-qml/chapter2-methods/piechart.h
- tutorials/extending-qml/chapter3-bindings/app.qml
- tutorials/extending-qml/chapter3-bindings/piechart.cpp
- tutorials/extending-qml/chapter3-bindings/piechart.h
- tutorials/extending-qml/chapter4-customPropertyTypes/app.qml
- tutorials/extending-qml/chapter4-customPropertyTypes/piechart.cpp
- tutorials/extending-qml/chapter4-customPropertyTypes/piechart.h
- tutorials/extending-qml/chapter4-customPropertyTypes/pieslice.cpp
- tutorials/extending-qml/chapter4-customPropertyTypes/pieslice.h
- tutorials/extending-qml/chapter5-listproperties/app.qml
- tutorials/extending-qml/chapter5-listproperties/piechart.cpp
- tutorials/extending-qml/chapter5-listproperties/piechart.h
- tutorials/extending-qml/chapter5-listproperties/pieslice.cpp
- tutorials/extending-qml/chapter5-listproperties/pieslice.h
- tutorials/extending-qml/chapter6-plugins/app.qml
- tutorials/extending-qml/chapter6-plugins/import/chartsplugin.cpp
- tutorials/extending-qml/chapter6-plugins/import/chartsplugin.h
- tutorials/extending-qml/chapter6-plugins/import/piechart.cpp
- tutorials/extending-qml/chapter6-plugins/import/piechart.h
- tutorials/extending-qml/chapter6-plugins/import/pieslice.cpp
- tutorials/extending-qml/chapter6-plugins/import/pieslice.h
- tutorials/extending-qml/chapter1-basics/main.cpp
- tutorials/extending-qml/extending-qml.pro
- tutorials/extending-qml/chapter1-basics/chapter1-basics.pro
- tutorials/extending-qml/chapter1-basics/chapter1-basics.qrc
- tutorials/extending-qml/chapter2-methods/chapter2-methods.pro
- tutorials/extending-qml/chapter2-methods/chapter2-methods.qrc
- tutorials/extending-qml/chapter3-bindings/chapter3-bindings.pro
- tutorials/extending-qml/chapter3-bindings/chapter3-bindings.qrc
- tutorials/extending-qml/chapter4-customPropertyTypes/chapter4-customPropertyTypes.pro
- tutorials/extending-qml/chapter4-customPropertyTypes/chapter4-customPropertyTypes.qrc
- tutorials/extending-qml/chapter5-listproperties/chapter5-listproperties.pro
- tutorials/extending-qml/chapter5-listproperties/chapter5-listproperties.qrc
- tutorials/extending-qml/chapter6-plugins/app.pro
- tutorials/extending-qml/chapter6-plugins/app.qrc
- tutorials/extending-qml/chapter6-plugins/chapter6-plugins.pro
- tutorials/extending-qml/chapter6-plugins/import/import.pro
- tutorials/extending-qml/chapter6-plugins/import/qmldir
See also Integrating QML and C++.


The model M_Transformer is a model of a transformer with the possibility to choose the number of inductors. Inside the model, an inductance matrix is built based on the inductance of the inductors and the coupling inductances between the inductors given as a parameter vector from the user of the model.
An example shows that approach:
The user chooses a model with three inductors,
that means the parameter N has to be
3. Then he has to specify the inductances of the
three inductors and the three coupling inductances. The coupling
inductances are no real existing devices, but effects that occur
between two inductors. The inductances (main diagonal of the
inductance matrix) and the coupling inductances have to be
specified in the parameter vector L. The length
dimL of the parameter vector is calculated as follows:
dimL=(N*(N+1))/2
The following example shows how the parameter vector is used to fill in the inductance matrix. To specify the inductance matrix of a three inductances transformer (N=3):
the user has to allocate the parameter vector L[6] , since Nv=(N*(N+1))/2=(3*(3+1))/2=6. The parameter vector must be filled like this: L=[1,0.1,0.2,2,0.3,3] .
Inside the model, two loops are used to fill the inductance matrix to guarantee that it is filled in a symmetric way.
| Version | Revision | Date | Author | Comment |
|---|---|---|---|---|
| 4163 | 2010-09-11 | Dietmar Winkler | Documentation corrected according to documentation guidelines. | |
| 2008-11-24 | Kristin Majetta | Documentation added. | ||
| 2008-11-16 | Kristin Majetta | Initially implemented |


Haystack comes with a couple common template tags to make using some of its special features available to templates.
Takes a block of text and highlights words from a provided query within that block of text. Optionally accepts arguments to provide the HTML tag to wrap highlighted word in, a CSS class to use with the tag and a maximum length of the blurb in characters.
The defaults are span for the HTML tag, highlighted for the CSS class and 200 characters for the excerpt.
Syntax:
{% highlight <text_block> with <query> [css_class "class_name"] [html_tag "span"] [max_length 200] %}
Example:
# Highlight summary with default behavior.
{% highlight result.summary with request.query %}
# Highlight summary but wrap highlighted words with a div and the
# following CSS class.
{% highlight result.summary with request.query html_tag "div" class "highlight_me_please" %}
# Highlight summary but only show 40 words.
{% highlight result.summary with request.query max_length 40 %}
The highlighter used by this tag can be overridden as needed. See the Highlighting documentation for more information.
Fetches similar items from the search index to find content that is similar to the provided model’s content.
Note
This requires a backend that has More Like This built-in.
Syntax:
{% more_like_this model_instance as varname [for app_label.model_name,app_label.model_name,...] [limit n] %}
Example:
# Pull a full SearchQuerySet (lazy loaded) of similar content.
{% more_like_this entry as related_content %}
# Pull just the top 5 similar pieces of content.
{% more_like_this entry as related_content limit 5 %}
# Pull just the top 5 similar entries or comments.
{% more_like_this entry as related_content for "blog.entry,comments.comment" limit 5 %}
This tag behaves exactly like SearchQuerySet.more_like_this`, so all notes in that regard apply here as well.


IN LOVE AND WAR A film review by James Berardinelli Copyright 1997 James Berardinelli
RATING (0 TO 10): 4.5 Alternative Scale: ** out of ****
United States, 1996 U.S. Release Date: 1/24/97 (wide) Running Length: 1:54 MPAA Classification: PG-13 (Violence, mature themes, sex, brief nudity) Theatrical Aspect Ratio: 2.35:1
Cast: Sandra Bullock, Chris O'Donnell, MacKenzie Astin, Emilio Bonucci, Ingrid Lacey, Ian Kelly, Margot Steinberg, Tara Hugo Director: Richard Attenborough Producers: Dmitri Villard and Richard Attenborough Screenplay: Allan Scott, Clancy Sigal, and Anna Hamilton Phelan based on the book HEMINGWAY IN LOVE AND WAR: THE LOST DIARY OF AGNES VON KUROWSKY by Henry S. Villard and James Nagel Cinematography: Roger Pratt Music: George Fenton U.S. Distributor: New Line Cinema
The pairing of an Oscar-winning director with two of today's hottest stars creates expectations for something more impressive than a somnambulant, meandering romantic melodrama. IN LOVE AND WAR, Richard Attenborough's first directorial effort since 1993's SHADOWLANDS, is dead-on-arrival. The problem isn't so much that both leads, Sandra Bullock and Chris O'Donnell, are miscast (although they are), but that the film is devoid of passion. IN LOVE AND WAR is a frustrating motion picture -- frustrating because you want to feel more for the characters than you ever do.
In a story that's based on real people and true events, Chris O'Donnell plays a 18-year old Ernest Hemingway who is shipped overseas to help with the war effort in 1918 Italy. Hemingway, anxious to get into the thick of things, volunteers to ship supplies to the men on the front lines. Once there, he is caught in an Austrian attack, and, while attempting to carry an injured soldier to safety, he is shot in the leg. He soon finds himself in a hospital, being tended to by Agnes von Kurowsky (Sandra Bullock), a 26-year old volunteer Red Cross nurse. When gangrene sets in, the doctor advises amputation, but, through tireless ministering to the wound, Agnes manages to stop the putrefaction's spread, and Hemingway is allowed to keep his leg. As he convalesces, he and Agnes spend a great deal of time together, and, predictably, fall in love.
Supposedly, Hemingway's experiences with Agnes in Italy formed the basis for A FAREWELL TO ARMS, but it would be difficult to make that connection from this film, an uninspired motion picture populated by one- and two-dimensional characters. IN LOVE AND WAR is devoid of the passion that's so necessary for the effective enactment of a compelling love story. The emotion has been sucked out, leaving behind a beautiful-looking shell. The costumes and sets are wonderful, and the battle scenes are expertly staged, but, in the end, who cares? Consider the sweep of THE ENGLISH PATIENT and you'll recognize just how flat IN LOVE AND WAR is.
Both Bullock and O'Donnell, presumably chosen because of their box- office appeal, are out of their depth. And, while they don't do terrible jobs, neither is capable of effectively exposing their character's emotional core. Of course, the script doesn't give them a lot to work with -- it's an unremarkable story peppered with stilted dialogue -- but there's no discernible chemistry. Not only do we have trouble accepting the fresh-faced O'Donnell as one of the twentieth century's greatest authors, but, despite her obvious star quality, Bullock's Agnes hardly seems to be the kind of woman to inspire great literature. At least the supporting players -- MacKenzie Astin as Henry Villard, Hemingway's pal; Emilio Bonucci as a doctor smitten by Agnes; and Ingrid Lacey as Mac, Agnes' friend -- turn in solid performances.
Structurally, there are also serious problems. The love affair comprises only half of the movie's running length. A lengthy prologue is needed to set up the situation in Italy, so the film is nearly a half-hour old before Agnes and Hemingway meet. The final act, a thirty-minute denouement, is poorly-paced and tedious. IN LOVE AND WAR limps to a lame, dissatisfying conclusion.
Not since Demi Moore's ill-advised version of THE SCARLET LETTER has a period piece with such impeccable technical credentials betrayed so many glaring flaws. Four years ago, Attenborough released the disappointing biopic, CHAPLIN. Twelve months later, he rebounded with what is arguably his most emotionally moving film to date, SHADOWLANDS. One can only hope that history will be repeated and that the director's next effort will enable us to forget this one. Not that anyone is likely to remember something as singularly unremarkable as IN LOVE AND WAR.
- James Berardinelli e-mail<EMAIL_ADDRESS>ReelViews web site: http://www.cybernex.net/~berardin
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


Heavy rain at Sabarimala
Police personnel extend a helping hand to pilgrims
by Special CorrespondentSabarimala witnessed heavy rain on Tuesday posing much difficulty to pilgrims in undertaking the trek through the steep Neelimala path.
However, a large number of Ayyappa devotees, most of them from Andhra Pradesh, Karnataka and Tamil Nadu, trekked the hills braving the heavy downpour.
The police personnel deployed on the holy 18 steps (Pathinettampady) extended a helping hand to the pilgrims climbing the steep steps leading to the temple.
LMVs permitted
Special Commissioner appointed by the Kerala High Court M. Manoj said the court has permitted chauffeur-driven light motor vehicles (LMV) to take the pilgrims to Pampa and return to Nilackal after dropping the passengers at Pampa.
The court order came as a relief to scores of pilgrims who were forced to terminate their journey at the Nilackal base camp and proceed to Pampa only in KSRTC chain services.
The Travancore Devaswom Board (TDB) has made arrangements to provide sufficient number of pilgrim shelters to accommodate 17,000 people at the Sannidhanam, according to devaswom executive officer Rajendra Prasad.
The board has opened 40 counters for supplying medicated drinking water at the Sannidhanam, besides the drinking water kiosks.
The TDB works department has provided storage tanks having a total capacity of 2.65 crore litres at the Sannidhanam.
Chief engineer G. Krishnakumar told The Hindu that the department had provided 998 toilets, including 500 container toilets, at the Sannidhanam.
Mr. Krishnakumar said the sewage treatment plant with a capacity to treat five million litres of sewage a day at the Sannidhanam was fully operational. This was besides three incinerators for solid waste disposal.
He said the board had provided 970 toilets at the Nilackal base camp and 130 drinking water kiosks.
The Nilackal base camp has also got facility to accommodate 9,000 pilgrims at its shelters, besides parking facility for 9,000 vehicles in 16 parking lots.


Currently a hard at work student at Epicodus and a
full-time employee at a grocery store.
With a diverse background in online marketing, and great interpersonal communication skills,
a strong work ethic and desire to learn how to code,
I'm hoping to eventually make an impact and hopefully launch myself into a career within the industry upon graduation.
About Myself
On my spare time I like to stay active, whether that is working out at the gym, snowboarding trips at Mt. Hood or going to do local photography. At home,
I am fully capable of watching TV and playing video games for extended periods of time.
I also really enjoy:
- Finding new local coffee shops throughout Portland!
- Drinking quality craft beer at a good PNW brewery!


| do.nothing {tao} | R Documentation |
Nothing is done, nothing is left undone.
do.nothing(...)
do.nothing.else(...)
... |
Arguments avail not. |
What difference between yes and no?
What difference between success and failure?
Must you value what others value, avoid what others avoid?
How ridiculous!
Lao Tsu, Aaron A. King
do.nothing()
## Not run:
do.nothing.else()
## End(Not run)


| Module | ScottBarron::Acts::StateMachine::ClassMethods |
| In: |
lib/acts_as_state_machine.rb
|
Wraps ActiveRecord::Base.calculate to conveniently calculate all records in a given state. Options:
# File lib/acts_as_state_machine.rb, line 277 def calculate_in_state(state, *args) with_state_scope state do calculate(*args) end end
Wraps ActiveRecord::Base.count to conveniently count all records in a given state. Options:
# File lib/acts_as_state_machine.rb, line 266 def count_in_state(state, *args) with_state_scope state do count(*args) end end
Define an event. This takes a block which describes all valid transitions for this event.
Example:
class Order < ActiveRecord::Base
acts_as_state_machine :initial => :open state :open state :closed event :close_order do transitions :to => :closed, :from => :open end
end
transitions takes a hash where :to is the state to transition to and :from is a state (or Array of states) from which this event can be fired.
This creates an instance method used for firing the event. The method created is the name of the event followed by an exclamation point (!). Example: order.close_order!.
# File lib/acts_as_state_machine.rb, line 219 def event(event, opts={}, &block) tt = read_inheritable_attribute(:transition_table) state_events_table = read_inheritable_attribute(:state_events_table) et = read_inheritable_attribute(:event_table) e = et[event.to_sym] = SupportingClasses::Event.new(event, opts, tt, state_events_table, &block) define_method("#{event.to_s}!") { e.fire(self) } end
Wraps ActiveRecord::Base.find to conveniently find all records in a given state. Options:
# File lib/acts_as_state_machine.rb, line 255 def find_in_state(number, state, *args) with_state_scope state do find(number, *args) end end
Define a state of the system. state can take an optional Proc object which will be executed every time the system transitions into that state. The proc will be passed the current object.
Example:
class Order < ActiveRecord::Base
acts_as_state_machine :initial => :open state :open state :closed, Proc.new { |o| Mailer.send_notice(o) }
end
# File lib/acts_as_state_machine.rb, line 240 def state(name, opts={}) state = SupportingClasses::State.new(name.to_sym, opts) read_inheritable_attribute(:states)[name.to_sym] = state state_events_table[name.to_sym] = [] define_method("#{state.name}?") { current_state == state.name } end
# File lib/acts_as_state_machine.rb, line 192 def states_table read_inheritable_attribute(:states) end


- Research & Learn: Drone.io Github Repo, Trying Drone.io, and Drone.io Docs.
- Objective: What Drone.io is and getting started.
I’ve dived into a new effort to figure out Drone.io, get it running, and if plausible contribute in some way to the project. This was kick started yesterday while I was speaking with Joachim (T @lindyhop && G @josmo) about some projects we’re working on. We discussed the design of Drone.io, how we’re using it on some projects internally here @PelotonTechio. I will, and others will be posting more on what we’re doing with Drone.io later, but for now, I’ve put together this introduction to what Drone.io is, and getting started with it.
My First Steps
I was fortunate to join Joachim a few weeks ago for a Share-out @PelotonTechio where someone from the team shares information they’ve recently gained while working on a project, toying around with a personal project, or other research they’ve been doing. From this, I had a little head start of what Drone.io is about, but still dug in from the very start. Which in my case, that meant grabbing the code and looking directly into things.
What is Drone.io?
In simple terms, Drone is a continuous integration platform using containers, primarily Docker based containers. These containers provide complete control over each build environment with the obvious isolation that containers provide. The goal of Drone is to help ship code similar to the way Github does, as per the stated objective in the README.md. Check out more on that specific here.
If you’re curious about what Github does, and it’s TLDR; and you don’t want to click through, here’s the synopsis in one graph:
A secondary goal is to replace Jenkins as an industry wide integration tool. We’ll all get to see how that goes as time rolls onward.
Getting a Build Started
The first step, if you’ve got a build environment already, is simply to create a .drone.yml file. This file is a subset of the docker-compose style format. This yaml file describes the services and the container image that will be used. For instance, here’s an example from the docs.
pipeline:
build:
image: golang
commands:
- go get
- go build
- go test
services:
postgres:
image: postgres:9.4.5
environment:
- POSTGRES_USER=myapp
This is a simple service running postgres using the postgres 9.4.5 docker image and the pipeline is based on the golang image. The first pipeline step is to build using the commands go get
, go build
, and go test
. The service in this situation would likely be available for that build to use for integration tests with the database server.
This also points to how the architecture works for this particular process. Drone starts these containers up based on the specified images. That image acts as the starting point for the container point which will be used to put code on that will eventually be built, tested, or otherwise used for this processing.
Once the image is pulled, Drone automatically clones the repository you specify onto a locally mounted volume, called a workspace, on the running container. The clone process is parallel to executing a command similar to the following (from the docs here):
git clone --depth=50 --recusive=true \
https://github.com/octocat/hello-world.git \
/drone/src/github.com/octocat/hello-world
git checkout 7fd1a60
That the basic steps and idea for getting a build setup. It’s one seriously clean, smooth, and seamless way to setup a build. In the coming weeks I’ll have more information about builds for specific stacks, but for now, let’s take a look at some other elements beyond setting up a simple build.
Setting up Some Drone(s)
Alright, so after digging through a bit I realized I just needed to dig in and get a Drone service running for myself. So this was my first attempt at getting Drone up and running. I saw the “click this one cool button to make it work on Azure“ button but I have two issues with this: 1. I’m not actually learning anything about what is being done, and if it breaks I’m up the proverbial creek without a paddle 2. I currently, among all clients and people I cohack with, have zero need to know how it works on Azure. But hey, maybe in the future. For now, I just want to get something working locally, as it seems like this would be reasonable.
Prerequisite Knowledge
Digging through the documentation it is immediately clear that it behooves the admin of Drone to know a thing or three about Docker Compose, in addition to merely Docker. The first sample file that is in the docs here in the installation guide is simply a Docker Compose yaml file.
version: '2'
services:
drone-server:
image: drone/drone:0.5
ports:
- 80:8000
volumes:
- ./drone:/var/lib/drone/
restart: always
environment:
- DRONE_OPEN=true
- DRONE_GITHUB=true
- DRONE_GITHUB_CLIENT=${DRONE_GITHUB_CLIENT}
- DRONE_GITHUB_SECRET=${DRONE_GITHUB_SECRET}
- DRONE_SECRET=${DRONE_SECRET}
drone-agent:
image: drone/drone:0.5
command: agent
restart: always
depends_on: [ drone-server ]
volumes:
- /var/run/docker.sock:/var/run/docker.sock
environment:
- DRONE_SERVER=ws://drone-server:8000/ws/broker
- DRONE_SECRET=${DRONE_SECRET}
The installation guide generally follows the setup with the assumption of hosting it with a public access URI so that Github OAUTH can be setup. I simply wanted to get some basic elements tested out so I just thought I’d give it a go without any of that setup. Just run the basic service and get the UI setup first.
With that, I thought I’d just try to copy and paste the Docker Compose file into a docker-compose.yaml and just docker-compose up
the thing. Theoretically it shouldn’t hurt anything right? Well, without even setting the environment variables I kicked off the command.
Well, that was kind of useless. But you know, I immediately learned a few things just from observation of this attempt. Obviously it would, it should fail considering. So for attempt two I set the environment variables. It was a bit LOLz…
$ docker-compose up
WARNING: The DRONE_SECRET variable is not set. Defaulting to a blank string.
WARNING: The DRONE_GITHUB_CLIENT variable is not set. Defaulting to a blank string.
WARNING: The DRONE_GITHUB_SECRET variable is not set. Defaulting to a blank string.
Creating network "drone_default" with the default driver
Pulling drone-server (drone/drone:0.5)...
0.5: Pulling from drone/drone
a3ed95caeb02: Pull complete
802d894958a2: Pull complete
f294f54a4453: Pull complete
Digest: sha256:f04adc8fd1097671af6d74dd809eefea6e5062a881912322d3d908e167253a97
Status: Downloaded newer image for drone/drone:0.5
Creating drone_drone-server_1
Creating drone_drone-agent_1
Attaching to drone_drone-server_1, drone_drone-agent_1
drone-server_1 | time="2017-01-25T18:59:14Z" level=fatal msg="failed to generate token from DRONE_AGENT_SECRET"
drone-agent_1 | 1:M 25 Jan 18:59:15.243 * connecting to server ws://drone-server:8000/ws/broker
drone-agent_1 | 1:M 25 Jan 18:59:15.283 # connection failed, retry in 15s. websocket.Dial ws://drone-server:8000/ws/broker: dial tcp: lookup drone-server on <IP_ADDRESS>:53: no such host
So even without the environment variables set it attempted to go about launching a drone-server_1 and go through various steps. I quickly killed the efforts of the executing Docker Compose with Ctrl+C and then a quick call to docker-compose down
.
$ docker-compose down
WARNING: The DRONE_SECRET variable is not set. Defaulting to a blank string.
WARNING: The DRONE_GITHUB_CLIENT variable is not set. Defaulting to a blank string.
WARNING: The DRONE_GITHUB_SECRET variable is not set. Defaulting to a blank string.
Removing drone_drone-agent_1 ... done
Removing drone_drone-server_1 ... done
Removing network drone_default
It appears at this point that it stopped and cleaned up appropriately. Also I wanted to see if I could get things going without the Github integration. I removed those environment variables form the list. That included deleting these lines.
- DRONE_GITHUB=true
- DRONE_GITHUB_CLIENT=${DRONE_GITHUB_CLIENT}
- DRONE_GITHUB_SECRET=${DRONE_GITHUB_SECRET}
I also made a change for the DRONE_SERVER, set the variables remaining. My yaml looked like this when completed.
version: '2'
services:
drone-server:
image: drone/drone:0.5
ports:
- 80:8000
volumes:
- ./drone:/var/lib/drone/
restart: always
environment:
- DRONE_OPEN=true
- DRONE_SECRET=${DRONE_SECRET}
drone-agent:
image: drone/drone:0.5
command: agent
restart: always
depends_on: [ drone-server ]
volumes:
- /var/run/docker.sock:/var/run/docker.sock
environment:
- DRONE_SERVER=ws://localhost:8000/ws/broker
- DRONE_SECRET=${DRONE_SECRET}
To run this I setup a .env file, which can be used beside a docker-compose.yaml file to store environment variables. Since I didn’t want to clutter up my actual environment variables on my machine while testing this out, this seemed a better route. The initial .env file had the following content.
DRONE_SECRET='thesecret'
After running docker-compose
this time, I got the following.
$ docker-compose up
Creating network "drone_default" with the default driver
Creating drone_drone-server_1
Creating drone_drone-agent_1
Attaching to drone_drone-server_1, drone_drone-agent_1
drone-server_1 | time="2017-01-25T19:11:53Z" level=fatal msg="version control system not configured"
drone-agent_1 | 1:M 25 Jan 19:11:53.770 * connecting to server ws://localhost:8000/ws/broker
drone-agent_1 | 1:M 25 Jan 19:11:53.772 # connection failed, retry in 15s. websocket.Dial ws://localhost:8000/ws/broker: dial tcp [::1]:8000: getsockopt: connection refused
drone_drone-server_1 exited with code 1
drone-server_1 | time="2017-01-25T19:11:53Z" level=fatal msg="version control system not configured"
Well that escalated quickly to hostility! Egads! No version control system configured! Ugh. Ok, I guess I’ve got to have that as a default. I was hoping that it would present some type of default setup for this and just let me get running, especially since I want to host this locally, not out in internet land where I’d have a valid URI to use. With a quick change I added a few things back to the file with the following changes.
version: '2'
services:
drone-server:
image: drone/drone:0.5
ports:
- 80:8000
volumes:
- ./drone:/var/lib/drone/
restart: always
environment:
- DRONE_OPEN=true
- DRONE_GITHUB=true
- DRONE_GITHUB_CLIENT=${DRONE_GITHUB_CLIENT}
- DRONE_GITHUB_SECRET=${DRONE_GITHUB_SECRET}
- DRONE_SECRET=${DRONE_SECRET}
drone-agent:
image: drone/drone:0.5
command: agent
restart: always
depends_on: [ drone-server ]
volumes:
- /var/run/docker.sock:/var/run/docker.sock
environment:
- DRONE_SERVER=ws://drone-server:8000/ws/broker
- DRONE_SECRET=${DRONE_SECRET}
Then I navigated out to https://github.com/settings/applications/new and created an application for my localhost, guessing what it would prospectively be.
(Made a screenshot, then realized I had to take off the port numbers. No need for those)
Next accepted the permissions.
The screen upon confirmation has the appropriate secret and client info for the application.
The .env file then included the following changes.
DRONE_SECRET='thesecret'
DRONE_GITHUB_CLIENT=30clientbclient8d
DRONE_GITHUB_SECRET=8csecret09fesecret3be1a2427b80easecretcf
I then spooled up with docker-compose up
again and progress was made!
$ docker-compose up
Recreating drone_drone-server_1
Recreating drone_drone-agent_1
Attaching to drone_drone-server_1, drone_drone-agent_1
drone-server_1 | time="2017-01-25T21:03:20Z" level=warning msg="agents can connect with token eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0ZXh0IjoiJ3RoZXNlY3JldCciLCJ0eXBlIjoiYWdlbnQifQ.q8qhOlPLQePSxKfnTe-uURfMOKSQznA2iaLQZnuOYgE"
drone-server_1 | [GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
drone-agent_1 | 1:M 25 Jan 21:03:21.763 * connecting to server ws://drone-server:8000/ws/broker
drone-server_1 | - using env: export GIN_MODE=release
drone-server_1 | - using code: gin.SetMode(gin.ReleaseMode)
drone-server_1 |
drone-server_1 | [GIN-debug] GET /static/*filepath --> github.com/drone/drone/router.Load.func1 (2 handlers)
drone-server_1 | [GIN-debug] GET /login --> github.com/drone/drone/server.ShowLogin (15 handlers)
drone-server_1 | [GIN-debug] GET /login/form --> github.com/drone/drone/server.ShowLoginForm (15 handlers)
drone-server_1 | [GIN-debug] GET /logout --> github.com/drone/drone/server.GetLogout (15 handlers)
drone-server_1 | [GIN-debug] GET /api/user --> github.com/drone/drone/server.GetSelf (16 handlers)
drone-server_1 | [GIN-debug] GET /api/user/feed --> github.com/drone/drone/server.GetFeed (16 handlers)
drone-server_1 | [GIN-debug] GET /api/user/repos --> github.com/drone/drone/server.GetRepos (16 handlers)
drone-server_1 | [GIN-debug] GET /api/user/repos/remote --> github.com/drone/drone/server.GetRemoteRepos (16 handlers)
drone-server_1 | [GIN-debug] POST /api/user/token --> github.com/drone/drone/server.PostToken (16 handlers)
drone-server_1 | [GIN-debug] DELETE /api/user/token --> github.com/drone/drone/server.DeleteToken (16 handlers)
drone-server_1 | [GIN-debug] GET /api/users --> github.com/drone/drone/server.GetUsers (16 handlers)
drone-server_1 | [GIN-debug] POST /api/users --> github.com/drone/drone/server.PostUser (16 handlers)
drone-server_1 | [GIN-debug] GET /api/users/:login --> github.com/drone/drone/server.GetUser (16 handlers)
drone-server_1 | [GIN-debug] PATCH /api/users/:login --> github.com/drone/drone/server.PatchUser (16 handlers)
drone-server_1 | [GIN-debug] DELETE /api/users/:login --> github.com/drone/drone/server.DeleteUser (16 handlers)
drone-server_1 | [GIN-debug] GET /api/teams/:team/secrets --> github.com/drone/drone/server.GetTeamSecrets (16 handlers)
drone-server_1 | [GIN-debug] POST /api/teams/:team/secrets --> github.com/drone/drone/server.PostTeamSecret (16 handlers)
drone-server_1 | [GIN-debug] DELETE /api/teams/:team/secrets/:secret --> github.com/drone/drone/server.DeleteTeamSecret (16 handlers)
drone-server_1 | [GIN-debug] GET /api/global/secrets --> github.com/drone/drone/server.GetGlobalSecrets (16 handlers)
drone-server_1 | [GIN-debug] POST /api/global/secrets --> github.com/drone/drone/server.PostGlobalSecret (16 handlers)
drone-server_1 | [GIN-debug] DELETE /api/global/secrets/:secret --> github.com/drone/drone/server.DeleteGlobalSecret (16 handlers)
drone-server_1 | [GIN-debug] POST /api/repos/:owner/:name --> github.com/drone/drone/server.PostRepo (15 handlers)
drone-server_1 | [GIN-debug] GET /api/repos/:owner/:name --> github.com/drone/drone/server.GetRepo (18 handlers)
drone-server_1 | [GIN-debug] GET /api/repos/:owner/:name/builds --> github.com/drone/drone/server.GetBuilds (18 handlers)
drone-server_1 | [GIN-debug] GET /api/repos/:owner/:name/builds/:number --> github.com/drone/drone/server.GetBuild (18 handlers)
drone-server_1 | [GIN-debug] GET /api/repos/:owner/:name/logs/:number/:job --> github.com/drone/drone/server.GetBuildLogs (18 handlers)
drone-server_1 | [GIN-debug] POST /api/repos/:owner/:name/sign --> github.com/drone/drone/server.Sign (19 handlers)
drone-server_1 | [GIN-debug] GET /api/repos/:owner/:name/secrets --> github.com/drone/drone/server.GetSecrets (19 handlers)
drone-server_1 | [GIN-debug] POST /api/repos/:owner/:name/secrets --> github.com/drone/drone/server.PostSecret (19 handlers)
drone-server_1 | [GIN-debug] DELETE /api/repos/:owner/:name/secrets/:secret --> github.com/drone/drone/server.DeleteSecret (19 handlers)
drone-server_1 | [GIN-debug] PATCH /api/repos/:owner/:name --> github.com/drone/drone/server.PatchRepo (19 handlers)
drone-server_1 | [GIN-debug] DELETE /api/repos/:owner/:name --> github.com/drone/drone/server.DeleteRepo (19 handlers)
drone-server_1 | [GIN-debug] POST /api/repos/:owner/:name/chown --> github.com/drone/drone/server.ChownRepo (19 handlers)
drone-server_1 | [GIN-debug] POST /api/repos/:owner/:name/builds/:number --> github.com/drone/drone/server.PostBuild (19 handlers)
drone-server_1 | [GIN-debug] DELETE /api/repos/:owner/:name/builds/:number/:job --> github.com/drone/drone/server.DeleteBuild (19 handlers)
drone-server_1 | [GIN-debug] GET /api/badges/:owner/:name/status.svg --> github.com/drone/drone/server.GetBadge (15 handlers)
drone-server_1 | [GIN-debug] GET /api/badges/:owner/:name/cc.xml --> github.com/drone/drone/server.GetCC (15 handlers)
drone-server_1 | [GIN-debug] POST /hook --> github.com/drone/drone/server.PostHook (15 handlers)
drone-server_1 | [GIN-debug] POST /api/hook --> github.com/drone/drone/server.PostHook (15 handlers)
drone-server_1 | [GIN-debug] GET /ws/broker --> github.com/drone/drone/server.Broker (15 handlers)
drone-server_1 | [GIN-debug] GET /ws/feed --> github.com/drone/drone/server.EventStream (15 handlers)
drone-server_1 | [GIN-debug] GET /ws/logs/:owner/:name/:build/:number --> github.com/drone/drone/server.LogStream (18 handlers)
drone-server_1 | [GIN-debug] GET /authorize --> github.com/drone/drone/server.GetLogin (15 handlers)
drone-server_1 | [GIN-debug] POST /authorize --> github.com/drone/drone/server.GetLogin (15 handlers)
drone-server_1 | [GIN-debug] POST /authorize/token --> github.com/drone/drone/server.GetLoginToken (15 handlers)
drone-server_1 | [GIN-debug] GET /api/builds --> github.com/drone/drone/server.GetBuildQueue (16 handlers)
drone-server_1 | [GIN-debug] GET /api/agents --> github.com/drone/drone/server.GetAgents (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/ --> github.com/drone/drone/server.IndexHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/heap --> github.com/drone/drone/server.HeapHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/goroutine --> github.com/drone/drone/server.GoroutineHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/block --> github.com/drone/drone/server.BlockHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/threadcreate --> github.com/drone/drone/server.ThreadCreateHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/cmdline --> github.com/drone/drone/server.CmdlineHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/profile --> github.com/drone/drone/server.ProfileHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/symbol --> github.com/drone/drone/server.SymbolHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] POST /api/debug/pprof/symbol --> github.com/drone/drone/server.SymbolHandler.func1 (16 handlers)
drone-server_1 | [GIN-debug] GET /api/debug/pprof/trace --> github.com/drone/drone/server.TraceHandler.func1 (16 handlers)
drone-agent_1 | 1:M 25 Jan 21:03:21.966 * connection established, ready to process builds.
drone-agent_1 | 1:M 25 Jan 21:03:51.766 - stomp: send heart-beat.
drone-agent_1 | 1:M 25 Jan 21:03:51.866 - stomp: received heart-beat
drone-agent_1 | 1:M 25 Jan 21:04:21.770 - stomp: send heart-beat.
drone-agent_1 | 1:M 25 Jan 21:04:21.870 - stomp: received heart-beat
drone-agent_1 | 1:M 25 Jan 21:04:51.765 - stomp: send heart-beat.
drone-agent_1 | 1:M 25 Jan 21:04:51.867 - stomp: received heart-beat
Alright. So that actually gave me something useful. From this point I opened up Kitematic, just to see the instances and have an easy to navigate to the UI.
There were the running instances. I clicked on the link for the UI on the server and immediately it served up my request.
At this point I’m ready to get going on some builds.  Cheers!


Executive Summary
Summary – Bent Engineering, DBA Revoltwind
Bent Engineering has developed a revolutionary type of wind driven electric generator that hangs instead of being mounted atop a tower. The hanging wind turbine (HWT) was invented because city code prohibited windmill towers. The windmill blades and alternator had already been hand built. The only way to try it was to hang it on a tree branch. It required a rigid hanger and hinge with stop to prevent the spinning blades from striking the hanger. A counter balance to keep the alternator with blades attached from facing straight upwards was required. It could be short and heavy or long and lighter weight. A vane was added to make it point into the wind quickly. It was originally named the Gooseneck Alternator because it looked like a goose in flight. The little windmill was spinning at near ground level and ran a string of LED lights attached to the line from which it hung. They brightened when the wind blew harder. The neighbors were curious where they could get one and the hobby became a startup. The design can be fitted to any existing windmill blade/alternator combination. A design for manufacture was under construction when final US patent approval came in 2019. Field measurements of power output combined with the known costs to build it allowed us to accurately determine the cost per watt at various wind speeds. The results indicate that the HWT makes electricity at a significantly lower cost than any other technology. And in a convenient and portable form that requires no land ownership or permits on the part of the owner. It need not be made large or located in high wind speeds to justify its cost. If it can be placed in high wind it can pay for itself in under a year and run for 20 making power for only the cost of maintenance. Maintenance is performed at ground level with simply hand tools by lowering it to the ground. The global electric power market is measured in quadrillions of dollars and needs to expand to many times its current size to meet growing demand. The HWT is now the lowest cost method for making electric power. All we need to do is figure out how to use this invention and let it go to work.
Problem/Solution
Green electric power is critically needed to sustain our growing population and protect the environment. Fossil fuels are being used up and phased out. Nuclear power requires large expenditures decades in advance and hazardous materials that must be stored securely for years into the future. Wind and solar farms consume real estate in amounts that are not available to meet the expected demand. Land acquisition, environmental studies and permitting require that these projects be paid for in advance. The payback period is measured in decades. They produce low voltage that is not compatible with the high voltage grid. The electricity they produce must be converted to high voltage by high tech electronic devices and high voltage transformers cooled with toxic oils in substations. The large farms do not operate when the grid goes down because they need grid power to operate.
To date the solar and wind farms in operation around the globe have had varying degrees of success. Many financial investments were made that did not produce the expected returns. The variable power output of green energy sources that are tied to the grid reduces the efficiency of the primary fossil fuel burning plant. If this effect is large enough the power being made by the wind farm may be dumped entirely.
Our HWT invention can be made in sizes small to large using everything from bamboo to carbon fiber and suspended on existing infrastructure to produce power immediately at the point of use. They can act alone or be networked into the grid using grid tie in electronics. With an onboard rechargeable battery each windmill can act as an independent WIFI hot spot or cellular communication node. Thus allowing networks anywhere there is wind even if grid power is not available and expansion of coverage into all areas of the globe that have some wind.
Because the device naturally produces low voltage power, it is ideal for charging any rechargeable battery. They will be paired with everything from mobile phones to electric vehicles. Drone delivery of parcels is extremely energy intensive. Clusters of HWT’s will be set up and used to charge batteries for drones. This will make drone delivery inexpensive and sustainable. They will be used to build electric vehicle charging stations in homes and along the roadside across the country. The HWT is a godsend to any disaster relief effort. And they can bring power into mountainous terrain where there is often no way to carry in and set up heavy generating equipment.
Growth through partnerships in all nations is the fastest way to get this device into the hands of the people who will use it to help solve one of the greatest challenges in human history. We can no longer exist on only food, clothing, and shelter. Without electric power we cannot physically sustain our growing population.
Advantages of Hanging
Removal of the tower and the land required for the tower from the windmill system saves over 90% of the cost and 99% of the weight. The HWT can be lowered to the ground for maintenance. This eliminates the need for specially trained experts that are often flown in by helicopter and cannot work until the weather cooperates. Users will decide where to position windmills to capture the greatest amount of wind and can easily relocate them. Tower mounted wind turbines must be large in diameter and tall to justify the cost of the land and tower. Differences in wind speed across the giant rotor area create large bearing stresses and vibration that causes fatigue cracking in blades and structural supports. Hanging the turbine will reduce the stress on the bearing significantly and allow for less expensive material substitutions in these expensive components.
While there is some scale advantage in cost and efficiency to building the HWT in a large size, many small HWT’s will perform the same duty as a large one and are easier to maintain. They can be installed on rugged terrain with no earth moving equipment or massive concrete footers. They can be lowered to the ground and parked when storms are seen approaching. Large tower mounted windmills can only be built where specially designed trucks can get in to deliver the 100 plus foot long blades. Heavy equipment and concrete are required that must be hauled uphill to get to the construction site from a nearby town with enough oil and gas to make concrete in quantity. The HWT has no such requirements. In fact the HWT is the first windmill electric generator that most people can actually own. It is not surprising that fewer than 1 million tower mounted windmills exist today given the land restrictions created by the need for a tower. We expect that demand for the HWT will be in the billions of units as people learn to use it.
Markets
The six inch blade RW-Mini weighs ¼ pound and can make up to 5 watts. As a smartphone charger that can be carried in a backpack and deployed instantly anywhere there is wind it could reach a large fraction of the smartphone market and will likely be used by the mobile phone makers to promote the sale of their products in a sustainable form and expand their market into off grid communities. Though small in size it can trickle charge or maintain batteries in laptop computers, vehicles, marine equipment and security systems. In quantity the ReVolt Mini will cost under $10 to build. There are over 5 billion smartphones at the present time.
The RW-1 that is coming into production weighs only 16 pounds and can produce 200 watts. In 15 mph wind it makes 50 watts. A typical cell tower could be powered by 20 of them. If hung from the cell tower they would be mounted on the lower part of the tower just above tree tops and roof lines. They would not increase the wind load on the cell tower substantially. The cost would be about 10 thousand dollars. A power line run to the same cell tower from the grid will cost hundreds of thousands or more. It may pass through land owned by others who are paid a right of way fee. The HWT will allow cell towers to be placed far from grid power on a small patch of real estate. Bridges, highway signs, billboards and remote monitoring equipment can be powered inexpensively by them. If the faces of a skyscraper were blanketed with many small HWT’s they could produce a tremendous amount of power without increasing the wind load to the building and be mounted higher than a tower can reach.
The RW-1 can be hung on existing infrastructure without major disruption. One on each power pole for instance. There could be a windmill on every power pole, cell tower and skyscraper today. But for a device that makes a small amount of power and gets hit by lightning frequently the maintenance cost is too high. By comparison, the RW-1 can be hung on a cable with an electronic winch. Maintenance is performed with the push of a button at ground level where there is no fall hazard. The HWT cannot be struck by lightning if hung on a grounded hook or line.
Tower mounted wind turbines have reached a size where blade length is limited by tower height. Using the HWT design it is possible to build a wind turbine with blades longer than existing tower mounted technology can achieve. If hung beneath a blimp, a standard large wind farm turbine would cost 1/10th as much and operate nearly 100% of the time in high wind at high altitude beneath the blimp. It would produce hydrogen gas to be stored in the blimp using water extracted from the atmosphere by condensers mounted on the blimp. The tether that holds the blimp fixed to the ground would deliver electricity, hydrogen to burn as fuel, pure oxygen, and pure water safe for drinking. All generated by power made from the windmill and water extracted from the air. It could be flown into any desert. If the windmill requires maintenance it can be lowered to the ground. Storage of hydrogen gas at altitude is preferable to storage on the ground.
People will figure out how to use buildings, slopes, trees, etc. to channel wind towards an HWT hanging close to the ground and many advances will be made as engineers gain experience with them.
There are as many uses for the HWT as there are users of the HWT!
Competition
Portable power generation can be accomplished using gasoline, kerosene, diesel and natural gas. The systems are well understood, available in quantity and reliable. Solar panels that are portable are growing in popularity and reasonably priced. And there are many small wind turbine designs that rely on clamps to secure them to structures. To get the same power as the RW-1 out of solar panels will require 2- standard size (39” X 65”) solar panels that must be secured to the ground and protected from strong wind, shade, dust, hail, and debris. Solar panels typically operate for 6 hours during the day and cannot operate at night. The grass beneath a solar panel must be cut. Animals, insects and fungi that make their homes beneath a solar panel will require removal or poisoning. And solar panels require removal of ice and snow as well as occasional cleaning to remove the thin film of grime that accumulates and reduces efficiency. Our product is unique because it has the ability to capture a lot of power on a small footprint and is located above the heads of people, and moving machinery. They will not prevent the sun from striking the ground beneath them. Small windmills do not harm birds and bats. They do not throw off heavy ice as large wind turbines do. So the land beneath them is safe for other uses.
Risk/Opportunity
The technology is new and unfamiliar to engineers, developers, architects and city planners. The claims made in this summary cannot be supported beyond the limited testing performed by the inventor. There are a large number of unknowns that must become known for large scale acceptance. We feel that these unknowns will be quickly answered by early adapters of the technology because the savings potential is too compelling to ignore. The machine is attractive and will garner attention from green energy enthusiasts worldwide. It is its own advertising bill board and is highly visible. Many people will not like the way they look. As when America was electrified and people did not want to look at power lines everywhere. Now we have come to accept them because we are dependent on electric power.
Our biggest recognized opportunity is the growing awareness by the people of the magnitude of the energy problem and rising demand in nations that have no oil or fossil fuel. In the US commitments are being made to go green by some future date and there are sustainability mandates on most new construction. Most states do not have the land required to go green using wind and solar farms and have not done the research needed to identify unintended costs associated with going green. The HWT allows the states to meet their green energy objectives at a significant cost reduction over other technologies without a massive up front effort. We are in the beginning stages of learning to live without fossil fuels. The HWT provides electric power at a cost so low that the work required to make use of it will get done. And many new inventions will be developed into products that allow HWT’s to be installed and used productively on existing infrastructure.
Global warming is accelerating as thermal momentum builds in the ecosystem. If we have a means to eliminate one of the causes of global warming at a cost savings we must move quickly to find out if it will work on a large scale. The economy needs a boost, billions of people need power immediately and we need to take back control of the chemistry of the atmosphere. Our plan is to license the HWT technology to manufacturing partners around the globe. This will allow existing windmill producers and electronic device makers to compete and grow the technology rapidly. Large utility companies and network providers will learn to incorporate it for the savings and benefits it provides through new products and public/private partnerships. By scaling the number and size of HWT’s purchased, any green energy budget can be utilized to complete a project.
We believe that relief agencies around the globe will provide HWT’s to people who cannot afford them and that emergency supply warehouses will be stocked with them.
Management Team
The management team is led by Chief Executive Officer Stephen Cowap who founded his company, Bent Engineering, in July of 2011. He has a Master of Science degree in ceramic engineering from the University of Illinois, 1984. He was a glass technologist for Owens Corning and Philadelphia Quartz. He is the author of several patents. Was a member of ASTM C08, and is a member of the honorary engineering fraternity, Tau Beta Pi.


Working for Anvil was a great experience and I learned a lot about digital marketing. Design, research, and planning, were apart of my daily routine and my role as a marketing intern. Recently the company updated their logo, so I’ helped redesign their marketing collateral to go with the new branding, and also improved the overall appearance. A lot of my projects at Anvil also involved research; I assisted with business development, and client research for different marketing strategies.


close_session
function, which automatically detaches all the behaviors and routines running on all robots and also stops the simulator. Then restart the notebook (Kernel->Restart
in the menu) and call the open_session
function again.epuck.detach_all_behaviors()
and epuck.detach_all_routines()
on all robots. This has the advantage of not having to re-execute all your code since you will keep the references to the ePucks and the simulator. The simulator will still be running. This means that for example the present spheres will still be there. The sphere apparition will also still be running if it has been previously started (to stop it, you have to call simulator.stop_sphere_apparition()
). If this method causes trouble, switch the one above.epuck.has_eaten()
for the latter, as seen in class). You will have demonstrated that it works as expected if we clearly see on the figure that eating events occur more when the glucose level is low. You can apply this method on most of your behaviors and/or routines.


A few years ago I decided to take some time
off after completing another long contract and having reached 10 years of
commuting into
However during my break the ACCU conference occurred and I reluctantly agreed to write up a review. This felt like a safe option, as being a review it was entirely subjective and so I couldn’t really say anything that might be considered “wrong” per-se. Up to that point the only thing I’d ever written were some lengthy diatribes to my team mates about the technical debt in the codebase and how we should probably go about tackling it. Each email had taken ages to pen and involved constant refactoring to try and get the tone right. The thought of writing anything longer wasn’t exactly appealing.
I subsequently decided that the safest route was to self-publish via a blog. This way nothing could be rejected by an editor and so anything I wrote was definitely going to see the light of day. Being my own publisher also meant that I had no deadlines. And so after cranking out a few really safe posts about what I intended to get out of writing, who the ACCU was, etc. I started to consider tackling something meatier…
It was then that I realised I really didn’t
have anything original to say. As I looked back at my career as an
Seven months later after playing it safe I finally started to consider sticking my neck on the line. By then I had thought about a technique I had used a few years back which I pondered might have some merit in it. I put together a draft, sent it off to a fellow ACCU member who had recently asked me to look over a couple of their articles and waited for the feedback. The feedback was really useful but it seemed I still had quite a bit of work to do to knock the article into shape.
That article sat unfinished in my “pending”
folder for over three years! In the meantime I continued to bash out more safe
reviews of the conference,
So, if you haven’t got anything original to say, what’s the answer – plagiarise? That’s not really a viable solution. And then it slowly dawned on me as I started to read more and more of the old classic books and papers that much of what is said is not necessarily that new anyway, but what is new is the way it’s presented. As is hopefully apparent from my article in the previous C Vu about getting to grips with list comprehensions [1] it took a number of different books, articles, talks and thinking to eventually understand the concept.
My first non-review style article finally appeared almost 4 years after I initially plucked up the courage to even begin writing. It was about accessing more than 4 GB from a 32-bit Windows process and was pretty niche given that 64-bit was becoming prevalent even in the slow moving enterprise world by the time it got published. But I had finally bitten the bullet and stuck my neck out.
I’m a very defensive writer and speaker. I do not have the courage to suggest what you should or should not do, instead I prefer to present what I have done, backed up where possible by what my influences are with the only expectation being that it may be of some value to someone else. But my fear is that someone will point out what is obvious to everyone else and negate my entire article or talk by describing how I should be dong it. It’s not that I’m afraid to be wrong, on the contrary I want to learn, but I’d feel upset about wasting not only my time, but the time of the reviewers and readers.
At the conference this year I spoke to a few people who appear to be under a similar illusion that they have nothing original to say. For a start they may work in a different industry to me and have different constraints and cultures which is already interesting. However they find that despite the plethora of content out on the internet their colleagues are still unaware of many of the concepts and techniques that those more experienced take for granted.

I’ve tried to digest the Wikipedia page on monads a number of times but have
found myself lost in a
So if you labour under the belief that everything has already been said and that no regurgitation of existing ideas is useful then ask yourself this – why did Kevlin Henney begin his talk on Immutability at this years’ ACCU conference with a modern take on a 20 year old article written way back in issue 8 of Overload [3]?
They say “those who cannot remember the past are condemned to repeat it” [4]. Perhaps you can help out those of us unaware of some aspects of the past by ensuring we don’t waste time rediscovering it and allowing us to stand on your shoulders as well in the future.
[1] C Vu 26-2 (May 2014)
[2] http://en.wikipedia.org/wiki/Monad_(functional_programming)
[3] Circle & Ellipse – Vicious Circles, Kevlin Henney, Overload 8, 1995
[4] http://en.wikipedia.org/wiki/George_Santayana
12 June 2014
Bio
Chris is a freelance developer who started out as a bedroom coder in the 80’s writing assembler on 8-bit micros; these days it’s C++ and C#. He also commentates on the Godmanchester duck race and can be contacted via<EMAIL_ADDRESS>or @chrisoldwood.


Garrett's Catzone was one of my first projects I created at epicodus. Although the website content is rather silly, I very much enjoyed making my first project about my cats. I worked on this project with Justin Haupt using HTML and CSS. The goals of this project were to:
You can take a look at our work & code by clicking here
This website was created by my partner & I Omar K. We were tasked with making a HTML website for a fictitious cupcake company. The code used on this website was:
You can take a look at our work & code by clicking here
This website was created by my partner & I Joe Pritchet. In this project, we were tasked with making a fake Wikipedia page by recreating grid layouts in HTML, CSS and Bootstrap. This project was our most challenging yet. The goals in this project were to:
You can take a look at our work & code by clicking here


Nov. 19, 2014: The calm between the storms
This week, The Buffalo News recounts one of the most memorable storms to strike Western New York. Follow along daily.
The snowbound residents and motorists of Western New York were in need of help on Wednesday, Nov. 19, 2014, after a storm dumped 5 feet of snow over a swath of the region. They needed food. They needed their streets plowed. They needed to clear their roofs. Some needed to be rescued from their stranded vehicles, while some needed to find their vehicles.
What they didn’t need was more snow. But that’s what they got.
The snow band finally shifted, giving Northtowns residents a brief taste of what their neighbors to the south had encountered. The sun even came out for a while.
Call it the calm between the storms.
Round Two of lake-effect snow hit with less ferocity than Round One, dropping 2 more feet on some the most affected parts of the region, while continuing to barely touch the rest. For even the most winter-hardened, it had an “Are you kidding me?” quality.
Driving bans were still in effect and the Thruway was still closed for more than 100 miles, but the thought of driving anywhere was a pipe dream for people who could not find a way out of their homes. Some reported climbing through windows only to encounter snow so deep they could not take a step.
The snow began having an effect – several buildings and a warehouse in Cheektowaga collapsed under the weight. And the death toll continued to climb: By the end of Wednesday, it was seven, most attributed to shoveling or plowing.
Gov. Andrew M. Cuomo began what would become a weeklong presence in the area as he helped direct snow removal efforts. During one of his many news briefings, he called the storm “an extraordinarily difficult situation.”
For the thousands of people wondering if their houses were going to fall on top of them before they had a chance to escape, that may have been the understatement of the year.
Looking back at Nov. 19, 2014
• Five dead as monster storm dumps historic amount of snow
• Here we go again: Second wave of lake-effect snow hits Buffalo
• Snowstorm brings out the best in Buffalonians: Stories from the storm
• Cheektowaga warehouse roof collapse forces evacuation of nearby nursing facility
• Stuck 35 hours on Thruway: ‘He just feels abandoned’
• Across Erie County, plow crews are challenged by snow, irritated by abandoned cars
• Many stranded motorists on Thruway not happy about being abandoned
• To surprise of truckers stuck on Thruway, Cuomo goes ‘door-to-door’
• • •
Click here for additional coverage from our archives.
• • •
Inside The News: Reporters and photographers shared what it was like to live through the storm when you also had to cover it.


--- layout: post title: 3 Tips for Choosing Your First College Schedule date: 2012-09-03 07:05:25.000000000 -07:00 type: post parent_id: '0' published: true pd: '' status: publish categories: - Classroom Talk - College Prep - Guest Posts tags: - college classes - College Prep - picking a course schedule in college author: login: k email: k@k display_name: mcary first_name: '' last_name: '' ---
Guest Post By Karen Smith Summer has peaked, Labor Day is nigh, and the start of the school year approaches. With so much going on during your first few week of college -- moving, orientation, roommates, activities, parties, etc. etc. -- it’s important to remember the “real” reason you’re there: classes. I Know: downer, right? But I promise, some of your classes will be as fun as anything else you do on campus. Others...you’ll just survive. Here are my top pearls of academic wisdom for incoming freshmen:
1. Try some of everything. You may already know exactly what you want to do. But at most schools you won’t have to declare a major right away, sometimes not until the end of your sophomore year. That doesn’t mean you shouldn’t give it some thought, of course. But be well-rounded. Try something bizarre that sounds like it might be fun. Do some science, some humanities, some social science...something hands-on and something philosophical. Think of it as your first plate at an all-you-can-eat buffet, where you want to try a little of everything so you can go back for more of what you liked best.
2. Know your limits. More then fifteen hours of class your first semester is probably a crazy idea. There are other aspects to this college thing, and they are important too. You want to have a social life. Also, know when you’re most effective and be realistic about what time of day you sign up for. I went back and looked at my college transcript after I graduated, and realized something extraordinary: every class I took in the afternoon, I got an A or an A-, and every class I took before lunch, I got an A- or a B-, across the board. Some of us just aren’t morning people. If you have this same tendency to want to stay up late and sleep in, you can either work with it or against it.
3. Stay aware of add/drop deadlines. Most colleges will give you a chance to try things out and switch them around, within reason. Know exactly how long that window is, and don’t lose sight of the deadlines.  It can take a couple weeks to see whether you and a professor will have the right sort of connection to advance your learning.  That's all I've got for now, though there are other factors that will go into your enrollment such as required courses, core curricula, and whether you’ve tested out of classes via Advanced Placement high school courses.   Karen Smith, a former newspaper reporter, now freelances for websites including onlinebusinessdegree.org. She hopes to bring her readers the latest in business student news, as well as up-to-date, informed advice on everything from careers to parenting to health and more. Karen welcomes your comments below!


Camille Kostek reacts to Rob Gronkowski, James Corden’s Lakers dance
by Jaclyn HendricksIt seems Camille Kostek taught boyfriend Rob Gronkowski a few moves.
On Tuesday, Gronkowski and James Corden of the “Late Late Show” joined the Laker Girls for a halftime performance inside the Staples Center. Dancing to “Stay” by Alessia Cara and Zedd, the dynamic duo showed off their skills at center court to an enthralled audience, which also included Kostek, a former Patriots cheerleader.
“A little role reversal tonight 💃 I used to be the halftime cheerleader, now I’m sidelines to his performance tonight,” Kostek posted on Instagram. “Still deciding if I’m a proud girlfriend over this 😅 nevertheless …. this is an EPIC #NeverNotDancing moment I am proud to witness by Mr James and Robert James 😂 I LOVE YOU BOTH.”
Venus Williams also performed with the Laker Girls, along with comedian Ian Karmel.
Gronkowski’s set came hours after the former Patriots tight end announced a major Super Bowl bash in Miami ahead of February’s big game.
“No one knows Super Bowl weekend like myself. I’ve experienced it in every aspect — as a player, as a spectator — I wanted to do my very own thing and Gronkify it,” Gronkowski told Page Six. “Why not spice up the Super Bowl?”
Kostek, who has been linked to Gronkowski since 2015, is also expected to attend the party.


Are you passionate about social change?

If you answered “yes” to these questions, I know exactly how you feel: I was there myself. During my high school and college years, I was extremely passionate about social change but I didn't achieve much despite going to countless marches because I didn't know what I was doing.
After organizing for over ten years and reading extensively about creative activism and politial organizing, I wrote Blueprint for Creative Dissent. I want you to avoid making the same mistakes I made, so I'm giving you the eBook for free! All you have to do is click the link below.
In addition, I'm currently in the postgraduate programme at Plymouth College of Art, where I am reseraching how art can be used to dismantle cognitive barriers that enable systemic oppression. If you enjoy my eBook, please stay tuned because there is more to come!
*You will be automatically entered into my mailing list. Through my list, I will send you updates about my art. You can unsubscribe at any time.


We have a fully trained, experienced service department ready to handle all of your servicing needs. Whether you need a simple adjustment or a performance overhaul, our trained engineers will get you safely back out riding. We have been in the repair and service business since 1993.
Find Out MoreReady to start your next project with us? That's great! Give us a call or send us an email and we will get back to you as soon as possible!
484, Industrial Area, Phase-I,
Panchkula - 134113
Take me there!
+91-9876171243 (M)


The Web UI Framework supports the "page" as a component. This means that a created page has several events and methods. This section introduces the events and methods in the Web UI Framework Page component.
The following table lists the events related to pages.
| Event | Description |
|---|---|
| pagebeforechange | Triggered before switching from the current page. |
| pagebeforecreate | Triggered before the new page component is created and initialized. |
| pagebeforehide | Triggered before the current page is about to be closed. |
| pagebeforeload | Triggered before an external page is loaded. |
| pagebeforeshow | Triggered before the new page is displayed. |
| pagechange | Triggered after switching from the current page to the new page. |
| pagechangefailed | Triggered when the page switching fails. |
| pagecreate | Triggered after the new page component creation. |
| pagehide | Triggered after the current page is hidden. |
| pageinit | Triggered after the page component initialization occurs. |
| pageload | Triggered after an external page is loaded. |
| pageremove | Triggered after an external page is removed from the DOM. |
| pageshow | Triggered after the new page is displayed. |
To bind an event callback on the Back key, use the following code:
window.addEventListener('tizenhwkey', function(ev) { if (ev.originalEvent.keyName == "back") { // Call window.history.back() to go to previous browser window // Call tizen.application.getCurrentApplication().exit() to exit application // Add script to add another behavior } });
| Method | Description |
|---|---|
addBackBtn ( )- deprecated |
Adds the Back button. |
blur ( ) |
Removes the focus from the page and all descendants. |
focus ( ) |
Sets the focus to the page. |
updatePageLayout ( ) |
Calculates and updates the content height. |
addBackBtn: deprecated
Adds the Back button.
addBackBtn ( )
| Note |
|---|
| This method is deprecated since 2.3 because you can use the hardware Back key. |
blur
Removes the focus from the page and all descendants.
blur ( )
| Note |
|---|
| This method is only available through the TAU API. |
Return value:
No return valueCode example:

focus
Sets the focus to the page. For example, when the page has an input element (the autofocus attribute), it focuses this element automatically.
focus ( )
| Note |
|---|
| This method is only available through the TAU API. |
Return value:
No return valueCode example:

updatePageLayout
Calculates and updates the content height.
updatePageLayout ( )
| Note |
|---|
| This method is only available through the TAU API. |
Return value:
No return valueCode example:


Maze to Enlightenment!
Use the keyboard arrow keys to move the buddha and push barrels onto the X on the floor to obtain nirvana!
You can do it!


Bayesian dynamic regression models where the regression coefficients can vary over time as random walks. Gaussian, Poisson, and binomial observations are supported. The Markov chain Monte Carlo computations are done using Hamiltonian Monte Carlo provided by Stan, using a state space representation of the model in order to marginalise over the coefficients for efficient sampling. For non-Gaussian models, walker uses the importance sampling type estimators based on approximate marginal MCMC as in Vihola, Helske, Franks (2017, <arXiv:1609.02541>).
| Version: | 0.2.3-1 |
| Depends: | R (≥ 3.4.0), Rcpp (≥ 0.12.9), bayesplot, rstan (≥ 2.18.1) |
| Imports: | dplyr, ggplot2, KFAS, methods |
| LinkingTo: | StanHeaders (≥ 2.18.0), rstan (≥ 2.18.1), BH (≥ 1.66.0), Rcpp (≥ 0.12.9), RcppArmadillo, RcppEigen (≥ <IP_ADDRESS>.0) |
| Suggests: | diagis, gridExtra, knitr (≥ 1.11), rmarkdown (≥ 0.8.1), testthat |
| Published: | 2018-11-09 |
| Author: | Jouni Helske [aut, cre] |
| Maintainer: | Jouni Helske <jouni.helske at iki.fi> |
| BugReports: | https://github.com/helske/walker/issues |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | https://github.com/helske/walker |
| NeedsCompilation: | yes |
| SystemRequirements: | C++14, GNU make |
| Citation: | walker citation info |
| Materials: | README |
| CRAN checks: | walker results |
| Reference manual: | walker.pdf |
| Vignettes: |
Efficient Bayesian generalized linear models with time-varying coefficients |
| Package source: | walker_0.2.3-1.tar.gz |
| Windows binaries: | r-devel: walker_0.2.3-1.zip, r-release: walker_0.2.3-1.zip, r-oldrel: walker_0.2.3-1.zip |
| OS X binaries: | r-release: walker_0.2.3-1.tgz, r-oldrel: walker_0.2.3-1.tgz |
| Old sources: | walker archive |
Please use the canonical form https://CRAN.R-project.org/package=walker to link to this page.


{%extends "index.html" %} {% macro render_radio_field(field) -%} {% for value, label, _ in field.iter_choices() %}
Please fill all the following fields:
*Please notice that, with no exception, all payments will be done through the Host Institution. Hence, all felllow candidates should discuss or sort this issue with their mentors and Host Institution before applying for the UNU-BIOLAC Fellowship Programme. The completed Vendor Form is mandatory for the Fellow application to be evaluated


| a condition occurrence of | |
for the first time in the person's history |
|
|
occurrence start is: |
|
|
occurrence end is: |
|
|
Condition Type is: |
|
|
with a Stop Reason |
|
|
Condition Source Concept is
|
|
|
with age |
|
|
with a gender of:
|
|
|
with a Provider Specialty of:
|
|
|
with a Visit occurrance of: |


Hey! You need to enable JavaScript to run this application — Don't worry it's a zero-analytics site 😇


STIFF UPPER LIPS (1998) Rating = * out of ****** http://www.reviewfilm.com
Peter Ustinov, Prunella Scales and Sean Pertwee make complete fools of themselves in this unbelievably feeble comedy. Ostensibly a spoof on Merchant Ivory productions (particularly A Passage To India) and the English class system, it is simply dreadful. A bunch of upper class twits, the Ivorys (Scales, Georgina Cates, Samuel West and Robert Portal) wander about India, accompanied by their servant George (Pertwee).  Since they are closet homosexuals anyway, they haven't the slightest interest in her. However, their love affair leads to trouble and dire consequnces for George.
I have a confession to make - I may have given the impression that there is a coherent plot. There is not. Instead, there is a series of desperately unfunny scenes, which don't deserve a description. The film attempts to emulate the Carry On movies, but fails miserably, since it lacks the sense of fun and cheekiness of that series. God knows what director and writer Gary Sinyor was thinking - this film is a huge step down after his promising debut (Leon the Pig Farmer) and his follow-up, Solitaire for Two.
One can't help wishing for something like Top Secret or Hot Shots! while watching Stiff Upper Lips - and any movie that makes you wish for a Charlie Sheen performance should probably left well alone.
(c) Review of Film 1999
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


new Model(storage)
Creates a new Model instance and hooks up the storage.
Parameters:
| Name | Type | Description |
|---|---|---|
storage |
object | A reference to the client side storage class |
Methods
create(titleopt, callbackopt)
Creates a new todo model
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
title |
string |
<optional> |
The title of the task |
callback |
function |
<optional> |
The callback to fire after the model is created |
getCount()
Returns a count of all todos
read(queryopt, callbackopt)
Finds and returns a model in storage. If no query is given it'll simply
return everything. If you pass in a string or number it'll look that up as
the ID of the model to find. Lastly, you can pass it an object to match
against.
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
query |
string | number | object |
<optional> |
A query to match models against |
callback |
function |
<optional> |
The callback to fire after the model is found |
Example
model.read(1, func); // Will find the model with an ID of 1
model.read('1'); // Same as above
//Below will find a model with foo equalling bar and hello equalling world.
model.read({ foo: 'bar', hello: 'world' });
remove(id, callback)
Removes a model from storage
Parameters:
| Name | Type | Description |
|---|---|---|
id |
number | The ID of the model to remove |
callback |
function | The callback to fire when the removal is complete. |
removeAll(callback)
WARNING: Will remove ALL data from storage.
Parameters:
| Name | Type | Description |
|---|---|---|
callback |
function | The callback to fire when the storage is wiped. |
update(id, data, callback)
Updates a model by giving it an ID, data to update, and a callback to fire when
the update is complete.
Parameters:
| Name | Type | Description |
|---|---|---|
id |
number | The id of the model to update |
data |
object | The properties to update and their new value |
callback |
function | The callback to fire when the update is complete. |