{{ site.conferencedate }}
A Practical Introduction to Data Science in Python
Sunday, October 25th, 2015
Paper Submission Deadline:
{{ site.deadline_submission }}
Author Notification:
{{ site.deadline_notification }}
Camera Ready Submission:
{{ site.deadline_camera }}
Poster Submission Deadline:
{{ site.deadline_poster }}


Very positive, easy to get along with, enthusiastic, project oriented Mechanical Engineer with varied job experiences in several industries, including structural engineering, graphic design, and most recently security and data collection. Bilingual, fluently speak English and Russian. Currently continuing education to increase my range of skills. Current field of study is Information Technology(IT). Learning programming and networking along with hardware aspect of IT.
Designing and creating is in my blood. In my spare time, I design and build motorcycles, small and medium size buildings, race tracks and ramps for RC cars, remodel home interiors, enjoy coming up with creative life hacks, always looking for new and efficient ways of doing things. I enjoy riding motorcycles, international and local travel, live music, concerts and theatre and educating myself on new technologies. Also, on the list of my other outdoor activities is: skydiving, flying small airplanes, skiing, jet skiing, water skiing.


#include <AntisymmetricExpFit.h>
Public Types | |
| typedef long double | Real |
|
typedef Eigen::Matrix< Real, Eigen::Dynamic, 1 > | RealVector |
|
typedef Eigen::Matrix< Real, Eigen::Dynamic, Eigen::Dynamic > | RealMatrix |
|
typedef const Eigen::EigenSolver< RealMatrix > ::EigenvalueType | Eigenvalues |
|
typedef Eigen::EigenSolver < RealMatrix > ::EigenvectorsType | Eigenvectors |
Public Member Functions | |
| AntisymmetricExpFit (const std::vector< double > &, bool=true) | |
| void | fit (double) |
| void | fit (int) |
| void | set_data (const std::vector< double > &, bool=true) |
| Real | mu_approx (int) |
| returns the value of the approximant at the j'th point. | |
| Real | residual (int) |
| returns the approximant minus the exact value at point i | |
| Real | two_norm () |
| returns the 2-norm error of the approximant | |
| Real | one_norm () |
| returns the 1-norm error of the approximant | |
| void | print () |
| Prints out the values of the approximant against the data. | |
| void | print_approximant () |
| Prints the approximant to standard out. | |
| void | decompose () |
| Find the eigenvectors and eigenvalues of the Hankel matrix. | |
| void | fit_exponents (int) |
| void | fit_amplitudes () |
| Eigenvalues & | eigenvalues () |
| Eigenvectors | eigenvectors () |
Public Attributes | |
| RealVector | mu |
| RealVector | A |
| RealVector | k |
Static Public Attributes | |
| static const Real | PI = 3.141592653589793238463 |
Protected Member Functions | |
| void | change_variable (RealVector &, const Real &, RealVector &) |
| void | find_zeroes (RealVector &, const Real &, const Real &, RealVector &) |
Protected Attributes | |
| Eigen::EigenSolver< RealMatrix > | ESolver |
| RealMatrix | H |
| bool | provable |
The function is sampled at a set of points. One half of the points are provided on construction, these are reflected about the point one half step above the last point.
| AntisymmetricExpFit::AntisymmetricExpFit | ( | const std::vector< double > & | y, | |
| bool | p = true | |||
| ) |
Constructs an instance of AsymmetricExpFit, forms the Hankel matrix and solves for the eigenvectors.
| y | Half of the data we wish to find an antisymmetric fit of. The point of antisymmetry lies at y.size()-0.5. y.size() should be even. | |
| p | if true, the provable method of solving is used, otherwise the alternative method is used. See accompanying paper for further details. |
| void AntisymmetricExpFit::fit | ( | double | max_error | ) |
Fits an exponential sum to the data in the Hankel matrix, H, whose error is bounded by max_error
| void AntisymmetricExpFit::fit | ( | int | n | ) |
Fits an exponential sum with 'n' terms to the data in the Hankel matrix, H.
| void AntisymmetricExpFit::set_data | ( | const std::vector< double > & | y, | |
| bool | p = true | |||
| ) |
Used to define the data points we wish to fit the approximant to (if different from that sent to the constructor).
| y | Half of the data to fit. The point of antisymmetry lies at y.size()-0.5. y.size() should be even | |
| p | if true, the provable method of solving is used, otherwise the alternative method is used. See accompanying paper for further details. |
| void AntisymmetricExpFit::fit_exponents | ( | int | c | ) |
Find zeroes of the polynomial , where is the eigenvector, and put any zeroes that lie in the interval [0:1] into k
.
| c | The identifier of the eigenvector to find zeroes of. |
| void AntisymmetricExpFit::fit_amplitudes | ( | ) |
Solevs the Vandermonde system to find the least squares fit of the amplitudes for a given k
.
| AntisymmetricExpFit::Eigenvalues & AntisymmetricExpFit::eigenvalues | ( | ) | [inline] |
| AntisymmetricExpFit::Eigenvectors AntisymmetricExpFit::eigenvectors | ( | ) | [inline] |
| void AntisymmetricExpFit::change_variable | ( | RealVector & | P, | |
| const Real & | alpha, | |||
| RealVector & | Q | |||
| ) | [protected] |
Changes the variable of a polynomial represented in P and stores the result in Q so that where
| void AntisymmetricExpFit::find_zeroes | ( | RealVector & | P, | |
| const Real & | a, | |||
| const Real & | b, | |||
| RealVector & | Z | |||
| ) | [protected] |
Finds the zeroes of P(x) in the domain , putting the results into Z


Disney Plus hits 10M subscribers in 1 day
by The Associated Press, StaffNEW YORK -- Disney Plus says it hit more than 10 million sign-ups on its first day of launch, far exceeding expectations.
Disney's mix of Marvel and Star Wars movies and shows, classic animated films and new series appears to be a hit out of the gate after its launch on Tuesday.
Disney has invested billions in its streaming service, which costs $7 a month or $70 a year after a 7-day free trial. Customers of some Verizon wireless and home-internet plans were offered a year free.
Disney didn't break down where the subscriptions came from or if they were free or paid monthly or yearly. Some analysts thought it would take Disney a year to reach 10 million subscribers.
Netflix has garnered 158 million subscribers since launching its streaming platform in 2007.


At Least 9 Shot, Multiple Killed in California Backyard
by NBC Bay Area staffMultiple people were shot at a home in Fresno, California, late Sunday, according to a report from NBC affiliate KSEE.
The shooting was reported at about 6 p.m. near Peach and Olive avenues, where there was gathering in the backyard of a home for a Sunday football game, KSEE reported, citing Fresno police.
Police told the TV station at least nine people were shot, with several people being found dead in the backyard. The injured victims were taken to local hospitals, some in critical condition.
The suspects were still at-large, police told KSEE.
No further details were immediately available.


