CSAPI(Campaigns) Category Reference
| Declared in | CSAPI+Campaigns.h |
Tasks
-
– createCampaignWithClientID:name:subject:fromName:fromEmail:replyTo:htmlURL:textURL:listIDs:segmentIDs:completionHandler:errorHandler:
Create a draft campaign ready to be tested as a preview or sent.
-
– createCampaignFromTemplateWithClientID:name:subject:fromName:fromEmail:replyTo:listIDs:segmentIDs:templateID:templateContent:completionHandler:errorHandler:
Create a draft campaign using a template.
-
– deleteCampaignWithID:completionHandler:errorHandler:
Delete a campaign from your account
-
– sendCampaignImmediatelyWithCampaignID:confirmationEmailAddress:completionHandler:errorHandler:
Schedule a draft campaign to be sent immediately
-
– sendCampaignWithCampaignID:confirmationEmailAddress:sendDate:completionHandler:errorHandler:
Schedule a draft campaign to be sent at a custom date and time in the future
-
– sendCampaignPreviewWithCampaignID:recipients:personalize:completionHandler:errorHandler:
Send a preview of any draft campaign to a number of email addresses you specify. You can also set how we should treat any personalization tags in your draft campaign.
-
– unscheduleCampaignWithID:completionHandler:errorHandler:
Cancels the sending of the campaign and moves it back into the drafts. If the campaign is already sent or in the process of sending, this operation will fail.
-
– getCampaignSummaryWithCampaignID:completionHandler:errorHandler:
Get a basic summary of the results of a sent campaign
-
– getCampaignEmailClientUsageWithCampaignID:completionHandler:errorHandler:
Gets the list of email clients used by subscribers to open the campaign.
-
– getCampaignListsAndSegmentsWithCampaignID:completionHandler:errorHandler:
Get the lists and segments a campaign was sent to
-
– getCampaignRecipientsWithCampaignID:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all the subscribers that a given campaign was sent to
-
– getCampaignBouncesWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all the subscribers who bounced for a given campaign
-
– getCampaignOpensWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all subscribers who opened the email for a given campaign
-
– getCampaignClicksWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all subscribers who clicked a link in the email for a given campaign
-
– getCampaignUnsubscribesWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all subscribers who unsubscribed from the email for a given campaign
-
– getCampaignSpamComplaintsWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all subscribers who marked a given campaign as spam
Instance Methods
createCampaignFromTemplateWithClientID:name:subject:fromName:fromEmail:replyTo:listIDs:segmentIDs:templateID:templateContent:completionHandler:errorHandler:
Create a draft campaign using a template.
- (void)createCampaignFromTemplateWithClientID:(NSString *)clientID name:(NSString *)name subject:(NSString *)subject fromName:(NSString *)fromName fromEmail:(NSString *)fromEmail replyTo:(NSString *)replyTo listIDs:(NSArray *)listIDs segmentIDs:(NSArray *)segmentIDs templateID:(NSString *)templateID templateContent:(NSDictionary *)templateContent completionHandler:(void ( ^ ) ( NSString *campaignID ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- clientID
The ID of the client for whom the campaign should be created.
- name
Name of the campaign
- subject
Subject of the email
- fromName
Senders name
- fromEmail
Senders email address
- replyTo
Email address to use in the Reply-To field
- listIDs
Array of list IDs
- segmentIDs
Array of segment IDs
- templateID
The ID of the template which should be used to create the campaign.
- templateContent
The content to be used for the editable areas of the template.
The structure of templateContent is important. If you wanted to provided content for the editable areas of the following HTML template:
 <title>My Template</title>
<singleline>Enter heading...</singleline>

<multiline>Enter description...</multiline>
  <repeater> <layout label="My layout">

<singleline></singleline>

<multiline></multiline>

 </layout> </repeater>
<unsubscribe>Unsubscribe</unsubscribe>

You could define templateContent as follows:
NSDictionary *templateContent = @{ @"SingleLines": @[ @{@"Content": @"This is a heading", @"Href": @"http://example.com/"} ], @"MultiLines": @[ @{@"Content": @"
This is example

multiline content...
"} ], @"Images": @[ @{@"Content": @"http://example.com/image.png", @"Alt": @"This is alt text for an image", @"Href": @"http://example.com/"} ], @"Repeaters": @[ @{ @"Items": @[ @{ @"Layout": @"MyLayout", @"SingleLines": @[ @{@"Content": @"This is a repeater heading", @"Href": @"http://example.com/"} ], @"MultiLines": @[ @{@"Content": @"
This is example

multiline content...
"} ], @"Images": @[ @{@"Content": @"http://example.com/image.png", @"Alt": @"This is alt text for a repeater image", @"Href": @"http://example.com/"} ] } ] } ] };
Be sure to check out http://www.campaignmonitor.com/api/campaigns/#creating_a_campaign_from_template for details of the structure of templateContent.
- completionHandler
Completion callback, with ID of the successfully created campaign as the only argument
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#creating_a_campaign_from_template
Declared In
CSAPI+Campaigns.h
createCampaignWithClientID:name:subject:fromName:fromEmail:replyTo:htmlURL:textURL:listIDs:segmentIDs:completionHandler:errorHandler:
Create a draft campaign ready to be tested as a preview or sent.
- (void)createCampaignWithClientID:(NSString *)clientID name:(NSString *)name subject:(NSString *)subject fromName:(NSString *)fromName fromEmail:(NSString *)fromEmail replyTo:(NSString *)replyTo htmlURL:(NSString *)htmlURL textURL:(NSString *)textURL listIDs:(NSArray *)listIDs segmentIDs:(NSArray *)segmentIDs completionHandler:(void ( ^ ) ( NSString *campaignID ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- clientID
The ID of the client for whom the campaign should be created.
- name
Name of the campaign
- subject
Subject of the email
- fromName
Senders name
- fromEmail
Senders email address
- replyTo
Email address to use in the Reply-To field
- htmlURL
URL for the HTML content
- textURL
URL for the plain text content (use an empty string if you want the plain text content to be generated from the HTML content)
- listIDs
Array of list IDs
- segmentIDs
Array of segment IDs
- completionHandler
Completion callback, with ID of the successfully created campaign as the only argument
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#creating_a_draft_campaign
Declared In
CSAPI+Campaigns.h
deleteCampaignWithID:completionHandler:errorHandler:
Delete a campaign from your account
- (void)deleteCampaignWithID:(NSString *)campaignID completionHandler:(void ( ^ ) ( void ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign to delete
- completionHandler
Completion callback
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#deleting_a_campaign
Declared In
CSAPI+Campaigns.h
getCampaignBouncesWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all the subscribers who bounced for a given campaign
- (void)getCampaignBouncesWithCampaignID:(NSString *)campaignID date:(NSDate *)date page:(NSUInteger)page pageSize:(NSUInteger)pageSize orderField:(NSString *)orderField ascending:(BOOL)ascending completionHandler:(void ( ^ ) ( CSPaginatedResult *paginatedResult ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign you want data for. You can get the ID by calling getSentCampaignsWithClientID:completionHandler:errorHandler:.
- date
Bounces after the specified date will be returned
- page
The page to retrieve
- pageSize
The number of subscribers to retrieve per page. Values accepted are between
10
and1000
.
- orderField
The subscriber field to order the list by. Values accepted are
email
,name
ordate
.
- ascending
Whether to sort the list (see
orderField
) in ascending order
- completionHandler
Completion callback, with a
CSPaginatedResult
as the first and only argument. Items in the result list areCSCampaignBouncedRecipient
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_bounces
Declared In
CSAPI+Campaigns.h
getCampaignClicksWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all subscribers who clicked a link in the email for a given campaign
- (void)getCampaignClicksWithCampaignID:(NSString *)campaignID date:(NSDate *)date page:(NSUInteger)page pageSize:(NSUInteger)pageSize orderField:(NSString *)orderField ascending:(BOOL)ascending completionHandler:(void ( ^ ) ( CSPaginatedResult *paginatedResult ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign you want data for. You can get the ID by calling getSentCampaignsWithClientID:completionHandler:errorHandler:.
- date
Clicks after the specified date will be returned
- page
The page to retrieve
- pageSize
The number of subscribers to retrieve per page. Values accepted are between
10
and1000
.
- orderField
The subscriber field to order the list by. Values accepted are
email
,name
ordate
.
- ascending
Whether to sort the list (see
orderField
) in ascending order
- completionHandler
Completion callback, with a
CSPaginatedResult
as the first and only argument. Items in the result list areCSCampaignRecipientClicked
:
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_clicks
Declared In
CSAPI+Campaigns.h
getCampaignEmailClientUsageWithCampaignID:completionHandler:errorHandler:
Gets the list of email clients used by subscribers to open the campaign.
- (void)getCampaignEmailClientUsageWithCampaignID:(NSString *)campaignID completionHandler:(void ( ^ ) ( NSArray *campaignEmailClientUsage ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign for which email client usage should be found.
- completionHandler
Completion callback, with an array of
CSCampaignEmailClient
objects as the first and only argument
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_email_client_usage
Declared In
CSAPI+Campaigns.h
getCampaignListsAndSegmentsWithCampaignID:completionHandler:errorHandler:
Get the lists and segments a campaign was sent to
- (void)getCampaignListsAndSegmentsWithCampaignID:(NSString *)campaignID completionHandler:(void ( ^ ) ( NSArray *lists , NSArray *segments ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign you want data for
- completionHandler
Completion callback, with an array of
CSList
objects as the first argument and an array ofCSSegment
objects as the second argument
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_lists_and_segments
Declared In
CSAPI+Campaigns.h
getCampaignOpensWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all subscribers who opened the email for a given campaign
- (void)getCampaignOpensWithCampaignID:(NSString *)campaignID date:(NSDate *)date page:(NSUInteger)page pageSize:(NSUInteger)pageSize orderField:(NSString *)orderField ascending:(BOOL)ascending completionHandler:(void ( ^ ) ( CSPaginatedResult *paginatedResult ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign you want data for. You can get the ID by calling getSentCampaignsWithClientID:completionHandler:errorHandler:.
- date
Opens after the specified date will be returned
- page
The page to retrieve
- pageSize
The number of subscribers to retrieve per page. Values accepted are between
10
and1000
.
- orderField
The subscriber field to order the list by. Values accepted are
email
,name
ordate
.
- ascending
Whether to sort the list (see
orderField
) in ascending order
- completionHandler
Completion callback, with a
CSPaginatedResult
as the first and only argument. Items in the result list areCSCampaignRecipient
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_opens
Declared In
CSAPI+Campaigns.h
getCampaignRecipientsWithCampaignID:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all the subscribers that a given campaign was sent to
- (void)getCampaignRecipientsWithCampaignID:(NSString *)campaignID page:(NSUInteger)page pageSize:(NSUInteger)pageSize orderField:(NSString *)orderField ascending:(BOOL)ascending completionHandler:(void ( ^ ) ( CSPaginatedResult *paginatedResult ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign you want data for. You can get the ID by calling getSentCampaignsWithClientID:completionHandler:errorHandler:.
- page
The page to retrieve
- pageSize
The number of subscribers to retrieve per page. Values accepted are between
10
and1000
.
- orderField
The subscriber field to order the list by. Values accepted are
email
,name
ordate
.
- ascending
Whether to sort the list (see
orderField
) in ascending order
- completionHandler
Completion callback, with a
CSPaginatedResult
as the first and only argument. Items in the result list areCSCampaignRecipient
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_recipients
Declared In
CSAPI+Campaigns.h
getCampaignSpamComplaintsWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all subscribers who marked a given campaign as spam
- (void)getCampaignSpamComplaintsWithCampaignID:(NSString *)campaignID date:(NSDate *)date page:(NSUInteger)page pageSize:(NSUInteger)pageSize orderField:(NSString *)orderField ascending:(BOOL)ascending completionHandler:(void ( ^ ) ( CSPaginatedResult *paginatedResult ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign you want data for. You can get the ID by calling getSentCampaignsWithClientID:completionHandler:errorHandler:.
- date
Spam complaints after the specified date will be returned
- page
The page to retrieve
- pageSize
The number of subscribers to retrieve per page. Values accepted are between
10
and1000
.
- orderField
The subscriber field to order the list by. Values accepted are
email
,name
ordate
.
- ascending
Whether to sort the list (see
orderField
) in ascending order
- completionHandler
Completion callback, with a
CSPaginatedResult
as the first and only argument. Items in the result list areCSCampaignRecipient
:
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_spam_complaints
Declared In
CSAPI+Campaigns.h
getCampaignSummaryWithCampaignID:completionHandler:errorHandler:
Get a basic summary of the results of a sent campaign
- (void)getCampaignSummaryWithCampaignID:(NSString *)campaignID completionHandler:(void ( ^ ) ( CSCampaignSummary *campaignSummary ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign you want data for
- completionHandler
Completion callback, with a
CSCampaignSummary
object as the only argument
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_summary
Declared In
CSAPI+Campaigns.h
getCampaignUnsubscribesWithCampaignID:date:page:pageSize:orderField:ascending:completionHandler:errorHandler:
Get a paged result representing all subscribers who unsubscribed from the email for a given campaign
- (void)getCampaignUnsubscribesWithCampaignID:(NSString *)campaignID date:(NSDate *)date page:(NSUInteger)page pageSize:(NSUInteger)pageSize orderField:(NSString *)orderField ascending:(BOOL)ascending completionHandler:(void ( ^ ) ( CSPaginatedResult *paginatedResult ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign you want data for. You can get the ID by calling getSentCampaignsWithClientID:completionHandler:errorHandler:.
- date
Unsubscribes after the specified date will be returned
- page
The page to retrieve
- pageSize
The number of subscribers to retrieve per page. Values accepted are between
10
and1000
.
- orderField
The subscriber field to order the list by. Values accepted are
email
,name
ordate
.
- ascending
Whether to sort the list (see
orderField
) in ascending order
- completionHandler
Completion callback, with a
CSPaginatedResult
as the first and only argument. Items in the result list areCSCampaignRecipient
:
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#campaign_unsubscribes
Declared In
CSAPI+Campaigns.h
sendCampaignImmediatelyWithCampaignID:confirmationEmailAddress:completionHandler:errorHandler:
Schedule a draft campaign to be sent immediately
- (void)sendCampaignImmediatelyWithCampaignID:(NSString *)campaignID confirmationEmailAddress:(NSString *)emailAddress completionHandler:(void ( ^ ) ( void ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign to send
- emailAddress
The email address that the confirmation email will be sent to
- completionHandler
Completion callback
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#sending_a_draft_campaign
Declared In
CSAPI+Campaigns.h
sendCampaignPreviewWithCampaignID:recipients:personalize:completionHandler:errorHandler:
Send a preview of any draft campaign to a number of email addresses you specify. You can also set how we should treat any personalization tags in your draft campaign.
- (void)sendCampaignPreviewWithCampaignID:(NSString *)campaignID recipients:(NSArray *)recipients personalize:(NSString *)personalize completionHandler:(void ( ^ ) ( void ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign to send
- recipients
A collection of intended recipients of the campaign preview.
- personalize
Option to control personalization of the campaign preview. Only relevant when the campaign actually includes personalization tags. Valid variations are:
- Fallback (Use the fallback terms.)
- Random (Choose a random recipient from the lists and segments allocated to the campaign.)
- A specific email address (Use the personalisation details attached to the email address. Only valid if the subscriber is a recipient of the campaign. The address will not be sent a copy of the email.)
- completionHandler
Completion callback
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#sending_a_campaign_preview
Declared In
CSAPI+Campaigns.h
sendCampaignWithCampaignID:confirmationEmailAddress:sendDate:completionHandler:errorHandler:
Schedule a draft campaign to be sent at a custom date and time in the future
- (void)sendCampaignWithCampaignID:(NSString *)campaignID confirmationEmailAddress:(NSString *)emailAddress sendDate:(NSDate *)sendDate completionHandler:(void ( ^ ) ( void ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign to send
- emailAddress
The email address that the confirmation email will be sent to
- sendDate
The date and time the campaign should be scheduled to be sent
- completionHandler
Completion callback
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#sending_a_draft_campaign
Declared In
CSAPI+Campaigns.h
unscheduleCampaignWithID:completionHandler:errorHandler:
Cancels the sending of the campaign and moves it back into the drafts. If the campaign is already sent or in the process of sending, this operation will fail.
- (void)unscheduleCampaignWithID:(NSString *)campaignID completionHandler:(void ( ^ ) ( void ))completionHandler errorHandler:(CSAPIErrorHandler)errorHandler
Parameters
- campaignID
The ID of the campaign to be unscheduled.
- completionHandler
Completion callback
- errorHandler
Error callback
Discussion
http://www.campaignmonitor.com/api/campaigns/#unscheduling_a_campaign
Declared In
CSAPI+Campaigns.h


Hot-keys on this page
n s m x c change column sorting
| Module | statements | missing | excluded | coverage |
|---|---|---|---|---|
| Total | 646 | 52 | 0 | 92% |
| courses/__init__.py | 0 | 0 | 0 | 100% |
| courses/admin.py | 15 | 0 | 0 | 100% |
| courses/apps.py | 3 | 0 | 0 | 100% |
| courses/fields.py | 20 | 0 | 0 | 100% |
| courses/forms.py | 3 | 0 | 0 | 100% |
| courses/models.py | 61 | 0 | 0 | 100% |
| courses/templatetags/__init__.py | 0 | 0 | 0 | 100% |
| courses/templatetags/course.py | 13 | 0 | 0 | 100% |
| courses/tests/__init__.py | 0 | 0 | 0 | 100% |
| courses/tests/test_models.py | 128 | 0 | 0 | 100% |
| courses/tests/test_templatetags.py | 23 | 0 | 0 | 100% |
| courses/tests/test_views.py | 109 | 0 | 0 | 100% |
| courses/urls.py | 4 | 0 | 0 | 100% |
| courses/views.py | 130 | 48 | 0 | 63% |
| students/__init__.py | 0 | 0 | 0 | 100% |
| students/admin.py | 1 | 0 | 0 | 100% |
| students/apps.py | 3 | 0 | 0 | 100% |
| students/forms.py | 4 | 0 | 0 | 100% |
| students/models.py | 1 | 0 | 0 | 100% |
| students/tests/__init__.py | 0 | 0 | 0 | 100% |
| students/tests/test_views.py | 77 | 0 | 0 | 100% |
| students/urls.py | 4 | 0 | 0 | 100% |
| students/views.py | 47 | 4 | 0 | 91% |
No items found using the specified filter.


Statistic - Email subscriptions per topic
{{^topics}}
You are not allowed to view any topics.
{{/topics}}
{{#topics}}
{{ name }} - Cumulative subscription
as {{ date }}
- Confirmed
- {{ nbConfirmed }}
- Awaiting email confirmation
- {{ nbUnconfirmed }}
{{/topics}}


Searching for the connections
Crazy In Alabama A film review by Michael Redman Copyright 1999 by Michael Redman
** (out of ****)
The human mind spends a lot of time trying to make sense of things. We devote an amazing amount of energy sifting through chaos, trying to find the patterns. It's why optical illusions work. It's why everyone has their own ideas of how life works.
The idea that there is no pattern, no "why," is so alien that we reject it. We need order and connections, even if they are illusions.
Attempting to find the connections between the two stories in "Crazy In Alabama" is not only a fool's errand, but it ruins what might have otherwise been an acceptable little film.
 He beats her. He's kept her pregnant for years by punching holes in her diaphragm. She's so tired of him that when he tells her she can't go to Hollywood to pursue her dream of stardom, she poisons him and cuts off his head with her electric carving knife.
She stuffs his body in the family freezer, drops off her seven young kids at mama's house and hits the road for sunny California with poor hubby's head in a Tupperware container by her side.
Back at mama's place, the influx of youngsters forces her to move Peejoe (Lucas Black) and his brother, orphaned grandsons she has been raising, to their uncle Dove's (David Morse).
Living in the small town of Industry, Peejoe soon comes face-to-face with the racial unrest that was Alabama in 1965. When Sheriff Doggett (Meat Loaf Aday) kills a black teen trying to swim in a public pool, Peejoe becomes radicalized to the plight of Negroes.
So there you have it. Zany Lucille is driving to the big city on a one-woman "Thelma And Louise" trek to strike it big and 13-year-old Peejoe is immersed in the civil rights movement. What's the connection?
Hell if I know.
Sure there are some thematic similarities. Women and Blacks have been kept down for centuries and both are beginning to awaken. But Lucille's half of the film is played for laughs and Peejoe's is deadly serious. Although the film was adapted from Mark Childress' novel, it doesn't work as one story. It feels like the studio had two completely different tales and stapled the scripts together.
The frustration is that either could have been a satisfying film. Lucille's search for self identity and fame has some hilarious moments. Peejoe coming of age in the turbulent sixties is often poignant.
Either story could have worked. Not both.
It's too bad. Watching the film, trying to fit the two together, I kept making excuses because there are so many good scenes. I kept hoping that it would all fall together in the end. Ultimately it doesn't.
Actor Antonio Banderas' directoral debut takes a few more wrong steps than just the juxtaposition of the mis-matched plots. Both have some problems. The decapitated head talking to Lucille is neither funny nor entertaining. The depiction of the plight of oppressed people told through white eyes is an overworked error.
 Unfortunately she occasionally appears disconnected from her character.
Black is grand as the homegrown southern kid. His role here rivals his performance as the trusting boy in "Slingblade". Kids who come across as real children on the screen are rare. He does it to perfection.
A few of the supporting characters are strong also. Morse turns in a good understated job as the liberal mortician. Meat Loaf's redneck sheriff is fun to watch, cliched as it is. Rod Steiger show up as a judge at the courtroom finale. He almost seems like he's in a different film than the rest of the cast, but adds a touch of energy.
Wait until this comes out on video. Then do your own editing, putting the scenes from each story together and watch it that way. You'll have two acceptable short films rather than one longer one that just doesn't work.
(Michael Redman has written this column for over 24 years...or is it 25? Send your chaos vs. order theories to<EMAIL_ADDRESS>[This appeared in the 10/28 "Bloomington Independent", Bloomington, Indiana. Michael Redman can be contacted at<EMAIL_ADDRESS>--<EMAIL_ADDRESS>This week's film review: http://www.indepen.com/ Film reviews archive: http://us.imdb.com/M/reviews_by?Michael%20Redman This week's Y2K article: http://www.indepen.com/ Y2K archives: http://www.indepen.com/y2k.html
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


Bus Mall Product Survey
Thank you for participating in our Bus Mall Product Survey. All votes are anonymous, we do not retain personal information from survey participants. The voting information collected will be used to help drive future production decisions on our product offerings.
Survey Instructions
Please 'click' on whichever of the three images shown that you would be most likely to purchase out of the three. Please be sure to click only on an image (and not the area surrounding the image).
There will be 25 rounds of images and following the last round you will have an opportunity to review the results from all completed surveys. Results are calculated on a simple voting tally and also as a percentage of the votes per times the image was displayed.
Voting Results
Below are the votes received for each product from all surveys.
Percentage Results
Below are the percentage of votes per displays for all products from all surveys.


Vchan: Low-latency inter-VM communication channels
Today’s post is an update to Vincent Bernardoff’s introducing vchan blog post, updated to use the modern build scheme for Mirage.
Unless you are familiar with Xen’s source code, there is little chance that you’ve ever heard of the vchan library or protocol. Documentation about it is very scarce: a description can be found on vchan’s public header file, that I quote here for convenience:
Originally borrowed from the Qubes OS Project, this code (i.e. libvchan) has been substantially rewritten […] This is a library for inter-domain communication. A standard Xen ring buffer is used, with a datagram-based interface built on top. The grant reference and event channels are shared in XenStore under a user-specified path.
This protocol uses shared memory for inter-domain communication, i.e. between two VMs residing in the same Xen host, and uses Xen’s mechanisms – more specifically, ring buffers and event channels – in order to achieve its aims. The term datagram-based interface simply means that the interface resembles UDP, although there is support for stream based communication (like TCP) as well.
The vchan
protocol is an important feature in MirageOS 2.0 since it
forms the foundational communication mechanism for building distributed
clusters of unikernels that cooperate to solve problems that are beyond
the power of a single node. Instead of forcing communication between
nodes via a conventional wire protocol like TCP, it permits highly efficient
low-overhead communication to nodes that are colocated on the same Xen
host machine.
Before diving into vchan, I thought I’d also take the opportunity to describe the Ubuntu-Trusty environment for developing and running Xen unikernels.
Installing Xen on Ubuntu
Ubuntu 14.04 has good support for running Xen 4.4, the most recent release (at time of writing). For running VMs it’s a good idea to install Ubuntu on an LVM volume rather than directly on a partition, which allows the use of LVs as the virtual disks for your VMs. On my system I have a 40 Gig partition for ‘/’, an 8 Gig swap partition and the rest is free for my VMs:
$ sudo lvs
LV VG Attr LSize Pool Origin Data% Move Log Copy% Convert
root st28-vg -wi-ao--- 37.25g
swap_1 st28-vg -wi-ao--- 7.99g
In this particular walkthough I won’t be using disks, but later posts will. Install Xen via the meta-package. This brings in all you will need to run VMs:
$ sudo apt-get install xen-system-amd64
It used to be necessary to reorder the grub entries to make sure Xen was started by default, but this is no longer necessary. Once the machine has rebooted, you should be able to verify you’re running virtualized by invoking ‘xl’:
$ sudo xl list
Name ID Mem VCPUs State Time(s)
Domain-0 0 7958 6 r----- 9.7
My machine has 8 Gigs of memory, and this list shows that it’s all being used by my dom0, so I’ll need to either balloon down dom0 or reboot with a lower maximum memory. Ballooning is the most straightfoward:
$ sudo xenstore-write /local/domain/0/memory/target 4096000
$ sudo xl list
Name ID Mem VCPUs State Time(s)
Domain-0 0 4000 6 r----- 12.2
This is handy for quick testing, but is discouraged by the Xen folks. So alternatively, change the xen command line by
editing /etc/default/grub
and add the line:
GRUB_CMDLINE_XEN_DEFAULT="dom0_mem=4096M,max:4096M"
Once again, update-grub and reboot.
Mirage
Now lets get Mirage up and running. Install ocaml, opam and set up the opam environment:
$ sudo apt-get install ocaml opam ocaml-native-compilers camlp4-extra
...
$ opam init
...
$ eval `opam config env`
Don’t forget the ocaml-native-compilers
, as without this we can’t
compile the unikernels. Now we are almost ready to install Mirage; we
need two more dependencies, and then we’re good to go.
$ sudo apt-get install m4 libxen-dev
$ opam install mirage mirage-xen mirage-unix vchan
Where m4
is for ocamlfind, and libxen-dev
is required to compile the
unix variants of the xen-evtchn
and xen-gnt
libraries. Without these
installing vchan will complain that there is no xen-evtchn.lwt
library installed.
This second line installs the various Mirage and vchan libraries, but doesn’t build the demo unikernel and Unix CLI. To get them, clone the ocaml-vchan repository:
$ git clone https://github.com/mirage/ocaml-vchan
The demo unikernel is a very straightforward capitalizing echo server. The main function simply consists of
let (>>=) = Lwt.bind
let (>>|=) m f = m >>= function
| `Ok x -> f x
| `Eof -> Lwt.fail (Failure "End of file")
| `Error (`Not_connected state) ->
Lwt.fail (Failure (Printf.sprintf "Not in a connected state: %s"
(Sexplib.Sexp.to_string (Node.V.sexp_of_state state))))
let rec echo vch =
Node.V.read vch >>|= fun input_line ->
let line = String.uppercase (Cstruct.to_string input_line) in
let buf = Cstruct.create (String.length line) in
Cstruct.blit_from_string line 0 buf 0 (String.length line);
Node.V.write vch buf >>|= fun () ->
echo vch
where we’ve defined an error-handling monadic bind (>>|=
) which
is then used to sequence the read and write operations.
Building the CLI is done simply via make
.
$ make
...
$ ls -l node_cli.native
lrwxrwxrwx 1 jludlam jludlam 52 Jul 14 14:56 node_cli.native -> /home/jludlam/ocaml-vchan/_build/cli/node_cli.native
Building the unikernel is done via the mirage
tool:
$ cd test
$ mirage configure --xen
...
$ make depend
...
$ make
...
$ ls -l mir-echo.xen echo.xl
-rw-rw-r-- 1 jludlam jludlam 596 Jul 14 14:58 echo.xl
-rwxrwxr-x 1 jludlam jludlam 3803982 Jul 14 14:59 mir-echo.xen
This make both the unikernel binary (the mir-echo.xen file) and a convenient xl script to run it. To run, we use the xl tool, passing ‘-c’ to connect directly to the console so we can see what’s going on:
$ sudo xl create -c echo.xl
Parsing config from echo.xl
kernel.c: Mirage OS!
kernel.c: start_info: 0x11cd000(VA)
kernel.c: nr_pages: 0x10000
kernel.c: shared_inf: 0xdf2f6000(MA)
kernel.c: pt_base: 0x11d0000(VA)
kernel.c: nr_pt_frames: 0xd
kernel.c: mfn_list: 0x114d000(VA)
kernel.c: mod_start: 0x0(VA)
kernel.c: mod_len: 0
kernel.c: flags: 0x0
kernel.c: cmd_line:
x86_setup.c: stack: 0x144f40-0x944f40
mm.c: MM: Init
x86_mm.c: _text: 0x0(VA)
x86_mm.c: _etext: 0xb8eec(VA)
x86_mm.c: _erodata: 0xde000(VA)
x86_mm.c: _edata: 0x1336f0(VA)
x86_mm.c: stack start: 0x144f40(VA)
x86_mm.c: _end: 0x114d000(VA)
x86_mm.c: start_pfn: 11e0
x86_mm.c: max_pfn: 10000
x86_mm.c: Mapping memory range 0x1400000 - 0x10000000
x86_mm.c: setting 0x0-0xde000 readonly
x86_mm.c: skipped 0x1000
mm.c: MM: Initialise page allocator for 0x1256000 -> 0x10000000
mm.c: MM: done
x86_mm.c: Pages to allocate for p2m map: 2
x86_mm.c: Used 2 pages for map
x86_mm.c: Demand map pfns at 10001000-2010001000.
Initialising timer interface
Initializing Server domid=0 xs_path=data/vchan
gnttab_stubs.c: gnttab_table mapped at 0x10001000
Server: right_order = 13, left_order = 13
allocate_buffer_locations: gntref = 9
allocate_buffer_locations: gntref = 10
allocate_buffer_locations: gntref = 11
allocate_buffer_locations: gntref = 12
Writing config into the XenStore
Shared page is:
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0d 00 0d 00 02 01 01 00 09 00 00 00 0a 00 00 00
0b 00 00 00 0c 00 00 00
Initialization done!
Vchan is domain-to-domain communication, and relies on Xen’s grant tables to share the memory. The entries in the grant tables have domain-level access control, so we need to know the domain ID of the client and server in order to set up the communications. The test unikernel server is hard-coded to talk to domain 0, so we only need to know the domain ID of our echo server. In another terminal,
$ sudo xl list
Name ID Mem VCPUs State Time(s)
Domain-0 0 4095 6 r----- 1602.9
echo 2 256 1 -b---- 0.0
In this case, the domain ID is 2, so we invoke the CLI as follows:
$ sudo ./node_cli.native 2
Client initializing: Received gntref = 8, evtchn = 4
Mapped the ring shared page:
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0d 00 0d 00 02 01 01 00 09 00 00 00 0a 00 00 00
0b 00 00 00 0c 00 00 00
Correctly bound evtchn number 71
We’re now connected via vchan to the Mirage domain. The test server is simply a capitalisation service:
hello from dom0
HELLO FROM DOM0
Ctrl-C to get out of the CLI, and destroy the domain with an xl destroy
:
$ sudo xl destroy test
vchan
is a very low-level communication mechanism, and so our next post on
this topic will address how to use it in combination with a name resolver
to intelligently map connection requests to use vchan
if available, and
otherwise fall back to normal TCP or TCP+TLS.
- Irmin 0.12 with portable filesystem watching released
- MirageOS Summer 2016 Hackathon roundup
- MirageOS Summer 2016 Hackathon announcement, and talk roundup
- MirageOS Spring 2016 Hackathon!
- MirageOS security advisory 00: mirage-net-xen
- Introducing Functoria
- Run Mirage Unikernels on KVM/QEMU with Solo5
- MirageOS hackathon
- Introducing Charrua — a DHCP implementation
- Unikernel.org


| Package | Description |
|---|---|
| com.gratex.perconik.activity.ide.listeners | |
| sk.stuba.fiit.perconik.core |
Base interfaces and classes of the core listener and resource model.
|
| sk.stuba.fiit.perconik.core.adapters |
Adapters for listeners supported by the default core implementation.
|
| sk.stuba.fiit.perconik.core.listeners |
Interfaces for listeners supported by the default core implementation.
|
| Modifier and Type | Class and Description |
|---|---|
class |
IdeCodeListener
A listener of IDE code events.
|
class |
IdeCommitListener
A listener of IDE commit events.
|
class |
IdeDocumentListener
A listener of IDE document events.
|
class |
IdeElementListener
A listener of IDE code element events.
|
class |
IdeFindListener
A listener of IDE find events.
|
class |
IdeListener
A base class for all IDE listeners.
|
class |
IdeProjectListener
A listener of IDE project events.
|
class |
IdeStateListener
A listener of IDE state change events.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractCountingListener
An abstract implementation of
CountingListener
holding event counts in an atomic map. |
class |
AbstractFilteringListener<T>
An abstract implementation of
FilteringListener
holding acceptable event types in an immutable set. |
| Modifier and Type | Class and Description |
|---|---|
class |
CommandExecutionAdapter
An abstract adapter class for a
CommandExecutionListener . |
class |
CompletionAdapter
An abstract adapter class for a
CompletionListener . |
class |
DocumentAdapter
An abstract adapter class for a
DocumentListener . |
class |
EditorAdapter
An abstract adapter class for a
EditorListener . |
class |
FileBufferAdapter
An abstract adapter class for a
FileBufferListener . |
class |
GitConfigurationAdapter
An abstract adapter class for a
GitConfigurationListener . |
class |
GitIndexAdapter
An abstract adapter class for a
GitIndexListener . |
class |
GitReferenceAdapter
An abstract adapter class for a
GitReferenceListener . |
class |
JavaElementAdapter
An abstract adapter class for a
JavaElementListener . |
class |
LaunchAdapter
An abstract adapter class for a
LaunchListener . |
class |
LaunchConfigurationAdapter
An abstract adapter class for a
LaunchConfigurationListener . |
class |
LaunchesAdapter
An abstract adapter class for a
LaunchesListener . |
class |
MarkSelectionAdapter
An abstract adapter class for a
MarkSelectionListener . |
class |
OperationHistoryAdapter
An abstract adapter class for a
OperationHistoryListener . |
class |
PageAdapter
An abstract adapter class for a
PageListener . |
class |
PartAdapter
An abstract adapter class for a
PartListener . |
class |
PerspectiveAdapter
An abstract adapter class for a
PerspectiveListener . |
class |
RefactoringExecutionAdapter
An abstract adapter class for a
RefactoringExecutionListener . |
class |
RefactoringHistoryAdapter
An abstract adapter class for a
RefactoringHistoryListener . |
class |
ResourceAdapter
An abstract adapter class for a
ResourceListener . |
class |
SearchQueryAdapter
An abstract adapter class for a
SearchQueryListener . |
class |
SearchResultAdapter
An abstract adapter class for a
SearchResultListener . |
class |
SelectionAdapter
An abstract adapter class for a
SelectionListener . |
class |
StructuredSelectionAdapter
An abstract adapter class for a
StructuredSelectionListener . |
class |
TestRunAdapter
An abstract adapter class for a
TestRunListener . |
class |
TextInputAdapter
An abstract adapter class for a
TextInputListener . |
class |
TextSelectionAdapter
An abstract adapter class for a
TextSelectionListener . |
class |
ViewAdapter
An abstract adapter class for a
ViewListener . |
class |
WindowAdapter
An abstract adapter class for a
WindowListener . |
class |
WorkbenchAdapter
An abstract adapter class for a
WorkbenchListener . |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJavaElementListener
An abstract implementation of
JavaElementListener . |
class |
AbstractResourceListener
An abstract implementation of
ResourceListener . |


黒の手番です。64 はどう動かしますか？
Unlimited
pips Black=160 White=148
(CorrectAnswer= 0/0, ErrorScore= 0)
1. 24/18* 18/14 eq:+0.267 57.18% (G:14.69% B:0.90%) 42.82% (G:12.33% B:0.44%) 2. 24/20 24/18* eq:+0.181 (-0.087) 55.40% (G:13.40% B:0.78%) 44.60% (G:13.38% B:0.44%) 3. 24/18* 13/9 eq:+0.153 (-0.115) 54.54% (G:15.02% B:0.92%) 45.46% (G:14.49% B:0.67%) 4. 24/18* 6/2 eq:-0.024 (-0.291) 50.68% (G:12.52% B:0.63%) 49.32% (G:16.86% B:0.96%) 5. 13/9 13/7 eq:-0.094 (-0.362) 47.90% (G:13.49% B:0.70%) 52.10% (G:16.48% B:1.16%)


Data¶
As the goal of Linguistica 5 is to perform automatic linguistic analysis for some given data, it is important to understand what data Linguistica 5 can handle.
Two types of data are recognized:
- raw corpus text
- wordlist
If you use Linguistica 5 via the Graphical user interface (GUI) or the Command line interface (CLI), then your data is a file on your local drive. However, if you use it as a Python library instead, your data can either be a file from the local drive or an in-memory Python object.
Raw corpus text¶
A raw corpus text is simply a plain text file.
An example is the English Brown corpus (Kučera and Francis 1967) with
about one million word tokens (for about 50,000 word types) available
here.
This corpus is a built-in dataset that comes with Linguistica 5 –
its file path is accessible as brown
as follows:
import linguistica as lxa
from linguistica.datasets import brown
lxa_object = lxa.read_corpus(brown)
In lieu of brown
, you may pass the file path as argument to
read_corpus()
for your raw corpus text.
As long as your corpus is
one single text file encoded in Unicode UTF-8,
Linguistica 5 can handle it.
Alternatively, if you use Linguistica 5 as a Python library in your own
Python programs and would like to use an in-memory object as corpus data,
the function from_corpus()
(see Data source) is probably what
you need.
Wordlist¶
A wordlist file is a plain text file in a specific format (more below)
that Linguistica 5 recognizes as a wordlist.
The Linguistica team has conventionally called this format .dx1
(think: a dictionary file; that’s “one” but not “L” at the end)
which is also the file extension name.
An example of a .dx1
file is english-cmudict.dx1
available
here.
(This file is essentially the
CMU Pronouncing Dictionary
with English words represented phonemically by Arpabet,
with the addition of word token counts—if available—based on the English
Brown corpus.) This wordlist is also a built-in dataset:
import linguistica as lxa
from linguistica.datasets import cmudict
lxa_object = lxa.read_wordlist(cmudict)
cmudict
is the file path for the built-in english-cmudict.dx1
.
It can be replaced with the file path of a wordlist from your local drive.
As for the format of a wordlist file, each line of the file contains three pieces of information for a unique word type:
The word itself
By default, case does not matter, as Linguistica 5 internally processes all words in lowercase.
Token count of the word type
This is based on some corpus data. If unavailable, put down 1 here.
Phonemic representation (optional)
A list of phonemes/phones (separated by spaces) for the pronunciation of the word. If unavailable, the word itself with its list of letters is taken to be phonemic representation.
To illustrate what the required format looks like, here are a few lines
from english-cmudict.dx1
:
ABANDON 18 AH0 B AE1 N D AH0 N
ABANDONED 26 AH0 B AE1 N D AH0 N D
ABANDONING 8 AH0 B AE1 N D AH0 N IH0 NG
If phonemic representations were not available, these lines would be as follows:
ABANDON 18
ABANDONED 26
ABANDONING 8
Blank lines as well as those that begin with #
(for comments, metadata etc)
are ignored by Linguistica 5.
To use Linguistica 5 as a Python library with an in-memory wordlist object,
the relevant function is from_wordlist()
(see Data source).


3 Introduction
3.1 Objectives
Aim: To introduce R commands for analysing single categorical predictors.
By the end of this practical participants should be able to perform the following statistical analyses:
- One-way Analysis of Variance (ANOVA)
- Kruskal-Wallis test
For each of these, participants should be able to:
- Perform the test in R
- Interpret the output
- Check the assumptions of the test
- Carry out a post-hoc test if appropriate
The tests covered in this practical are:
- One-way ANOVA
- Kruskall-Wallis test
3.2 Background
This practical focuses on the implementation of various statistical tests relating to categorical predictors. These boil down to ANOVA and Kruskal-Wallis (which is a non-parametric alternative). Again, it does not focus on the underlying theory of the tests (although the demonstrators will be happy to answer any questions that you may have).
For each test there will be a section that:
- explains the purpose of the test,
- explains how to visualise the data,
- explains how to perform the test in R,
- explains how to interpret the output and report the results, and
- explains how to assess the assumptions required to perform the test.


Id: 459
Name: Butthole Ice Cream Guy
Status: Alive
Species: Alien
Type:
Gender: Male
OriginName: unknown
OriginUrl:
LocationName: Interdimensional Cable
LocationUrl: https://rickandmortyapi.com/api/location/6
Image: https://rickandmortyapi.com/api/character/avatar/459.jpeg
Episode: ['https://rickandmortyapi.com/api/episode/19']
Url: https://rickandmortyapi.com/api/character/459
Created: 2018-05-01T16:53:23.462Z


JavaScript Activity 2
Input String:
PART 1
X
Input Number:
PART 2
X
Input Hour(s):
PART 3
X
LONGEST WORD FINDER
×
IF NUMBER IS PRIME OR NOT
×
HOURS TO MINUTES CONVERTER
×


NHS faces 'unprecedented shortage' of lifesaving medicines
The NHS is running out of dozens of lifesaving drugs, including those used to treat cancer, heart conditions and epilepsy, according to a leaked document circulated to doctors.
The 24-page document from the supply team at the Department of Health and Social Care, even recommends patients break tablets in half in order to make their prescriptions last longer.
In total there are 86 drug shortages, with 17 new shortages on top of 69 other medications which have been affected, the Guardian reported.
These include antibiotics for tuberculosis, various cancer drugs, as well as drugs for heart conditions and Hepatitis vaccines.
Patients also face the prospect of being prioritised over others for some lifesaving drugs.
Given the shortages, the document also says that unlicensed versions may have to be imported, but that ‘lead times vary’.
Dr Nick Mann, a GP in Hackney in London, told the Guardian: ‘This situation is absolutely unprecedented.
‘Previously we would have one or two or three drugs that would go offline for a while, but this is something on a different level.
Advertisement Advertisement
‘It is going to render the day-to-day treatments that doctors provide very difficult.’
The papers which were circulated to doctors on Friday, also noted that while some drugs could be switched out for alternatives, ‘it was not always safe to do so’.
A spokesman at the Association for the British Pharmaceutical Industry said: ‘For new on-patent medicines there is an agreement between the government and pharmaceutical companies to cap NHS spending growth on branded medicines at 2 per cent, with anything over this paid back to the government.
‘Manufacturers know that any medicine shortage is extremely worrying for the people affected by it and they do everything they can to prevent medicine supply problems occurring and to resolve them quickly if they do happen.’


WAYDOWNTOWN -----------
In downtown Calgary, a complex of shopping malls, offices and apartments are interconnected via glass walkways for block after city block. Five wildly different office colleagues have wagered a month's salary that whoever can stay inside the longest wins the pot in cowriter (with James Martin)/director Gary Burns' "waydowntown."
Playing in relative real time over the course of a lunch hour on the 24th day of the bet, we first meet Tom (Fab Filipo), the new guy in the office, a marijuana smoking Goth and the bet's chief architect. Tom takes pleasure in rattling go-getter Sandra (Marya Delver) with creepy facts about recycled air, while growing somewhat concerned with the mental health of 'Sadly I'm' Brad (Don McKellar, "Last Night"), a twenty year office veteran. Randy (Tobias Godson) informs Tom that Curt (Gordon Currie), the engaged-to-be-married-for-two-years office lothario, won a bet like this before, so Tom nudges Curt towards easy prey - the also engaged, mousy clerk Vicki (Jennifer Clement).
Tom's been tasked with picking up a gift for the firm's octogenarian owner, Mr. Mather (Harris Hart), but is consistently kept off course by one comic incident after another. He keeps crossing paths with Sandra, who's just been given the important job of following Mather during lunch hour because he's a kleptomaniac. Tom becomes troubled by his ethics when he won't go outside to check on the possible suicide he may have caused while Sandra manically steals perfumed magazine inserts which she uses like a gas mask. Randy hangs out with a shopping mall security guard, commenting on the passers-by. Back in the office, while the receptionist eavesdrops on Curt and Vickie's bathroom
encounter, Brad escalates from stapling himself with motivational mottos ('Don't compromise - prioritize') to dancing ever closer to the glass windows clutching a marble-filled bottle. By film's end, all five will have shifted their priorities when they realize where their bet as led them.
Martin and Burns' script is amusing and often inventive, although some choices, such as making Mather's gift a $3,500 crystal vase, are nonsensically plot driven. Visually, "waydowntown" is more like a music video than a theatrical film, with Tom frequently flying around corridors like the super heroes he sees darting around corners. We see his imaginings of an arch villain taking hostage the enclosed inner city visualized like a floating snow globe. The office interiors look like temporary structures and are photographed with no imagination. Use of a French language cover of the Petulia Clark hit "Downtown" is a witty acknowledgement of its Canadian location.
"waydowntown" joins the likes of "Office Space" and "Haiku Tunnel" in the genre of cubie comedy. It's a cute flick, but its small screen look makes it better suited for video.
B-
For more Reeling reviews visit www.reelingreviews.com
<EMAIL_ADDRESS><EMAIL_ADDRESS>========== X-RAMR-ID: 29487 X-Language: en X-RT-ReviewID: 250235 X-RT-TitleID: 1108317 X-RT-SourceID: 386 X-RT-AuthorID: 1487
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


Asynchronous modules¶
Using native modules instead of generic Lua modules are important when using sockets to communicate with e.g databases to get the best performance, since the generic modules will block during long operations. If the operations you are doing are relatively fast then you may get away with using a generic module. This is something you have to benchmark yourself in your specific cases.
Creating modules for Turbo using the highly abstracted IOStream classes is real easy. If there is not a driver for e.g a database etc available then please do try to make it.
Overview¶
There are many ways of implementing async modules in Turbo.lua. To list the most apparent:
- Using callbacks
- Using Coroutine wrappable functions
- Using Coroutines and the CoroutineContext class
Which one suits your module best is up to your. Know that at the time of writing, no functions within the Lua Coroutine namespace is inlined by LuaJIT. Instead it fallbacks to the very fast interpreter. So if every little performance matters then callbacks are the way to go. All of the modules in the core framework uses Coroutine wrappable functions, except the HTTPClient, which uses coroutines and the CoroutineContext class.
Callback based modules is probably the flavour that most have used before. Basically you take in a callback (and maybe a callback argument/userdata) as argument(s) for the functions of your module. This function is then called when I/O has been completed. This means the user of your module must either split his program flow into seperate functions (seemingly in parts) or create closures inside functions.
Coroutine wrappable functions means that the functions of your API strictly adhers to the convention where the last two arguments of a functions always are a callback AND a callback argument (the argument is passed as first argument into the provided callback when it is called on I/O completion). If, and only if these requirements are met, the users of your module may use the turbo.async.task function to wrap the function and use the builtin Lua yield functionality. These functions then supports both callback-style and yield-style programming.
Coroutine directly with the CoroutineContext class does not offer a callback compatible API, and the users of the module must always yield to the I/O loop. This has some advantages in that it creates a 100% “I don’t care about this async stuff” environment.
Programmatically this can be illustrated as follows:
“I don’t care about this async stuff” module:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | local turbo = require "turbo"
local turboredis = require "turbo-redis"
local rconn = turboredis.connect("<IP_ADDRESS>", 1337)
local ExampleHandler = class("ExampleHandler", turbo.web.RequestHandler)
function ExampleHandler:get()
self:write("The value is " .. rconn:get("myvalue"))
end
local application = turbo.web.Application({
{"^/$", ExampleHandler}
})
application:listen(8888)
turbo.ioloop.instance():start()
|
Callback-type module:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | local turbo = require "turbo"
local turboredis = require "turbo-redis"
local rconn = turboredis.connect("<IP_ADDRESS>", 1337)
local ExampleHandler = class("ExampleHandler", turbo.web.RequestHandler)
function ExampleHandler:get()
local _self = self
rconn:get("myvalue", function(val)
_self:write("The value is " .. rconn:get("myvalue"))
end)
end
local application = turbo.web.Application({
{"^/$", ExampleHandler}
})
application:listen(8888)
turbo.ioloop.instance():start()
|
Callback-type module with callback argument and no closures, probably well known for those familiar with Python and Tornado.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | local turbo = require "turbo"
local turboredis = require "turbo-redis"
local rconn = turboredis.connect("<IP_ADDRESS>", 1337)
function ExampleHandler:_process_request(data)
self:write("The value is " .. data)
end
local ExampleHandler = class("ExampleHandler", turbo.web.RequestHandler)
function ExampleHandler:get()
rconn:get("myvalue", ExampleHandler._process_request, self)
end
local application = turbo.web.Application({
{"^/$", ExampleHandler}
})
application:listen(8888)
turbo.ioloop.instance():start()
|
Coroutine wrappable Callback-type module:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | local turbo = require "turbo"
local turboredis = require "turbo-redis"
local task = turbo.async.task
local yield = coroutine.yield
local rconn = turboredis("<IP_ADDRESS>", 1337)
local ExampleHandler = class("ExampleHandler", turbo.web.RequestHandler)
function ExampleHandler:get()
self:write("The value is " .. yield(task(turboredis.get(rconn, "myvalue"))))
end
local application = turbo.web.Application({
{"^/$", ExampleHandler}
})
application:listen(8888)
turbo.ioloop.instance():start()
|
The easiest to use is probably the first, where the program flow and code paths are more easily followed. The builtin HTTPClient uses this style of API... It is probably also a good choice for database queries etc, so you can keep your logic clean and easy to follow.
All callbacks added to the I/O loop are executed in its own coroutine. The callback functions can yield execution back to the I/O loop. Lua yield’s can return a object as it return to where the coroutine where started... This is utilized in the Turbo.lua I/O loop which will treat yields different based on what they return as they yield. The I/O Loop supports these returns:
- A function, that will be called on next iteration and its results returned when resuming the coroutine thread.
- Nil, a empty yield that will simply resume the coroutine thread on next iteration.
- A CoroutineContext class, which acts as a reference to the I/O loop which allow the coroutine thread to be managed manually and resumed on demand.

We will create this one with a API that supports the business as usual programming style where the programmer does not yield or control this flow by himself. Note that this is in no way a complete and stable module, it is only meant to give some pointers:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 | local turbo = require "turbo"
-- Create a namespace to return.
local couch = {}
-- CouchDB class, it is obviously optional if you want to use object orientation or not.
couch.CouchDB = class("CouchDB")
-- Init function to setup connection to CouchDB and more.
function couch.CouchDB:initialize(addr, ioloop)
assert(type(addr) == "string", "addr argument is not a valid address.")
self.ioloop = ioloop
local sock, msg = turbo.socket.new_nonblock_socket(
turbo.socket.AF_INET,
turbo.socket.SOCK_STREAM,
0)
if sock == -1 then
error("Could not create socket.")
end
self.sock = sock
self.iostream = turbo.iostream.IOStream(
self.sock,
self.io_loop,
1024*1024)
local hostname, port = unpack(addr:split(":"))
self.hostname = hostname
self.port = tonumber(port)
self.connected = false
self.busy = false
local _self = self
local rc, msg = self.iostream:connect(
self.hostname,
self.port,
turbo.socket.AF_INET,
function()
-- Set a connected flag, so that we know we can process requests.
_self.connected = true
turbo.log.success("Couch Connected!") end,
function() turbo.log.error("Could not connect to CouchDB!") end)
if rc ~= 0 then
error("Host not reachable. " .. msg or "")
end
self.iostream:set_close_callback(function()
_self.connected = false
turbo.log.error("CouchDB disconnected!")
-- Add reconnect code here.
end)
end
function couch.CouchDB:get(resource)
assert(self.connected, "No connection to CouchDB, can not process request.")
assert(not self.busy, "Connection is busy, try again later.")
self.busy = true
self.headers = turbo.httputil.HTTPHeaders()
self.headers:add("Host", self.hostname)
self.headers:add("User-Agent", "Turbo Couch")
self.headers:set_method("GET")
self.headers:set_version("HTTP/1.1")
self.headers:set_uri(resource)
local buf = self.headers:stringify_as_request()
-- Write request HTTP header to stream and wait for finish using the simple way with turbo.async.task wrapper
-- function.
coroutine.yield (turbo.async.task(self.iostream.write, self.iostream, buf))
-- Wait until end of HTTP response header has been read.
local res = coroutine.yield (turbo.async.task(self.iostream.read_until_pattern, self.iostream, "\r?\n\r?\n"))
-- Decode response header.
local response_headers = turbo.httputil.HTTPParser(res, turbo.httputil.hdr_t["HTTP_RESPONSE"])
-- Read the actual body now that we know the size of body.
local body = coroutine.yield (turbo.async.task(
self.iostream.read_bytes,
self.iostream,
tonumber((response_headers:get("Content-Length")))))
-- Decode JSON response body and return it to caller.
local json_dec = turbo.escape.json_decode(body)
return json_dec
end
--- Add more methods :)
return couch
|
Usage from a turbo.web.RequestHandler:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | local turbo = require "turbo"
local couch = require "turbo-couch"
-- Create a instance.
local cdb = couch.CouchDB("localhost:5984")
local ExampleHandler = class("ExampleHandler", turbo.web.RequestHandler)
function ExampleHandler:get()
-- Write response directly through.
self:write(cdb:get("/test/toms_resource"))
end
turbo.web.Application({{"^/$", ExampleHandler}}):listen(8888)
turbo.ioloop.instance():start()
|


- main(String[]) - Static method in class comTCP.EchoClient
-
main method
accepts a connection, receives a message from client then sends an echo to the client,
it has a default host name as localhost and a default port as 3100,
both of which can be changed by passing parameters in the args[]
- main(String[]) - Static method in class comTCP.EchoServerMultiThreaded
-
main method, default port set to 3100 and can be changed by
passing parameters in args[]
- main(String[]) - Static method in class http.client.WebPing
-
the main function for a web ping using the socket to connect to the server.
- main(String[]) - Static method in class http.server.processTest
-
- main(String[]) - Static method in class http.server.WebServer
-
Start the application.
- main(String[]) - Static method in class multicastClient.MulticastEchoClientConsole
-
the main program of the console version multicast echo client,
multicast and broadcast use the particular address
<IP_ADDRESS> to <IP_ADDRESS>.
- main(String[]) - Static method in class multicastClient.MulticastEchoClientIHM
-
the main program that launches the GUI
- main(String[]) - Static method in class multicastClient.MulticastEchoClientServer
-
the main program of the console version multicast echo client,
designed to be used for the UDP communication on the server side.
- multicastClient - package multicastClient
-
components for the UDP clients.
There are 3 versions of multicast clients: console version, GUI version and server console version.
- MulticastEchoClientConsole - Class in multicastClient
-
UDP multicast client console version main program
- MulticastEchoClientConsole() - Constructor for class multicastClient.MulticastEchoClientConsole
-
- MulticastEchoClientIHM - Class in multicastClient
-
UDP multicast client GUI version main program
- MulticastEchoClientIHM() - Constructor for class multicastClient.MulticastEchoClientIHM
-
multicast and broadcast use the particular address
<IP_ADDRESS> to <IP_ADDRESS>.
- MulticastEchoClientServer - Class in multicastClient
-
UDP multicast client server console version main program
- MulticastEchoClientServer() - Constructor for class multicastClient.MulticastEchoClientServer
-
- MulticastSubscriber - Interface in multicastClient
-
multicast subscriber interface, designed for GUI version to receive instant messages,
methods are invoked by the Client Listen Thread


Bloodhound is the typeahead.js suggestion engine. Bloodhound is robust, flexible, and offers advanced functionalities such as prefetching, intelligent caching, fast lookups, and backfilling with remote data.
The constructor function. It takes an options hash as its only argument.
javascript
var engine = new Bloodhound({
name: 'animals',
local: [{ val: 'dog' }, { val: 'pig' }, { val: 'moose' }],
remote: 'http://example.com/animals?q=%QUERY',
datumTokenizer: function(d) {
return Bloodhound.tokenizers.whitespace(d.val);
},
queryTokenizer: Bloodhound.tokenizers.whitespace
});
Kicks off the initialization of the suggestion engine. This includes processing
the data provided through local
and fetching/processing the data provided
through prefetch
. Until initialized, all other methods will behave as no-ops.
Returns a jQuery promise which is resolved when engine has been initialized.
```javascript var promise = engine.initialize();
promise .done(function() { console.log(‘success!’); }) .fail(function() { console.log(‘err!’); }); ```
After the initial call of initialize
, how subsequent invocations of the method
behave depends on the reinitialize
argument. If reinitialize
is falsy, the
method will not execute the initialization logic and will just return the same
jQuery promise returned by the initial invocation. If reinitialize
is truthy,
the method will behave as if it were being called for the first time.
```javascript var promise1 = engine.initialize(); var promise2 = engine.initialize(); var promise3 = engine.initialize(true);
promise1 === promise2; promise3 !== promise1 && promise3 !== promise2; ```
Takes one argument, datums
, which is expected to be an array of
datums. The passed in datums will get added to the search index that
powers the suggestion engine.
javascript
engine.add([{ val: 'one' }, { val: 'two' }]);
Removes all suggestions from the search index.
javascript
engine.clear();
If you’re using prefetch
, data gets cached in local storage in an effort to
cut down on unnecessary network requests. clearPrefetchCache
offers a way to
programmatically clear said cache.
javascript
engine.clearPrefetchCache();
If you’re using remote
, Bloodhound will cache the 10 most recent responses
in an effort to provide a better user experience. clearRemoteCache
offers a
way to programmatically clear said cache.
javascript
engine.clearRemoteCache();
Returns a reference to the Bloodhound constructor and reverts
window.Bloodhound
to its previous value. Can be used to avoid naming
collisions.
javascript
var Dachshund = Bloodhound.noConflict();
Computes a set of suggestions for query
. cb
will be invoked with an array
of datums that represent said set. cb
will always be invoked once
synchronously with suggestions that were available on the client. If those
suggestions are insufficient (# of suggestions is less than limit
) and remote
was configured, cb
may also be
invoked asynchronously with the suggestions available on the client mixed with
suggestions from the remote
source.
javascript
bloodhound.get(myQuery, function(suggestions) {
suggestions.each(function(suggestion) { console.log(suggestion); });
});
When instantiating a Bloodhound suggestion engine, there are a number of options you can configure.
datumTokenizer
– A function with the signature (datum)
that transforms a
datum into an array of string tokens. Required.
queryTokenizer
– A function with the signature (query)
that transforms a
query into an array of string tokens. Required.
limit
– The max number of suggestions to return from Bloodhound#get
. If
not reached, the data source will attempt to backfill the suggestions from
remote
. Defaults to 5
.
dupDetector
– If set, this is expected to be a function with the signature
(remoteMatch, localMatch)
that returns true
if the datums are duplicates or
false
otherwise. If not set, duplicate detection will not be performed.
sorter
– A compare function used to sort matched datums for a given query.
local
– An array of datums or a function that returns an array of
datums.
prefetch
– Can be a URL to a JSON file containing an array of datums or, if
more configurability is needed, a prefetch options hash.
remote
– Can be a URL to fetch suggestions from when the data provided by
local
and prefetch
is insufficient or, if more configurability is needed,
a remote options hash.
Prefetched data is fetched and processed on initialization. If the browser supports local storage, the processed data will be cached there to prevent additional network requests on subsequent page loads.
WARNING: While it’s possible to get away with it for smaller data sets, prefetched data isn’t meant to contain entire data sets. Rather, it should act as a first-level cache for suggestions. If don’t keep this warning in mind, you run the risk of hitting local storage limits.
When configuring prefetch
, the following options are available.
url
– A URL to a JSON file containing an array of datums. Required.
cacheKey
– The key that data will be stored in local storage under.
Defaults to value of url
.
ttl
– The time (in milliseconds) the prefetched data should be cached in
local storage. Defaults to 86400000
(1 day).
thumbprint
– A string used for thumbprinting prefetched data. If this
doesn’t match what’s stored in local storage, the data will be refetched.
filter
– A function with the signature filter(parsedResponse)
that
transforms the response body into an array of datums. Expected to return an
array of datums.
ajax
– The ajax settings object passed to jQuery.ajax
.
Remote data is only used when the data provided by local
and prefetch
is
insufficient. In order to prevent an obscene number of requests being made to
the remote endpoint, requests are rate-limited.
When configuring remote
, the following options are available.
url
– A URL to make requests to when when the data provided by local
and
prefetch
is insufficient. Required.
wildcard
- The pattern in url
that will be replaced with the user’s query
when a request is made. Defaults to %QUERY
.
replace
– A function with the signature replace(url, query)
that can be
used to override the request URL. Expected to return a valid URL. If set, no
wildcard substitution will be performed on url
.
rateLimitBy
– The method used to rate-limit network requests. Can be either
debounce
or throttle
. Defaults to debounce
.
rateLimitWait
– The time interval in milliseconds that will be used by
rateLimitBy
. Defaults to 300
.
filter
– A function with the signature filter(parsedResponse)
that
transforms the response body into an array of datums. Expected to return an
array of datums.
ajax
– The ajax settings object passed to jQuery.ajax
.
Datums are JavaScript objects that hydrate the pool of possible suggestions.
Bloodhound doesn’t expect datums to contain any specific properties as any
operations performed on datums are done using functions defined by the user i.e.
datumTokenizer
, dupDetector
, and sorter
.
The algorithm used by bloodhounds for providing suggestions for a given query
is token-based. When Bloodhound#get
is called, it tokenizes query
using
queryTokenizer
and then invokes cb
with all of the datums that contain those
tokens.
For a quick example, if a datum was tokenized into the following set of tokens…
javascript
['typeahead.js', 'typeahead', 'autocomplete', 'javascript'];
…it would be a valid match for queries such as:
typehead
typehead.js
autoco
java type


Module: AbstractController::Helpers::ClassMethods
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Instance Chain:
self,
Resolution
|
|
| Defined in: | actionpack/lib/abstract_controller/helpers.rb |
Instance Attribute Summary
- #_helpers=(value) writeonly
Instance Method Summary
- #_helpers_for_modification
-
#all_helpers_from_path(path)
Returns a list of helper names in a given path.
-
#clear_helpers
Clears up all existing helpers in this class, only keeping the helper with the same name as this class.
-
#helper(*args, &block)
Includes the given modules in the template class.
-
#helper_method(*methods)
Declare a controller method as a helper.
-
#inherited(klass)
When a class is inherited, wrap its helper module in a new module.
-
#modules_for_helpers(modules_or_helper_prefixes)
Given an array of values like the ones accepted by #helper, this method returns an array with the corresponding modules, in the same order.
- #default_helper_module! private
- #define_helpers_module(klass, helpers = nil) private
Resolution
- Included
Instance Attribute Details
#_helpers=(value) (writeonly)
[ GitHub ]# File 'actionpack/lib/abstract_controller/helpers.rb', line 92
attr_writer :_helpers
Instance Method Details
#_helpers_for_modification
[ GitHub ]# File 'actionpack/lib/abstract_controller/helpers.rb', line 231
def _helpers_for_modification unless @_helpers self._helpers = define_helpers_module(self, superclass._helpers) end _helpers end
#all_helpers_from_path(path)
Returns a list of helper names in a given path.
ActionController::Base.all_helpers_from_path 'app/helpers'
# => ["application", "chart", "rubygems"]
# File 'actionpack/lib/abstract_controller/helpers.rb', line 107
rdoc_method :method: all_helpers_from_path
#clear_helpers
Clears up all existing helpers in this class, only keeping the helper with the same name as this class.
# File 'actionpack/lib/abstract_controller/helpers.rb', line 222
def clear_helpers inherited_helper_methods = _helper_methods self._helpers = Module.new self._helper_methods = Array.new inherited_helper_methods.each { |meth| helper_method meth } default_helper_module! unless anonymous? end
#default_helper_module! (private)
[ GitHub ]#define_helpers_module(klass, helpers = nil) (private)
[ GitHub ]# File 'actionpack/lib/abstract_controller/helpers.rb', line 239
def define_helpers_module(klass, helpers = nil) # In some tests inherited is called explicitly. In that case, just # return the module from the first time it was defined return klass.const_get(:HelperMethods) if klass.const_defined?(:HelperMethods, false) mod = Module.new klass.const_set(:HelperMethods, mod) mod.include(helpers) if helpers mod end
#helper(*args, &block)
Includes the given modules in the template class.
Modules can be specified in different ways. All of the following calls include FooHelper
:
# Module, recommended.
helper FooHelper
# String/symbol without the "helper" suffix, camel or snake case.
helper "Foo"
helper :Foo
helper "foo"
helper :foo
The last two assume that "foo".camelize
returns “Foo”.
When strings or symbols are passed, the method finds the actual module object using String#constantize. Therefore, if the module has not been yet loaded, it has to be autoloadable, which is normally the case.
Namespaces are supported. The following calls include Foo::BarHelper
:
# Module, recommended.
helper Foo::BarHelper
# String/symbol without the "helper" suffix, camel or snake case.
helper "Foo::Bar"
helper :"Foo::Bar"
helper "foo/bar"
helper :"foo/bar"
The last two assume that "foo/bar".camelize
returns “Foo::Bar”.
The method accepts a block too. If present, the block is evaluated in the context of the controller helper module. This simple call makes the wadus
method available in templates of the enclosing controller:
helper do
def wadus
"wadus"
end
end
Furthermore, all the above styles can be mixed together:
helper FooHelper, "woo", "bar/baz" do
def wadus
"wadus"
end
end
# File 'actionpack/lib/abstract_controller/helpers.rb', line 211
def helper(*args, &block) modules_for_helpers(args).each do |mod| next if _helpers.include?(mod) _helpers_for_modification.include(mod) end _helpers_for_modification.module_eval(&block) if block_given? end
#helper_method(*methods)
Declare a controller method as a helper. For example, the following makes the current_user
and logged_in?
controller methods available to the view:
class ApplicationController < ActionController::Base
helper_method :current_user, :logged_in?
private
def current_user
@current_user ||= User.find_by(id: session[:user])
end
def logged_in?
current_user != nil
end
end
In a view:
<% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
Parameters
-
method[, method]
- A name or names of a method on the controller to be made available on the view.
# File 'actionpack/lib/abstract_controller/helpers.rb', line 140
def helper_method(*methods) methods.flatten! self._helper_methods += methods location = caller_locations(1, 1).first file, line = location.path, location.lineno methods.each do |method| # def current_user(*args, &block) # controller.send(:'current_user', *args, &block) # end _helpers_for_modification.class_eval <<~ruby_eval.lines.map(&:strip).join(";"), file, line def #{method}(*args, &block) controller.send(:'#{method}', *args, &block) end ruby2_keywords(:'#{method}') ruby_eval end end
#inherited(klass)
When a class is inherited, wrap its helper module in a new module. This ensures that the parent class’s module can be changed independently of the child class’s.
# File 'actionpack/lib/abstract_controller/helpers.rb', line 84
def inherited(klass) # Inherited from parent by default klass._helpers = nil klass.class_eval { default_helper_module! } unless klass.anonymous? super end
#modules_for_helpers(modules_or_helper_prefixes)
Given an array of values like the ones accepted by #helper, this method returns an array with the corresponding modules, in the same order.
# File 'actionpack/lib/abstract_controller/helpers.rb', line 97
rdoc_method :method: modules_for_helpers


UX/UI designer and researcher based in Stockholm, Sweden.
Portfolio
About
I graduated with a bachelors in Computer Science with a specialization in Human-Computer Interaction from Stockholm university 2019. I am a UX/UI designer, researcher and a programmer.
My primary interest within HCI is to collaborate with the user in order to find efficient solutions to problems.
I am proficient in wireframing, rapid prototyping and agile development. My CV contains detailed information on my proficiency with different tools.
TrainingBuddy is an application created to help inexperienced gymgoers become familiar with the gym.
The application offers the user a wide variety of different workout schedules, as well as an explanation on how to perform a particular exercise.
Tools
The tools used in this development cycle ranged from research methods, wireframing tools and prototyping tools used for creating both Lo-Fi and Hi-Fi prototypes.
- Balsamiq for wireframing
- Figma for Lo-Fi and Hi-fi prototyping
Approach
The focus with this prototype was to create a highly usable application that would aid newcomers in the gym with their workout.
Our primary focus with the prototype was for it to have a high degree of usefulness and fluency, meaning that the user would get the hang of the usability of the prototype very quickly.
This was achieved firstly through semi-structured interviews where we asked questions relating to the users goals, needs and encountered problems in the gym. The user group consisted of
men and women who were beginners in the gym. The users were chosen by being asked "do you go the gym, and if so, do you know how to structure your workout in the gym?"
Those who responded by saying that they were unfamiliar with the gym were chosen to be in the user group. In total we had 15 people in the usergroup.
The user test consisted of the users interacting with a Lo-Fi interactive prototype created through sigma. Even though Figma is a Hi-Fi tool the prototype used in the test was quite "empty",
meaning it was more similar to wireframes. Figma was used for the interactive capabilites. The users were asked to navigate to certain pages within the prototype and complete certain tasks.
The difficulty of finding the pages and completing the tasks were then used to assess the usability of the prototype. The users were also asked how we could improve upon the application.
Final prototype
The needs of the users were many; a training guide, a motivational trainer, logbook, comparing results to friends, etc. The constraints meant that we would not be able to prototype everything the user wanted so the primary focus was on the actual training guide.
SmartShield
Ideation
SmartShield was a prototype ideated within a course in HCI in Stockholm University. The goal was for the project group to create a hi-fi prototype with interactive capabilities.
Most groups decided to stay within the sphere of applications and websites whereas our group wanted to deviate from the predicted path. We decided to brainstorm and see what we came up with.
We came up with SmartShield through our final converging session where we improved upon ideas and chose one.
SmartShield
SmartShield is a 3D simulated prototype that uses Augmented Reality to project digital screens on to the cars windshield.
The idea for SmartShield came about through a casual discussion regarding road safety. A recent study had shown that many of the road accidents were caused by smartphone usage during driving.
We wanted to create something that would help reduce the number of accidents and make the road safer for all drivers.
As this was a prototype highly dependent on the userbase we wanted to spend a considerable amount of time on the actual user testing.
User Research
The user research consisted of the use of several research tools; questionnaire, semi-formal interviews, lo-fi prototype, hi-fi prototype and the "talk-aloud" method.
The users were chosen through a survey which confirmed their experience with driving as well as their age. We were looking for users with a high level of driving experience within the age of 20-65 as this is the age group with the highest working cognitive function.
The first user test was conducted with a Lo-Fi prototype using the talk-aloud method. Before the test started the user had to fill in a questionnaire, and at the end we conducted a small semi-formal interview.
All of the user tests were video recorded.
Lo-Fi prototype
The Lo-Fi prototype was created by using a sheet of A3 paper and pen and paper.
The idea here was to create a paper windshield with compononents that the user could then move around in order to customize the interface to their liking. The components we chose to include in the artifact were; music, navigation, speed, fuel and phone notifications.
A picture would be taken of all the "windshields" at the end. We then put together these pictures into heatmaps which showed us were the users preferred to put the different functions.
Photos taken during the Lo-Fi user tests. On the left users are interacting with the prototype. Shown on the right are the generated heatmaps indicating the preferred placements of the different functions.
The Lo-Fi user test was concluded with a semi-formal interview regarding their driving in traffic.
Hi-Fi prototype
FindMe
A simple way to keep track of your belongings.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia neque assumenda ipsam nihil, molestias magnam, recusandae quos quis inventore quisquam velit asperiores, vitae? Reprehenderit soluta, eos quod consequuntur itaque. Nam.
Controller
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia neque assumenda ipsam nihil, molestias magnam, recusandae quos quis inventore quisquam velit asperiores, vitae? Reprehenderit soluta, eos quod consequuntur itaque. Nam.
MotiWay
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia neque assumenda ipsam nihil, molestias magnam, recusandae quos quis inventore quisquam velit asperiores, vitae? Reprehenderit soluta, eos quod consequuntur itaque. Nam.
Submarine
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia neque assumenda ipsam nihil, molestias magnam, recusandae quos quis inventore quisquam velit asperiores, vitae? Reprehenderit soluta, eos quod consequuntur itaque. Nam.


VAGISIL ANTI ITCH ORIGINAL STRENGTH- benzocaine and resorcinol cream
VAGISIL ANTI ITCH MAXIMUM STRENGTH- benzocaine and resorcinol cream
Combe Incorporated
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
Vagisil Anti-Itch Creme Original Strength
Active Ingredients
Benzocaine 5%
Purpose
External analgesic
Active Ingredients
Resorcinol 2%
Purpose
External analgesic
Use
- temporarily relieves itching
Warnings
For external use only
Avoid contact with eyes
Stop use and ask a doctor if
condition worsens, or if symptoms persist for more than 7 days, or clear up and occur again within a few days
Do not apply over large areas of the body
Keep out of reach of children
If swallowed, get medical help or contact a Poison Control Center right away
Directions
- adults and children 2 years and older: apply a fingertip amount (approximately 1-inch strip) to affected area not more than 3 to 4 times daily
- children under 2 years: consult a doctor
Inactive ingredients
water, cetyl alcohol, glyceryl stearate, PEG-100 stearate, mineral oil, isopropyl palmitate, aloe barbadensis leaf juice, tocopheryl acetate, retinyl palmitate, zea mays (corn) oil, cholecalciferol, lanolin alcohol, fragrance, methylparaben, carbomer, isopropyl myristate, isopropyl stearate, sodium sulfite, triethanolamine, trisodium HEDTA
Vagisil Anti-Itch Creme Maximum Strength
Active Ingredients
Benzocaine 20%
Purpose
External analgesic
Active Ingredients
Resorcinol 3%
Purpose
External analgesic
Use
- temporarily relieves itching
Warnings
For external use only
Avoid contact with eyes
Stop use and ask a doctor if
condition worsens, or if symptoms persist for more than 7 days, or clear up and occur again within a few days
Do not apply over large areas of the body
Keep out of reach of children
If swallowed, get medical help or contact a Poison Control Center right away
Directions
- adults and children 12 years and older: apply a fingertip amount (approximately 1-inch strip) to affected area not more than 3 to 4 times daily
- children under 12 years: consult a doctor
Inactive ingredients
water, mineral oil, cetyl alcohol, propylene glycol, glyceryl stearate, PEG-100 stearate, isopropyl palmitate, aloe barbadensis leaf juice, tocopheryl acetate, retinyl palmitate, zea mays (corn) oil, cholecalciferol, lanolin alcohol, fragrance, methylparaben, carbomer, isopropyl myristate, isopropyl stearate, sodium sulfite, triethanolamine, trisodium HEDTA
Principal Display Panel
Vagisil®
ANTI-ITCH CREME
ORIGINAL STRENGTH
NET WT. 1 OZ (28 g)
itch-creme-01.jpg">
Principal Display Panel
Vagisil®
ANTI-ITCH CREME
MAXIMUM STRENGTH
NET WT. 1 OZ (28 g)
itch-creme-02.jpg">


Kenyan water discovery brings hope to parched north
The Kenyan government and UNESCO on Wednesday announced the discovery of a huge supply of underground water in the impoverished, drought-stricken extreme north of the country.
The find, made using advanced satellite exploration technology and backed up by UNESCO drilling, was hailed as a scientific breakthrough that could radically change the lives of the half-million people living in one of the world's most arid regions.
Two aquifers -- underground layers of permeable rock or silt soaked in water -- were found in the Turkana region, the scene of a devastating drought two years ago that aid workers said pushed malnutrition rates up to 37 percent.
"The news about these water reserves comes at a time when reliable water supplies are highly needed," said Judi Wakhungu, cabinet secretary in the Kenyan ministry of environment, water and natural resources.
"This newly found wealth of water opens a door to a more prosperous future for the people of Turkana and the nation as a whole. We must now work to further explore these resources responsibly and safeguard them for future generations," Wakhungu said at the start of a water security conference in Nairobi.
The firm which carried out the survey, Radar Technologies International (RTI), said the area hosts a minimum reserve of 250 billion cubic meters of water, which is recharged at a rate of 3.4 billion cubic meters per year -- almost equivalent to annual water consumption in Austria.
"Hundreds of thousands of livestock die because of recurring droughts. This won't happen anymore," RTI president Alain Gachet told AFP.
"We've just doubled the country's drinking water reserves. The needs are huge, as women often have to walk 10 to 20 kilometres to get water."
RTI said the largest find -- the Lotikipi Basin Aquifer, located west of Lake Turkana -- was roughly the size of the US state of Rhode Island.
The smaller Lodwar Basin Aquifer, meanwhile, could feed the parched regional capital of Lodwar -- although UNESCO cautioned that water quality still needed to be assessed.
The hostile and desert-like Turkana region, near the northern border with Uganda, South Sudan and Ethiopia, is the poorest in the country, and its mostly-nomadic people are among the most vulnerable in Africa.
Fighting between rival groups -- often armed with guns -- over grazing land for their livestock is common in the region.
Of Kenya's 41 million strong population, 17 million lack access to safe water, and 28 million do not have adequate sanitation.
Kenya's northern region already hosts Lake Turkana -- the world's biggest desert lake stretching 250 kilometres (150 miles) long by 60 kilometres wide at its largest point -- but the famous jade-coloured waters are threatened by hydroelectric dams cutting off feeder streams in neighbouring Ethiopia.
But water is not the only resource under the ground, with exploratory oil drilling ongoing.


Thoughts of Mine
Uploading to Google Drive — Without Google Drive
There are lots of great reasons to ask students to submit assignments to a cloud-based service like Google Drive or Dropbox. When students submit work online...
Gangnam Style, Arts Education, and the US Economy
NPR’s Planet Money podcast is one of my favorite things to listen to when I’m running. In a recent episode, “Why K-Pop is Taking over the World,” they discus...
Using Spotify in the Aural Skills Classroom
At Furman we are really lucky to have well-equipped classrooms that make it very easy to display a computer screen, project a score, and play music from a de...
Dropvox
Now that I’m thinking about it, another classroom tool I’ve used a lot this year is DropVox. It’s functionality isn’t a lot different from the Memos app that...
""


Alice was beginning to get very tired of sitting on her knees by her sister on the grassy
bank, and of having nothing to do: once or twice she had peeped into the dusty old
book her sister was reading, but it had no pictures or conversations in
it, ‘and what is the use of a book,’ thought our little Alice ‘without pictures or
conversations?’
Alice was beginning to get very tired of sitting by her sister on the
bank, and of having nothing to do. O: once or twice she had peeped into the
book her sister was reading, but it had no pictures or conversations in
it, ‘and what is the use of a book,’ thought Alice? ‘without pictures or
conversations?’
My favorite color is blue!


Now, I know you're gagging to know about Grid-Based Design. That is a method of composing a page that appeals to the way a user naturally reads: they start at top-left of the page, then down, then they read from the left of the page, going across and down again. Websites typically take this natural flow into account, ensuring that readers enjoy looking at the site and will stay on it and view the content, which is the whole point, right? For an illustration, see below:
Now if you think grids are exciting, you may just explode when I talk about responsive webpages. We've all got smartphones and tablets, and I'm sure we've all visited a fair few half-arsed mobile sites (*coughfacebookcough*). Well the great thing is that they don't even need to exist! With 'media queries' in your CSS, you can build one page that automagically responds to whatever device or screensize you're using without needing a separate page for mobiles at all! Neat eh? Here are some great examples. On that last one, check how the heading moves from vertical to horizontal - I love that!.
Perhaps less exciting than responsive layout but just as important, is semantic structure. You see, it's not just machines that have gotta read your code. Other people do too. YOU do too. Semantic structure is about using the right tags in a logical, readable way that makes sense to any human reading it. It's also a somewhat controversial topic - people just can't quite seem to agree on how nit-picky we should be about this stuff.
In addition to the awesome stuff mentioned above, I got a fair bit out of the second lesson. I learned about using the overflow attribute to stop your text spilling out of a box, and about tools like placehold.it and Google Fonts. Those are gonna be super useful in the weeks to come!


Weather Dashboard
Search for a city:
No City Listed
Temperature: -
Humidity: -
Wind speed: -
UV Index:
-
5 Day Forecast
×
Some error text


IMMORTAL BELOVED A film review by Steve Rhodes Copyright 1995 Steve Rhodes
RATING (0 TO ****): **
IMMORTAL BELOVED is the reputedly true story of Ludwig van Beethoven. The degree to which they stretched the truth for dramatic purposes, I have no idea since I know only of Beethoven 's music and little of his life other than he was deaf at the end. For some reason, the script's plausibility never bothered me, and I took the movie totally on face value.
IMMORTAL BELOVED is told as a mystery, but actually the mystery is more of a ruse to be able to tell the story of Beethoven's life in a fresh way. The mystery is that when he died he left all of his estate to "his immortal beloved", but no one knew who that was. His secretary (Jeroen Krabbe) decides to dedicate his life to finding out who she was. The movie then tells Beethoven's life in flashback from his severe beatings as a child to his death after composing his ninth symphony.
We find many amazing things about his life. He was the Mick Jagger of his time! His music turned his female fans (Isabella Rosselini, Johanna Ter Steege, Valeria Golino, and others) into ecstasy, and he had many lovers, groupies if you will. He was considered something of a villain by their fathers.
Moreover, Beethoven (Gary Oldman) we find was a crude, mean, vicious, angry, and extremely obnoxious person. The movie seems to say that although he is terrible to everyone around him, this is because he was a victim of child abuse and deafness. There are periodic statements that he is a good person inside and that people are just not able to see that part of him. Perhaps.
I am not a big fan of Gary Oldman. I found his SID AND NANCY repulsive in the extreme. He has done some acting I like, but his specialty is playing despicable characters (he was Lee Harvey Oswald in JFK). The minor character parts of the movie played by Steege and Golino I found I enjoyed the most.
Now, unless you are an historian, comes the only real reason to see movie--the music. The show opens with a piano sonata and ends with an amazing set of images while playing the Ode to Joy part of Beethoven's last symphony. What do you think of when you hear his choral symphony? I sure never thought of what they did, yet it worked wonderfully well. The music is all directed by Sir. Georg Solti and is beautiful.
I have to mention the art decoration as another outstanding part.  Actually, the credits show it was filmed in Prague, but hey, save a few bucks wherever you can I suppose.
What is wrong with the show? The script is pretty outlandish and tries to cover way too much material. The editing is too choppy. Finally, I just did not buy Oldman as Beethoven. I thought he was miscast and he certainly overacted.
It does seem like producers feel they can only make movies about composers if they show them as bizarre and quirky individuals. I think back to the only movie about by far and away my favorite composer - Gustav Mahler. It was called simply MAHLER. It was directed by Ken Russell, and he has Mahler hallucinating about death and Nazis and has him seeing his wife dancing on his grave in jackboots to the tune of one of Mahler's greatest symphonies. Sure.
The movie runs too long at 2:03, but if they felt that they had to cover as much ground as they attempted, then it should have been a 3 or 4 hour movie. The movie is correctly rated R for the beating of one small child and the death of another, for rape, murder, blood, and a little nudity. [Actually, the show featured some very effective kissing.] I think older teenagers could see it though since it does present the items above in a non-exploitive fashion. If you are a lover of classical music, then you will probably enjoy yourself as I did; otherwise, I would say skip it. I give it a very mild thumbs up overall, and I award it **.
**** = One of the top few films of this or any year. A must see film. *** = Excellent show. Look for it. ** = Average movie. Kind of enjoyable. * = Poor show.  Totally unbearable.
REVIEWED WRITTEN ON: January 26, 1995
Opinions expressed are mine and not meant to reflect my employer's.
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


These icons can be used by name in Svg component and all Taiga UI component accepting icons as input.


The website is solving people's problem of having accessing to a wide market of goods at low prices and short shipping times. Given there are so many types of products that a user could be looking for when entering the site, it is difficult to cater the homepage to each user's needs.
The website is solving people's problem of accessing free music and identifying/finding new music that aligns with their preferences. The process of finding new music for the user is a black box process and thus the site must depends on their song selection alone, hooking the user on the first few songs provided, in order to win the users trust/prove to the user that the site can provide he or she with music he or she likes.
The website is solving people's problem of browsing all possible flight choices across the globe - most travel search engines fail when you fly across country borders. There is a challenge of showing the user the flights he or she most desired when there are 1000+ options given the user's initial search criteria.