Today, Monotype has a B2B commerce model. Challenge was to identify a potential business opportunity in consumer solution market. The target audience was millennials.
We proposed a solution that allow millennial to share content casually (Casual impulse) while maintaining high levels of creativity (Professional creativity). In instant messaging apps, the chat bubble has no function other than wrapping
the text inside. The solution helped to make them useful and usable.
My role in this project included the conceptualisation of the idea, the User and Market research, Demo app Ui designing and creating message style illustrations.
1. Filed four utility patent applications as an Inventor in “Selectable Styles for Text Messaging System publishers, for Brand owners, Font service providers and User devices ”
2. Moreover, as a result of the project, Monotype
acquired Swyft Media firm for $27 million.
Owlie is an AI based Facebook Messenger app that simplifies user’s day-to-day decision-making problems. User just has to feed in the question he wants to ask to his friends, Owlie will generate interactive polls that can be sent to
friends via Facebook Messenger.
Concept developementConceiving the idea, User interviews and Surveys, Market Research, Business Model development.
Product designProduct Roadmap, User flow, Wireframe and prototype of the app, UI design, User testing of the app, Brand design, Messenger bot flow, Website design and development
1. Filed a patent application as an Inventor in “Context Analysis of Message Enhancement”
2. Looking at the quality of product and problem that we are trying to solve, Facebook funded the project through the Bootstrap FbStart Program.
Some people are good at making decisions in their lives while others are not. Some take help of internet while some need help from their friends, family, acquaintances etc. Depending on the type of the decision, some dig into the matter and carefully analysis before taking the decision while others don’t.
Presently, millennials have many ways that help them to solve their day to day decision making problems — like friends, family, internet, few mobile apps. But unfortunately, either these applications have poor user experience, ‘another app to download’ problem or solved problems specific to only one category like politics, fashion industry etc. Similarly, brands have no straightforward approach to reach to their consumers for their product reviews to reach to better decision making for their products or services.
Messaging apps like Facebook Messenger, WhatsApp, LINE, KakaoTalk etc. are used for having such conversations. But the response rate to the advice from peers on these messaging apps decreases due to these factors:
No Response Aggregation
Inefficient Process — cluttered UI, typing hassle, deviation from topic, long time to conclude etc.
The design was supposed to come out to be high-end design something like Uber, which is acceptable by all demography. Along with that, it needs to be highly interactive and fluid with easiest and simplest way to create and answer polls. Other inspirations are: Paper (Facebook), Twitter Moments, Snapchat and Medium.
Owlie is an AI based Facebook Messenger app and bot, that simplifies user’s day-to-day decision-making process. User just has to feed in the question he wants to ask to his friends, Owlie will generate interactive polls that can be
sent to friends via Facebook Messenger.
Note:The conceptualisation of this idea is explained in the previous project.
Team: Evan Scronce and Sohaj Singh Brar
Product Roadmap, User flow, Wireframe and prototype of the app, UI design, User testing of the app, Brand design, Messenger bot flow, Website design and development
From the research (mentioned in the previous project), it was clear that decision-making conversations among groups is convoluted, inefficient and inconclusive in OTT messaging apps.
Messaging apps like Facebook Messenger, WhatsApp, LINE, KakaoTalk etc. are used for having such conversations. But the response rate on these messaging apps decreases due to these factors:
No Response Aggregation
Inefficient Process — cluttered UI, typing hassle, deviation from topic, long time to conclude etc.
The design was supposed to come out to be high-end design something like Uber, which is acceptable by all demography. Along with that, it needs to be highly interactive and fluid with easiest and simplest way to create and answer polls. Other inspirations are: Paper (Facebook), Twitter Moments, Snapchat and Medium.
Many millennials love posting pictures on social networking sites. But most of them don’t know much about photography and how to use creative tools like Ps etc. to add text creatively. the application will allow the user to creatively post pictures with quotes in different font styles.
Researching the existing procreative apps (like instagram, aviary etc.), their market and finding potential revenue sources; and Designing the app
Market insights were gathered to understand the problem with the existing products and also during the creation process. I analyzed and tested few apps in this domain like Word Swag, Aviary, Phonto, Instagram, typic, Over, Word Dream etc.
The whole research lead to the following conclusions:
1. Top 2 Social networks (Facebook and Twitter) today are predominantly text based which is slowly moving towards more personalized content (pictures, videos etc.)
2.
Millennials want to stand out by being more creative among their peers
3. The creation process in existing platforms are too cumbersome to use.
Find research on existing similar products here.
Includes wide variety of artworks like anatomy study, realistic sketching, modular, origami, stippling, hatching, caricatures, oil painting, digital art, concept art; to animation, clay modelling, paper mache, wiremodelling, thread art etc.
You can find more of my artworks on my facebook page
Conceptualise and define a unique design for new Monotype Office building
Design direction in Interior design of new Monotype India office. Assisting the architects with creating the complete user journey, layout design, mood board, colour scheme, furniture design, wall elevation design, ceiling design etc.
James Fooks Bale, Sohaj Singh Brar, TechnoSmart (Architects)
1. Archaic design
2. Had space only for workstations and meeting rooms
3. The new office building has low ceiling, hence less breathing space
4. Due to walled meeting rooms, the space seemed less airy and more congested
5. No out of the box design elements
1. Most of the work stations were fixed and could not be replaced
2. Many existing doors have thick wooden border around and cannot be replaced with full glass doors
3. The existing false ceiling cannot be removed from work stations
The idea is to increase the breathing space as much as possible. To achieve that, we removed the false ceiling from the cafe, gym, reception and boarding rooms area. Also to give the appearance of openness, the color palette consisted >90%
of white and remaining as Monotype’s brand Blue and Red colours as highlights.
1. Cafe to have industrial look with white brick wall and wooden flooring
2. Reception will have the ceiling of vintage-industrial ceiling design to bring out feel of 130 years old company in contrast to white reception wall with
light dispersed from the back of the white lettering carved out of it, hence giving it modern look. Back of the reception will have same white brick wall design of cafe
3. Central pillars to have ascending shades of grey with glass
board covering to use them as brainstorming walls. The remaining two pillars will have the Monotype brand colours of Blue and Red
4. The two board rooms will be separated by glass wall that can be slide down to convert them into
one huge meeting room. This glass wall will have Noto Typeface graphic design
5. Keeping the modern design extended to Gym, black with yellow color touch will run across this section
A family group bot in your messaging app that can handle many of your day to day family queries/tasks/problems.
Understand the family group dynamics and its problems and propose a solution.
Primary Research, Secondary Research, Conceptualisation of the idea, SWOT analysis, B-model generation, Revenue estimation
Even today, when we have WhatsApp, Messenger and other messaging apps to chat/call/send location etc., still almost every person faces communication problems with their families — whether it is related to calling a family member for urgent
document requirement when they are not around, or missing important notes in message clutter in family group, or receiving calls for information like “when will you reach home?”, “can you bring blah blah stuff from the market” during an
important meeting.
So the problem was real, no doubt. But in order to understand all the concerns discreetly, I talked to people and did surveys from which I figured out the major problems to be —
Interview — I talked to 5 individuals with following personas:
1. Recently married, 27, F. Have a big in-laws families. Work as software developer. Lives in a joint family.
2. Married, 35, Parent, working as project
manager, Has a boy. Lives with her husband and son.
3. Unmarried, F, staying with parents.
4. Unmarried, 27. Staying with roommates - away from family.
5. Unmarried, M, 26. Staying with Family.
Survey — Conducted a survey among 35 individuals with the following background
From this survey, I got to know the following —
1. Multiple groups (avg.2) of different family circles
2. Users prefer one-to-one conversations outside of the group for discussions
3. Document sharing happens usually via Email and messaging apps (one-to-one)
4. Wishes,
Jokes, Photos & Videos constitute the bulk of the conversations
5. Groups are used for decision-making
6. Important discussions happen over voicecalls
7. Some users stay on in family groups out of politeness
Intelligent bot that listens to group conversations and provides replies and proactive recommendations based on context
Key Features —
1. Replies for common queries
• Official data (Social security number, etc)
• Contacts
• Birthdays
2. Summarize conversation
3. Locate members based on toggle
4. Create checklists, reminders
and to-do lists
5. Decision making supports
In order to create an intelligent family conversation bot, we need to collect data of a particular family. This can be majorly done by-
a) Syncing various accounts (Fb, Drive etc.), contact list and calendars
b) Understanding group
conversations using NLP and AI
As there are a lot of use cases for this bot, many of these tasks will require a brand assistant to finish them. For e.g. Bot may remind you your sister’s birthday a week before because in order to buy her favourite item or the one she is recently looking
to buy online, can be found on Amazon (brand) which will take 5 days to reach to her place.
From the research, it was understood that most of the problem exist in private conversations or personal media (sharing, creation etc.) But most of the existing products are already trying to solve problems in Media sharing. Private conversations
is still an untapped area.
In order to simplify this problem, the story of the conversations in messages needs structuring. If all the messages are treated as different entities, as it happens in all messaging apps (other than
iMessage in which Apple has recently released similar feature just for marking calendars), this problem regarding private conversations can never be solved.