| {{player.name}} | {{player.points}} | {{player.kills}} / {{player.deaths}} / {{player.suicides}} | {{player.kills + player.deaths + player.suicides === 0 ? "0.00" : (player.kills * 100 / (player.kills + player.deaths + player.suicides)).toFixed(2)}} | {{player.ping ? player.ping.toString() + " ms" : ""}} | |
| {{player.name}} | {{player.points}} | {{player.kills}} / {{player.deaths}} / {{player.suicides}} | {{player.kills + player.deaths + player.suicides === 0 ? "0.00" : (player.kills * 100 / (player.kills + player.deaths + player.suicides)).toFixed(2)}} |
| {{team.teamName}} | {{team.points}} |
| {{player.name}} | {{player.points}} | {{-player.blunders}} | {{player.kills}} / {{player.deaths}} / {{player.suicides}} | {{player.kills + player.deaths + player.suicides === 0 ? "0.00" : (player.kills * 100 / (player.kills + player.deaths + player.suicides)).toFixed(2)}} | {{player.ping ? player.ping.toString() + " ms" : ""}} | |
| {{player.name}} | {{player.points}} | {{player.kills}} / {{player.deaths}} / {{player.suicides}} | {{player.kills + player.deaths + player.suicides === 0 ? "0.00" : (player.kills * 100 / (player.kills + player.deaths + player.suicides)).toFixed(2)}} |
| {{getTimestamp(event.time)}} |
{{event.player}}
{{event.player}}
End of Level
{{event.player}} x{{(Math.sqrt(8 * event.score + 1) - 1) / 2}} = {{event.score}} points
{{event.player}} Found
{{event.player}} Lost
{{event.player}} +{{event.points}} Points
{{event.player}}
{{event.player}}
{{event.killer}} {{event.killed}}
{{event.player}}
Robot {{event.player}}
Start of Level
{{event.player}}
{{event.player}}
{{event.event}}
|
| {{getTimestamp(event.time)}} |
{{event.player}}
{{event.player}}
End of Level
{{event.player}}
{{event.player}} Pickup
{{event.player}} Returned
{{event.player}} {{event.team}} Scored
{{event.player}}
{{event.player}} {{event.team}}
{{event.killer}} {{event.killed}}
{{event.player}} {{event.team}}
{{event.player}} {{event.team}}
{{event.player}}
Start of Level
{{event.player}}
{{event.player}} {{event.team}}
{{event.player}}
{{event.event}}
|


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use OSLSchema | |
|---|---|
| net.ontopia.topicmaps.schema.impl.osl | The classes and interfaces used to represent constructs in the Ontopia Schema Language. |
| net.ontopia.topicmaps.schema.impl.osl.cmdline | |
| net.ontopia.topicmaps.webed.core | The core interfaces of the Web Editor Framework; the main interfaces used to build Web Editor applications. |
| net.ontopia.topicmaps.webed.impl.actions.tmobject | Web editor action classes dealing with more than one kind of topic map object. |
| net.ontopia.topicmaps.webed.impl.actions.topicmap | The implementation of the action interfaces belonging to Ontopia's web editor framework related to the execution of modifications of the topic map. |
| net.ontopia.topicmaps.webed.impl.utils |
| Uses of OSLSchema in net.ontopia.topicmaps.schema.impl.osl |
|---|
| Fields in net.ontopia.topicmaps.schema.impl.osl declared as OSLSchema | |
|---|---|
protected OSLSchema |
TopicConstraintCollection.schema
|
protected OSLSchema |
SchemaValidator.schema
|
protected OSLSchema |
OSLSchemaContentHandler.schema
|
protected OSLSchema |
AssociationClass.schema
|
| Methods in net.ontopia.topicmaps.schema.impl.osl that return OSLSchema | |
|---|---|
OSLSchema |
OSLSchemaContentHandler.getSchema()
|
| Methods in net.ontopia.topicmaps.schema.impl.osl with parameters of type OSLSchema | |
|---|---|
protected void |
OSLSchemaWriter.export(OSLSchema schema,
DocumentHandler dh)
|
| Constructors in net.ontopia.topicmaps.schema.impl.osl with parameters of type OSLSchema | |
|---|---|
AssociationClass(OSLSchema schema)
INTERNAL: Creates an association class definition belonging to the schema. |
|
RuleSet(OSLSchema schema,
String id)
INTERNAL: Creates a new rule set object. |
|
TopicClass(OSLSchema schema,
String id)
INTERNAL: Creates a topic class belonging to the given schema. |
|
TopicConstraintCollection(OSLSchema schema,
String id)
INTERNAL: Creates a new collection of topic constraints. |
| Uses of OSLSchema in net.ontopia.topicmaps.schema.impl.osl.cmdline |
|---|
| Methods in net.ontopia.topicmaps.schema.impl.osl.cmdline that return OSLSchema | |
|---|---|
OSLSchema |
Generate.createSchema(String input)
Creates a schema from the given topic map which is read in fist. |
OSLSchema |
Generate.createSchema(TopicMapIF tm)
Creates a schema from the given topic map. |
| Constructors in net.ontopia.topicmaps.schema.impl.osl.cmdline with parameters of type OSLSchema | |
|---|---|
AssociationClassAnalyzer(OSLSchema schema,
TopicIF assoctype,
Collection associations)
|
|
TopicClassAnalyzer(OSLSchema schema,
TopicIF topictype,
Collection topics)
|
| Uses of OSLSchema in net.ontopia.topicmaps.webed.core |
|---|
| Methods in net.ontopia.topicmaps.webed.core that return OSLSchema | |
|---|---|
OSLSchema |
OSLSchemaAwareIF.getSchema()
INTERNAL: Gets schema object. |
| Methods in net.ontopia.topicmaps.webed.core with parameters of type OSLSchema | |
|---|---|
void |
OSLSchemaAwareIF.setSchema(OSLSchema schema)
INTERNAL: Sets the schema object. |
| Uses of OSLSchema in net.ontopia.topicmaps.webed.impl.actions.tmobject |
|---|
| Methods in net.ontopia.topicmaps.webed.impl.actions.tmobject that return OSLSchema | |
|---|---|
OSLSchema |
OSLValidate.getSchema()
|
| Methods in net.ontopia.topicmaps.webed.impl.actions.tmobject with parameters of type OSLSchema | |
|---|---|
void |
OSLValidate.setSchema(OSLSchema schema)
|
| Uses of OSLSchema in net.ontopia.topicmaps.webed.impl.actions.topicmap |
|---|
| Fields in net.ontopia.topicmaps.webed.impl.actions.topicmap declared as OSLSchema | |
|---|---|
protected OSLSchema |
AbstractTopicMapAction.schema
The schema object which may be available (optionally). |
| Methods in net.ontopia.topicmaps.webed.impl.actions.topicmap that return OSLSchema | |
|---|---|
OSLSchema |
AbstractTopicMapAction.getSchema()
|
| Methods in net.ontopia.topicmaps.webed.impl.actions.topicmap with parameters of type OSLSchema | |
|---|---|
void |
AbstractTopicMapAction.setSchema(OSLSchema schema)
|
| Uses of OSLSchema in net.ontopia.topicmaps.webed.impl.utils |
|---|
| Methods in net.ontopia.topicmaps.webed.impl.utils with parameters of type OSLSchema | |
|---|---|
Collection |
SchemaUtils.getAllowedAssocTypes(OSLSchema schema,
TopicIF topic)
INTERNAL: Returns a collection of association types that can be played by the given topic. |
Collection |
SchemaUtils.getAllTopicNameConstraints(OSLSchema schema,
TopicIF topic)
INTERNAL: Returns the complete set of topic name constraints in this collection, including those of sub collections. |
Collection |
SchemaUtils.getExtOccConstraints(OSLSchema schema,
TopicIF topic)
INTERNAL: Returns the complete set of constraints for external occurrences for the given topic in the specified schema. |
Collection |
SchemaUtils.getIntOccConstraints(OSLSchema schema,
TopicIF topic)
INTERNAL: Returns the complete set of constraints for internal occurrences for the given topic in the specified schema. |
protected Collection |
SchemaUtils.getOccurrenceConstraints(OSLSchema schema,
TopicIF topic,
boolean internal)
|
TypeStorage |
SchemaUtils.getRemainingExtOccTypes(OSLSchema schema,
TopicIF topic)
INTERNAL: Returns a set of topic objects which belong to external occurrence types that are allowed to add to the given topic. |
TypeStorage |
SchemaUtils.getRemainingIntOccTypes(OSLSchema schema,
TopicIF topic)
INTERNAL: Returns a set of topic objects which belong to internal occurrence types that are allowed to add to the given topic. |
protected TypeStorage |
SchemaUtils.getRemainingOccTypes(OSLSchema schema,
TopicIF topic,
Collection occCons)
|
TypeStorage |
SchemaUtils.getRemainingRoleTypes(OSLSchema schema,
AssociationIF assoc)
INTERNAL: Returns a set of topic objects which belong to role types that are allowed to add to the given association. |
ScopeStorage |
SchemaUtils.getRemainingTopicNameThemes(OSLSchema schema,
TopicIF topic)
INTERNAL: Returns a set of topic objects which belong to themes that are allowed to add to the topic name by the given topic. |
Collection |
SchemaUtils.getRoleConstraints(OSLSchema schema,
AssociationIF assoc)
INTERNAL: Returns the collection of role constraints in this class definition. |
TopicIF |
SchemaUtils.getRoleType4AssocType(OSLSchema schema,
TopicIF assocType,
TopicIF player)
INTERNAL: Get the allowed association role type for the given association type with the help of the schema. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


--- layout: post esbma_id: 1603 title: Results from our Coupon Experiment date: 2006-06-07 15:06:35 keywords: biz ---
During the month of May 2006, we conducted an experiment with the coupon code feature of our online store. On May 1st, I posted a coupon code here on my blog. The coupon was good for a 20% discount during the month of May. Now I am ready to report the results of the experiment.
Looking at the customers who responded to my question, I see several positives:
In contrast, 12 people said the coupon did not affect their decision. They were planning to make a purchase at full price, but they were able to pay less because they found the coupon. An optimist could find positive things to say about those 12 transactions. After all, we don't want to be in the habit of complaining when we people trade us cash for our software.
But the fact is that these 12 transactions can also be seen in a negative light. Those customers paid 20% less than they were willing to pay. The aggregate amount saved by those customers is effectively a cost of having the coupon.
A rather simplistic judgment of the coupon experiment would be to add up an estimate of the incremental revenue produced by the coupon and subtract the total amount saved by the 12 folks who would have been willing to pay full price. (I'm sure there are several reasons why this analysis is simplistic, but the first one that comes to mind is that it ignores the future positive effects of having 5 customers we would not otherwise have.)
Anyway, I'm not disclosing actual revenue numbers here, but I will say this: It appears that the net revenue from this coupon experiment was positive, but it was not a very large number. (Keep in mind that I only asked for feedback from 25 of the coupon customers, and only 21 of them replied.)
One interesting way to use coupon codes is to track the effectiveness and reach of an advertisement. For example, we might put a coupon code in a print ad and then watch how many times the coupon gets used. This would give us some sort of indication of the effectiveness of that ad.
In this case, the coupon appeared in a blog entry, not in a print ad. Can we look at the data from this experiment and draw any conclusions about the reach and effectiveness of my blog? I'm not sure, but it seems like I would be extrapolating from very little data. I'll predict that if we place a coupon in a print ad, it will show up in less than 9.5% of our transactions. Nonetheless, the 9.5% number seemed kind of low to me. Think of it this way: Over 90% of our customers in May could have saved money on their purchase if they were reading my blog. :-)
For now, I will decline to draw any solid conclusions on this issue. The 9.5% number may end up being useful for comparisons later.
Traditional coupons are a way of charging lower prices to customers who are more price-sensitive. Joel Spolsky explains this concept rather well in his article on pricing. I summarize it like this:
Grocery store coupons are a form of market segmentation. People who are willing to take the time to clip coupons from the Sunday newspaper inserts are rewarded for their efforts with discounted prices. The value of the coupons (the amount of the discount) is specifically tuned to ensure that the time spent clipping them is worth approximately minimum wage. Most affluent customers eventually realize that clipping coupons is a very low-paying job, so they stop doing it. Therefore, the groceries get sold to two different groups of people at two different prices, and the "consumer surplus" is captured.
Obviously, some of our customers are more price-sensitive than others. It makes sense that our coupon would be appealing to the more price-sensitive folks in our customer base. Some of the data from our experiment seems consistent with this:
But one piece of data suggests that if our coupon was an attempt at market segmentation, it failed miserably: 12 out of 25 people questioned used the coupon to get a discount even though they would have been willing to pay full price. Why did this happen?
I observe that the coupon on my blog was simply far too easy to find. Just Google for "SourceGear coupon code" and it shows up as the second result. If we want to decrease the percentage of people who used the coupon simply because they saw it, we need to add more hassle. The grocery store example suggests that a relatively small amount of tedium will be an effective obstacle. Clipping coupons from the Sunday newspaper isn't really that difficult, but lots of people just don't bother.
The transparency in this note is, well, atypical. I am writing this because I think people might find it interesting, but I am taking somewhat of a risk. I hope that nothing I have written here causes offense to any of our customers. :-)
If you are reading this and you happen to be one of our more "price-sensitive" customers, please know that we appreciate your business. I feel humbled by every customer who chooses our products, from the small shop with one license to the large enterprise with hundreds of seats.
Also, if you are one of the coupon customers who responded to my question, thank you again for taking the time to provide useful information.
I think this coupon experiment was interesting. It's over for now, and there are currently no valid coupon codes in the SourceGear store. But I think we'll probably try this concept again sometime in the future. As I've hinted here, I want to see what kind of different results we might get by placing a coupon code someplace other than here on my blog.


Update
Manual Update to 0.14
This update converts the old config style into YAML:
- Copy one of init/config/*.yml files to .loft_deploy/config.yml; based on the role of the local.
- Hand copy/paste config values from .loft_deploy/config into .loft_deploy/config.yml.
- Delete .loft_deploy/config.
- Run
ldp clearcache
.
- Run
ldp configtest
and adjust as necessary.


#GIVE US YOUR BROKEN MOBILE
BECAUSE THIRD-PARTY COUNTRIES DO ALSO DESERVE IT. YOU CAN MAKE IT TRUE
LOCATIONS WILL BE PUBLISHED SOON..
HOME
SOLUTIONS
TBM Tumor Classifier
Colorectal cancer
Breast Cancer
CAMPAIGN
CLOUD SERVICE


Master of Science, Computational Analysis & Public Policy
University of Chicago
Advanced Courses in Programming, Machine Learning, Databases & Economics to prepare for a career at the intersection of technology & policy.
Bachelor of Science, Economics
Lahore University of Management Sciences
A liberal arts education focusing on courses ranging from Economics, Psychology, Math & Computer Science


Our focus is mainly on creating tools/programs/software/hardware framework to help science students learn better. It can be anything which promotes learning by exploring and experimenting.
Got a different idea? Related to Science, Technology, Maths, Engineering, Arts or Design? Go ahead and add it HERE.... If you see an idea you'd like to hack/collaborate on, add your name to it! Wish to be a mentor? Write to us in detail about yourself and the proposed science hack idea at shdbelgaum[AT]gmail.com
Need more ideas? Browse some of the ideas from London's Science Hack Day . To submit your science hack idea fill Science Hack Submission Form.
Ambassador Science Hack Day, Founder FOSSASIA,Organizes SHDs across Asia.
Hong Phuc Dang has lived several years in the US and Singapore after her childhood in Vietnam. Apart from the fascination in mathematics and technology she is interested in how technology can improve peoples live.
As a member of the FashionTec working group she works on topics of mathematical grading of garment patterns.She also coordinates the Google Summer of Code program of the project.
Hong Phuc has appeared at International Open Source events like the Libre Graphics Meeding and organized hackathons and workshops in Vietnam and Cambodia. She is also a core-member of GNOME.Asia and FOSSASIA. Professionally, Hong Phuc works as a consultant and researcher for an International data research company.
Hack Idea : senseBoxA well known name in the Python community of India. CPython core developer, currently working as Fedora Cloud Engineer at Red Hat.
Kushal has been elected as a Director at the Python Software Foundation. He has been a mentor and an Ambassador at The Fedora Project. Along side his contributions to CPython, Kushal has also been contributing to a wide variety of upstream projects.
He started 'dgplug' - Linux Users Group of Durgapur and wrote a book titled "Python for you and me". Kushal has been coordinating the DGPLUG summer training program for many years to help new participants take their first steps in contributing to Free and Open Source Software.
Hack Idea : NodeMCU and SensorsYoung Scientist in the making. Masters in Physics from Indian Institute of Science Education and Research, Mohali.
Jithin is working on instrumentation for labs and has independently developed severel python powered versatile lab tools, latest one is SEELABLET - An instrumentation cluster for science and engineering experiments.
Jithin has been awarded Junior Science Talent Search Examination (JSTSE) Scholorship and Kishore Vaigyanik Protsahan Yojana(KVPY) Scholarship. He also has many awards in the field of robotics, football and volleyball.
Accomplished flautist, guitarist and Sangeet Bhushan awarded by Pracheen kala kendra for vocal classical - A multidimensional young genius, indeed!
Hack Idea : SeeLablet and Solar LanternA motivated and charismatic individual! Founder and CEO at Bangalore Makespace and Open Source Creativity, which is now the largest maker community in India.
A devout advocate and ambassador of the Maker Movement, Kavita believes in harnessing the power of collaboration in creative communities and has been instrumental in setting the stage for Makers, Hackers and Do-It-Togetherers’ to join hands and co-create with one another.
Kavita graduated with a Masters of Science in Electrical and Computer Engineering from Carnegie Mellon University, Pennsylvania, USA, where she also worked as an Associate Researcher at The Robotics Institute (RI) and The Language Technologies Institute as part of CMU’s School of Computer Science.
Hack Idea : Beam BotNitesh is a computer scientist, a hardware hacker and a amateur flutist. He likes to build stuff using laser cutting, 3D printing, leds and junk hardware.
He has made his own 3D printer for printing with edible materials like chocolate and Halwa using opensource tools. He also works in robotics. As an exchange student, he has worked with Professor Raul Rojas at Free University Berlin, and programmed a simultaneous localization and mapping (SLAM) algorithm for a small autonomous car. At IIIT Bangalore, he has worked on programming a collision avoidance mechanism for the prototype of an autonomous wheelchair using bio-inspired collision avoiding behavior of a grasshopper
Hack Idea : Laser PrintersFriend , Programmer , Teacher , Amateur musician , Social entrepreneur, OSH / FOSS advocate.
Akshai is Research assistant at FOSSEE, IIT Bombay, Co-Founder at Microhope Foundation, Former OSH Developer at ICFOSS , Govt. of Kerala. Former Fellow at Kerala Start-Up Mission. He Studied Electronics and Communication engineering at College of Engineering Kallooppara.
Hack Idea : ESP12 ModuleA Physics Teacher who loves FOSS, Fedora, Python and believes that 'A Clean House is a Sign of a Wasted Life !'
Praveen has been a Fossasia-GSoC :Google Summer of Code alumnus (internship for three years,2014, 2015 and 2016). He is also mentor for Google Code-In and proud Fedora volunteer. Actively involved in ExpEYES project, teacher training programs and currently working on Pocket Science Lab along with Jithin B P.
He is currently pursuing PhD in Physics from VTU, Belgaum. E-content developer for National Repository of Open Educational Resources (NROER) for School Education by Central Institute of Education Technology (CIET) and a member of committee for “Development of ICT Refresher Course for students and teachers” @ CIET-NCERT, New Delhi.
Hack Idea : Patterns using LasersOpen Source enthusiast and full stack developer who loves anything in Python or JavaScript
Saptak was a GSoCer in year 2016 with FOSSASIA. He has also been a mentor in Google Code-in 2015. He is an organizer in Google Developer's Group, Allahabad and has been an active contributor in many open source organisations.
He is presently an undergrad in Information Technology doing his final years in IIIT Allahabad. Apart from development he is hugely interested in research topics like Natural Language Processing and Cognitive Science using EDA signal.
Hack Idea : Fun with Chrome Extension DevelopmentPropose a hack and be a mentor. Hack Idea can be anything from science, Tech, software or an app.
Science Hack ProjectPropose a hack idea and be a mentor. Let's learn together.
Science Hack ProjectHong Phuc is getting this amazing tool to SHD. The senseBox is a do-it-yourself kit for stationary and mobile sensor stations – the Citizen Science Toolkit.
With senseBox , citizens and schools are able to collect environmental data using sensors for climate (weather, air quality), transport (traffic density or noise pollution) and many more phenomena to find out more about the environment. The data collected may be published as open data on the openSenseMap.
Join this projectNodeMCU is an open-source firmware and development kit that helps you to prototype your IOT product within a few script lines. Join Kushal in this hack to create amazing science tools with NodeMCU, Temperature Sensors and power of Python Programming Language.
Join this projectBEAM robotics (from Biology, Electronics, Aesthetics and Mechanics) is a style of robotics that primarily uses simple analogue circuits, such as comparators, instead of a microprocessor in order to produce an unusually simple design.
While not as flexible as microprocessor based robotics, BEAM robotics can be robust and efficient in performing the task for which it was designed. BEAM robots may use a set of the analog circuits, mimicking biological neurons, to facilitate the robot's response to its working environment.
Join this projectVelocity measurement with lasers and photosensors . Jithin will be using the SEELablet, an awesome instrumentation cluster made by our own young scientist Jithin himself
Seelablet can be used to measure time intervals between successive obstructions to a laser beam that is incident on a photo transistor. We can measure speeds of athletes , or other things like the speed of a karate chop.
Join this projectHacking the solar garden lamps to automatically detect human/animal presence using Passive IR sensor
We are making solar lanterns as a part of 'Science Toys and Soldering' Workshops for highschool kids, to be conducted at SHD Belgaum. The concept and design of the solar lantern is by Jithin B P and Praveen Patil with support and inspiration from Akiba @freaklabs
Lets hack these solar lanterns to make them useful as beautiful detectors lamps in the garden.
Join this projectLet's create mesmorizing patterns with Light, Music and PSLab.
"Lissajous Figures, Spirographs, Harmonograms and Cymatics" - Recreating the unseen into seen art and science!
Nature has been a perennial source of inspiration for many! Artists, architects, designers imitate the design patterns of nature; poets describe its beauty and scientists try to unravel the mysteries of nature. A deep look into nature unlocks imagination, and inspires creativity. Here, we will try to create few amazing patterns and mashups with Light, Sound and Physics!
Join this projectUse your voice to transform laser light into amazing patterns..
By talking, humming, or singing into the Sound Visualizer, you’ll be able to see sound as vibrations (or pressure waves) and experience beautiful patterns and resonant vibration modes.
Lets make the device from available resources, innovate and add better safety features to enable it to be used by kids.
Join this projectLearn by Exploring and Experimenting can be assiated with simple demonstration tools that can make the science concepts easy to understand.
In this hack we will try to setup cool demos with Laser light to explain various optical phenomena, fluorescence and photochromism
Join this projectAdd Internet to your next project with an adorable, bite-sized WiFi microcontroller, at a price you like! The ESP8266 ESP12 processor from Espressif is an 80 MHz microcontroller with a full WiFi front-end (both as client and access point) and TCP/IP stack with DNS support as well.
Akshai is an expert in microcontroller programming. Join him to learn and hack with ESP12
Join this projectWith the entire information technology and user end slowly shifting towards website, browsers now play an important role. We can't think about a system without browser and Google Chrome is one of the most famous. But how about we increase the capabilities of a browser and make it do much more than it can actually do? Well, a Chrome Extension allows you to do exactly that and much more.
Join this projectEver wondered how those huge websites are built and is there an easy way to get a decent website built in a very short period of time without needing to learn a lot? But then you don't want to use default website templates either? Well, you are in luck. Front-end frameworks like Bootstrap, Semantic-UI, Materialize allow you to do exactly that in a very limited amount of time. You can create your own custom website without thinking much about stylesheets and scripting.
Join this projectPropose your cool ideas for Science Hack Day India. Need Ideas? Browse through idea page of London Science Hack Day
Propose Hack Idea


A context manager that lifts ops out of control-flow scopes and function-building graphs.
tf.compat.v1.init_scope
tf.compat.v2.init_scope
tf.init_scope()
There is often a need to lift variable initialization ops out of control-flow
scopes, function-building graphs, and gradient tapes. Entering an
init_scope
is a mechanism for satisfying these desiderata. In particular,
entering an init_scope
has three effects:
(1) All control dependencies are cleared the moment the scope is entered;
this is equivalent to entering the context manager returned from
control_dependencies(None)
, which has the side-effect of exiting
control-flow scopes like tf.cond
and tf.while_loop
.
(2) All operations that are created while the scope is active are lifted
into the lowest context on the context_stack
that is not building a
graph function. Here, a context is defined as either a graph or an eager
context. Every context switch, i.e., every installation of a graph as
the default graph and every switch into eager mode, is logged in a
thread-local stack called context_switches
; the log entry for a
context switch is popped from the stack when the context is exited.
Entering an init_scope
is equivalent to crawling up
context_switches
, finding the first context that is not building a
graph function, and entering it. A caveat is that if graph mode is
enabled but the default graph stack is empty, then entering an
init_scope
will simply install a fresh graph as the default one.
(3) The gradient tape is paused while the scope is active.
When eager execution is enabled, code inside an init_scope block runs with eager execution enabled even when defining graph functions via tf.contrib.eager.defun. For example:
tf.compat.v1.enable_eager_execution() @tf.contrib.eager.defun def func(): # A defun-decorated function constructs TensorFlow graphs, # it does not execute eagerly. assert not tf.executing_eagerly() with tf.init_scope(): # Initialization runs with eager execution enabled assert tf.executing_eagerly()
RuntimeError
: if graph state is incompatible with this initialization.


On a Unix system, in which the MPI library is implemented in C, then there are various possible options, of which two of the most obvious are presented here. Which is better depends on whether the linker and compiler support weak symbols.
If the compiler and linker support weak external symbols (e.g. Solaris 2.x, other system V.4 machines), then only a single library is required through the use of #pragma weak thus
#pragma weak MPI_Example = PMPI_Example int PMPI_Example(/* appropriate args */) { /* Useful content */ }The effect of this #pragma is to define the external symbol MPI_Example as a weak definition. This means that the linker will not complain if there is another definition of the symbol (for instance in the profiling library), however if no other definition exists, then the linker will use the weak definition.
In the absence of weak symbols then one possible solution would be to use the C macro pre-processor thus
#ifdef PROFILELIB # ifdef __STDC__ # define FUNCTION(name) P##name # else # define FUNCTION(name) P/**/name # endif #else # define FUNCTION(name) name #endifEach of the user visible functions in the library would then be declared thus
int FUNCTION(MPI_Example)(/* appropriate args */) { /* Useful content */ }The same source file can then be compiled to produce both versions of the library, depending on the state of the PROFILELIB macro symbol.
It is required that the standard MPI library be built in such a way that the inclusion of MPI functions can be achieved one at a time. This is a somewhat unpleasant requirement, since it may mean that each external function has to be compiled from a separate file. However this is necessary so that the author of the profiling library need only define those MPI functions that she wishes to intercept, references to any others being fulfilled by the normal MPI library. Therefore the link step can look something like this
% cc ... -lmyprof -lpmpi -lmpiHere libmyprof.a contains the profiler functions that intercept some of the MPI functions. libpmpi.a contains the ``name shifted'' MPI functions, and libmpi.a contains the normal definitions of the MPI functions.