About me
I work as "Solution Director Innovation" for HCL Software. I'm based in Singapore.
Contact
Disclaimer
This site is in no way affiliated, endorsed, sanctioned, supported, nor enlightened by current or previous employers. I may be an employee, but the opinions, theories, facts, etc. presented here are my own and are in now way given in any official capacity. In short, these are my words and this is my site, not IBM's - and don't even begin to think otherwise.
© 2003 - 2022 Stephan H. Wissel - some rights reserved as listed here: Unless otherwise labeled by its originating author, the content found on this site is made available under the terms of an Attribution/NonCommercial/ShareAlike Creative Commons License, with the exception that no rights are granted -- since they are not mine to grant -- in any logo, graphic design, trademarks or trade names of any type. Code samples and code downloads on this site are, unless otherwise labeled, made available under an Apache 2.0 license. Other license models are available on written request and written confirmation.
Tools I use
- This blog serves static pages from an nginx HTTP server running on Ubuntu
- Blog articles are created using Markdown and stored in a Bitbucket repository. On new content creation a Bitbucket pipeline renders the blog entriy and index pages using Java and Mustache
- Comments are captured using a Heroku application that submits a file to Bitbucket and creates a Pull Request that I need to approve (contemplating to automate that) to be added to the static pages
- Comment entry is based on Markdown by John Gruber
- Graphics are created with SmartDraw, Omnigraffle or Sketch
- Wireframes are created with Balsamiq Mockups
- Sequence diagrams use WebSequenceDiagrams or PlantUML
- Image manipulation is done by The Gimp
- The mindmaps are either iMindMap by Tony Buzan or XMind, the living prove, that Eclipse RCP applications can perform well
- Layout is based on Twitter Bootstrap


The MPoL-dev organization provides tools for Regularized Maximum Likelihood imaging and modeling
Packages
MPoL
Regularized maximum likelihood imaging for radio interferometers
Documentationvisread
Tools for reading visibility data from CASA measurement sets
Documentation


As defined at, https://developers.google.com/maps/documentation/javascript/reference#MapOptions, you can add any attributes except control-related to map attributes.


Backpack is a location based augmented reality app that has many features.
Introducing Backpack! Backpack is an app where travellers who are new to the area can "become one of the locals" by discovering the history of places, monuments, statues, buildings, as well as tips and information about attractions, restaurants, shops, routes, and prices. No longer should you hesitate when it comes to choosing a place to visit. Simply open up the app and look at other user's experiences and choose where you want to go. Had a great time? Share your experience as well to become varified and recieve points to unlock coupons and special offers.
| Feature | Paid | Free |
|---|---|---|
| Ads | X | ✓ |
| Access to message board | ✓ | X |
| History log of places visited | ✓ | X |
| Deals for nearby shops and restaurants | ✓ | X |
| Ability to use coupons and deals at nearby stores through app | ✓ | X |
| GPS tracking | ✓ | ✓ |
| Ability to get verified for posting | ✓ | ✓ |
| Connection to social media | ✓ | ✓ |
| Rank correlating to the number of spots visited | ✓ | ✓ |
| Pricing on nearby food and drink | ✓ | ✓ |