Chapter 3: A Reassuring Co-Incidence
April 13, 2021
NOTE: This post is part of my extended series on the “Experience of Development”. If you’ve not read the two-part introduction yet, it’s perhaps a good idea to hop over and check out part 1 and part 2 before continuing.
I wasn’t sure if my ideas regarding the experience of development would make sense to anyone else. But then I saw a post on twitter from Sergey Bykov and I realised there were at least two of us thinking along similar lines. His tweet was something he said in a 2015 Microsoft article (the italics are mine):
“People tend to equate computer science with mathematics, but I think of programming as more similar to physics,” he explains. “[…] I learned that when you have a problem in physics, first you must understand what pieces are involved, how they connect and how they influence each other. You build a mental model and only then would you try and solve the problem and eventually apply math.
“When you program systems, it’s the same. You identify the pieces involved, how they interact, build a model, and then you apply mathematics and programming. In reality you spend a very small percentage of time writing code and more time figuring out why things don’t work as intended.”
W.o.w.
It was all there, in microcosm, but still all there. The problem-solution mental model which is constructed using substrate models. Even the conveying of those models to the outside world in the form of code, and the subsequent wrestling with the difference between what you thought would be the result, and what the result turned out to be.
In the article he was quoted in Sergey went on to use this realisation as a jumping off point to argue for simpler cloud programming models. My goal is to take this in a different direction. I want to interrogate further these elements which Sergey and I have both identified and see what more we can learn from them about the act of development and our experience of it. Perhaps this will also lead to improved programming models and languages, libraries and frameworks, but I really want to give we developers a better understanding of what happens to us when we code.
It was thinking about this specifically human, and consequently personal, aspect which made me pay closer attention to what Sergey described. While all the elements of my conjecture, as well as the supporting concepts, were there, was it all completely relatable?
Well no. And the differences between us are, I think, worth examining. I know this because of the interviews which I did with various friends from the Winter Tech Forum and their personal insights which they shared with me. I learned then that what you might think we would all do in the same way, is in fact a source of great variety.
The first thing which jumps out from Sergey’s quote is the suggestion (although I could be interpreting it a little literally) of a good deal of up-front mental-model manipulation - what he describes as the selection, connection, and interaction - all prior to his writing any code. I don’t doubt that this is how he does it. People I have interviewed have articulated similar approaches. If I were to describe this way of approaching things I might use verbs such as “construct”, “invent”, “shape” and “create”. It is as if Sergey and his ilk have an intimate knowledge and grasp of their substrate mental models, and from those, carefully combine these consciously and methodically to get to the result they need.
I however go about things in a different way. When I code I always feel as if I am working somewhat in the dark. Verbs I might use for a significant part of my process are “discover”, “find”, “explore”, and “recognise”. My approach to things has more in common with starting with a large lump of clay and then slowly but surely paring pieces away, sub-dividing, cleaving, differentiating, until the detail I need reveals itself.
Now it should be made clear that neither of these is better than the other. Nor am I suggesting that these are the only two types of experience of this aspect, nor that they even comprise the vast majority of the experience of developing code. But I do believe it is very interesting to think about why these differences might arise. Does it spring from how we are most comfortable thinking creatively to make things or solve problems? Does it highlight a more structured versus free-form ways of approaching matters? Might we argue one is more scientific and compositional while the other more sketchy and reducing? Could it indicate a predeliction for verbal or visual thinking? Or linear compared to non-linear thinking? It’s interesting to consider all these possibilities, but not yet, there are other posts for that, and we have another personal difference between myself and Sergey to consider.
This second difference is in the getting of the mental models into the outside world. Sergey seems to indicate he first thinks in terms that seem completely mental, and then, in a distinctly separate step expresses this by “applying mathematics and programming”. It sounds here as if (and again I could be way off base) the constructed problem-solution model is, for Sergey, truly an abstract one. That is to say, he’s not thinking in the constructs of the language or framework which he is going to use to encode his models outside of his mind. The conveying seems to be both a distinct step, and an act of translation into a specific syntax.
I however, am not so pure, nor so distinct. I still think largely in the constructs of the language which best represents the programming model I am targetting. For example, if I’m writing object-oriented, memory-managed code, there will be a lot of Java constructs and Java libraries swilling around in my mind.
So what do I mean by “not so distinct?” I mean, frequently I will use the act of drafting the code, of working with the syntax itself, on the screen in front of me, to help push along my mental-model manipulations. Sometimes this will be simply to get the fast feedback of the red squiggly lines telling me my conception won’t compile; but other times there is something about seeing the constructs out there on the screen in front of me, with their names and their syntax-highlighted, which gives me a clarity I need to lock something down and move to the next element.
In the first difference I shared what I knew from interviews: many folks think far more like Sergey in that regard and far less like me. Is it the same with this second difference? Of course. And just as before, I am in no way arguing for one way being superior to another, nor for these two approaches being the only ways it is done.
So again, what might these external manifestations of difference lead us to uncover? I believe that my reliance on the syntax more directly, and consequently on much, much tighter loops out of my head and into the IDE, are due to a far fuzzier way of thinking.It could also be because I’m just not as good a developer as many others I’ve worked with and spoken to. One thing I do know is that as I code, my mind frequently transitions rapidly from small-scale to large-scale then back again, and this means if I don’t flush my buffers to the outside world regularly I am in danger of losing things - of losing pieces of mental model.
You can see this very clearly when I code. I’m always impressed when people write their functions starting at the top and working their way down to the bottom. I meanwhile jump around, between classes, between functions, between lines in a function. I drop TODOs everywhere when ideas come to me, and consequently the act of tidying my code is frequently an explicitly separate and significant step.Pairing with me can be quite a labor of love. Does it work for me? Yes, it seems to. Does it work for everyone? Definitely not.I’ve had feedback on just this specific point.
Having looked a little at the two differences, what is most striking however is the similarity between Sergey’s “figuring out why things don’t work as intended” and my conjecture that the experience of this surprise is where much (though not all) of the emotion experienced in development comes from. How so? It doesn’t seem very significant when expressed how Sergey puts it does it.
Well, what is exciting to me, is that despite the significant differences in thinking and coding styles which I believe exist between Sergey and I (and backed up by experiences I’ve had with others) Sergey still thinks this mismatch aspect worthy to be called out. In fact, it’s so important that it justifies his proposal for a new approach to cloud-computing models. If someone who relies on syntax and code and the external loop as little as Sergey thinks the mis-match is important, then thats good enough for me.
That’s it for this post. I’m going to keep sharing these musings, and hopefully also begin to bring in some specific case-studies of how development is experienced by specific individuals. In the meantime I’d love to know what you think. If you have any thoughts or any other kind of feedback please leave a comment below, or reach out to me on Twitter. Thanks!


Functionality is not implemented yet. Here would be listed for example the changes in Episerver page addresses. They could be used to create new redirections.


The goals of this project are to engage trained citizen scientists, professional water quality managers, and the public at large to begin to understand where and when different species of cyanobacteri occur.
Contact Us
Have questions or want to get involved? Just email us.


| Amazon AWS | Microsoft Azure | Google Cloud | |
|---|---|---|---|
| Terraform OSS 99 | Click Here | Click Here | Coming Soon |
| Terraform Enterprise 99 | Click Here | Click Here | Coming Soon |
| Terraform OSS + Intro to Enterprise 101 | Coming Soon | Click Here | Coming Soon |
| Vault OSS 99 | Click Here | Click Here | Coming Soon |
| Vault OSS + Intro to Enterprise 101 | Coming Soon | Click Here | Coming Soon |


FlightSurety
Check Operational Status
Purchase Insurance
Flight Status Update
Insurance Payout
Check
Passenger
Flight (*)
Amount
eth
Buy
(*) Airline
Flight Number
Timestamp
Passenger
Flight (*)
Fetch
(*) Airline
Flight Number
Timestamp
Passenger
Flight (*)
Withdraw
(*) Airline
Flight Number
Timestamp


| I l@ve RuBoard |
The win32file module contains functions that interface to the File and other I/O-related Win32 API functions.
| CreateFile( ) |
Opens or creates a file or a number of other objects and returns a handle that can access the object.
handle = CreateFile(FileName, DesiredAccess, ShareMode, SecurityAttributes, CreationDisposition, FlagsAndAttributes, TemplateFile)
The name of the file, pipe, or other resource to open.
An integer determining the access this file is opened with. This allows the file to be opened with read access, write access, read-write access, or device access. The following flags are defined:
Specifies the file to be opened with device query access. This allows the application to query the device attributes without accessing the device.
Specifies read access to the file. Combine with win32file.GENERIC_WRITE for read-write access.
Specified write access to the file. Combine with win32file.GENERIC_WRITE for read-write access.
A set of bit flags that determines how the file is to be shared. If ShareMode is 0, the file can't be shared, and all subsequent attempts to open the file fail until the handle is closed. This parameter can be a combination of the following values:
Windows NT only. Only requests to open the file for delete mode succeed.
Only requests to open the file for read mode succeed.
Only requests to open the file for write mode succeed.
Determines whether the file is inherited by child processes. On Windows NT, this specifies the security descriptor for the file if the underlying filesystem supports security.
Specifies what action to take on files that already exist and what action to take on files that don't already exist. This can be one of the following values:
A new file is to be created. An exception is thrown if the file already exists.
A new file is to be created. If an existing file exists, it's overwritten.
Opens an existing file. If the file doesn't already exist, an exception is thrown.
Opens an existing file if it exists, or creates a new file if not.
Opens the file and truncates its length to zero. The file must have been opened with write access. If the file doesn't exist, an exception is thrown.
Specifies the attributes and other flags for the file. This can be a combination of the following flags:
The file should be archived; that is, it has the archive attribute set.
The file or directory is to be encrypted. This flag has no affect if the filesystem doesn't support encryption.
The file is hidden and not included in a normal directory listing.
There are no special attributes on the file. This value is valid only when used alone.
The data of the file isn't available immediately because it has been moved to temporary offline storage.
The file is marked as read-only. Applications can open the file for read access but not write access.
The file is a system file and used exclusively by the operating system.
The file is used for temporary storage, and the operating system attempts to keep the entire file in memory when possible to speed access. Applications should remove these files as soon as possible.
The system writes all data immediately to the disk, bypassing the lazy-write capabilities of the cache.
All I/O on this file occurs asynchronously. When a file is opened in this mode, read and write operations may return ERROR_IO_PENDING, and the event in the OVERLAPPED object is set when the I/O operation completes. Files opened with this flag must provide an OVERLAPPED object.
The system opens the file with no buffering or caching.
Indicates the file is accessed randomly. The system uses this as a hint to optimize caching of the file.
Indicates the file is accessed sequentially. The system uses this as a hint to optimize caching of the file.
The operating system deletes the file automatically when the last handle to it is closed. Subsequent attempts to open the file (except for delete) fail.
Indicates the file is being opened for a backup operation. Special NT security requirements apply.
Changes the semantics of the file to resemble POSIX files. Used only by the POSIX subsystem; shouldn't be used by Windows applications.
Inhibits the reparse functionality of the NTFS filesystem and is beyond the scope of this book.
Used by remote storage systems and is beyond the scope of this book.
A handle to another file used as a template for file attributes or None. Under Windows 95, this parameter must be None.
A PyHANDLE object to the file.
| ReadFile( ) |
Reads data from an open file.
errCode, data = ReadFile(FileHandle, Size, Overlapped)
The file handle identifying the file to read from. This handle typically is obtained from win32file.CreateFile().
If Size is specified as a Python integer, it's the number of bytes to read from the file. When using overlapped I/O, a ReadBuffer should be used, indicating where the ReadFile operation should place the data.
An OVERLAPPED object or None if overlapped I/O isn't being performed. This parameter can be omitted, in which case None is used.
Either 0, or ERROR_IO_PENDING.
The data read from the file.
| WriteFile( ) |
Writes data to an open file.
errCode = WriteFile(FileHandle, Data, Overlapped)
The file handle identifying the file to read from. This handle typically is obtained from win32file.CreateFile().
The data to write to the file, as a Python string.
An OVERLAPPED object or None if overlapped I/O isn't being performed. This parameter can be omitted, in which case None is used.
| I l@ve RuBoard |


deep breathe, you made it this far!
wow, i imagine you must be overwhelmed.
i get it, it's a lot of information to take in, and a lot of
ways we're unintentionally
harming our bodies.
so why is that important to me?
holistic living has always been part of my lifestyle. i've grown up with a healthy mix of homeopathic ways and western medicine, and decided to try low-tox living in march of 2020. so yes, i'm new to this. i say low-tox, because i'm still in the middle of switching all my products. i'm here to say, you really
don't know the immense amount of chemicals that we've incorporated into our lives until you try and cut it out. in order to minimize both waste and financial bills, i've slowly transitioned, and man can i say it's life changing.
as someone who's always had a weird mix of health issues, when i heard about the idea of non-toxic living, i literally said why not. let's give it a chance, it'll probably be a waste of time, but maybe something will help. and man was i proven wrong. making the switch to low-tox living has changed my health, my hormones, my skin, my sleep, my migraines and so much more for the better! and i don't say that lightly. while there are many ways to make the switch, i went the essential oil route, and that's where my products, recipes and help come from.
i want to take some time to walk you through what a day in life of living non-toxic looks like for me as well as what products and oils i love. disclaimer, just because what i use works for me, does! not! mean! it will work for you! that’s one of the reasons i wanted to provide research and other resources. living non-toxic is personalized to each person, and you will find things your body loves that mine doesn’t. check it out!


GluGo
GluGo
Username:
Password:
Login
Create Account
Forgot password?
x
Forgot Password
Email:
Send Password


Home
Home Top
History
Problem Statement
Problem Characteristics
Solution Statement
Solution Characteristics
Team
Presentations
Presentations Top
Feasibility
Feasibility V2
Design
Prototype
PrototypeDemo
Deliverables
Deliverables Top
MFCD
Current Process Flow
Solution Process Flow
Work Breakdown Structures
Database Schema
Algorithms
User Roles
Risks
RWP vs Prototype
Links to other Deliverables
Mock-Ups
Labs
User Stories
User Stories Top
User Stories RWP
User Stories Prototype
Glossary
References
A
3
framework
Aggregation and Archiving of Artifacts
"Repository of Reliable Resources"
GUI Mock-Ups
Mock-Ups will be posted as available.
Login Screen
Upload
Filter
Invite
New User


{% extends 'search/search_form_base.html' %} {% block search_heading %}
Try searching ‘wild cherries 1969’, ‘august 1972’ or ‘horsham town hall’


The Page Model
As mentioned in How it works, markdown fragments in source files are parsed into javascript page and fragment objects when the generator is loaded.
The representation in memory is very simple.
generator.pages
is a flat array of all page
objects in source order.
Each page
object has:
_txt: the unparsed page body text (usually markdown)
_hdr: the unparsed page header
_fragments: a flat array of page fragments for rendering in order
_href: the url path for the page
_file: a reference to a source file object for saving edits
_parent: the parent page in the page url hierarchy
_children: an array of child pages in the page url hierarchy
_next: the next sibling page in the url hierarchy
_prev: the previous sibling page in the url hierarchy
#*: #named fragments for rendering fragments by name
*: named values parsed from the page header
This basic structure, which is derived from a very simple text file format, is sufficient to represent complex pages with lots of fragments, as well as complex hierarchical sites with lots of pages.
And, by breaking pages into fragments, standard markdown can be used inside fragments, without requiring additional markdown extensions to represent arbitrary layout elements like columns and sections.
Generator Plugins for themes or custom sites may manipulate page objects, creating additional properties for alternative content hierarchies or to classify various types of pages.
Plugins can also use the page structure to generate menus, sitemaps, and other navigation.