APP ICONS
Our app icons use reductive design principles, meaning all elements should be distilled down to their simplest form. App icons are used throughout the app to give affordance to an action, clarify content, simplify text, improve aesthetic of a list or to give user feedback.
GUIDELINES
- Icons should be used sparingly, when text does not work.
- Icon usage should be universal and understandable (i.e. trash can = delete)
- App icons use the 24px square grid. Stick to the grid!
- Every app icon should have at least 2px padding to contain the icon inside the 24px grid (therefore an icon’s maximum size should be 22px x 22px)
32px clickable area should be used, that is, 24px icon plus 8px margin.
- Placing icons together: since icons are centered in the 24px grid with a 2px padding, icons can be placed right next to each or in 8px increments after that. Generally, 0px, 8px, 16px or 24px.
ILLUSTRATIVE
The purpose of these illustration icon sets is to provide a small visual element to otherwise over explanatory/wordy views or to add another visual touch to content headers. Use these icons sparingly.
GUIDELINES
- Illustrative icons should never be used as replacements for app icons or navigational elements.
- A 48px clickable area should be used for illustrative icons
- Illustrative icons use the 48px square grid. Stick to the grid!
INTERCOM BUBBLE
Sits in the bottom right corner of the screen. used for the help center, matches the purple help color, don’t mess with it.
GUIDELINES
Don’t touch the intercom bubble!
Consider including the intercom bubble in your mockups (location/placement?)
NAMECHIPS
Namechips are used to represent users, team members and clients using their initials.
GUIDELINES
- Resting, namechips are gray (#CFCFCF) unless used to indicate who they are:
- Canopy Green = Team member
- Vibrant Blue = Client
- 5px border radius
- Come in 4 square sizes: 24px, 32px, 48px and 56px
BEST PRACTICES (apply to all icons)
- Avoid resizing icons to maintain 24px.
- Icons are generally Monsoon Gray (#777777).
- When used for active menu items or to show editing, icons can be Canopy Green (#00BF4B) or use vibrant blue (#3399FF) as an extra indicator for actions.


The forces at work behind Sydney's Powerhouse design competition
by Michael Bleby-
Designers switch to gender neutral jewellery
-
Harvey Norman’s Slovenian love story
-
Mail-order meat on the menu for ‘most beautiful butcher in the world’
-
The jewellery people buy when price is no object
-
The 20 best wines of 2019 (including a surprise $10 bottle)


Largest Decline in Access to Improved Water Sources
1992 - 2015
Data as of 2015 Percentage of the total population using improved water sources. An “improved” source is one that is likely to provide "safe" water, such as a household connection, a borehole, etc. Current information does not allow yet to establish a relationship between access to safe water and access to improved sources, but WHO and UNICEF are examining this relationship. (Source: Aquastat)


val individuals: List<Program<TProgram, TOutput>>
The population at the end of the evolution process.
individuals - The population at the end of the evolution process.
individuals


Update: Son of former German president stabbed to death at Berlin hospital
by AFP/The LocalThe son of former German president Richard von Weizsäcker was killed after presenting a lecture at a Berlin hospital.
Fritz von Weizsäcker, who worked as a doctor, had just delivered a lecture on liver diseases at the Schlosspark hospital in the western Berlin neighbourhood of Charlottenburg on Tuesday evening when he was stabbed, a police spokesman said. One other person was seriously injured.
The 59-year-old, a father-of-four, died at the scene despite efforts to save him. The incident took place around 6.50pm.
Around 20 people were in attendance at the lecture. The suspect was overpowered by the other people present, one of whom, said to be an off-duty policeman, was severely injured by the attacker.
Prosecutors said the 57-year-old attacker had bought the knife in his home state of Rhineland-Palatinate in the far west of Germany and travelled to Berlin by train.
They said he had been diagnosed with an "acute mental illness" and had a "probably delusional general dislike" of the Weizsäcker family.
Police tweeted about the "violent attack" on Tuesday night.
Head of the pro-business FDP party, Christian Lindner, paid tribute to his friend on Twitter, calling him a "passionate doctor and a fine person". He voiced his grief, saying that "once again we ask ourselves what sort of world are we living in."
His father, Richard von Weizsäcker, was considered one of Germany's great post-war political figures.
Spiegel magazine said the suspect had researched the elder Weizsäcker's role on the board of chemicals giant Böhringer Ingelheim during the 1960s before he began his political career.
The company at the time reportedly supplied the United States with some of the chemicals in Agent Orange, a powerful defoliant used in the Vietnam War that caused severe health problems for humans exposed to it.
Weizsäcker was president of West Germany from 1984 to 1990, and then held the same position in the united Germany from 1990 to 1994.
He was previously a deputy in the lower house of parliament for the CDU now led by Chancellor Angela Merkel, and mayor of West Berlin. He died in 2015.
Merkel said the killing was "a terrible moment for the von Weizsäcker family", her spokesman Steffen Seibert told reporters.


Stolen defibrillator found in Louth; One still missing in Wicklow
by By Elaine Keogh- with reporting from Vivienne Clarke
A potentially life-saving defibrillator, that was stolen from outside a shop in Co Louth, has been found.
It was stolen on Friday night from outside the Village Store in Aston Village, Drogheda.
The theft by two young men was captured on CCTV footage that has been given to the gardaí.
Local resident Kenneth Flood confirmed this morning that it had been found.
He said it was discovered "this morning in Redshank Court. It wasn't there yesterday so it was brought back and dumped."
Locals had searched for the device over the weekend. 12 local residents, including staff at the nearby Aston Village Educate Together primary school had been trained as first responders and were able to use it.
Mr Flood, who paid for the device during his time as a councillor, said that the Order of Malta will check the AED to see if it is okay to use.
Over the weekend a funding page was set up to pay for a replacement. However, Mr Flood confirmed this morning that Sinn Féin councillors have agreed to cover the costs of replacing it or repairing it from their community allocation funds.
It was one of two defibrillators stolen over the weekend, the other was taken in Wicklow.
Speaking on RTÉ's Morning Ireland today, Dr David Menzies - medical director of national Community First Responder network - explained the importance of defibrillators.
“It is a piece of equipment that can deliver an electric shock to a patient’s heart if they are in cardiac arrest," said Dr Menzies.
“Ireland has about 13 of these a day, outside of hospital environments, the chances of survival are completely time dependent, so there's two interventions that are proven to work, one is early CPR and Ireland is really good at that, we have a rate of over 80 per cent bystander CPR which is probably world leading.
“The second intervention is defibrillator and that's really effective within the first 10 minutes. So this is not something that the ambulance service or the health service on its own can solve.
“The cheapest defibrillator is just north of €1,000 plus VAT, they need to be kept in a heated cabinet as cold weather will degrade the battery. You're looking at €1500 for that community to replace this.”
READ MORE
Storm Atiyah: Thousands of homes and businesses without power; More stormy weather expected


This module can be mixed into all classes, whose instances respond to the
and size-methods, like for example Array. The returned elements from []
should respond to the succ method.
Returns a minimized version of this object, that is successive elements are substituted with ranges a..b. In the situation ..., x, y,... and y != x.succ a range x..x is created, to make it easier to iterate over all the ranges in one run. A small example:
[ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ].minimize # => [ 'A'..'C', 'G'..'G', 'K'..'M' ]
If the order of the original elements doesn't matter, it's a good idea to first sort them and then minimize:
[ 5, 1, 4, 2 ].sort.minimize # => [ 1..2, 4..5 ]
# File lib/spruz/minimize.rb, line 15 def minimize result = [] last_index = size - 1 size.times do |i| result << [ self[0] ] if i == 0 if self[i].succ != self[i + 1] or i == last_index result[-1] << self[i] result << [ self[i + 1] ] unless i == last_index end end result.map! { |a, b| a..b } end
First minimizes this object, then calls the replace method with the result.
# File lib/spruz/minimize.rb, line 30 def minimize! replace minimize end
Invert a minimized version of an object. Some small examples:
[ 'A'..'C', 'G'..'G', 'K'..'M' ].unminimize # => [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ]
and
[ 1..2, 4..5 ].unminimize # => [ 1, 2, 4, 5 ]
# File lib/spruz/minimize.rb, line 38 def unminimize result = [] for range in self for e in range result << e end end result end
Invert a minimized version of this object in place.
# File lib/spruz/minimize.rb, line 49 def unminimize! replace unminimize end


is a Physical Oceanographer, who received his Ph.D. in 1994 from the University of Hamburg, Germany. He currently works as a Research Scientist at the Alfred Wegener Institute for Polar and Marine Research and as a Director and Researcher at the scientific company Ocean Atmosphere Systems GmbH. He acted as the assistant coordinator for the project ACCESS. His work focuses on numerical modeling of sea ice and ocean, and more recently also on interdisciplinary aspects of climate change in the Arctic.


--- layout: default-tabs title: dubspace description: Rhythm Shoot Em Up Bullet Hell developer: Alex Bennett display-img: /assets/images/dubspace/banner.jpg header: video: embed: /CimLHtWK-bE?playlist=CimLHtWK-bE overlay_image: /assets/images/dubspace/title-box.png download_url: https://drive.google.com/open?id=0BzLBvlzBp2H4a0w4X1V4MDBCbU0 tabs: main: - General Info - Code Examples snippets: - Enemy.cs - PlayerController.cs ---
Made in 2012 as my year 12 semester (16 weeks) extended project. This game was my first complete project and was made during my first year of learning programming. Its coded entirely using javascript and the only external package used was iTween.
I have recently decided to port the game to Unity 5 and C#, where I will have to remake much of the game. The provided code snippets are the start reimplementations of the AI and Player controller scripts.
W A S D to move, LMB to shoot, Spacebar to use special move, Scroll or 1, 2, 3, to change special ability and ESC to pause.
 The player HUD is located around the player so they don't have to look away from the enemies they are trying to avoid.
There are 4 enemy types:
The Waves gamemode has a boss every 5 waves and is my favourite mode.  Also upon testing the game for this portfolio I have noticed a few bugs. Sometimes the game crashes on exit, as well as enemies will randomly die over time, which is likely a coroutine issue.


Box Alignment
Once you have items on a flexbox or grid layout, you can control how those items fit inside those layouts.
Space Between
space(-DIR)(-AMT)
- DIR
x
y
- AMT
0
0.5
1
1.5
2
2.5
3
3.5
4
5
6
7
8
9
10
11
12
14
16
20
24
28
32
36
40
44
48
52
56
60
64
72
80
96
px
reverse
- DIR
I often just want to put some space in between elements. I know I could use a list, but then I'd have to undo some of the other spacing. Tailwind gives you a real easy set of classes to take care of that.
You get the typical scale from 0 to 96, plus px
, which means one pixel.
There's a reverse options when you are using a reverse flex. like when you're using space-x-2
with flex-row-reverse
you'd add space-x-reverse
.
You can use these without flex on simple items like divs or display blocks, but they work real well with flex items.
Justify Content
justify(-DIR)
- DIR
start
end
center
between
around
evenly
- DIR
Justify content works with either grid or flex items and let you control how elements are postioned in the main axis.
justify-start
places items at the beginning, justify-end
puts them at the end, justify-center
centers them.
Then there's a set of justify classes that spread items around justify-between
makes sure there is equal space between the items. justify-around
does the same thing, but puts equal space on each side. Finally justify-evenly
does the same thing as justify around, but gets rid of the double space.
All of this is better with some samples.
Justify Items
justify-items(-DIR)
- DIR
auto
start
end
center
stretch
- DIR
Specifically for grid items, you can control how items are placed within their axis. This is similar to Justify Content.
justify-items-auto
is the default, which looks the same as justify-items-stretch
which stretches the items to fit their grid lines.
justify-items-start
makes the items align to the beginning of the grid lines, justify-items-end
aligns the items to the end, and justify-items-center
aligns them to the center of the grid.
Justify Self
justify-self(-DIR)
- DIR
auto
start
end
center
stretch
- DIR
Justify self is similar to Justify items, but applies to a single element.
In the example, you can see that I've set all of the items to use a justify-items-auto
layout, but each of the green ones uses one of the other classes.
Align Content
content(-DIR)
- DIR
center
start
end
between
around
evenly
- DIR
Align Content works with flex and grid containers and align based on the cross axis.
The classes are pretty straightforward and much like the justify content classes with content-evenly
In the example, I've given each of the containers a height of 40 units and made sure that the elements that have been aligned have been sized to full heights.
Align Items
items(-DIR)
- DIR
center
start
end
baseline
stretch
- DIR
Align Items lets you control how different rows are position on flex and grid containers. The example shows you the differences.
Most are straightforward, but take a look at items-baseline
. It's slightly different than items-center
. Although the text is different sizes, the browser will try to align the baselines when placing the elements.
Also, notice that I have no heights, just different padding on the items which gives them the extra heights.
Align Self
items(-DIR)
- DIR
center
start
end
baseline
stretch
- DIR
Align self lets you control the alignment of individual items. Notice that self-auto
and self-stretch
look the same.
Place Content
place-content(-DIR)
- DIR
center
start
end
between
around
evenly
stretch
- DIR
Place content lets you take care of justifying and aligning at the same time and you'll see that it's very similar to the content classes, but the names are a combination of content and align.
Place Items
place-items(-DIR)
- DIR
auto
start
end
center
stretch
- DIR
Similarly place items controls how items are justified and aligned.
Place Self
place-items(-DIR)
- DIR
auto
start
end
center
stretch
- DIR
Place self lets you control individual items inside place content containers, helping you justify and align them..


Gecode::Int::GCC::Edge Class Reference
Detailed Description
Class for edges in the variable-value-graph.Definition at line 310 of file graphsup.icc.
Constructors | |
| Edge (VarNode *x, ValNode *v) | |
| Construct edge from variable node x and value node y. | |
| void * | operator new (size_t, void *) |
| Create a new edge in memory. | |
Access | |
| template<BC > | |
| bool | used (void) |
| return whether the edge is used | |
| template<BC > | |
| bool | matched (void) |
| return whether the edge is matched | |
| bool | is_deleted (void) |
| return whether the edge has been deleted from the graph | |
| Edge * | next (bool t) const |
| return a pointer to the next edge If t is false the function returns the next edge incident on x otherwise it returns the next edge incident on v | |
| Edge * | next (void) const |
| return the pointer to the next edge incident on x | |
| Edge * | prev (void) const |
| return the pointer to the previous edge incident on x | |
| Edge * | vnext (void) const |
| return the pointer to the next edge incident on v | |
| Edge * | vprev (void) const |
| return the pointer to the previous edge incident on v | |
| VarNode * | getVar (void) |
| return the pointer to the variable node x of this edge | |
| ValNode * | getVal (void) |
| return the pointer to the value node v of this edge | |
| VVGNode * | getMate (bool t) |
| return pointer to x if t = true otherwise return v | |
| template<BC > | |
| void | use (void) |
| Update. | |
| template<BC > | |
| void | free (void) |
| Mark the edge as unused. | |
| template<BC > | |
| void | reset (void) |
| Reset the edge ( free the edge, and unmatch the edge including its end-nodes. | |
| template<BC > | |
| void | match (void) |
| Match the edge. | |
| template<BC > | |
| void | unmatch (void) |
| Unmatch the edge and the incident nodes. | |
| template<BC > | |
| void | unmatch (bool t) |
| Unmatch the edge and ( x if t=false, v otherwise ). | |
| void | unlink (void) |
| Unlink the edge from the linked list of edges. | |
| void | del_edge (void) |
| Mark the edge as deleted during synchronization. | |
| void | insert_edge (void) |
| Insert the edge again. | |
| Edge ** | next_ref (void) |
| return the reference to the next edge incident on x | |
| Edge ** | prev_ref (void) |
| return the reference to the previous edge incident on x | |
| Edge ** | vnext_ref (void) |
| return the reference to the next edge incident on v | |
| Edge ** | vprev_ref (void) |
| return the reference to the previous edge incident on v |
Constructor & Destructor Documentation
Member Function Documentation
| void * Gecode::Int::GCC::Edge::operator new | ( | size_t | , | |
| void * | p | |||
| ) | [inline] |
| bool Gecode::Int::GCC::Edge::used | ( | void | ) | [inline] |
return whether the edge is used
An edge can be used in a matching on the graph, a path on the graph or a cycle in the graph.
Definition at line 1115 of file graphsup.icc.
| bool Gecode::Int::GCC::Edge::matched | ( | void | ) | [inline] |
| bool Gecode::Int::GCC::Edge::is_deleted | ( | void | ) | [inline] |
return whether the edge has been deleted from the graph
Definition at line 1259 of file graphsup.icc.
| Edge * Gecode::Int::GCC::Edge::next | ( | bool | t | ) | const [inline] |
return a pointer to the next edge If t is false the function returns the next edge incident on x otherwise it returns the next edge incident on v
Definition at line 1129 of file graphsup.icc.
| Edge * Gecode::Int::GCC::Edge::next | ( | void | ) | const [inline] |
| Edge * Gecode::Int::GCC::Edge::prev | ( | void | ) | const [inline] |
| Edge * Gecode::Int::GCC::Edge::vnext | ( | void | ) | const [inline] |
| Edge * Gecode::Int::GCC::Edge::vprev | ( | void | ) | const [inline] |
| VarNode * Gecode::Int::GCC::Edge::getVar | ( | void | ) | [inline] |
return the pointer to the variable node x of this edge
Definition at line 1172 of file graphsup.icc.
| ValNode * Gecode::Int::GCC::Edge::getVal | ( | void | ) | [inline] |
| VVGNode * Gecode::Int::GCC::Edge::getMate | ( | bool | t | ) | [inline] |
| void Gecode::Int::GCC::Edge::use | ( | void | ) | [inline] |
| void Gecode::Int::GCC::Edge::free | ( | void | ) | [inline] |
Mark the edge as unused.
the failure is here, capacity is not increased for value nodes
Definition at line 1097 of file graphsup.icc.
| void Gecode::Int::GCC::Edge::reset | ( | void | ) | [inline] |
Reset the edge ( free the edge, and unmatch the edge including its end-nodes.
Definition at line 1108 of file graphsup.icc.
| void Gecode::Int::GCC::Edge::match | ( | void | ) | [inline] |
| void Gecode::Int::GCC::Edge::unmatch | ( | void | ) | [inline] |
| void Gecode::Int::GCC::Edge::unmatch | ( | bool | t | ) | [inline] |
| void Gecode::Int::GCC::Edge::unlink | ( | void | ) | [inline] |
| void Gecode::Int::GCC::Edge::del_edge | ( | void | ) | [inline] |
| void Gecode::Int::GCC::Edge::insert_edge | ( | void | ) | [inline] |
| Edge ** Gecode::Int::GCC::Edge::next_ref | ( | void | ) | [inline] |
| Edge ** Gecode::Int::GCC::Edge::prev_ref | ( | void | ) | [inline] |
return the reference to the previous edge incident on x
Definition at line 1153 of file graphsup.icc.
| Edge ** Gecode::Int::GCC::Edge::vnext_ref | ( | void | ) | [inline] |
| Edge ** Gecode::Int::GCC::Edge::vprev_ref | ( | void | ) | [inline] |
return the reference to the previous edge incident on v
Definition at line 1163 of file graphsup.icc.
The documentation for this class was generated from the following file:
- gecode/int/gcc/graphsup.icc (Revision: 6323)


--- layout: post title: Invite to Google Plus - Its Like Facebook, But Less Evil categories: [] tags: [] status: publish type: post published: true meta: _original_post_id: '' _original_import_author: John Duprey author: ---
Come, my friends and family to GooglePlus:
https://plus.google.com/_/notifications/ngemlink?path=%2F%3Fgpinv%3DVNab14oCFew%3APVx-UBkq0D8 This invite is your way to a better social web. -- its like Facebook, but less Evil:


People
Moffitt advanced to Professor of Medicine at the University of California School of Medicine in one year's time. In 1912, he was asked to be Dean of the medical school, a post that he held until called to World War I as a major in the Army Medical Corps. When the Regents and President Wheeler sought to reorganize the University of California Medical School, it was Moffitt who was asked to direct the activity. In the years preceding the war, he toured the country studying other medical centers with his characteristic thoroughness. As a result of his travels, he brought many outstanding faculty members to the University of California, including George Whipple, Karl F. Meyer, Frank Lynch, Herbert M. Evans, and William P. Lucas. Moffitt raised the funds among his many friends for the construction of UC Hospital which opened in 1917, the final step in the reorganization of the medical school.
Moffitt was an gifted clinician, and carried his exceptional clinical ability into his teaching and into his private practice. His fame spread early and he became known as one of the nation's best-known clinicians. He was a member of the Association of American Physicians and its president in 1922. Always interested in medical education, he was an ardent proponent of bedside teaching, and to all of his students and colleagues he was the ultimate clinical teacher. He had a phenomenal memory, able to call to mind details of cases seen long ago, or the exact passages of medical textbooks and journals, with an accuracy that astounded his listeners. He solved clinical problems by direct attack, rather than by the process of elimination. He had a certain brusqueness and aloofness, both of which were but a thin cloak to cover up his highly sensitive and kindly nature.
On his return from Army service in 1919, he was made Chairman of the Division of Medicine. He retired in 1937, continuing on as a familiar sight at conferences, rounds, and bedside teaching. Few things were ever done at the medical school without consultation with "The Chief," as he had long been known. His contribution to the University of California is shown by the naming of Herbert C. Moffitt Hospital. In his self-effacing way, he was much opposed to accepting this honor. He died at age eighty-three, having received most every honor and award that can come to one in medicine.


My Portfolio
Hi everyone! My name is Jennifer Guerrero, and I am a sophomore at the University of Illinois at Urbana-Champaign. I am of Mexican/Honduran heritage, and I was born and raised in Chicago. I am a CSSI alum, and I am very excited to learn more about CS through SPS and to meet new people.
Hobbies/Interests
Click here to see some quality green content.
Greetings!:


Maybe! Plenty of people do, but not everyone can. It's a common hobbyist activity, but not something that people would usually do for a job.
There's nothing fundamentally special about the computers that run web servers. They're just computers running an operating system such as Linux, Mac OS, or Windows (usually Linux). Their connection to the Internet is a little different from a typical home or mobile Internet connection, though. A server usually needs to have a stable (static) IP address so that clients can find it and connect to it. Most home and mobile systems don't assign your computer a static IP address.
Also, most home Internet routers don't allow incoming connections by default. You would need to reconfigure your router to allow it. This is totally possible, but way beyond the scope of this course (and I don't know what kind of router you have).
Lastly, if you run a web service at home, your computer has to be always on.
So, for the next exercise in this course, you'll be deploying one of your existing web services to Heroku , a commercial service that will host it on the web where it will be publicly accessible.
Heroku (and many other web hosting services) works closely with Git: you can deploy a particular version of your code to Heroku by pushing it with the git push command. So in order to deploy your code, it first needs to be checked into a local Git repository.
This Git repository should be separate from the one created when you downloaded the exercise code (the course-ud303 directory). Create a new directory outside of that directory and copy the bookmark server code (the file BookmarkServer.py from last lesson) into it. Then set this new directory up as a Git repository:
First, visit this link and follow the instructions to sign up for a free Heroku account:
There are a few configuration files that Heroku requires for deployment, to tell its servers how to run your application. For the case of the bookmark server, I'll just give you the required content for these files. These are just plain text files and can be created in your favorite text editor.
runtime.txt tells Heroku what version of Python you want to run. Check the currently supported runtimes in the Heroku documentation; this will change over time! As of early 2020, the currently supported version of Python 3 is python-3.7.2; so this file just needs to contain the text python-3.7.2.
requirements.txt is used by Heroku (through pip) to install dependencies of your application that aren't in the Python standard library. The bookmark server has one of these: the requests module. We'd like a recent version of that, so this file can contain the text requests>=2.12. This will install version 2.12 or a later version, if one has been released.
Procfile is used by Heroku to specify the command line for running your application. It can support running multiple servers, but in this case we're only going to run a web server. Check the Heroku documentation about process types for more details. If your bookmark server is in BookmarkServer.py, then the contents of Procfile should be web: python BookmarkServer.py.
There's one small change that you have to make to your server code to make it run on Heroku. The bookmark server from Lesson 2 listens on port 8000. But Heroku runs many users' processes on the same computer, and multiple processes can't (normally) listen on the same port.
The way it does this is through an environment variable — a configuration variable that is passed to your server from the program that starts it, usually the shell. Python code can access environment variables in the os.environ dictionary. The names of environment variables are usually capitalized; and the environment variable we need here is called, unsurprisingly, PORT.
The port your server listens on is configured when it creates the HTTPServer instance, near the bottom of the server code. We can make it work with or without the PORT environment variable, like so:
To access os.environ , you will also need to import os at the top of the file.
Make these changes to your server code, run the server locally to test that it still works, then commit it to your Git repository:
Before you can put your service on the web, you have to give it a name. You can call it whatever you want, as long as the name is not already taken by another user! Your app's name will appear in the URI of your deployed service. For instance, if you name your app silly-pony, it will appear on the web at https://silly-pony.herokuapp.com/.
Use heroku create your-app-name to tell Heroku about your app and give it a name. Again, you can choose any name you like, but it will have to be unique — the service will tell you if you're choosing a name that someone else has already claimed.
Finally, use git push heroku master to deploy the app!
If your app doesn't work quite right as deployed, one resource that can be very helpful is the server log. Since your service isn't running on your own local machine any more, those logs aren't going to show up in your terminal! Instead, they're available from the Heroku dashboard.
Take a look at https://dashboard.heroku.com/apps/little-bookmarks/logs, but replace "little-bookmarks" with your own app's name.
Being able to handle two ongoing tasks at the same time is called concurrency, and the basic http.server.HTTPServer doesn't have it. It's pretty straightforward to plug concurrency support into an HTTPServer, though. The Python standard library supports doing this by adding a mixin to the HTTPServer class. A mixin is a sort of helper class, one that adds extra behavior the original class did not have. To do this, you'll need to add this code to your bookmark server:
Then look at the bottom of your bookmark server code, where it creates an HTTPServer. Have it create a ThreadHTTPServer instead:
Commit this change to your Git repository, and push it to Heroku. Now when you test it out, you should be able to add an entry that points to the service itself.
The Web was originally designed to serve documents, not to deliver applications. Even today, a large amount of the data presented on any web site is static content — images, HTML files, videos, downloadable files, and other media stored on disk.
Specialized web server programs — like Apache, Nginx, or IIS — can serve static content from disk storage very quickly and efficiently. They can also provide access control, allowing only authenticated users to download particular static content.
Some web applications have several different server components, each running as a separate process. One thing a specialized web server can do is dispatch requests to the particular backend servers that need to handle each request. There are a lot of names for this, including request routing and reverse proxying.
Some web applications need to do a lot of work on the server side for each request, and need many servers to handle the load. Splitting requests up among several servers is called load balancing.
Load balancing also helps handle conditions where one server becomes unavailable, allowing other servers to pick up the slack. A reverse proxy can health check the backend servers, only sending requests to the ones that are currently up and running. This also makes it possible to do updates to the backend servers without having an outage.
Handling a large number of network connections at once turns out to be complicated — even more so than plugging concurrency support into your Python web service.
As you may have noticed in your own use of the web, it takes time for a server to respond to a request. The server has to receive and parse the request, come up with the data that it needs to respond, and transmit the response back to the client. The network itself is not instantaneous; it takes time for data to travel from the client to the server.
In addition, a browser is totally allowed to open up multiple connections to the same server, for instance to request resources such as images, or to perform API queries.
All of this means that if a server is handling many requests per second, there will be many requests in progress at once — literally, at any instant in time. We sometimes refer to these as in-flight requests, meaning that the request has "taken off" from the client, but the response has not "landed" again back at the client. A web service can't just handle one request at a time and then go on to the next one; it has to be able to handle many at once.
Imagine a web service that does a lot of complicated processing for each request — something like calculating the best route for a trip between two cities on a map. Pretty often, users make the same request repeatedly: imagine if you load up that map, and then you reload the page — or if someone else loads the same map. It's useful if the service can avoid recalculating something it just figured out a second ago. It's also useful if the service can avoid re-sending a large object (such as an image) if it doesn't have to.
One way that web services avoid this is by making use of a cache, a temporary storage for resources that are likely to be reused. Web systems can perform caching in a number of places — but all of them are under control of the server that serves up a particular resource. That server can set HTTP headers indicating that a particular resource is not intended to change quickly, and can safely be cached.
There are a few places that caching usually can happen. Every user's browser maintains a browser cache of cacheable resources — such as images from recently-viewed web pages. The browser can also be configured to pass requests through a web proxy, which can perform caching on behalf of many users. Finally, a web site can use a reverse proxy to cache results so they don't need to be recomputed by a slower application server or database.
All HTTP caching is supposed to be governed by cache control headers set by the server. You can read a lot more about them in this article by Google engineer Ilya Grigorik.
hy serve static requests out of cache (or a static web server) rather than out of your application server? Python code is totally capable of sending images or video via HTTP, after all. The reason is that — all else being equal — handling a request faster provides a better user experience, but also makes it possible for your service to support more requests.
If your web service becomes popular, you don't want it to bog down under the strain of more traffic. So it helps to handle different kinds of request with software that can perform that function quickly and efficiently.
All HTTP caching is supposed to be governed by cache control headers set by the server. You can read a lot more about them in this article by Google engineer Ilya Grigorik.
Cookies are a way that a server can ask a browser to retain a piece of information, and send it back to the server when the browser makes subsequent requests. Every cookie has a name and a value, much like a variable in your code; it also has rules that specify when the cookie should be sent back.
What are cookies for? A few different things. If the server sends each client a unique cookie value, it can use these to tell clients apart. This can be used to implement higher-level concepts on top of HTTP requests and responses — things like sessions and login. Cookies are used by analytics and advertising systems to track user activity from site to site. Cookies are also sometimes used to store user preferences for a site.
The first time the client makes a request to the server, the server sends back the response with a Set-Cookie header. This header contains three things: a cookie name, a value, and some attributes. Every subsequent time the browser makes a request to the server, it will send that cookie back to the server. The server can update cookies, or ask the browser to expire them.
Browsers don't make it easy to find cookies that have been set, because removing or altering cookies can affect the expected behavior of web services you use. However, it is possible to inspect cookies from sites you use in every major browser. Do some research on your own to find out how to view the cookies that your browser is storing.
By the way, if you try to research "cookie fields" with a web search, you may get a lot of results from the Mrs. Fields cookie company. Try "HTTP cookie fields" for more relevant results.
The first two, the cookie's name and content, are also called its key and value. They're analogous to a dictionary key and value in Python — or a variable's name and value for that matter. They will both be sent back to the server. There are some syntactic rules for which characters are allowed in a cookie name; for instance, they can't have spaces in them. The value of the cookie is where the "real data" of the cookie goes — for instance, a unique token representing a logged-in user's session.
The next two fields, Domain and Path, describe the scope of the cookie — that is to say, which queries will include it. By default, the domain of a cookie is the hostname from the URI of the response that set the cookie. But a server can also set a cookie on a broader domain, within limits. For instance, a response from www.udacity.com can set a cookie for udacity.com, but not for com.
The fields that Chrome describes as "Send for" and "Accessible to script" are internally called Secure and HttpOnly, and they are boolean flags (true or false values). The internal names are a little bit misleading. If the Secure flag is set, then the cookie will only be sent over HTTPS (encrypted) connections, not plain HTTP. If the HttpOnly flag is set, then the cookie will not be accessible to JavaScript code running on the page.
Finally, the last two fields deal with the lifetime of the cookie — how long it should last. The creation time is just the time of the response that set the cookie. The expiration time is when the server wants the browser to stop saving the cookie. There are two different ways a server can set this: it can set an Expires field with a specific date and time, or a Max-Age field with a number of seconds. If no expiration field is set, then a cookie is expired when the browser closes.
To set a cookie from a Python HTTP server, all you need to do is set the Set-Cookie header on an HTTP response. Similarly, to read a cookie in an incoming request, you read the Cookie header. However, the format of these headers is a little bit tricky; I don't recommend formatting them by hand. Python's http.cookies module provides handy utilities for doing so.
To create a cookie on a Python server, use the SimpleCookie class. This class is based on a dictionary, but has some special behavior once you create a key within it:
Then you can send the cookie as a header from your request handler:
self.send_header("Set-Cookie", out_cookie["bearname"].OutputString())
To read incoming cookies, create a SimpleCookie from the Cookie header:
As a result, you are getting a dictionary with the values passed in the Url:
Be aware that a request might not have a cookie on it, in which case accessing the Cookie header will raise a KeyError exception; or the cookie might not be valid, in which case the SimpleCookie constructor will raise http.cookies.CookieError.
Important safety tip: Even though browsers make it difficult for users to modify cookies, it's possible for a user to modify a cookie value. Higher-level web toolkits, such as Flask (in Python) or Rails (in Ruby) will cryptographically sign your cookies so that they won't be accepted if they are modified. Quite often, high-security web applications use a cookie just to store a session ID, which is a key to a server-side database containing user information.
Another important safety tip: If you're displaying the cookie data as HTML, you need to be careful to escape any HTML special characters that might be in it. An easy way to do this in Python is to use the html.escape function, from the built-in html module!
A server that remembers you
In this exercise, you'll build a server that asks for your name, and then stores your name in a cookie on your browser. You'll be able to see that cookie in your browser's cookie data. Then when you visit the server again, it'll already know your name.
Back in Lesson 1, you used the host or nslookup command to look up the IP addresses of a few different web services, such as Wikipedia and your own localhost. But domain names play a few other roles in HTTP besides just being easier to remember than IP addresses. A DNS domain links a particular hostname to a computer's IP address. But it also indicates that the owner of that domain intends for that computer to be treated as part of that domain.
Imagine what a bad guy could do if they could convince your browser that their server evilbox was part of (say) Facebook, and get you to request a Facebook URL from evilbox instead of from Facebook's real servers. Your browser would send your facebook.com cookies to evilbox along with that request. But these cookies are what prove your identity to Facebook … so then the bad guy could use those cookies to access your Facebook account and send spam messages to all your friends.
In the immortal words of Dr. Egon Spengler: It would be bad.
This is just one reason that DNS is essential to web security. If a bad guy can take control of your site's DNS domain, they can send all your web traffic to their evil server … and if the bad guy can fool users' browsers into sending that traffic their way, they can steal the users' cookies and reuse them to break into those users' accounts on your site.
When a browser and a server speak HTTPS, they're just speaking HTTP, but over an encrypted connection. The encryption follows a standard protocol called Transport Layer Security, or TLS for short. TLS provides some important guarantees for web security:
Note: TLS is also very often referred to by the older name SSL (Secure Sockets Layer). Technically, SSL is an older version of the encryption protocol. This course will talk about TLS because that's the current standard.
Privacy : You're reading your email in a coffee shop, and the shop owner can read your email off of their Wi-Fi network you're using.
Authenticity : You think you're logging into Facebook, but actually you're sending your Facebook password to a server in the coffee shop's back room.
Integrity : The coffee shop owner doesn't like cat pictures, so they replace all the cat pictures on the web pages you're looking at with pictures of celery.
Note: In some browser documentation you'll see references to SSL certificates. These are the same as TLS certificates. Remember, SSL is just the older version of the encryption standard.
Most Browsers have a lock icon next to the URI when you're viewing an HTTPS web site.
Clicking on the lock is how you start exploring the details of the HTTPS connection.
Those are how the browser indicates to the user that their connection is being protected by TLS. However, these dialogs also show a little about the server's TLS setup.
The server-side configuration for TLS includes two important pieces of data: a private key and a public certificate . The private key is secret; it's held on the server and never leaves there. The certificate is sent to every browser that connects to that server via TLS. These two pieces of data are mathematically related to each other in a way that makes the encryption of TLS possible.
The server's certificate is issued by an organization called a certificate authority (CA) . The certificate authority's job is to make sure that the server really is who it says it is — for instance, that a certificate issued in the name of Heroku is actually being used by the Heroku organization and not by someone else.
The role of a certificate authority is kind of like getting a document notarized. A notary public checks your ID and witnesses you sign a document, and puts their stamp on it to indicate that they did so.
The data in the TLS certificate and the server's private key are mathematically related to each other through a system called public-key cryptography. The details of how this works are way beyond the scope of this course. The important part is that the two endpoints (the browser and server) can securely agree on a shared secret which allows them to scramble the data sent between them so that only the other endpoint — and not any eavesdropper — can unscramble it.
A server certificate indicates that an encryption key belongs to a particular organization responsible for that service. It's the job of a certificate authority to make sure that they don't issue a cert for (say) udacity.com to someone other than the company who actually runs that domain.
But the cert also contains metadata that says what DNS domain the certificate is good for. The cert in the picture above is only good for sites in the .herokuapp.com domain. When the browser connects to a particular server, if the TLS domain metadata doesn't match the DNS domain, the browser will reject the certificate and put up a big scary warning to tell the user that something fishy is going on
Every request and response sent over a TLS connection is sent with a message authentication code (MAC) that the other end of the connection can verify to make sure that the message hasn't been altered or damaged in transit.
If your browser believes the attacker's server is udacity.com, it will send your udacity.com authentication cookies to the attacker's server. They can then put those cookies in their own web client and masquerade as you when talking to the real site. Also, if your browser is fetching content from the attacker's server, the attacker can put whatever they want in that content. They could even forward most of the content from the real server.
However, compromising Udacity's site would not allow an attacker to break into your Gmail or Facebook accounts, and fortunately it wouldn't let the attacker blow up your computer either.
HTTPS only protects your data in transit. It doesn't protect it from an attacker who has taken over your computer, or the computer that's running your service.
APIs are a huge part of the morden web. A lot of web application makes use of a server side part that exposes an API and a client side that sends queries to that API, but not every API call makes sense as a GET or POST query
The GET Method is really for requesting a copy of a resource and Post is for things that act more or less like form submission.
The different HTTP methods each stand for different actions that a client might need to perform upon a server-hosted resource. Unlike GET and POST, their usage isn't built into the normal operation of web browsers; following a link is always going to be a GET request, and the default action for submitting an HTML form will always be a GET or POST request.
However, other methods are available for web APIs to use, for instance from client code in JavaScript. If you want to use other methods in your own full-stack applications, you'll have to write both server-side code to accept them, and client-side JavaScript code to make use of them.
The HTTP PUT method can be used for creating a new resources. The client sends the URI path that it wants to create, and a piece of data in the request body. A server could implement PUT in a number of different ways — such as storing a file on disk, or adding records to a database. A server should respond to a PUT request with a 201 Created status code, if the PUT action completed successfully. After a successful PUT, a GET request to the same URI should return the newly created resource.
The destructive counterpart to PUT is DELETE, for removing a resource from the server. After a DELETE has happened successfully, further GET requests for that resource will yield 404 Not Found ... unless, of course, a new resource is later created with the same name!
Most applications that involve creating and deleting resources on the server are going to require authentication, to make sure that the client is actually someone we want to trust with that power.
The PATCH method is a relatively new addition to HTTP. It expresses the idea of patching a resource, or changing it in some well-defined way. (If you've used Git, you can think of patching as what applying a Git commit does to the files in a repository.)
However, just as HTTP doesn't specify what format a resource has to be in, it also doesn't specify in what format a patch can be in: how it should represent the changes that are intended to be applied. That's up to the application to decide. An application could send diffs over HTTP PATCH requests, for instance. One standardized format for PATCH requests is the JSON Patch format, which expresses changes to a piece of JSON data. A different one is JSON Merge Patch.
There are a number of additional methods that HTTP supports for various sorts of debugging and examining servers.
An HTTP method asks the server to do something to a resource, which is named by a URI.
HTTP can't prevent a service from using methods to mean something different from what they're intended to mean, but this can have some surprising effects. For instance, you could create a service that used a GET request to delete content. However, web clients don't expect GET requests to have side-effects like that. In one famous case from 2006, an organization put up a web site where "edit" and "delete" actions happened through GET requests, and the result was that the next search-engine web crawler to come along deleted the whole site.
For much more about HTTP methods, consult the HTTP standards documents.
The new version of HTTP is called HTTP/2. It's based on earlier protocol work done at Google, under the name SPDY (pronounced "speedy").
Unfortunately, we can't show you very much about HTTP/2 in Python, because the libraries for it are not very mature yet (as of early 2017). We'll still take a look at the motivations for the changes that HTTP/2 brings, though.
Some other languages are a little bit more up to the minute; one of the best demonstrations of HTTP/2's advantages is in the Gophertiles demo from the makers of the Go programming language. In order to see the effects, you'll need to be using a browser that supports HTTP/2. Check CanIUse.com to check that your browser does!
This demo lets you load the same web page over HTTP/1.1 and HTTP/2. It also lets you add extra latency (delay) to each request, simulating what happens when you access a server that's far away or when you're on a slow network. The latency options are zero (no extra latency), 30 milliseconds, 200 milliseconds, and one second. Try it out!
HTTP/2 should load much faster than HTTP/1, if your browser is using it!
You don't have to take the Go folks' word for it, either; there's http://www.https2demo.io/ too, and also https://http2.akamai.com/demo . Each of these demos works similarly to the Gophertiles demo, and will show you much the same effects. The HTTP/2 one is (on average) a whole lot faster, especially with high latency.
But why is it faster? To answer that, we first need to look at some browser behavior in HTTP/1.1.
Since the early days of HTTP, browsers have kept open multiple connections to a server. This lets the browser fetch several resources (such as images, scripts, etc.) in parallel, with less waiting. However, the browser only opens up a small number of connections to each server. And in HTTP/1.1, each connection can only request a single resource at a time.
As an exercise, take a look at the server in Lesson-3/3_Parallelometer. Try running this server on your computer and accessing it at http://localhost:8000to see parallel requests happening. The code here is based on the threading server that you've seen earlier in this lesson.
Depending on your browser, you may see different numbers, but most likely the biggest one you'll see is 6. Common browsers such as Chrome, Firefox, and Safari open up as many as six connections to the same server. And under HTTP/1.1, only one request can effectively be in flight per connection, which means that they can only have up to six requests in flight with that server at a time.
requests.get("http://localhost:8000/")
But if you're requesting hundreds of different tiny files from the server — as in this demo or the Gophertiles demo — it's kind of limiting to only be able to fetch six at a time. This is particularly true when the latency (delay) between the server and browser gets high. The browser can't start fetching the seventh image until it's fully loaded the first six. The greater the latency, the worse this affects the user experience.
HTTP/2 changes this around by multiplexing requests and responses over a single connection. The browser can send several requests all at once, and the server can send responses as quickly as it can get to them. There's no limit on how many can be in flight at once.
And that's why the Gophertiles demo loads much more quickly over HTTP/2 than over HTTP/1.
When you load a web page, your browser first fetches the HTML, and then it goes back and fetches other resources such as stylesheets or images. But if the server already knows that you will want these other resources, why should it wait for your browser to ask for them in a separate request? HTTP/2 has a feature called server push which allows the server to say, effectively, "If you're asking for index.html, I know you're going to ask for style.css too, so I'm going to send it along as well."
The HTTP/2 protocol was being designed around the same time that web engineers were getting even more interested in encrypting all traffic on the web for privacy reasons. Early drafts of HTTP/2 proposed that encryption should be required for sites to use the new protocol. This ended up being removed from the official standard … but most of the browsers did it anyway! Chrome, Firefox, and other browsers will only attempt HTTP/2 with a site that is using TLS encryption.
Now you have a sense of where HTTP development has been going in the past few years. You can read much more about HTTP/2 in the
Here are some handy resources for learning more about HTTP:


Sara Falamaki and Asghar Kazi
Every computer system that interacts with rules, codes them
So that everyone uses the same rules
and
Rule changes are propagated across applications
Often the interaction between rules is incomprehensible to mere humans...
... for both our customers and staff
AI
Machine Learning
Law, equity, judgements
RoboCops
RoboJudges
RoboDebt
Automatic Anything
... Anything scary!
This is a questionaire that can be used to determine what financial help you're eligible for in New Zealand, created using Rules As Code
Here is a French example
We aim to make Rules as Code the easiest approach for drafting, consulting, implementing and communicating prescriptive rules and legislation.


This summer, I had the pleasure of working as a Data Analyst Intern at Voices.com as a part of my MSc in Business Analytics. Voices.com is a marketplace website that matches business clients with voice-over talent.
During my internship at Voices.com, I became involved in a variety of analytics projects. I committed to a customer segmentation analysis on voice-over talent, analyzed customer churn, built dashboards for core metrics, and designed A/B tests! Through these projects, I procured even more experience with the R programming language. In this post, I will showcase R tips that I learned this summer for data analysis and visualization. Hopefully, you can apply some of these tips to your own data analysis projects.
1. Removing similarly-named objects from R’s Global Environment
Say that you are in the middle of a data analysis and you need to test out a part of your code. If you’re like me, you will test sections of code and assign the results to a new object named something like test
. After I’m finished testing my code, I’m left with a RStudio environment that looks like this:
My first tip will allow us to selectively delete these test
objects. This is accomplished through the following code:
rm(list = ls()[str_detect(ls(), "string")])
Let’s break down what is going on in this code.
rm()
removes objects from the R environment.
ls()
lists all the objects in the R environment.
str_detect()
fromstringr
detects a specified pattern in a string.
"string"
is the pattern which our objects of interest have in common (e.g. “test”).
The innermost part of the code,str_detect(ls(), "string")
, detects the specified pattern within the environment. The previous code, enclosed in square brackets, indexes the list of object names in the environment (ls()[str_detect(ls(), "string")]
). Finally, that code is entered as the list argument in therm()
function. Ultimately,rm(list = ls()[str_detect(ls(), "test")])
removes objects with the matching"test"
pattern from the environment!
2. coord_cartesian()
for zooming in on ggplots
Say that you are producing a histogram from your data that looks something like this:
aq <- as_tibble(airquality)
ggplot(aq, aes(x = Ozone)) +
geom_histogram(fill = customBlue, binwidth = 5) +
theme_light() +
labs(y = "Count", x = "Ozone")
For whatever reason, you are only interested in visualizing a subset of this data. For example, we only want to visualize the histogram between Ozone values 0 and 50. You can achieve this using xlim()
:
ggplot(aq, aes(x = Ozone)) +
geom_histogram(fill = customBlue, binwidth = 5) +
theme_light() +
labs(y = "Count", x = "Ozone") +
xlim(c(0, 50))
But using xlim()
has resulted in an odd behaviour. Our histogram looks different than the original above. This is because xlim()
(and scale_x_continuous(limits = ...)
) has excluded all data that don’t fall within the limits. In this example, xlim()
excluded data points near 0 and 50. This is problematic if our goal is to visualize the same data without excluding data that lies on the edge of our criteria.
Instead, we can use coord_cartesian()
to achieve a true “zoom in” on our original data visualization.
ggplot(aq, aes(x = Ozone)) +
geom_histogram(fill = customBlue, binwidth = 5) +
theme_light() +
labs(y = "Count", x = "Ozone") +
coord_cartesian(xlim = c(0, 50))
Setting the xlim
argument within coord_cartesian()
results in the desired behaviour. Note that the previous erroneous behaviour of xlim()
isn’t restricted to histograms! Remember this tip so that you don’t accidentally exclude data from your visualizations!
3. Intra-figure legends in ggplot2
graphics
I agree with Edward Tufte’s disdain for legends in data visualizations. Legends, when placed on outside of a visualization, oblige your audience to look back-and-forth to interpret what you are presenting. This means that your audience has to focus on the format of your visualization before they can begin interpreting the content or message you are trying to deliver. That’s why I always try to use direct labels on my data visualizations instead of legends, like so:
But say you want to do the same direct labelling with a messier or more complicated visualization…
Now, I would hope that you would never have to present a spaghetti graph like this, but this is a situation where direct labels are not as easily implemented. Instead, we’ll use a legend. To reduce the amount of back-and-forth your audience has to do, we can place the legend within the figure as a compromise.
aq %>%
filter(Month != 5) %>%
ggplot(aes(x = Day, y = Temp, group = Month, colour = factor(Month))) +
geom_line(size = 1) +
geom_point(size = 3) +
scale_colour_manual(values = c(customBlue, customOrange, customYellow, customPurple)) +
coord_cartesian(ylim = c(50, 100)) +
labs(title = "Mean temperature by day grouped by month",
y = "Mean Temperature (F)",
colour = "Month") +
theme_light() +
theme(legend.background = element_blank(), ## These lines here!
legend.position = c(0.25, 0.2), ## These lines here!
legend.title = element_text(size = 12),
legend.text = element_text(size = 12))
This is accomplished by using theme(legend.background = element_blank(), legend.position = c(0.25, 0.2), ...)
to make the legend background transparent and to move the legend into the figure. This intra-figure legend will reduce, but not eliminate all of the figure’s interpretability issues. At the very least, it is a good compromise when you can’t directly label your data.
4. High resolution plot outputs via CairoPNG()
Exporting graphics in R can be challenging. New users will typically use RStudio’s Export button in the Plots window to save images to their working directory. In my experience, this method results in pixelated, low resolution graphics. There is nothing more demotivating than working on a visualizations for hours, only to have them look mediocre when presenting them.
This is where the Cairo
package comes in. The formula for generating Cairo
outputs is as follows:
CairoPNG(filename = "filename.png", res = 300, units = "in", width = 16, height = 9)
ggplot()...
dev.off()
- The first line initializes a graphics device via Cairo to render a high quality image of your visualization in the file format of your choosing. Here, I specify a PNG output through
CairoPNG()
, but other formats include JPEG, TIFF, and PDF.
- The second portion of the script should contain your visualization code.
- The last part is specifying
dev.off()
, which turns the graphics device off.
After executing the code in order, a high quality output of your visualization will be found in your working directory.
Note that your visualization might be slightly different from your viewer pane preview. It is then up to you to adjust your visualization code before running the whole code chunk again to see the changes. Use this tip so that your visualizations are always high res and crisp for your audience!
5. Fuzzy joins on intervals with genome_left_join()
The last tip is for dirty data joining! You may find yourself in a situation where you want to join two data frames / tables but you don’t have the necessary number of unique identifiers. For example, you are looking at event data in two separate data frames, where one data frame contains subscription data and the other contains cancellation case data.
memberships
## # A tibble: 8 x 4
## id sub_id start_date end_date
## <dbl> <dbl> <date> <date>
## 1 1 12 2019-09-05 2020-09-05
## 2 1 41 2018-09-05 2019-09-05
## 3 2 57 2019-07-01 2020-07-01
## 4 2 62 2018-07-01 2019-07-01
## 5 3 78 2019-02-01 2020-02-01
## 6 3 87 2018-02-01 2019-02-01
## 7 4 35 2018-05-25 2019-05-25
## 8 4 23 2017-05-25 2018-05-25
cancellations
## # A tibble: 3 x 4
## id case_open_date case_close_date retain
## <dbl> <date> <date> <lgl>
## 1 1 2020-05-09 2020-05-12 TRUE
## 2 3 2019-11-30 2019-12-01 FALSE
## 3 4 2018-04-25 2018-04-27 FALSE
In this example, we can identify which members have subscriptions and cancellation cases through id
. But we don’t have enough information to know which subscription each cancellation case belongs to. To know this, we would need a unique subscription id variable in the cancellation case data. Unfortunately, we only have subscription ids in memberships
. We can solve this problem with something called a fuzzy join.
In many programming languages, a left or right join allows you to link data frames or tables that contain a key identifier variable that is common between the two. This allows the analyst to link the data frames based on an exact match of the key id variables in each data frame. In our example, that would be the id
variable. Fuzzy joins differ as they allow you to link data frames based on inexact matching. This inexact matching technique is particularly useful in combination with an exact match.
In the following example, we will use genome_left_join()
from the fuzzyjoin
package to perform a fuzzy left join of cancellations
on memberships
. This join will be based on criteria of an exact match of id
and an inexact match of the subscription period (between start_date
to end_date
) that overlaps with the case period (between case_open_date
to case_close_date
).
# Convert start_date and end_date to numeric
memberships <- memberships %>%
mutate(start_date = as.numeric(start_date),
end_date = as.numeric(end_date))
# Convert case_open_date and case_close_date to numeric
cancellations <- cancellations %>%
mutate(case_open_date = as.numeric(case_open_date),
case_close_date = as.numeric(case_close_date))
# Fuzzy join
mem_canc <- memberships %>%
genome_left_join(cancellations,
by = c("id" = "id",
"start_date" = "case_open_date",
"end_date" = "case_close_date")) %>%
# Then convert start_date, end_date, case_open_date, and case_close_date back to dates
mutate( start_date = as_date(start_date),
end_date = as_date(end_date),
case_open_date = as_date(case_open_date),
case_close_date = as_date(case_close_date))
The first two code chunks change our subscription and case dates to integers (which represent the number of days since 1970-01-01). The result of the fuzzy join is a single data frame containing all rows from memberships
and the matched rows of cancellations
. Any rows in memberships
that do not have a matching row in cancellations
are filled with NAs.
mem_canc
## # A tibble: 8 x 7
## id sub_id start_date end_date case_open_date case_close_date retain
## <dbl> <dbl> <date> <date> <date> <date> <lgl>
## 1 1 12 2019-09-05 2020-09-05 2020-05-09 2020-05-12 TRUE
## 2 1 41 2018-09-05 2019-09-05 NA NA NA
## 3 2 57 2019-07-01 2020-07-01 NA NA NA
## 4 2 62 2018-07-01 2019-07-01 NA NA NA
## 5 3 78 2019-02-01 2020-02-01 2019-11-30 2019-12-01 FALSE
## 6 3 87 2018-02-01 2019-02-01 NA NA NA
## 7 4 35 2018-05-25 2019-05-25 NA NA NA
## 8 4 23 2017-05-25 2018-05-25 2018-04-25 2018-04-27 FALSE
Now we can see which subscriptions the cancellation cases belong to. From here, I could further clean this data by changing the end_date
of the subscription to match the cancellation case_close_date
, if the subscription was successfully cancelled according to retain
. This would allow me to calculate churn rates of the subscribers, which has huge implications for a subscription business’ monthly and annual revenue.
Note: to perform a fuzzy join with genome_left_join()
you will require the Bioconductor
and IRanges
packages as well. Installation instructions can be found here.
Conclusion
Thanks for reading this blog post! Hopefully, you’ll be able to use some of these tips to make your data analyses cleaner, crisper, and more accurate!
Feel free to share this content with others who may benefit from using any of these tips. As always, the full code for this post is available here. Happy coding!


Version Check:
DBs6xColorKeyboard
Total ModMyI Downloads:
Total ModMyI Downloads:
- This package installs DBs6x version for ColorKeyboard.
- Must be installed to work:
(Purchased)-ColorKeyboard. - Any questions, Comments, Suggestions, pleases contact<EMAIL_ADDRESS>- ..... If you like this theme please donate to DBs using the DirtyBeans Donate Button.
- Change theme in ColorKeyboard Settings.
- Tested on firmware 6.0.0 - 6.1.2 (iPhone 4/4s).
Reporting Bugs:
Donate:


LOGIN
User Email
Password
GO
Forgot your password?
REGISTER
User Email
Password
Repeat Password
NEXT


{{include '../particals/linker.html' }}
{{ include '../particals/header.html'}} {{block 'content' }} 默认模板 {{/block}} {{include '../particals/footer.html' }}


The standard classes in
the javax.imageio.stream
package are able to create
ImageInputStream
s and ImageOutputStream
s
that:
- Read from a
File
- Read from an
InputStream
, using a temporary File
as a
cache
- Read from an
InputStream
, using a byte array in memory as a
cache
- Write to a
File
- Write to an
OutputStream
, using a temporary File
as a
cache
- Write to an
OutputStream
, using a byte array in memory as a
cache
It is possible to write
new implementations of ImageInputStream
and
InmageOutputStream that interface with other I/O primitives (for
example, databases or future fast I/O interfaces). The
ImageInputStreamImpl
and
ImageOutputStreamImpl
classes provide a base for
subclassing. Only a handful of methods are required to be
implemented by the subclass, although it is possible to implement
more for greater efficiency:
-
int
read()
-
int
read(byte[] b, int off, int len)
-
write(int
b)
-
write(byte[]
b, int off, int len)
-
seek(long
pos)
CONTENTS | PREV | NEXT


INTEGRATED ADMIN PANEL
Most of the institutes in the health sector today are unable to meet the current required standards for patient satisfaction and complain redressal. And lack of an integrated platform in hospital management systems plays a key role in achieving this. Keeping into consideration, the need of the hour, we as a responsible organisation, have already taken a step forward to solve the issue.
We have introduced an integrated Admin Panel for monitoring and supervising all the issues of the patients and even doctors. The Admin Panel provides a medium to connect the authorities with the patiens and the staff directly, thus ensuring a fair situation.
FACILITIES FOR THE ELDERLY ONES
Keeping into view, the needs and mandates of our elderly patients, we have introduced a lot of features to make the thinks easy and convinient for them.
We have included features such as priorities in appointments, getting access to the records of previous ailments and their detailed reports in a click, and personalised supervising through video chat(in case they are not able to show up for some reason) have proved to be a benchmark for getting along with them.
VIDEO CONFERENCING FACILITIES
In these trying times of COVID 19, it has been very difficult for people to come out of their houses for their routinely check-ups. The elder patients are the most affected of all as they can't show up for their regular appointments.
We have come up with an innovative way to tackle this situation by including the feature of OCS ie Over the Call Supervision, wherein patients can consult the doctor through video conferencing and their mandates can be taken care of.
MEASURES FOR COVID-19
We understand the fact that the most vulnerble of the patients are those who are suffering from the deadly COVID 19. They are the ones who need specific care and redressal and also need to be properly cut off from the mianstream for a better treatment.
We believe in transparency and thus, our COVID stats are available to all our patients. Furhet, we have a seperate COVID ward for treating our COVID patients and a detailed record of the bed available, and the record of the vaccines given, and the patient history are recorded with us to help us treat you better.


Email
Cards
Credit card number:
Cuotas:
Issuer:
Security code:
Expiration month:
Expiration year:
Card holder name:
Document type:
Document number:


We can use simple tags to change the appearance of text within Web pages. Even superscript and subscripts are supported.
& < > " ©
University of Liverpool Department of Computer Science Chadwick Building, Peach Street Liverpool, L69 7ZF, UK


I must tell the truth about it, because I wrote much code without even a bit of documentation for core functions, extensions and worst of all I had 0% code test coverage. I was loosing too much time to look back and get out the API looking at the code, and that drove me into the urgency to code down a solution. I think I found it both for tests issue and documentation lackage.
$backtotop$With core I mean all functionalities that can be found in the library without loading by hand additional
extensions, these are : JMVC, Controller, View, Model, Interface, Promise, Event, Errors, dom, events, io, head,
util, array, object.
The documentation is based on an .xml file (documentation.xml) and is shown using a tab extension, but is regards
only the core section and is far from being completed. In the head of the Api page I`ll try to keep
updated a day countdown, estimated on daily progresses.
All test for each function will be shown within the document.
Here You`ll find what will be the API specification document. At the moment You
cannot rely on it, because I must fix data in the documentation.xml. In the head I estimated how many days I need
yet to complete it, and I`m faithful to not go long.
There is absolutely no documentation for the extensions that can be found on the repo. I am thinking about a solution, because the core is 20% and extensions are the 80% of the whole work.
$backtotop$Googling around I read a basic solution. It`s pretty simple, maybe too simple, but has been a good base to start. Thank You Angus. The testsuite API will clarify every aspect, and even those missing, at the moment. My goal is to reach at least 80% test coverage.
$backtotop$Why You need to know why?... really You do not see nowadays the value of doing that? If You dont then just keep kicking your can around.
$backtotop$