We're gonna build a web app from scratch.
No frameworks, try to understand the basics.
Is it technical? Yup.
Good understanding of what the web is built on
Give you guys a starting point
Everyone learns something
Including us...like don't agree to do a live coding talk
A note-taking application
(insert joke about students taking notes)
Using Javascript.
(Why?)
#yolo
Installing, upgrading, configuring and removing stuff
JS -> npm or yarn
Ruby -> bundler
Python -> pip
Java -> maven
Libraries / dependencies
Versioning - your app and dependencies
"Works on my machine!" problem
Managing history of changes to files in your app
Some tools include:
You might see 'Wat?!' before anything else
fetchUsers().then(function(response) {
console.log(response)
})
fetchCities().then(function(response) {
console.log(response)
})
console.log('Wat?!')
async function() {
const users = await fetchUsers()
console.log(users)
const cities = await fetchUsers()
console.log(cities)
console.log('Wat?!')
}
Code quality / standards
Hypertext Transfer Protocol (HTTP) is an application protocol for distributed, collaborative, and hypermedia information systems.
(Stolen from wikipedia)
Hypertext Markup Language
p
is a paragraph tag
h1
is a header tag
div
is a divider/division tag
The W3C or WHATWG...depends who you ask
Obligatory Hacker News Link: https://news.ycombinator.com/item?id=16829473
Cascading Style Sheets
E.g., making your stuff look pretty
HTML for structure
CSS for presentation
Javascript for functionality
Allows you to query and manipulate your data in the database
Main commands: SELECT, INSERT, UPDATE, DELETE
Lot's of local data wrangling that can be repetitive
Makes sense to have scripts to automate these things
Representational state transfer
Basically, using HTTP methods (verbs) and routes to request system access and manipulate resources
HTTP methods: GET, POST, PUT, DELETE
Routes: http://mywebsite.com/notes/1234
GET request to /notes/123 - get note w/ id 123
POST request to /notes (with {data}) - create a note with {data}
http://mywebsite.com/{resource}/{id}
http://mywebsite.com/{resource}/{id}/{nested_resource}/{id}
GET request to /users/23/notes - gets all the notes for user w/ id 23
GET requests use query strings like /search?search_term=Game+of+thrones
POST requests use body like:
{
"title": "this is title",
"body": "some body text stuff"
}
(Where are PUT and DELETE?...stay tuned.
Automated test-driven development
1. First write a test for the code you wish you had
2. Run it and watch it fail (red)
3. Write the code to make it pass (green)
4. Refactor the code if you can w/o breaking the test
GET
and POST
PUT and DELETE were in the spec, but they got removed
This is what most web frameworks do
But that's not what we're gonna do...
TL;DL;
Ruby -> Rails
Python -> Django
Elixir -> Phoenix
Java -> Spring


{% autoescape None %}
birdhouse
Hi, {{ screen_name }}. Thanks for using birdhouse.
We're collecting your whole profile, all the time. Ability to select lists, twitter accounts, etc. coming soon.
If you no longer want to use birdhouse, you can revoke access via your Twitter account's Applications preferences.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/Check.20whether.20variable.20exists.html ---
def object_instance_exists(self, o): pass
Hopefully o is a string
Part of my algorithm for connecting graphics items with Lean instances needs to check whether an object specified by o already exists. So how can we do that with Lean commands?
There is something like mk_fresh_name
or something like that. I don't know anything about meta programming in Lean
@Johan Commelin thx, I'll look at my code again and see if I can use that instead
Can't really, unless I do a major redesign since I have:
def add_category(self, cat): if not self.interface().object_instance_exists(cat): self.interface().add_object_instance(cat) self.categories[id(cat)] = cat
Where interface() is the Lean interface
Shouldn't #check
do the above?
I'll do some reading and figure out a way to make it work :)
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Reports an unnecessary comparison with
.indexOf()
expression. An example of such an expression is comparing the result of
.indexOf()
with numbers smaller than -1.


This document describes the use of the NTP Project's plot_summary
program.
This document applies to version 4.2.8p8 of plot_summary
.
This section was generated by AutoGen,
using the agtexi-cmd
template and the option descriptions for the plot_summary
program.
This is the automatically generated usage text for plot_summary.
The text printed is the same whether selected with the help
option
(--help) or the more-help
option (--more-help). more-help
will print
the usage text by passing it through a pager program.
more-help
is disabled on platforms without a working
fork(2)
function. The PAGER
environment variable is
used to select the program, defaulting to more. Both will exit
with a status code of 0.
plot_summary - plot statistics generated by summary script - Ver. 4.2.8p8 USAGE: plot_summary [ -<flag> [<val>] | --<name>[{=| }<val>] ]... --directory=str Where the summary files are --identifier=str Origin of the data --offset-limit=float Limit of absolute offset --peer=str Peers to generate plots for - may appear multiple times --plot-term=str Gnuplot terminal --output-file=str Output file --dont-wait Don't wait for keystroke between plots -?, --help Display usage information and exit --more-help Pass the extended usage text through a pager Options are specified by doubled hyphens and their name or by a single hyphen and the flag character.
This is the “where the summary files are” option.
This option takes a string argument.
The directory where the plot_summary
will search for the
*_summary files generated by summary
script.
This is the “origin of the data” option. This option takes a string argument. Where does the plotted data come from, default to string "host" plus current hostname
This is the “peers to generate plots for” option. This option takes a string argument.
This option has some usage constraints. It:
By default the peer_summary plots are not generated. Use this option to specify list of peers if you want to generate plots for them.
This is the “gnuplot terminal” option.
This option takes a string argument.
This is string is passed directly to the gnuplot set terminal
command. Default is x11
if DISPLAY
is set and
dumb
is it's not'. See output from -e "set
terminal") for the list of available options.
This is the “output file” option.
This option takes a str argument.
Output file for gnuplot
, default to stdout.
One of the following exit values will be returned:


This example shows you how to use JSON data with Flotr. The canvas container is hidden when the page is
loaded. By pressing the button a GET request is send to json.txt.
This returns a JSON string with data for three series. When the returned json is a valid object, the
canvas container is shown and the graph is rendered with Flotr.draw()
. Here's the requested json:
{
series:[{
data:[[0,1],[1,4],[2,3],[3,6],[4,4.5]],
points:{show:true},
lines:{show:true}
},
[[0,0.5],[1,0.6],[2,1.8],[3,0.9],[4,2]],
[[0,1.5],[1,2],[2,4.5],[3,3.5],[4,5.5]]
],
options:{
mouse:{track:true},
xaxis:{noTicks:10, tickDecimals:1}
}
}
Let me give you one advise about JSON. To make sure you receive the data in the right format, use the Firefox extension Firebug
to console.log
(print) the response. With Firebug you can examine the Ajax request and it's response.
Also, it's worth reading Introduction to JSON on PrototypeJS.org.
Finished? Go to the example index page, play with the playground or read the Flotr Documentation Pages.


© Bruce Wilcox<EMAIL_ADDRESS>brilligunderstanding.com
Revision 6/25/2017 CS7.51
ChatScript ships with code and WINDOWS libraries for accessing Mongo but you need a database somewhere. On windows mongo access is using ChatScriptMongo.exe . On Linux you have to make mongoserver
. On Mac and IOS #define DISCARDMONGO is on by default.
If you have access to a Mongo server remotely, that's fine. If you need one installed on your machine, see the end for how to install one.
Aside from using Mongo to store data for a chatbot to look up, one can also use Mongo as a replacement for the local file system of the USERS directory. This allows you to scale CS horizontally by having multiple CS servers all connecting to a common Mongo DB machine so a user can be routed to any server. Log files will remain local but the USERS/topicxxxxx
will be rerouted, as will any ^export
or ^import
request. If you name your file USERS/ltm-xxxxx
then that will be routed to its own collection, otherwise it will go into the same collection as the topic file.
To set collections, on the command line use:
mongo="mongodb://localhost:27017 ChatScript topic:MyCollection"
or
mongo="mongodb://localhost:27017 ChatScript topic:MyCollection ltm:MyLtm"
or whatever. Obviously put the correct data for your mongo machine. CS will store user topic files in the Mongo machine and well as ^export
and ^import
data. For user and server logs it will continue to store those on the local machine. You may have the same or different collection active, one or two via filesystem replacement and once via normal script access.
There are only a couple of functions you need.
^mongoinit
( server domain collection )Once the named collection is open, it becomes the current database the server uses until you close it no matter how many volleys later that is. Currently you can only have one collection open at a time.
By the way, if a call to ^mongoinit
fails, the system will both write why to the user log and set it onto the value of $$mongo_error
. ^mongonit
will fail if the database is already open.
^mongoclose
()closes the currently open collection.
^mongoinsertdocument
(key string)does an up-sert of a json string (which need not have double quotes around it. Key is also a string which does not require double quotes.
^mongodeletedocument
(key)removes the corresponding data.
^mongofinddocument
(pattern)finds documents corresponding to the mongo pattern (see a mongo manual).
^mongoinit(mongodb://localhost:27017 ChatScript InputOutput)
^mongoinsertdocument(dog ^"I have a dog")
$_var = ^mongofinddocument(dog)
^mongodeletedocument(dog)
# $_var == I have a dog
^mongoclose()


Fleet fight statistics
Source code available at
GitHub
Loading ...
This application requires JavaScript enabled to run.


Class Base
Base class to implement a source code generator.
Direct known subclasses
Peg\Lib\Generator\ZendPHP
public
|
#
__construct( string $templates, string $output, string $generator_name,
The symbols object with all definitions required to generate the code. |
public
string
|
|
public
|
#
GetHeaderDefine( string $name )
Converts a header file name into a suitable flag for the compiler pre-processor. Eg: header.h -> PHP_HEADER_H this can be used for #ifndef checks on the generated code to prevent double inclusions. |
public
|
#
GetHeaderNamePHP( string $name )
Converts a header filename into one that doesn't conflicts with original which can be used to store the generated code. Eg: header.h -> php_header.h or lib/header.h -> php_lib_header.h |
public
|
#
GetSourceNamePHP( string $name )
Converts a header filename into a source file name which can be used to store the generated code. Eg: header.h -> php_header.cpp or lib/header.h -> php_lib_header.cpp |
public
|
#
GetCustomSources( )
Gets a list of custom source files on the custom_sources directory that resides in the templates/$generator_name directory with the .php extension stripped out. |
public
string
|
#
GetTemplatePath( string $name, string $type, string $subtype, string $dir, string $overrides_prefix = "", string $namespace = "" )
Get a php template file path based on the given parameters. |
public
string
|
#
GetGenericTemplate( string $name, string $subdir = "" )
Get a php template file for a given file name. |
public
string
|
#
GetParameterTemplate(
Retrieve the template path for parameters, also checks if a valid override exists and returns that instead. |
public
string
|
#
GetReturnTemplate(
Retrieve the template path for return, also checks if a valid override exists and returns that instead. |
public
|
#
RemoveHeader( string $header_name )
Deletes a generated header declarations file and its source file |
public
|
|
public
|
|
public
|
#
AddGenericFile( string $file_name, string & $content, string $subdir = "" )
Adds or updates a generic file if neccessary. |
abstract public
|
|
abstract public
string
|
|
abstract public
string
|
|
abstract public
string
|
#
GenerateFunction(
Generate the wrapping code of a specific C/C++ function. |
public
|
$symbols |
|
#
Reference to the symbols object with all definitions required to generate the code. |
public
string
|
$templates_path |
|
#
Path where template files reside. |
public
string
|
$output_path |
|
#
Path where the generated source code is going to be saved. |
public
string
|
$generator_name |
|
#
Name of the generator implementing this base class. Useful to determine the directory where generated source code is going to be stored. |


|
eccodes
|
Data Structures | |
| struct | codes_keys_iterator |
Macros | |
| #define | CODES_KEYS_ITERATOR_ALL_KEYS 0 |
| #define | CODES_KEYS_ITERATOR_SKIP_READ_ONLY (1<<0) |
| #define | CODES_KEYS_ITERATOR_SKIP_OPTIONAL (1<<1) |
| #define | CODES_KEYS_ITERATOR_SKIP_EDITION_SPECIFIC (1<<2) |
| #define | CODES_KEYS_ITERATOR_SKIP_CODED (1<<3) |
| #define | CODES_KEYS_ITERATOR_SKIP_COMPUTED (1<<4) |
| #define | CODES_KEYS_ITERATOR_SKIP_DUPLICATES (1<<5) |
| #define | CODES_KEYS_ITERATOR_SKIP_FUNCTION (1<<6) |
| #define | CODES_KEYS_ITERATOR_DUMP_ONLY (1<<7) |
Functions | |
| codes_keys_iterator * | codes_keys_iterator_new (codes_handle *h, unsigned long filter_flags, const char *name_space) |
| int | codes_keys_iterator_next (codes_keys_iterator *kiter) |
| const char * | codes_keys_iterator_get_name (codes_keys_iterator *kiter) |
| int | codes_keys_iterator_delete (codes_keys_iterator *kiter) |
| int | codes_keys_iterator_rewind (codes_keys_iterator *kiter) |
The keys iterator is designed to get the key names defined in a message. Key names on which the iteration is carried out can be filtered through their attributes or by the namespace they belong to.
| #define CODES_KEYS_ITERATOR_ALL_KEYS 0 |
Iteration is carried out on all the keys available in the message
| #define CODES_KEYS_ITERATOR_DUMP_ONLY (1<<7) |
only keys present in the dump
| #define CODES_KEYS_ITERATOR_SKIP_CODED (1<<3) |
coded keys are skipped by keys iterator.
| #define CODES_KEYS_ITERATOR_SKIP_COMPUTED (1<<4) |
computed keys are skipped by keys iterator.
| #define CODES_KEYS_ITERATOR_SKIP_DUPLICATES (1<<5) |
duplicates of a key are skipped by keys iterator.
| #define CODES_KEYS_ITERATOR_SKIP_EDITION_SPECIFIC (1<<2) |
edition specific keys are skipped by keys iterator.
| #define CODES_KEYS_ITERATOR_SKIP_FUNCTION (1<<6) |
function keys are skipped by keys iterator.
| #define CODES_KEYS_ITERATOR_SKIP_OPTIONAL (1<<1) |
optional keys are skipped by keys iterator.
| #define CODES_KEYS_ITERATOR_SKIP_READ_ONLY (1<<0) |
read only keys are skipped by keys iterator.
| int codes_keys_iterator_delete | ( | codes_keys_iterator * | kiter | ) |
Delete the iterator.
| kiter | : valid codes_keys_iterator |
| const char* codes_keys_iterator_get_name | ( | codes_keys_iterator * | kiter | ) |
| codes_keys_iterator* codes_keys_iterator_new | ( | codes_handle * | h, |
| unsigned long | filter_flags, | ||
| const char * | name_space | ||
| ) |
Create a new iterator from a valid and initialised handle.
| h | : the handle whose keys you want to iterate |
| filter_flags | : flags to filter out some of the keys through their attributes |
| name_space | : if not null the iteration is carried out only on keys belonging to the namespace passed. (NULL for all the keys) |
| int codes_keys_iterator_next | ( | codes_keys_iterator * | kiter | ) |
Step to the next iterator.
| kiter | : valid codes_keys_iterator |
| int codes_keys_iterator_rewind | ( | codes_keys_iterator * | kiter | ) |
Rewind the iterator.
| kiter | : valid codes_keys_iterator |


Who's behind this?
Hi, my name is Antonio. I was born in the wonderful land of Mexico but life has brought me to Poland. I moved to Wrocław in 2006 for an AIESEC intership and just liked it so much that now I'm living here indefinitely :)
I earn my bread and tortillas working as a web developer at Mindchili, I'm a design and photography amateur and love football more than i should.
What about this blog?
I don't consider myself as a very interesting person nor have a lot to say, so the main purpose of this blog is to have my own space to share some part of my life with family and friends as well as register part of my professional knowlege.
"Od samego rana" is a phrase in polish that means literaly "Since early morning". For me it means a lot more, but it's hard to explain haha.
Honor for the heros
This blog is made with Jekyll. And I forked the theme in github from Dirk Fabisch, you can see his original version here.
So, thanks a lot!


---
layout: default
title: Business Science
excerpt: Learn Data Science for Business - the enterprise-grade process of solving problems with data science and machine learning.
---
The enterprise-grade process of solving business problems
with data science and machine learningBusiness Science
Improve Your Data Science Skills
Learn Data Science For Business
Learning to achieve business objectives using data science enables you to become a strategic asset to your organization. We combine expert instructors, high-performance tools, and long-format courses that teach end-to-end data science projects with a focus on Return-On-Investment (ROI). This gets results.
Data Science is about learning the right tool for the job. Each have pros and cons, and you should have options. We offer multiple tracks depending on your programming language of choice.
(R Track)
The Virtual Workshop is an integrated collection of courses that teaches you 90% of the skills you will need to be successful as a data scientist within an enterprise. The central course teaches the critical analysis. The extension courses target critical skills such as web applications, communication, and package development.
(DS4B 201-R)
DS4B 201-R is a ground-breaking course that takes students from beginner to advanced in 10 weeks! The student evaluates one problem in-depth learning all of the critical aspects of applying data science and machine learning to business. Students consistently rate a 9 of 10 in course satisfaction!
(DS4B 201-P)
DS4B 201-P is the Python equivalent of our ground-breaking DS4B 201-R course. The student learns Python, Apache Spark (great for Big Data), and other tools taking them from beginner to advanced in 10 weeks! The course is under construction but targeted for Q4 2018.
{{ event_item.description }}
{{ event_item.description }}


--- layout: default title: Sahit's Talks ---
My talk on Online Gaussian Process Motion Planning presented at IROS 2019.
A collection of all my talks given for Georgia Tech's ML club.
Presented at HackGT as part of the AI track. We had 95 people attend the talk
Presented at The Agency
Presented at the GT Agency Lightning Talks where multiple researchers came up and talked about their work
Presented at The Agency
Written for RoboJackets with some help from Jason Gibson


#include <numaif.h> long set_mempolicy(int mode, const unsigned long *nodemask, unsigned long maxnode); Link with -lnuma.
A NUMA machine has different memory controllers with different distances to specific CPUs. The memory policy defines from which node memory is allocated for the process.
This system call defines the default policy for the process. The process policy governs allocation of pages in the process's address space outside of memory ranges controlled by a more specific policy set by mbind(2). The process default policy also controls allocation of any pages for memory-mapped files mapped using the mmap(2) call with the MAP_PRIVATE flag and that are only read [loaded] from by the process and of memory-mapped files mapped using the mmap(2) call with the MAP_SHARED flag, regardless of the access type. The policy is applied only when a new page is allocated for the process. For anonymous memory this is when the page is first touched by the application.
The mode argument must specify one of MPOL_DEFAULT, MPOL_BIND, MPOL_INTERLEAVE, or MPOL_PREFERRED. All modes except MPOL_DEFAULT require the caller to specify via the nodemask argument one or more nodes.
The mode argument may also include an optional mode flag. The supported mode flags are:
nodemask points to a bit mask of node IDs that contains up to maxnode bits. The bit mask size is rounded to the next multiple of sizeof(unsigned long), but the kernel will use bits only up to maxnode. A NULL value of nodemask or a maxnode value of zero specifies the empty set of nodes. If the value of maxnode is zero, the nodemask argument is ignored.
Where a nodemask is required, it must contain at least one node that is on-line, allowed by the process's current cpuset context, [unless the MPOL_F_STATIC_NODES mode flag is specified], and contains memory. If the MPOL_F_STATIC_NODES is set in mode and a required nodemask contains no nodes that are allowed by the process's current cpuset context, the memory policy reverts to local allocation. This effectively overrides the specified policy until the process's cpuset context includes one or more of the nodes specified by nodemask.
The MPOL_DEFAULT mode specifies that any nondefault process memory policy be removed, so that the memory policy "falls back" to the system default policy. The system default policy is "local allocation"---that is, allocate memory on the node of the CPU that triggered the allocation. nodemask must be specified as NULL. If the "local node" contains no free memory, the system will attempt to allocate memory from a "near by" node.
The MPOL_BIND mode defines a strict policy that restricts memory allocation to the nodes specified in nodemask. If nodemask specifies more than one node, page allocations will come from the node with the lowest numeric node ID first, until that node contains no free memory. Allocations will then come from the node with the next highest node ID specified in nodemask and so forth, until none of the specified nodes contain free memory. Pages will not be allocated from any node not specified in the nodemask.
MPOL_INTERLEAVE interleaves page allocations across the nodes specified in nodemask in numeric node ID order. This optimizes for bandwidth instead of latency by spreading out pages and memory accesses to those pages across multiple nodes. However, accesses to a single page will still be limited to the memory bandwidth of a single node.
MPOL_PREFERRED sets the preferred node for allocation. The kernel will try to allocate pages from this node first and fall back to "near by" nodes if the preferred node is low on free memory. If nodemask specifies more than one node ID, the first node in the mask will be selected as the preferred node. If the nodemask and maxnode arguments specify the empty set, then the policy specifies "local allocation" (like the system default policy discussed above).
The process memory policy is preserved across an execve(2), and is inherited by child processes created using fork(2) or clone(2).
For information on library support, see numa(7).


The user ID or UID is what the system really uses to enforce permissions
on files and processes. If two users have the same UID, they will be able
to access each others files - so every user should have a unique UID.
When creating a new user, you will have the following options:
- Automatic
- The UID will be assigned automatically by Webmin, based on those currently in use.
- Calculated
- The UID will be computed based on the username, using a checksum algorithm.
- Entered
- The final option allows you to enter whatever UID you like.
The root user always has a UID of 0. If you create another user
with UID 0, that user will have the same powers as root.
If you are editing an existing user and change the UID, the
Change user ID on files? option determines which files
(if any) have their ownership changed.


- Balloon - Class in balloonsTowerDefence
-
- Balloon(int, int, FloorGrid, BalloonType) - Constructor for class balloonsTowerDefence.Balloon
-
constructor a balloon object is created with the following as parameters int
floorX, int floorY, FloorGrid grid, BalloonType type
the balloon is spawned on the floorX and floorY coordinates and the default
values provided by the type specified
- Balloon(Texture, Floor, FloorGrid, int, int, float, float) - Constructor for class balloonsTowerDefence.Balloon
-
constructor a balloon object is created with the following as parameters
Texture instanceTexture, Floor startingFloorObject, FloorGrid grid, int
width, int height, float speed, float health
the balloon is created with a texture and spawned on the startingFloorObject
with a width and height and speed and health
- BalloonBlue - Class in balloonsTowerDefence
-
- BalloonBlue(int, int, FloorGrid, BalloonType) - Constructor for class balloonsTowerDefence.BalloonBlue
-
- BalloonRed - Class in balloonsTowerDefence
-
- BalloonRed(int, int, FloorGrid, BalloonType) - Constructor for class balloonsTowerDefence.BalloonRed
-
- BalloonRed(Texture, Floor, FloorGrid, int, int, float, float) - Constructor for class balloonsTowerDefence.BalloonRed
-
- balloonsTowerDefence - package balloonsTowerDefence
-
- BalloonType - Enum in balloonsTowerDefence
-
This class contains the default values for the balloon types
- barText - Static variable in class balloonsTowerDefence.SplashScreenLoading
-
- beginRound() - Method in class balloonsTowerDefence.RoundManager
-
Creates a new round
- Button - Class in userInterface
-
- Button(Texture, String, int, int, int, int) - Constructor for class userInterface.Button
-
Constructor pre: none post: This constructore takes a width and height just
incase if the game ressolution is changed and the textures are to big and
need to resized The texture is set along with the name of the button and x
and y positions The x and y are relative to the top left corner of the
texture
- Button(Texture, String, int, int) - Constructor for class userInterface.Button
-
Constructor pre: none post: This constructore dose not take a width and
height they are accuired straight from the teexture using methods provided in
the slick-util liberary The texture is set along with the name of the button
and x and y positions The x and y are relative to the top left corner of the
texture


Sobering Christmas Market images show 'ring of steel' protecting Birmingham, Manchester and Edinburgh visitors
Large concrete and metal barriers have been erected and pedestrianised areas blocked off in UK cities to prevent vehicles driving into crowds of festive revellers
by James Rodger, https://www.facebook.com/jamesrodgerjournalistSobering images show the "rings of steel" protecting Britain's Christmas markets this year as security is bolstered - despite the downgrading of the terror threat level.
Large concrete and metal barriers have been erected and pedestrianised areas blocked off in UK cities to prevent vehicles driving into crowds of festive revellers.
Heavy police presences could be seen in Birmingham, Manchester and Edinburgh with cops patrolling the perimeters of Christmas attractions which opened last week.
Visitors to the popular markets are penned in by heavy-duty blockades, built to stop vehicle-ramming attacks like the ones that rocked Berlin and London in 2016 and 2017.
The extra fortified measures come even after the Joint Terrorism Analysis Centre - part of MI5 - lowered the UK terror treat level from "severe" to "substantial" for the first time in five years.
It means a terrorist attack is now "likely" rather than "highly likely".
In Birmingham, police could be seen mingling with revellers enjoying bratwurst, mince pies and mulled wine at the Frankfurt Christmas Market which is celebrating 20 years in the city.
West Midlands Police said officers would be working closely with market staff and stall holders to hold daily briefings as well as monitoring public transport.
Superintendent Jack Hadley said: "As always, we can't wait to welcome the Frankfurt Christmas Market and the millions of visitors it attracts each year.
"I want to reassure the public that my officers will be in and around the market keeping the public safe and will also be on hand to help anybody who has any concerns.
"Throughout the year armed officers are stationed in the city centre on standby and ready to respond to an incident. This will be no different over the 2019 festive period.
"With such a vast amount of people visiting the market, we would encourage people to remain alert and to tuck away personal belongings.
"I want everyone who comes to visit to have a good time so I would encourage people to stay safe and enjoy."
Police Scotland said there would be increased patrols around Edinburgh's busy European Christmas Market, which drew a million visitors last year.
Inspector David Brady, from the City Centre Policing Team, said: “Edinburgh is undoubtedly one of the best cities in the world to celebrate Christmas and New Year in and Operation Winter City helps us keep the capital a wonderful place to stay in, as well as to visit during the festive period.
“We will have increased high-visibility patrols throughout the city and these officers will be on hand to provide the public with any assistance they require, while also looking out for any matters that require police attention.
“Our dedicated resources will be doing everything they can to keep the public safe, but our communities have a vital role to play in helping with this."
In 2016, an IS fanatic killed 12 when he ploughed a lorry through Berlin's Breitscheidplatz.
And in 2017 London was hit twice in the space of 12 months by terror attacks involving vehicles on Westminster Bridge and London Bridge.


--- layout: newsstory title: MERRY XMAS! match: Yeltz 0 Chippenham 1 ---
The weather was very Christmassy, but the festivities got off to a depressing start as the mighty Yeltz lost 1-0 to promotion rivals Chippenham at a freezing Grove.
It wasn't much of a game in the difficult conditions, although man of the match must have been the Chippenham keeper who made three or four outstanding saves. We had much the better of the first half, and although the second half was more even we didn't really deserve to lose in my completely unbiased opinion.
We're on holiday here at Yeltzland Towers for a few days, so I'm afraid the site (and especially YeltzTalk ) will get updated even slower than usual . Despite Saturday's result, things are looking a lot brighter than last Xmas. We are still top of what's admittedly quite a poor league, but Brendan's excellent management has brought a wave of optimism not seen for some time now. We are still top of the league and in prime spot to get promoted, so let's not start moaning now.
Have an very Merry Xmas, and let's hope there'll be some happy Christmas jumper wearers at Redditch on Boxing Day.
Halesowen Town: Clarke; Colwell, Burnham, N. Smith, L. Collins, S. Skidmore (G. Smith 77), Spencer, Hall, May, Taylor, R. Collins (Hines 64). Sub: Newall
Chippenham Town: Weaver; Vickerman, Dicks, Andrews, Rudge, Woods, Brown (Mings 89), Charity, Tweddle, Rawlins, Bent (R. Skidmore 90). Sub: Bright
Referee: S. Bratt (Walsall) Attendance: 912
Halesowen dominated with spells of neat passing play but failed to find the net and paid the price when Chippenham scored the winner on the break.
A bumper crowd saw few early chances as both sides slowly came to terms with a rock hard playing surface. Matty Hall swung in a 10th minute corner which Lee Collins headed over and Andy Spencer headed wide two minutes later when he met Richard Colwell's cross. At the other end Neil Smith cleared from Simon Charity after 20 minutes and Steve Brown swung in a dangerous corner which Tim Clarke temporarily lost.
Chippenham caused confusion with James Bent (11) and Steve Brown (7) swapping shirts from the numbers given on the official teamsheet.
Halesowen gradually gained the upper hand and Ross Collins headed over from Mark Taylor's 22nd minute cross. The Yeltz then enjoyed a purple patch before half-time but were kept at bay by the brilliance of Chippenham goalkeeper Steve Weaver and their own failings in front of goal.
Andy Spencer cleverly flicked the ball past the final defender before volleying high in the 32nd minute and seconds later Stuart Skidmore sent in a screaming 35-yard shot that Weaver saved athletically just under the crossbar. With the visitors pinned back, Leroy May met a 34th minute cross from Jason Burnham but his header was blocked on the line. From the resulting corner May headed against the crossbar and in the ensuing goalmouth scramble Neil Smith blasted well over from 8 yards out. Just before the break Matty Hall hit the side netting after good work from May and Spencer and in a rare counter-attack Chippenham's Matt Rawlins saw his 44th minute shot turned away in a crowded home goalmouth.
Weaver had to be alert two minutes into the second half to claw away a shot from Hall which bounced awkwardly off the frozen pitch as Halesowen continued to press with Chippenham content to play for the draw. Clarke beat away a 54th minute freekick from Grantley Dicks and Hall headed Richard Colwell's cross wide when well placed.
Disaster struck for Halesowen in the 70th minute when the visitors grabbed an unlikely winner after May allowed Nathan Rudge to head back across goal from a wide angle and hitman Rawlins had the simple task of beating Clarke from five yards out. Chippenham held onto their important winner although Weaver had to make a great save to deny substitute Gary Smith who turned in the box after being put through by Hall three minutes from time.


Storyboard BanfM2MTransformation
Class diagram for source model:
Class diagram for target model:
Create example source graph:
did not find method simpleMigrationByGenericGraph(Graph,Storyboard) in class org.sdmlib.test.examples.m2m.BanfM2MTransformations
Result graph:
Again the input graph:
The transformation code:
did not find method simpleMigrationToEvenMoreEvolvedGraphByGenericGraph(Graph,Storyboard) in class org.sdmlib.test.examples.m2m.BanfM2MTransformations
Result graph:
Let us derive the reverse transformation for the first model evolution:
_____ forward ______________ backward ___________
Pattern reverseRenameFirstNameAttrRule = revertRule(genericGraphPO.getPattern());
Pattern reverseRenameKindAttrRule = revertRule(renameKindAttrGraphPO.getPattern());
Pattern reverseRenamePersonsLinkRule = revertRule(renamePersonsLinkGraphPO.getPattern());
Pattern reverseRenameRelationsLinkRule = revertRule(renameRelationsLinkGraphPO.getPattern());


Substance
Amount
(mg)
FW
(g/mol)
Moles
(mmol)
Equiv.
Volume
(uL)
Density
(g/mL)
Comments
Stoichiometry widget
by the
Sydney Informatics Hub
at the University of Sydney


Inbox
Chats
John Doe
Another Doe
Doe Another
John
Display all 6 chats
Chat Live With Friends
No live chats started
Start New Chat
All
16
Newest
Important
Drafts
Other
-
This is randomly generated text messa..
-
This is randomly generated text messa..
-
This is randomly generated text messa..
-
This is randomly generated text messa..
-
This is random message
More ...
-
16m
This is randomly generated text message.
-
6m
Another randomly generated text message that is acting as response to the first message.
-
Last Message
2m Ago
Latest Conversation
No other conversations
Notes
Add a note
Details
User
John Doe
Email
<EMAIL_ADDRESS>Phone
+11 111 111 11


GitHub Universe 2020
This page does not exist. Please use the navigation to get to a working page. If you got here due to an error on our part, please let us know.
REGISTER
This page does not exist. Please use the navigation to get to a working page. If you got here due to an error on our part, please let us know.
Three channels of content dedicated to developers, enterprise teams, and college students.
New product announcements and deep dives.
Networking and learning opportunities, from Workshops to mentoring sessions.
Musical performances inspired by code and a few more surprises to come!
We’re adding more speakers every day!
Sign up for updates to stay in the loop.
Sign up for the latest GitHub Universe updates
Follow the event #GitHubUniverse


# coding:utf-8
#
# The MIT License (MIT)
#
# Copyright (c) 2016-2018 yutiansut/QUANTAXIS
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import requests
import pandas as pd
from QUANTAXIS.QAFetch.base import headers, _select_market_code
BusinessAnalysis_url = 'http://emweb.securities.eastmoney.com/PC_HSF10/BusinessAnalysis/BusinessAnalysisAjax?code={}{}'
headers_em = headers
headers_em['Host'] = 'emweb.securities.eastmoney.com'
[docs]def QA_fetch_get_stock_analysis(code):
"""
'zyfw', 主营范围 'jyps'#经营评述 'zygcfx' 主营构成分析
date 主营构成 主营收入(元) 收入比例cbbl 主营成本(元) 成本比例 主营利润(元) 利润比例 毛利率(%)
行业 /产品/ 区域 hq cp qy
"""
market = 'sh' if _select_market_code(code) == 1 else 'sz'
null = 'none'
data = eval(requests.get(BusinessAnalysis_url.format(
market, code), headers=headers_em).text)
zyfw = pd.DataFrame(data.get('zyfw', None))
jyps = pd.DataFrame(data.get('jyps', None))
zygcfx = data.get('zygcfx', [])
temp = []
for item in zygcfx:
try:
data_ = pd.concat([pd.DataFrame(item['hy']).assign(date=item['rq']).assign(classify='hy'),
pd.DataFrame(item['cp']).assign(
date=item['rq']).assign(classify='cp'),
pd.DataFrame(item['qy']).assign(date=item['rq']).assign(classify='qy')])
temp.append(data_)
except:
pass
try:
res_zyfcfx = pd.concat(temp).set_index(
['date', 'classify'], drop=False)
except:
res_zyfcfx = None
return zyfw, jyps, res_zyfcfx
cpbidu = 'http://emweb.securities.eastmoney.com/PC_HSF10/OperationsRequired/OperationsRequiredAjax?times=1&code=sz300059'
headers_em_OperationsRequired = headers
headers_em_OperationsRequired['Accept'] = '*/*'
headers_em_OperationsRequired['Referer'] = 'http://emweb.securities.eastmoney.com/PC_HSF10/OperationsRequired/Index?type=soft&code=sz300059'
headers_em_OperationsRequired['X-Requested-With'] = 'XMLHttpRequest'
research_report = 'http://emweb.securities.eastmoney.com/PC_HSF10/ResearchReport/ResearchReportAjax?code=sz300059&icode=447'


Hello {{userReporter.name}},
You reported Citizen OS topic "{{topic.title}}" as inappropriate on {{topicReport.createdAt}}. The violations have now been removed. Access to the topic has been restored by a reviewing moderator.
Please have a look. Should you still find the topic inappropriate, feel free to report it again.
You can find more details about Citizen OS moderation process here.
Thank you for helping us ensure a high quality of content within the Citizen OS user community!


Thinking of how to organize these ideas. I want a Log in security password system.
file:///C:/Users/binc/Documents/GitHub/Artists--Quotes2/css/styles.css
For you who know... No fuss no muss... For memories then... to memories now.
Thinking of how to organize these ideas. I want a Log in security password system.


Preparation time
30 mins to 1 hour
Cooking time
less than 10 mins
Serves
Serves 4
Preheat a griddle pan until very hot, or preheat the barbecue, allowing the flames to die down (approximately 40 minutes).
For the salmoriglio, place the oil and water into a bowl and whisk together until thick and emulsified.
Add the lemon juice and a pinch of salt, to taste.
Add the garlic, oregano, celery herb or leaves (if using) and parsley and stir well.
For the swordfish, brush the swordfish generously with oil and season well with peperoncini or crushed dried chilli and salt and freshly ground black pepper.
Place the swordfish onto the griddle pan or barbecue and cook for four minutes on each side, or until completely cooked through.
For the dressing, place the lemon juice and olive oil into a clean bowl and mix well.
Add the red chilli, garlic and season, to taste, with salt and freshly ground black pepper.
To serve, place the swordfish steaks onto four plates and drizzle over the salmoriglio. Place a large spoonful of the chopped tomatoes next to each portion of swordfish.
Top each pile of tomatoes with a little of the sliced roasted peppers, followed by some red onion and a sprinkle of preserved lemon pieces.
Drizzle the dressing over the tomato salad and sprinkle over the chopped coriander.


{% if object.stage_set %}
{% for stage in object.stage_set.all %}
{% get_obj_perms request.user for stage as "stage_perms" %}
{% if "view_project_stage" in stage_perms or perms.stages.view_stage %}
{% endfor %}
{% else %}
{% for stage in object.project.stage_set.all %}
{% get_obj_perms request.user for stage as "stage_perms" %}
{% if "view_project_stage" in stage_perms or perms.stages.view_stage %}