Add all directors and senior managers for the society. Any members on the board of directors are considered directors regardless
of the title given to the individual.
Add all general partners
Add all partners
Add all general partners as well as all limited partners holding at least 10% interest in the partnership
Shareholder Type {{element.position}} Partner Type {{element.position}} - {{element.partnerType}} Name {{element.name}} Email {{element.email}} Number of Non-voting Shares {{element.commonnonvotingshares}} Number of Voting Shares {{element.commonvotingshares}} Date Issued {{element.dateIssued | date:'yyyy-MM-dd' }} EditEdit Delete Delete


Brunette Bombshell Ana Cheri Leaves Little To The Imagination In Sparkly Lingerie
November 24, 2019
Brunette Bombshell Ana Cheri Leaves Little To The Imagination In Sparkly Lingerie
Model Ana Cheri has been in the city of love for the past few days, and on Sunday, she thrilled her 12.5 million followers with a sexy update in which she wore a skimpy pair of lingerie “Parisian style.”
The update consisted of two photos of the brunette bombshell standing in a hotel room in front of a window. She wore a mesh, nude-colored three-piece lingerie set that left little to the imagination. The sheer number featured a little bit of glitter, putting off a glam vibe.
The bra featured satin cups underneath the mesh cover, which was cinched between her breasts. The top called attention to her voluptuous chest.  The beauty paired the underwear with a matching garter belt. The outfit showed off Ana’s tight abs, curvy hips and toned thighs.
The first picture showed Ana from the front. She leaned on one elbow on the wall beside her as she gave the camera a sultry look. Playing with her hair with her other hand, she stood with one knee slightly bent — a pose that called attention to her curves.
The second snap showed the stunner from behind. She arched her back slightly, giving her followers a nice look at her pert derrière and most of Ana’s backside. The camera captured her as she smiled while looking down.
The model wore a full face of makeup that included dark brows, smoky eyeshadow and a red gloss on her lips. Her hair was pulled up into a high ponytail, and she wore a pale pink color on her nails. For accessories, she donned a gold necklace and bracelet.
In the post, Ana said that her time in Paris had been amazing.
Her fans thought she looked amazing in the lingerie, and told her so.
Loading...
“You are so beautiful and you have a perfect body,” one admirer gushed.
“You definitely are a vision of beauty,” wrote a second fan.
“Nice physique and a beautiful lady,” a third follower said.
There can be no denying that Ana has a body worthy of showing off. And the good news for her followers is that she doesn’t mind flashing a bit of skin. Most of her Instagram updates are tame, but she occasionally likes to share something a little risqué like the barely-there bunny outfit she wore for Halloween.


Nehemiah 13:27
Shall we then hearken unto you to do all this great evil, to transgress against our God in marrying strange wives?


What is Corona virus?
-
COVID-19 is the disease caused by the new coronavirus that emerged in China in December 2019.
- COVID-19 symptoms include cough, fever, shortness of breath, muscle aches, sore throat, unexplained loss
of
taste or smell, diarrhea and headache. COVID-19 can be severe, and some cases have caused death
- The new coronavirus can be spread from person to person. It is diagnosed with a laboratory test.
- There is no coronavirus vaccine yet. Prevention involves frequent hand-washing, coughing into the bend of
your elbow, staying home when you are sick and wearing a cloth face covering if you can't practice social
distancing.
How does the new coronavirus spread?
As of now, researchers know that the new coronavirus is spread through droplets released into
the air when an infected person coughs or sneezes. The droplets generally do not travel more than a few feet, and
they fall to the ground (or onto surfaces) in a few seconds — this is why social and physical distancing is
effective in preventing the spread.
How did this new coronavirus spread to humans?
COVID-19 appeared in Wuhan, a city in China, in December 2019. Although health officials are
still tracing the exact source of this new coronavirus, early hypotheses thought it may be linked to a seafood
market in Wuhan, China. Some people who visited the market developed viral pneumonia caused by the new
coronavirus. A study that came out on Jan. 25, 2020, notes that the individual with the first reported case became
ill on Dec. 1, 2019, and had no link to the seafood market. Investigations are ongoing as to how this virus
originated and spread.
What are symptoms of COVID-19?
COVID-19 symptoms include:
- Cough
- Fever
- Shortness of breath
- Muscle aches
- Sore throat
- Unexplained loss of taste or smell
- Diarrhea
- Headache
In rare cases, COVID-19 can lead to severe respiratory problems, kidney failure or death.
If you have a fever or any kind of respiratory difficulty such as coughing or shortness of breath, call your
doctor or a health care provider and explain your symptoms over the phone before going to the doctor’s office,
urgent care facility or emergency room.
If you have a medical emergency such as severe shortness of breath, call 911 and let them know about your
symptoms.
How is COVID-19 diagnosed?
Diagnosis may be difficult with only a physical exam because mild cases of COVID-19 may appear
similar to the flu or a bad cold. A laboratory test can confirm the diagnosis.
Learn
more about COVID-19 testing.
How is COVID-19 treated?
As of now, there is not a specific treatment for the virus. People who become sick from
COVID-19 should be treated with supportive measures: those that relieve symptoms. For severe cases, there may be
additional options for treatment, including research drugs and therapeutics.
How do you protect yourself from this Coronavirus?
It’s crucial to practice good hygiene, respiratory etiquette and social and physical
distancing.
Read
more about ways to protect yourself.
How medical students can stay safe from Coronavirus?
Medical students who are still interacting with patients and who might encounter those with
COVID-19 infections should keep safety guidelines in mind, experts say.
Rodney Rohde, a medical laboratory professional who specializes in virology and has an education-related Ph.D.,
says medical students should meticulously go through all the sanitation rules they are supposed to follow so that
they can rely on that knowledge during a crisis.
"In general, the best way for all of us to remain calm is to be prepared," Rohde, a former public health official
for the state of Texas, wrote in an email. "Understanding the institution's policies around infection prevention
and control is critical."
Medical students who are still interacting with patients and who might encounter those with COVID-19 infections
should keep safety guidelines in mind, experts say.
Rodney Rohde, a medical laboratory professional who specializes in virology and has an education-related Ph.D.,
says medical students should meticulously go through all the sanitation rules they are supposed to follow so that
they can rely on that knowledge during a crisis.
"In general, the best way for all of us to remain calm is to be prepared," Rohde, a former public health official
for the state of Texas, wrote in an email. "Understanding the institution's policies around infection prevention
and control is critical."
Medical students also need to safeguard their mental and spiritual health, Waggoner says, because it is hard to be
compassionate toward others without self-compassion. Meditation might be useful, she suggests, and med students
who are religious might find a sense of peace through prayer.


The charming adventures of an analyst and his solver.
Splitting large networks into fully connected subnetworks. Also, Las Vegas!
Note: A reader pointed out that Union-Find is a very efficient way to accomplish this task. So if you need to do something similar, start there!
Last week, Paul Rubin wrote an excellent post on Extracting a Connected Graph from an existing graph. Lately I've been performing related functions on data from OpenStreetMap, though without access to a solver. In my case I'm taking in arbitrary network data and splitting it into disconnected subnetworks. I thought it might be a good case study to show an algorithmic way doing this and some of the performance issues I ran into.
A small example can be seen below. This shows a road network around the Las Vegas strip. There is one main (weakly) connected network in black. The roads highlighted in red are disconnected from the main network. We want code that will split these into connected subnetworks.
Say we have data that looks like the following. Instead of nodes, the numbers in quotes represent edges. Think of these as streets.
{
"0": [1, 2, 3],
"1": [9248, 9249, 9250],
"2": [589, 9665, 9667],
"3": [0, 5, 6],
"4": [0, 5, 6],
"5": [588],
"6": [4, 8, 9],
...
}
Our basic strategy is the following:
#!/usr/bin/env python
import json
import sys
import time
class hset(set):
'''A hashable set. Note that it only hashes by the pointer, and not by the elements.'''
def __hash__(self):
return hash(id(self))
def __cmp__(self, other):
return cmp(id(self), id(other))
if __name__ == '__main__':
try:
inputfile = sys.argv[1]
except:
print 'usage: %s network.json' % sys.argv[0]
sys.exit()
print time.asctime(), 'parsing json input'
connections = json.load(open(inputfile))
edge_to_net = {} # Edge ID -> set([edges that are in the same network])
nets = set() # Set of known networks
print time.asctime(), 'detecting disconnected subgraphs'
for i, (from_edge, to_set) in enumerate(connections.iteritems()):
from_edge = int(from_edge)
try:
from_net = edge_to_net[from_edge]
except KeyError:
from_net = edge_to_net[from_edge] = hset([from_edge])
nets.add(from_net)
if not (i+1) % (25 * 1000):
print time.asctime(), '%d edges processed / %d current subnets' % (i+1, len(nets))
for to in to_set:
try:
to_net = edge_to_net[to]
# If we get here, merge the to_net into the from_net.
if to_net is not from_net:
to_net.update(from_net)
for e in from_net:
edge_to_net[e] = to_net
nets.remove(from_net)
from_net = to_net
except KeyError:
from_net.add(to)
edge_to_net[to] = from_net
print time.asctime(), len(nets), 'subnets found'
We run this against the network pictured above and it works reasonably quickly, finishing in about 7 seconds:
Mon Jul 29 12:22:38 2013 parsing json input Mon Jul 29 12:22:38 2013 detecting disconnected subgraphs Mon Jul 29 12:22:38 2013 25000 edges processed / 1970 current subnets Mon Jul 29 12:22:44 2013 50000 edges processed / 124 current subnets Mon Jul 29 12:22:45 2013 60 subnets found
However, when run against a road network for an entire city, the process continues for several hours. What is the issue?
The inefficiency occurs from lines 46 to 50. In this we are frequently removing references to every element in a large set. Instead, it would be better to remove as few references as possible. Therefore, instead of merging from_net into to_net, we will determine which network is the smaller of the two and marge that one into the larger one. Note that this does not necessarily change the worst case time complexity of the algorithm, but it should make the code fast enough to be useful. The new version appears below.
#!/usr/bin/env python
import json
import sys
import time
class hset(set):
'''A hashable set. Note that it only hashes by the pointer, and not by the elements.'''
def __hash__(self):
return hash(id(self))
def __cmp__(self, other):
return cmp(id(self), id(other))
if __name__ == '__main__':
try:
inputfile = sys.argv[1]
except:
print 'usage: %s network.json' % sys.argv[0]
sys.exit()
print time.asctime(), 'parsing json input'
connections = json.load(open(inputfile))
edge_to_net = {} # Edge ID -> set([edges that are in the same network])
nets = set() # Set of known networks
print time.asctime(), 'detecting disconnected subgraphs'
for i, (from_edge, to_set) in enumerate(connections.iteritems()):
from_edge = int(from_edge)
try:
from_net = edge_to_net[from_edge]
except KeyError:
from_net = edge_to_net[from_edge] = hset([from_edge])
nets.add(from_net)
if not (i+1) % (25 * 1000):
print time.asctime(), '%d edges processed / %d current subnets' % (i+1, len(nets))
for to in to_set:
try:
to_net = edge_to_net[to]
# If we get here, merge the to_net into the from_net.
if to_net is not from_net:
# Update references to and remove the smaller set for speed.
if len(to_net) < len(from_net):
smaller, larger = to_net, from_net
else:
smaller, larger = from_net, to_net
larger.update(smaller)
for e in smaller:
edge_to_net[e] = larger
nets.remove(smaller)
edge_to_net[to] = larger
from_net = larger
except KeyError:
from_net.add(to)
edge_to_net[to] = from_net
print time.asctime(), len(nets), 'subnets found'
Indeed, this is significantly faster. And on very large networks it runs in minutes instead of hours or days. On the small test case used for this post, it runs in under a second. While this could probably be done faster, that's actually good enough for right now.
Mon Jul 29 12:39:55 2013 parsing json input Mon Jul 29 12:39:55 2013 detecting disconnected subgraphs Mon Jul 29 12:39:55 2013 25000 edges processed / 1970 current subnets Mon Jul 29 12:39:55 2013 50000 edges processed / 124 current subnets Mon Jul 29 12:39:55 2013 60 subnets found


You need a premium account to export big documents. If you're signed as a regular user, exported documents are limited to 5KB content.
Alternatively, you can use the Print dialog to export as PDF.


- Guest Access Tokens
-
In order to facilitate sharing of private resources with non-members or members of federation nodes with limited identification discovery, Hubzilla should provide members with a mechanism to create and manage temporary ("throwaway") logins, aka "Zot Access Tokens". These tokens/credentials may be used to authenticate to a hubzilla site for the sole purpose of accessing privileged or access controlled resources (files, photos, posts, webpages, chatrooms, etc.).
- Create a token
-
The form to create/edit accepts three parameters, a human readable name, a password or access token, and an
optional expiration. Once expired, the access token is no longer valid, may no longer be used, and will be
automatically purged from the list of temporary accounts. The password field in the create/edit forms
displays the text of the access token and not an obscured password.
- Share a token
-
We do not specify mechanisms for sharing these tokens with others. Any communication method may be used. Any tokens you have created are added to the Access Control List selector and may be used anywhere that Access Control Lists are provided.
Example: A visitor arrives at your site. She has an access token you have provided, and attempts to visit one of your photo albums (which is restricted to be viewed only by yourself and one temporary identity). Permission is denied.
The visitor now selects "Login" from the menu navigation bar. This presents a login page. She enters the name and password you have provided her, and she can now view the restricted photo album.
Alternatively, you may share a link to a protected file by adding a parameter "&zat=abc123" to the URL, where the string "abc123" is the access token or password for the temporary login. No further negotiation is required, and the file is presented.


Coding Quiz Challenge
Try to answer the following questions correctly. These will include trivia about Javascript which can improve your overall knowledge in the subject.
Start!


We extend systems!
- synergize enterprise partnerships
- deploy vertical web services
- envisioneer transparent niches
- harness holistic channels
- leverage transparent portals
- incubate cutting-edge ROI
- redefine viral models
- cultivate killer e-services
- disintermediate one-to-one interfaces
- drive B2C e-markets
- incubate cutting-edge convergence
- enable proactive mindshare
- streamline plug-and-play deliverables
- syndicate turn-key schemas


class PacketFlow:
This class is used to describe UE traffic profile for the simulation.
| Method | __init__ |
Undocumented |
| Instance Variable | id |
Undocumented |
| Instance Variable | tMed |
Undocumented |
| Instance Variable | sMed |
Undocumented |
| Instance Variable | type |
Undocumented |
| Instance Variable | sliceName |
Undocumented |
| Instance Variable | pckArrivalRate |
Undocumented |
| Instance Variable | qosFlowId |
Undocumented |
| Instance Variable | packetSize |
Undocumented |
| Instance Variable | ue |
Undocumented |
| Instance Variable | sMax |
Undocumented |
| Instance Variable | tMax |
Undocumented |
| Instance Variable | tStart |
Undocumented |
| Instance Variable | appBuff |
Undocumented |
| Instance Variable | lostPackets |
Undocumented |
| Instance Variable | sentPackets |
Undocumented |
| Instance Variable | rcvdBytes |
Undocumented |
| Instance Variable | pId |
Undocumented |
| Instance Variable | header |
Undocumented |
| Instance Variable | meassuredKPI |
Undocumented |
| Method | setQosFId |
Undocumented |
| Method | queueAppPckt |
This method creates packets according to the packet flow traffic profile and stores them in the application buffer. |
| Method | getPsize |
Undocumented |
| Method | getParrRate |
Undocumented |
| Method | setMeassures |
This method calculates average PLR and throughput for the simulation. |


Need Any Help Schedule A Consultation
Available 24/7
At vero eos et accusamus etiusto odio dignissimos ducimus qui blanditiis praesentium.
Immediate Response
At vero eos et accusamus etiusto odio dignissimos ducimus qui blanditiis praesentium.
Free Case Review
At vero eos et accusamus etiusto odio dignissimos ducimus qui blanditiis praesentium.
About us
Set up since 2013 to support business with commitment to the quality and the excellence in providing products and services, software to support business, finance and accounting consultancy, HR Consultancy, Recruitment and Professional Training.
Our Mission
Provide timely, accurate and dependable solutions to our customers by anticipating and serving the customers needs with integrity, customer service and dedication.
Core Value
One stop solutions for customers to achieve their expectation and succeed together
Services
Consulting Services
Why Choose Us
We Are Awards Winning Company
KH Pro donec pulvinar magna id leoersi pellentesque impered dignis sim rhoncus euismod euismod eros vitae.
Client-Focused Solutions
At vero eos et accusamus etiusto odio dignissimos ducimus qui blanditiis praesentium.
Diversity & Inclusion
At vero eos et accusamus etiusto odio dignissimos ducimus qui blanditiis praesentium.
Women's Empowerment
At vero eos et accusamus etiusto odio dignissimos ducimus qui blanditiis praesentium.
Projects
Recent Case Studies
Capitalize on low hanging fruit to identify a ballpark value added activity to beta test. Override the digital divide with additional clickthroughs from DevOps. Nanotechnology immersion along the information highway.
Monty Moni
CEO, Keen IT SolutionCapitalize on low hanging fruit to identify a ballpark value added activity to beta test. Override the digital divide with additional clickthroughs from DevOps. Nanotechnology immersion along the information highway.
John Bhai
CEO, Brick ConsultingCapitalize on low hanging fruit to identify a ballpark value added activity to beta test. Override the digital divide with additional clickthroughs from DevOps. Nanotechnology immersion along the information highway.
Megan Scott
CEO, Keen IT SolutionCapitalize on low hanging fruit to identify a ballpark value added activity to beta test. Override the digital divide with additional clickthroughs from DevOps. Nanotechnology immersion along the information highway.
Wendy Gray
CEO, Keen IT SolutionCALL US 24/7
LATEST NEWS
Read Latest Updates
Strategy
Covid-19 threatens the next generation of smartphones
We denounce with righteous indige nation and dislike men who are so beguiled and demo realized by...
Management
Soundtrack filma Lady Exclusive Music
We denounce with righteous indige nation and dislike men who are so beguiled and demo realized by...
Consulting
Winged moved stars, fruit creature seed night.
We denounce with righteous indige nation and dislike men who are so beguiled and demo realized by...
Creative
Lights winged seasons fish abundantly evening.
We denounce with righteous indige nation and dislike men who are so beguiled and demo realized by...


| Amount | To Address | Completed | User |
|---|---|---|---|
| ${withdrawRequest.amount | rounded} LTC - (${withdrawRequest.amount | toCurrency:currentExchangeRate | usdFormat} USD) | ${withdrawRequest.to_address} | ${withdrawRequest.completed ? 'Completed' : 'Not Approved'} | ${withdrawRequest.user.name} |


WITNESS LIST
Criminal Jurisprudence Committee
March 25, 2014 - 10:30 AM
Interim Charge 1 Raising the age of juvenile jurisdiction
On:
Allen, Ray (Texas Probation Association)
Bittner, Marc (Self; 33rd and 424th Judicial District Juvenile Probation)
Carnegie, Jack (Self)
Cohen, Derek (Texas Public Policy Foundation)
Crawford, Cathryn (Self)
Dakroub, Brandon (Williamson County Attorney's Office)
Deitch, Michele (Self)
Edmonds, Shannon (Texas District and County Attorneys Assn)
Fain, Rosemary (Self)
Frost, Lynda (Hogg Foundation for Mental Health)
Griffiths, Mike (Texas Juvenile Justice Department)
Henneke, Elizabeth (Texas criminal justice coalition)
Hobbs, Dee (Williamson County Attorney's Office)
Johnson, Kameron (Self)
Kirk, Christopher (Self; Sheriffs Association of Texas)
Knight, Shelley (Dallas Sheriff's Department)
Marrus, Ellen (Self; University of Houston Center for Children, law & policy and th southwet
juenile denr ntr)
Meurer, Jeanne (Self; Travis county juvenile probation)
Molina, Laurie (Legislative Budget Board)
Parker, Laura (Self; 386th District Court)
Potts, Jeremy (Self)
Potts, Ronald (Self)
Rose, Lauren (Texans Care For Children)
Shaw, Riley (Self; Tarrant County District Attorney's Office)
Skurka, Mark (Nueces county district attorneys office)
Slayton, David (Office of Court Administration; Texas Judicial Council)
Turner, Randy (Tarrant County Juvenile Services and Texas Probation Association)
Valdez, Lupe (Texas sheriffs)
Vargas, Karla (Texas Appleseed)
Wang, Jason (Self)
Wood, Brandon (Texas Commission on Jail Standards)
Wood, Christene (Self; Moon v. Texas appellate team)
Registering, but not testifying:
For:
Moore, Adrian (Self; Council on At Risk Youth)
On:
Collier, Bryan (Texas Department of Criminal Justice)
McCraw, Steve (Texas Department of Public Safety)
Owens, Rissie (BOard of pardons and paroles)
1
WITNESS LIST
On:
Shier, Bill (Self)
Sprague, Shannon (Self)
Thomas, Nydia (Texas Juvenile Justice Department)
2


Structural basis for defects of Keap1 activity provoked by its point mutations in lung cancer.
Nrf2 regulates the cellular oxidative stress response, whereas Keap1 represses Nrf2 through its molecular interaction. To elucidate the molecular mechanism of the Keap1 and Nrf2 interaction, we resolved the six-bladed beta propeller crystal structure of the Kelch/DGR and CTR domains of mouse Keap1 and revealed that extensive inter- and intrablade hydrogen bonds maintain the structural integrity and proper association of Keap1 with Nrf2. A peptide containing the ETGE motif of Nrf2 binds the beta propeller of Keap1 at the entrance of the central cavity on the bottom side via electrostatic interactions with conserved arginine residues. We found a somatic mutation and a gene variation in human lung cancer cells that change glycine to cysteine in the DGR domain, introducing local conformational changes that reduce Keap1's affinity for Nrf2. These results provide a structural basis for the loss of Keap1 function and gain of Nrf2 function.


Trap 4 Traps all segments with any point in the field.
Move the cursor to one corner of the proposed field.
Press 4 to start a field trap.
Rubber banding is enabled
Move the cursor to the diagonal corner of the field.
Create a rectangle which defines the trap field.
Press 4 again to execute the trap.
All segments within or passing thru the field are added to the buffer.
Note that only rectangular fields can be created.
Entering 2 points on the same axis creates a line and traps all segments which pass through the line.
When Trap 0 - Remove has been selected, this operation removes the target segment from the buffer.


options.prototype
Methods and properties that should be available on the element instance. This behaves just like any prototype object does. All methods and properties are added to the element's prototype (native), or to the element instance during the created lifecycle (polyfill).
It's recommended you use the properties
option for properties you're exposing through your public API, but nothing is stopping you from putting them here if you don't need the special behaviour of properties
.


About
I am a Machine Learning Engineer with two years of experience, currently studing at The University of Ottawa, Specializing in Applied Artificial Intelligence. I enjoy applying Machine Learning to real-world tasks - model research as well as building inference pipelines for model deployment. I am proficient in TensorFlow and PyTorch, as well as the web frameworks Django and Flask for model serving. I have worked with a variety of Machine Learning applications, including Generative Networks, OCR, Semantic Similarity, Object Detection and Optical Character Recognition.
Education
MEng, Electrical and Computer Engineering (Concentration in Applied Artificial Intelligence)
University of Ottawa
B.E., Electronics and Telecommunication Engineering
Pune Institute of Computer Technology
Higher Secondary Education
Fergusson College
Secondary Education
The Bishop's School, Pune
Experience
- Working on the research and development of various Machine Learning algorithms used for semantic similarity, clustering, OCR and various other tasks.
- Conducting research to build custom Machine Learning models as well as evaluating pre-trained models to perform tasks associated with note taking.
- Assisting in backend system design and data platform design for deployment of these models.
- Also involved in operationalization and deployment of the researched algorithms ie. creating pipelines for training and inference of models.
- Contributed to the development of various Machine Learning solutions to help automate end user issues.
- Involved in research, scoping, benchmarking, operationalization and deployment of different NLP algorithms.
- Worked on developing Machine Learning pipelines to handle training, updation and deletion of Machine Learning models, and also inference pipelines for these models.
- Investigated and solved high priority bugs and helped improve underperforming models for clients.
- Contributed to the development of CRAL, a library used for abstraction of well known deep learning architectures for Computer Vision.
- Worked on the addition of well known deep learning architectures for computer vision into the library.
- Intensively involved in implementation, integration and testing of object detection models.
- Achieved mAP scores of more than 0.6 on standard benchmark datasets for all the integrated object detection models.
Publications
DPSRGAN: Dilation Patch Super-Resolution Generative Adversarial Networks
- Developed a novel Generative Adversarial Network architecture to increase the resolution of images.
- The input to the network is a low resolution image, which is upscaled natively by the network.
- The model is capable of upscaling input image by 4x the original resolution.
- The metrics obtained from our DPSRGAN are better than the previously proposed SRGAN, with a MOS of 3.91 out of 5 and a PSNR of 32.24.
Big Data Analytics for Sustainable Cities: Pune Tree Census Data Exploratory Analysis
- Developed a pipeline for analysis of tree census data using data of Pune, India.
- Introduced a novel metric, the Flora Biodiversity Index (FBI), to quantify the diversity of trees in a region.
- Drew insights from the data to determine uniformity of tree cover, areas deficient in trees and areas having a lower biodiversity.
- Our pipeline will be useful for cities to analyse their current green cover and work on making it better.
Projects
An application that can read license plates of vehicles and register offences.
A Machine Learning approach towards network threat detection.
An autonomous drone for survey and rescue.
- Tools: ROS, OpenCV
- A drone capable of detecting beacons and autonomously maneuvering itself in response.
- Part of the e-Yantra Robotics Competition (eYRC) held by IIT Bombay.


class DiceCoefficient : TextMetric
Allows to measure the similarity of texts according to the Dice coefficient. The dice coefficient measures the percentage of n-grams, which occur in both texts. It always evaluates to a heuristic value within the interval 0,1. Texts that reach a greater heuristic value are considered to be more similar than texts that reach a smaller heuristic value. The dice coefficient can also be applied to texts with different lengths.
DiceCoefficient(minLength: Int = 1, maxLength: Int = Int.MAX_VALUE)
Allows to measure the similarity of texts according to the Dice coefficient. The dice coefficient measures the percentage of n-grams, which occur in both texts. It always evaluates to a heuristic value within the interval 0,1. Texts that reach a greater heuristic value are considered to be more similar than texts that reach a smaller heuristic value. The dice coefficient can also be applied to texts with different lengths. |
val isGainMetric: Boolean
True, if the metric is a gain metric, i.e. that two strings that evaluate to a greater heuristic value are considered to be more similar than two strings that evaluate to a smaller heuristic value, false otherwise. |
|
val maxLength: Int
The maximum length of the n-grams that are taken into account by the metric |
|
val maxValue: Double
The maximum heuristic value, which is possibly calculated by the metric. |
|
val minLength: Int
The minimum length of the n-grams that are taken into account by the metric |
|
val minValue: Double
The minimum heuristic value, which is possibly calculated by the metric. |
open val isLossMetric: Boolean
True, if the metric is a loss metric, i.e. that two strings that evaluate to a smaller heuristic value are considered to be more similar than two strings that evaluate to a greater heuristic value, false otherwise. |
fun evaluate(text1: CharSequence, text2: CharSequence): Double
Calculates the heuristic value of two texts, text1 and text2, according to the metric. |


{% extends "layout.html" %} {% block page_title %} Do you need help to pay your rent or mortgage? {% endblock %} {% block content %} Back Do you need help to pay your rent or mortgage? Do you need help to pay your rent or mortgage? Yes, I have arrears Yes, I struggle to make the payments No {% endblock %}


Sam Ward: Great Britain and England hockey player fighting for career after eye injury
Sam Ward, 28, denied reports he has retired after being left with 'a very small amount of sight in his left eye'
Great Britain hockey player Sam Ward says he will do "everything" to reach the 2020 Olympics after losing the sight in his left eye following a ball to the head.
Ward, 28, has been told damage to the retina is partly irreversible after he was struck in the face during the Olympic qualifying play-off win against Malaysia on November 3.
He scored twice in the match to help book Great Britain's place at next year's Games in Tokyo.
Ward underwent surgery on November 13 to reconstruct his cheek after suffering facial fractures but it will be a number of months before the extent of the injury will be fully known, Great Britain Hockey said.
"I may get some sight back, but this won't be a quick process, and whether it will be sufficient for me to get back to playing international hockey only time will tell," Ward said, contrary to reports he had already decided to retire.
"It is a tough pill to swallow but, as people know, I am not one to give up easily and I will do everything can to make myself available for selection for Tokyo."
Great Britain and England Hockey's Performance Director, Ed Barney, said: "At present, our focus is on supporting Sam to the best possible extent and ensuring that he has access to the best medical provision and wider support.
"The players and staff wish Sam well during this challenging period."
Ward represented Great Britain at the Rio 2016 Olympics and helped England to European and Commonwealth Games bronze in 2017 and 2018 respectively.


FileDrop Test Sheet
This page tests FileDrop global utility methods. If this page backgruond is green then everything went fine for you.
Tested browsers that pass:
-
Internet Explorer:
XP SP3: 6
Win7 SP1: 8, 9, 10, 11
-
Internet Explorer x64:
XP SP2 x64: 6, 7
-
Firefox:
XP SP3: 26.0
-
Firefox x64:
XP SP2 x64: 23.0a1
-
Chrome:
XP SP2 x64: 29.0
-
Opera:
XP SP2 x64: 12.16
-
Safari:
XP SP3: 5.1.7
Win7 SP1: 5.1.7
Success.


Fastlane: deploy ios and android like a boss
Sorry, we can’t deploy, john is on vacation
Your team shouldn’t rely on only one person to release your mobile apps.
Once again, I gave a presentation at the SagLacIO. This time, it was about Fastlane. Here are a few links to get you started.
Getting started
Install ruby and start having fun:
Then follow instructions. If your app has both ios and android (ex; cordova, ionic, react native, hybrid project), I recommend starting with ios. You can add android support later by following the android documentation.
Useful Links
- Official website: fastlane.tools
- Github: github.com/fastlane/fastlane
- Getting started: fabric.io/features
- Example public repos using fastlane: github.com/fastlane/examples
- Documentation: docs.fastlane.tools
- Plugins: docs.fastlane.tools/plugins/available-plugins
- The guy behind Fastlane: Felix Krause (krausefx)
How to solve the “only one person can release an ios app”
You may share the certs by your own or Follow codesigning.guide and let fastlane match
handle everything for you!
Here goes the slides
I gave a quick explanation of what problems fastlane solves and I went trough a complete example of doing the fastlane init
and fastlane ios beta
to send an app on itunes connect!
If you have suggestions, feel free to poke me or open an issue.


Decentralized Applications (DApps)
In this chapter we will explore the world of Decentralized Applications or DApps. From the early days of Ethereum, the founders' vision was much broader than "smart contracts": no less than reinventing the web and creating a new world of DApps, aptly called web3. Smart contracts are a way to decentralize the controlling logic and payment functions of applications. Web3 DApps are about decentralizing all other aspects of an application: storage, messaging, naming etc (see Web3: A decentralized web using smart contracts and P2P Technologies).
While "decentralized apps" are an audacious vision of the future, the term "DApp" is often applied to any smart contract with a web front end. Some of these so-called DApps are highly centralized applications (CApps?). Beware of false DApps!
In this section we will develop and deploy a DApp: an auction platform. You can find the source code in the book’s repository under code/auction_dapp. We will look at each apsect of an auction application and see how we can decentralize the application as much as possible.
What is a DApp?
A Decentralized Application, or DApp, is an application which is mostly or entirely decentralized.
Consider all the possible aspects of an application that may be decentralized:
-
Front-end software
-
Back-end software (application logic)
-
Data storage
-
Name resolution
-
Message communications
Each of these can be somewhat centralized or somewhat decentralized. For example, a front-end can be developed as a web app that runs on a centralized server, or as a mobile app that runs on your device. The back-end and storage can be on private servers and proprietary databases, or a smart contract and P2P storage.
There are many advantages to creating a DApp that a typical centralized architecture can not provide:
1) Resiliency: by having the business-logic controlled by a smart contract, a DApp back-end will be fully distributed and managed on a blockchain platform. Unlike deploying an application on a centralized server, a DApp will have no downtime and will continue to be available as long as the platform is still operating.
2) Transparency: the on-chain nature of a DApp allows everyone to inspect the code and be more sure about its function. Any interaction with the DApp will be stored forever in the blockchain.
3) Censorship Resistance: as long as a user has access to an Ethereum node (running one if necessary), the user will always be able to interact with a DApp without interference from any centralized control. No service provider, or even the owner of the smart contract, can alter the code once it is deployed on the network.
In the Ethereum ecosystem as it stands today, there are very few truly decentralized apps - most still rely on centralized services and servers for some part of their operation. In the future, we expect that it will be possible for every part of any DApp to be operated in a fully decentralized way.
Smart contracts "back end"
In a DApp, smart contracts are used to store the business logic (program code) and the related state of your application. You can think of a smart contract replacing a server-side (a.k.a. "back-end") component in a regular application. This is an oversimplification, of course. One of the main differences is that any computation executed in a smart contract is very expensive and so should be kept as minimal as possible. It is therefore important to identify which aspects of the application need a trusted and decentralized execution platform.
Ethereum smart contracts allow you to build architectures in which a network of smart contracts call and pass data between each other, reading and writing their own state variables as they go, their complexity restricted only by the block gas limit. After deploying your smart contract, your business logic could well be used by many other developers in the future.
One major consideration of smart contract architecture design is the inability to change the code of a smart contract once it is deployed. It can be deleted if it is programmed with an accessible SELFDESTRUCT opcode, but other than complete removal, the code cannot be changed in any way.
The second major consideration of smart contract architecture design is DApp size; a really large monolithic smart contract may cost a lot of gas to deploy and use. Therefore, some applications may choose to have off-chain computation and an external data source. Keep in mind, however, that having the core business logic of the DApp be dependent on external data (e.g. from a centralized server) means your users will have to trust these external resources.
Front end (Web User Interface)
Unlike the business logic of the DApp, which requires a developer to understand the EVM and new languages such as Solidity, the client side interface of a DApp can use standard web technologies (HTML, CSS, JavaScript, etc). This allows a traditional web developer to use familiar tools, libraries and frameworks. Interactions with Ethereum, such as signing messages, sending transactions and key management are often conducted through the web browser, via an extension such as MetaMask.
Although it is possible to create a mobile DApp as well, currently there are few resources to help create mobile DApp front-ends, mainly due to the lack of mobile clients that can serve as a light client with key management functionality.
The front-end is usually linked to Ethereum via the web3.js JavaScript library, which is bundled with the front-end resources and served to a browser by a web server.
Data storage
Due to high gas costs and the currently low block gas limit, smart contracts are not suited to store or process large amounts of data. Hence, most DApps will utilize off-chain data storage services, meaning they store the bulky data off the Ethereum chain, on a data storage platform. That data storage platform can be centralized, for example a typical cloud database. Or, the data can be decentralized, stored on a P2P platform such as the Interplanetary File System (IPFS), or Ethereum’s own Swarm platform.
Decentralized P2P storage is ideal for storing and distributing large static assets such as images, videos, and the resources of the application’s front-end web interface (HTML, CSS, JavaScript, etc).
Inter-Planetary File System (IPFS)
The Inter-Planetary File System (IPFS) is a decentralized content-addressable storage system that distributes stored objects among peers in a P2P network. "Content Addressable" means that each piece of content (file) is hashed and the hash is used to identify that file. You can then retrieve any file from any IPFS node, by requesting it by its hash.
IPFS aims to replace HTTP as the protocol of choice for delivery of web applications. Instead of storing a web application on a single server, the files are stored on IPFS and can be retrieved from any IPFS node.
More information about IPFS can be found at https://ipfs.io
Swarm
Swarm is another content-addressable P2P storage system, similar to IPFS. Swarm is built by the Ethereum Foundation, as part of the Go-Ethereum suite of tools. Like IPFS, Swarm allows you to store files that get disseminated and replicated by Swarm nodes. You can access any Swarm file by referring to it by a hash. Swarm allows you to access a web site from a decentralized P2P system, instead of a central web server.
The home page for Swarm is itself stored on Swarm and accessible on your Swarm node or a gateway: https://swarm-gateways.net/bzz:/theswarm.eth/
Decentralized message communications protocols
Another major component of any application is inter-process communication. That means being able to exchange messages between applications, between different instances of the application, or between users of the application. Traditionally, this is achieved by reliance on a centralized server.
There are a variety of decentralized alternatives to a server-based protocols, offering messaging over a P2P network. The most notable P2P messaging protocol for DApps is Whisper, which is part of the Ethereum Foundation’s Go-Ethereum suite of tools. More information about Whisper can be found here: https://github.com/ethereum/wiki/wiki/Whisper
A basic DApp example: Auction DApp
In this section we will start building an example DApp, to explore the various decentralization tools. Our DApp will implement a decentralized auction.
The Auction DApp allows a user to register a "deed" token, which represents some unique asset, such as a house, a car, a trademark, etc. Once a token has been registered, the ownership of the token is transferred to the Auction DApp, allowing it to be listed for sale. The Auction DApp lists each of the registered tokens, allowing other users to place bids. During the auction, users can join a chat room, created specifically for each auction. Once an auction is finalized, the deed token ownership is transferred to the winner of the auction.
The overall auction process can be seen in Auction DApp: A simple example auction DApp:
The main components of our Auction DApp are:
-
A smart contract implementing ERC721 non-fungible "deed" tokens (DeedRepository).
-
A smart contract implementing an Auction (AuctionRepository) to sell the deeds.
-
A web front-end using the Vue/Vuetify JavaScript framework.
-
The web3.js library to connect to Ethereum chains (via MetaMask or other clients).
-
A Swarm client, to store resources such as images.
-
A Whisper client, to create per-auction chat rooms for all participants.
You can find the source code for the auction DApp in the book’s repository: https://github.com/ethereumbook/ethereumbook/tree/develop/code/auction_dapp
Auction DApp: Back-end smart Contracts
Our Auction DApp example is supported by two smart contracts that we need to deploy on an Ethereum blockchain in order to support the application: AuctionRepository and DeedRepository.
Let’s start by looking at DeedRepository, shown in DeedRepository.sol : An ERC721 deed token for use in an auction. This contract is an ERC-721 compatible "non-fungible token" (See [erc721]).
pragma solidity ^0.4.17;
import "./ERC721/ERC721Token.sol";
/**
* @title Repository of ERC721 Deeds
* This contract contains the list of deeds registered by users.
* This is a demo to show how tokens(deeds) can be mint and add to the repository
*/
contract DeedRepository is ERC721Token {
/**
* @dev Created a DeedRepository with a name and symbol
* @param _name string represents the name of the repository
* @param _symbol string represents the symbol of the repositor
*/
function DeedRepository(string _name, string _symbol) public ERC721Token(_name, _symbol) {}
/**
* @dev Public function to register a new deed
* @dev Call the ERC721Token Minter
* @param _tokenId uint256 represents a specific deed
* @param _uri string containing metadata/uri
*/
function registerDeed(uint256 _tokenId, string _uri) public {
_mint(msg.sender, _tokenId);
addDeedMetadata(_tokenId, _uri);
emit DeedRegistered(msg.sender, _tokenId);
}
/**
* @dev Public function to add metadata to a deed
* @param _tokenId represents a specific deed
* @param _uri text which describes the characteristics of a given deed
* @return whether the deed metadata was added to the repository
*/
function addDeedMetadata(uint256 _tokenId, string _uri) public returns(bool){
_setTokenURI(_tokenId, _uri);
return true;
}
/**
* @dev Event is triggered if deed/token is registered
* @param _by address of the registrar
* @param _tokenId uint256 represents a specific deed
*/
event DeedRegistered(address _by, uint256 _tokenId);
}
As you can see, the DeedRepository contract is a straightforward implementation of an ERC721-compatible token.
Our Auction DApp uses the DeedRepository contract to issue and track tokens for each auction. The auction itself is orchestrated by the AuctionRepository contract, which can be found here:
The AuctionRepository contract is too long to include here in full, but AuctionRepository.sol : The main Auction DApp smart contract is the main definition of the contract and data structures:
contract AuctionRepository {
// Array with all auctions
Auction[] public auctions;
// Mapping from auction index to user bids
mapping(uint256 => Bid[]) public auctionBids;
// Mapping from owner to a list of owned auctions
mapping(address => uint[]) public auctionOwner;
// Bid struct to hold bidder and amount
struct Bid {
address from;
uint256 amount;
}
// Auction struct which holds all the required info
struct Auction {
string name;
uint256 blockDeadline;
uint256 startPrice;
string metadata;
uint256 deedId;
address deedRepositoryAddress;
address owner;
bool active;
bool finalized;
}
The AuctionRepository contract manages all auctions with the following functions:
getCount() getBidsCount(uint _auctionId) getAuctionsOf(address _owner) getCurrentBid(uint _auctionId) getAuctionsCountOfOwner(address _owner) getAuctionById(uint _auctionId) createAuction(address _deedRepositoryAddress, uint256 _deedId, string _auctionTitle, string _metadata, uint256 _startPrice, uint _blockDeadline) approveAndTransfer(address _from, address _to, address _deedRepositoryAddress, uint256 _deedId) cancelAuction(uint _auctionId) finalizeAuction(uint _auctionId) bidOnAuction(uint _auctionId)
We can deploy these contracts to the Ethereum blockchain of our choice (e.g. Ropsten), using truffle in the book’s repository:
cd code/auction_dapp/backend truffle init truffle compile truffle migrate --network ropsten
DApp governance
If you read through the two smart contracts of the Auction DApp you will notice something important:
There is no special account or role that has special privileges over the DApp. Each auction has an owner with some special capabilities, but the Auction DApp itself has no privileged user.
This is a deliberate choice to decentralize the governance of the DApp and relinquish any control once it has been deployed. Some DApps, by comparison, have one or more privileged accounts, with special capabilities, such as the ability to terminate the DApp contract, to override or change its configuration, or to "veto" certain operations. Usually, these governance functions are introduced in the DApp in order to avoid unknown problems that might arise due to a bug.
The issue of governance is a particularly difficult one to solve. It represents a double-edged sword: On one side, privileged accounts are dangerous - if compromised they can subvert the security of the DApp. On the other side, without any privileged account, there are no recovery options if a bug is found. We have seen both of these risks manifest in Ethereum DApps. In the case of The DAO, there were some privileged accounts called the "curators", but they were very limited in their capabilities. Those accounts were not able to override the DAO attacker’s withdrawal of the funds. In a more recent case, the decentralized exchange Bancor experienced a massive theft because a privileged management account was compromised. Turns out, Bancor was not as decentralized as initially assumed.
When building a DApp, you have to decide if you want to make the smart contracts truly independent, launching them and then having no control, or creating privileged accounts and running the risk of those being compromised. Either choice carries risk, but in the long run, true DApps cannot have specialized access for privileged accounts - that’s not decentralized.
Auction DApp: Front-end user interface
Once the Auction DApp contracts are deployed, you can interact with them using your favorite JavaScript console and web3.js, or another web3 library. However, most users will need an easy-to-use interface. Our Auction DApp user interface is built using the as Vue.js JavaScript framework and Vuetify library of UI components.
You can find the user interface code in the code/auction_dapp/frontend folder in the book’s repository. The directory has the following structure and contents:
frontend/ |-- build | |-- build.js | |-- check-versions.js | |-- logo.png | |-- utils.js | |-- vue-loader.conf.js | |-- webpack.base.conf.js | |-- webpack.dev.conf.js | `-- webpack.prod.conf.js |-- config | |-- dev.env.js | |-- index.js | `-- prod.env.js |-- index.html |-- package.json |-- package-lock.json |-- README.md |-- src | |-- App.vue | |-- components | | |-- Auction.vue | | `-- Home.vue | |-- config.js | |-- contracts | | |-- AuctionRepository.json | | `-- DeedRepository.json | |-- main.js | |-- models | | |-- AuctionRepository.js | | |-- ChatRoom.js | | `-- DeedRepository.js | `-- router | `-- index.js
Once you have deployed the contracts, edit the front-end configuration in frontend/src/config.js and enter the address of the DeedRepository and AuctionRepository contracts, as deployed. The front-end application also needs access to an Ethereum node offering a JSON-RPC and websockets interface. Once you’ve configured the front-end, launch it with a web server on your local machine:
npm install npm run dev
The Auction DApp front-end will launch and will be accessible via any web browser at:
If all goes well, you should see Auction DApp User interface which illustrates the Auction DApp running in your web browser:
Further Decentralizing the Auction DApp
Our DApp is already quite decentralized, but we can improve things.
The AuctionRepository contract operates independently of any oversight, open to anyone. Once deployed it cannot be stopped, nor can any auction be censored. Each auction has a separate chat room that allows anyone to communicate about the auction without censorship or identification. The various auction assets, such as the description and associated image, are stored on Swarm, making them hard to censor or block.
Anyone can interact with the DApp by constructing transactions manually or by running the Vue frontend on their local machine. The DApp code itself is open source and developed collaboratively on a public repository.
But we can do more to make this DApp decentralized and resilient:
-
Store all the application code on Swarm or IPFS
-
Access the DApp by reference to a name, using the Ethereum Name Service
In the next sections we will further decentralize the Auction DApp.
Storing the Auction DApp on Swarm
We introduced Swarm in [swarm], earlier in this chapter. Our Auction DApp already uses Swarm to store the icon image for each auction. This is a much more efficient solution than attempting to store data on Ethereum, which is expensive. It is also a lot more resilient than if these images were stored on a centralized service like a web server or file server.
But we can take things one step further. We can store the entire front-end of the DApp itself in Swarm and run it from a Swarm node directly, instead of running a web server.
Preparing Swarm
To get started, we need to install Swarm and initialize our Swarm node. Swarm is part of the Ethereum Foundation’s Go-Ethereum suite of tools. Refer to the instructions for installing go-ethereum in [go_ethereum_geth], or to install a Swarm binary release, follow these instructions:
Once you have installed Swarm, you can check that it is working correctly by running it with the version command:
$ swarm version Version: 0.3 Git Commit: 37685930d953bcbe023f9bc65b135a8d8b8f1488 Go Version: go1.10.1 OS: linux
To start running Swarm, you must tell it how to connect to an instance of Geth, to access the JSON-RPC API. Get it started by following the instructions here:
When you start swarm, you should see something like this:
Maximum peer count ETH=25 LES=0 total=25 Starting peer-to-peer node instance=swarm/v0.3.1-225171a4/linux-amd64/go1.10 connecting to ENS API url=http://<IP_ADDRESS>:8545 swarm[5955]: [189B blob data] Starting P2P networking UDP listener up self=enode://f50c8e19ff841bcd5ce7d2d... Updated bzz local addr oaddr=9c40be8b83e648d50f40ad3d35f... uaddr=e Starting Swarm service 9c40be8b hive starting detected an existing store. trying to load peers hive 9c40be8b: peers loaded Swarm network started on bzz address: 9c40be8b83e648d50f40ad3d35f... Pss started Streamer started IPC endpoint opened url=/home/ubuntu/.ethereum/bzzd.ipc RLPx listener up self=enode://f50c8e19ff841bcd5ce7d2d...
You can confirm that your Swarm node is running correctly by connecting to the local Swarm gateway web interface: http://localhost:8500
You should see a Swarm gateway on localhost and be able to query any Swarm hash or ENS name:
Uploading files to Swarm
Once you have your local Swarm node and gateway running, you can upload to Swarm and the files will be accessible on any Swarm node, simply by reference to the file hash.
Let’s test this by uploading a file!
$ swarm up code/auction_dapp/README.md ec13042c83ffc2fb5cb0aa8c53f770d36c9b3b35d0468a0c0a77c97016bb8d7c
Swarm has uploaded the README.md file, and returned a hash. We can now use this hash to access the README.md from any Swarm node. For example, we could use the public Swarm gateway:
While uploading one file is relatively straightforward, it is a bit more complex to upload an entire DApp front-end. That’s because the various DApp resources (HTML, CSS, JavaScript, libraries etc.) have embedded references to each other. Normally, a web server translates URLs to local files and serves the correct resources. We can achieve the same for Swarm by packaging our DApp.
In the Auction DApp, there’s a script for packaging all the resources:
$ cd code/auction_dapp/frontend $ npm run build ><EMAIL_ADDRESS>build /home/aantonop/Dev/ethereumbook/code/auction_dapp/frontend > node build/build.js Hash: 9ee134d8db3c44dd574d Version: webpack 3.10.0 Time: 25665ms Asset Size Chunks Chunk Names static/js/vendor.77913f316aaf102cec11.js 1.25 MB 0 [emitted] [big] vendor static/js/app.5396ead17892922422d4.js 502 kB 1 [emitted] [big] app static/js/manifest.87447dd4f5e60a5f9652.js 1.54 kB 2 [emitted] manifest static/css/app.0e50d6a1d2b1ed4daa03d306ced779cc.css 1.13 kB 1 [emitted] app static/css/app.0e50d6a1d2b1ed4daa03d306ced779cc.css.map 2.54 kB [emitted] static/js/vendor.77913f316aaf102cec11.js.map 4.74 MB 0 [emitted] vendor static/js/app.5396ead17892922422d4.js.map 893 kB 1 [emitted] app static/js/manifest.87447dd4f5e60a5f9652.js.map 7.86 kB 2 [emitted] manifest index.html 1.15 kB [emitted] Build complete.
The result of this command will be a new directory code/auction_dapp/frontend/dist that contains the entire Auction DApp frontend, packed together:
dist/ |-- index.html `-- static |-- css | |-- app.0e50d6a1d2b1ed4daa03d306ced779cc.css | `-- app.0e50d6a1d2b1ed4daa03d306ced779cc.css.map `-- js |-- app.5396ead17892922422d4.js |-- app.5396ead17892922422d4.js.map |-- manifest.87447dd4f5e60a5f9652.js |-- manifest.87447dd4f5e60a5f9652.js.map |-- vendor.77913f316aaf102cec11.js `-- vendor.77913f316aaf102cec11.js.map
Now we can upload the entire DApp to Swarm, by using the up command and the recursive option. We will also tell Swarm that index.html is the defaultpath for loading this DApp:
swarm --bzzapi http://localhost:8500 --recursive --defaultpath dist/index.html up dist/ ab164cf37dc10647e43a233486cdeffa8334b026e32a480dd9cbd020c12d4581
Now, our entire Auction DApp is hosted on Swarm and accessible by the Swarm URL:
bzz://ab164cf37dc10647e43a233486cdeffa8334b026e32a480dd9cbd020c12d4581
We’ve made some progress in decentralizing our DApp, but we’ve made it harder to use. A URL like that is much harder to use than a web server with a nice name like auction_dapp.com. Are we forced to sacrifice usability in order to gain decentralization? Not necessarily. In the next section we will examine the Ethereum Naming System (ENS), which allows us to use easy-to-read names but still preserves the decentralized nature of our application.
Ethereum Naming System (ENS)
You can design the best smart contract in the world, but if you don’t provide a good interface for users, they won’t be able to access it.
On the traditional internet, the Domain Name system (DNS), allows us to use human-readable names in the browser, while resolving those names to IP addresses or other identifiers behind the scenes. On the Ethereum blockchain, the Ethereum Naming System (ENS) solves the same problem, but in a decentralized manner.
For example, the Ethereum Foundation donation address is 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359; in a wallet that supports ENS, it’s simply ethereum.eth.
ENS is more than a smart contract. ENS is a fundamental DApp itself, offering a decentralized name service. Furthermore, ENS is supported by a number of DApps for registration, management, and auctions of registered names. ENS demonstrates how DApps can work together: A DApp built to serve other DApps, supported by an ecosystem of DApps, embedded in other DApps, etc.
In this section we will look at how ENS works, how we can set up our own name and link it to a wallet or Ethereum address, how we can embed ENS in another DApp and how we can use ENS to name our DApp resources to make them easier to use.
History of Ethereum name services
Name registration was the first non-currency application of blockchains, pioneered by Namecoin. The Ethereum whitepaper gave a two-line Namecoin-like registration system as one of its example applications.
Early releases of Geth and the C++ Ethereum client had a built-in namereg contract (not used any more), and many proposals and ERCs for name services were made, but it was only when Nick Johnson started working for Ethereum Foundation in 2016 and took the project under his wing that serious work on a registrar started.
ENS was launched on Star Wars day, May 4, 2017 (after a failed attempt to launch it on Pi Day, March 15).
The ENS specification
ENS is specified mainly in three Ethereum Improvement Proposals (EIPs), namely ERC137, which specifies the basic functions of ENS, ERC162, which describes the auction system for the .eth root, and ERC181, which specifies reverse registration of addresses.
ENS follows a "sandwich" design philosophy: a very simple layer on the bottom, followed by layers of more complex but replaceable code, with a very simple top layer that keeps all the funds in separate accounts.
Bottom layer: Name Owners and resolvers
The ENS operates on "nodes" instead of human-readable names: a human-readable name is converted to a node using the "Namehash" algorithm.
The base layer of the ENS is a cleverly simple contract (less than 50 lines of code) defined by ERC137 that allows only nodes' owners to set information about their names and to create subnodes (the ENS equivalent of DNS subdomains).
The only functions on the base layer are those that enable a node owner to set information about their own node (specifically the resolver, time to live or transferring the ownership) and to create owners of new subnodes.
Namehash algorithm
Namehash is a recursive algorithm that can convert any name into a hash that identifies the name.
"Recursive" means that we solve the problem by solving a sub-problem that is a smaller problem of the same type, and then use the solution to the sub-problem to solve the original problem.
Namehash recursively hashes components of the name, producing a unique, fixed-length string for any valid input domain, or "node".
For example, the Namehash node of subdomain.example.eth is: keccak'example.eth' node) + keccak('subdomain'
. The sub-problem we must solve is to compute the node for example.eth, which is: keccak'.eth' node) + keccak('example'
. In turn, we must compute the node for eth, which is: keccakRoot Node) + keccak('eth'
.
The root node is what we call the "base case" of our recursion, and we obviously can’t define it recursively, or the algorithm will never terminate! The root node is defined as: 0x0000000000000000000000000000000000000000000000000000000000000000
(32 zero bytes).
Putting this all together, the node of subdomain.example.eth is therefore: keccak(keccak(keccak(0x0…0 + keccak('eth')) + keccak('example')) + keccak('subdomain'))
Generalizing, we can define the Namehash function as follows (the base case for the root node, or empty name, followed by the recursive step):
namehash([]) = 0x0000000000000000000000000000000000000000000000000000000000000000 namehash([label, …]) = keccak256(namehash(…) + keccak256(label))
In Python this becomes:
def namehash(name): if name == '': return '\0' * 32 else: label, _, remainder = name.partition('.') return sha3(namehash(remainder) + sha3(label))
Thus, mastering-ethereum.eth will be processed as follows:
namehash('mastering-ethereum.eth') ⇒ sha3(namehash('eth') + sha3('mastering-ethereum')) ⇒ sha3(sha3(namehash('') + sha3('eth')) + sha3('mastering-ethereum')) ⇒ sha3(sha3(('\0' * 32) + sha3('eth')) + sha3('mastering-ethereum'))
Of course, subdomains can themselves have subdomains: after subdomain.example.eth there could be a sub.subdomain.example.eth, then a sub.sub.subdomain.example.eth and so on. To avoid expensive recomputation, since Namehash depends only on the name itself, the node for a given name can be precomputed and inserted into a contract, removing the need for string manipulation, and permitting immediate lookup of ENS records regardless of the number of components in the raw name.
How to choose a valid name
Names consist of a series of dot-separated labels. Although upper and lower case letters are allowed, all labels should follow a UTS46 normalization process that case-folds labels before hashing them, so names with different case but identical spelling will end up with the same Namehash.
You could use labels and domains of any length, but for the sake of compatibility with legacy DNS, the following rules are recommended:
-
Labels should be no more than 64 characters each.
-
Complete ENS names should be no more than 255 characters.
-
Labels should not start or end with hyphens, or start with digits.
Root node ownership
One of the results of this hierarchical system is that it relies on the owners of the root node, who are able to create top level domains.
While the eventual goal is to adopt a decentralized decision-making process for new top level domains, right now the root node is controlled by a 4 out of 7 multisig, held by people in different countries (built as a reflection of the seven keyholders of the DNS system). As a result, a majority of at least 4 of the 7 keyholders is required to effect any change.
Currently the purpose and goal of these keyholders is to work in consensus with the community to:
-
Migrate and upgrade the temporary ownership of the .eth TLD (Top Level Domain) to a more permanent contract once the system is evaluated.
-
Allow adding new TLDs, if the community agrees they are needed.
-
Migrate the ownership of the root multisig to a more decentralized contract, when such a system is agreed upon, tested and implemented.
-
Serve as a last resort way to deal with any bugs or vulnerabilities in the top-level registries.
Resolvers
The basic ENS contract can’t add metadata to names; that is the job of "resolver contracts". These are user-created contracts that can answer questions about the name, such as "What’s the Swarm address associated with this app?", "What is the Ethereum address that receives payments in ether and tokens?", or "What’s the hash of the app?" (to verify its integrity).
Middle layer: the ".eth" nodes
At the moment, the only top level domain that is uniquely registrable in a smart contract is .eth.
There’s work on enabling traditional DNS domain owners to claim ENS ownership. While in theory this could work for .com the only domain that this has been implemented for so far is [.xyz, and only on Ropsten testnet](https://medium.com/the-ethereum-name-service/how-to-claim-your-dns-domain-on-ens-e600ef2d92ca).
.eth domains are distributed via an auction system. There is no reserved list or priority, and the only way to acquire a name is to use the system. The auction system is a complex piece of code (over 500 lines); most of the early development efforts (and bugs!) in ENS were in this part of the system, but it’s also replaceable and upgradeable (without risk to the funds—more on that later).
Vickrey Auctions
Names are distributed via a modified Vickrey Auction. In a traditional Vickrey auction, every bidder submits a sealed bid, and all of them are revealed simultaneously, at which point the highest bidder wins the auction, but only pays the second-highest bid. Therefore bidders are incentivized not to bid less than the true value of the name to them, since bidding their true value increases the chance they will win but does not affect the price they will eventually pay.
On a blockchain, some changes are required:
-
To ensure bidders don’t submit bids they have no intention of paying, they must lock up a value equal or higher than their bid beforehand, to guarantee the bid is valid.
-
Because you can’t hide secrets on a blockchain, bidders must execute at least two transactions (a commit–reveal process), in order to hide the original value and name they bid on.
-
Since you can’t reveal all bids simultaneously in a decentralized system, bidders must reveal their own bids themselves; if they don’t, they forfeit their locked-up funds. Without this forfeit, one could make many bids and choose to reveal only one or two, turning a sealed-bid auction into a traditional increasing price auction.
Therefore, the auction is a four-step process:
-
Start the auction. This is required to broadcast the intent to register a name. This creates all auction deadlines. The names are hashed, so that only those who have the name in their dictionary will know which auction was opened. This allows some privacy, useful if you are creating a new project and don’t want to share details about it. You can open multiple dummy auctions at the same time, so if someone is following you they cannot simply bid on all auctions you open.
-
Make a sealed bid: you must do this before the bidding deadline, by tying a given amount of ether to the hash of a secret message (containing, among others, the hash of the name, the actual amount of the bid, and a salt). You can lock up more ether than you are actually bidding in order to mask your true valuation.
-
Reveal the bid: during the reveal period, you must make a transaction that reveals the bid, which will then calculate the highest bid, the second higher bid and send ether back to unsuccessful bidders. Every time the bid is revealed the current winner is recalculated, therefore the last one to be set before the revealing deadline expires becomes the overall winner.
-
Clean up after: if you are the winner, you can finalize the auction in order to get back the difference between your bid and the second highest. If you forgot to reveal you can make a late reveal and recover a little of your bid.
Top layer of the ENS: the Deeds
The top layer of the ENS is yet another super-simple contract with a single purpose: to hold the funds.
When you win a name, the funds are not actually sent anywhere, but are just locked up for the period you want to hold the name (at least a year). This works like a guaranteed buy-back: if the owner does not want the name any more they can sell it back to the system and recover their ether (so the cost of holding the name is the opportunity cost of doing something with a return greater than zero).
Of course, having a single contract hold millions of dollars in ether has proven to be very risky, so instead ENS creates a Deed Contract for each new name. The Deed Contract is very simple (about 50 lines of code) and it only allows the funds to be transferred back to a single account (the deed owner) and to be called by a single entity (the registrar contract). This approach drastically reduces the attack surface where bugs can put the funds at risk.
Registering a name
Registering a name in ENS is a four-step process, as we saw in Vickrey Auctions. First we place a bid for any available name, then we reveal our bid after 48 hours to secure the name. ENS timeline for registration is a diagram showing the timeline of registration:
Let’s register our first name!
We will use one of several available user-friendly interfaces to search for available names, place a bid on the name ethereumbook.eth, reveal the bid and secure the name.
There are a number of web-based interfaces to ENS that allow us to interact with the ENS DApp. For this example, we will use the mycrypto.com interface, in conjunction with MetaMask as our wallet.
First, we need to make sure the name we want is available. While writing this book, we really wanted to register the name mastering.eth, but alas, Searching for ENS names on MyCrypto.com revealed it was already taken! Because ENS registrations only last one year, it might become possible to secure that name in the future. In the mean time, let’s search for ethereumbook.eth:
Great! The name is available. In order to register it, we need to move forward with Starting an auction for an ENS name. Let’s unlock MetaMask and start an auction for ethereumbook.eth:
|
Warning
|
As mentioned in Vickrey Auctions, you must reveal your bid within 48hrs after the auction is complete, or you lose the funds in your bid. Did we forget to do this and lose 0.1 ETH ourselves? You bet we did. Put a reminder on your calendar. |
Let’s make our bid. In order to do that we need to follow the steps in Placing a bid for an ENS name:
Take a screenshot, save your secret phrase (as a backup for your bid), and add a reminder in your calendar for the reveal date and time, so you don’t forget and lose your funds.
When you’re ready, select the big green submit button in the MetaMask transaction containing your bid:
If all goes well, return and reveal the bid in 48 hours and the name is now registered to your Ethereum address.
Managing your ENS name
Now that we have registered an ENS name, we can manage it using another user-friendly interface, by visiting: https://manager.ens.domains/
Once there, enter the name you want to manage in the search box. You need to have your Ethereum wallet (e.g. MetaMask) unlocked, so that the ENS manager DApp can manage the name on your behalf using the The ENS Manager web interface:
From this interface, we can create subdomains, set a resolver contracts (more on that later) and connect each name to the appropriate resource, such as the Swarm address of a DApp front-end.
Creating an ENS subdomain
First, let’s create a subdomain for our example Auction DApp, (see Adding the subdomain auction.ethereumbook.eth). We will name the subdomain auction, so the fully qualified name will be auction.ethereumbook.eth:
Once you create the subdomain, you enter auction.ethereumbook.eth in the search box and now you can manage the subdomain, just as we managed the domain ethereumbook.eth previously.
ENS Resolvers
In ENS, resolving a name is a two-step process:
-
The ENS registry is called with the name to resolve after hashing it. If the record exists, the registry returns the address of its resolver.
-
The resolver is called, using the method appropriate to the resource being requested. The resolver returns the desired result.
This two-step process has several benefits. By separating the functionality of resolvers from the naming system itself, we have a lot more flexibility. The owners of names can use custom resolvers to resolve any type or resource, extending the functionality of ENS. For example, if in the future you wanted to link a geolocation resource (longitude/lattitude) to an ENS name, you could create a new resolver that answers a geolocation query. Who knows what applications might be useful in the future? With custom resolvers, the only limitation is your imagination.
For convenience, there is a default public resolver that can resolve a variety of resources including:
-
Address (for wallets or contracts)
-
Content (a Swarm hash for DApps or contract source code)
Since we want to link our Auction DApp to a Swarm hash, we can use the public resolver, which supports content resolution, and don’t need to code or deploy a custom resolver. See Set the default public resolver for auction.ethereumbook.eth.
Let’s set our auction.ethereumbook.eth name to use the public resolver:
Resolving a name to a Swarm hash (content)
Once the resolver for auction.ethereumbook.eth is set to be the public resolver, we can set it to return the Swarm hash as the content of our name, see Set the 'content' return for auction.ethereumbook.eth:
Wait a short time for your transaction to be confirmed and you should be able to resolve the name correctly. Before setting a name, our Auction DApp could be found on a Swarm gateway by it’s hash:
or by searching in a DApp browser or Swarm gateway for the Swarm URL:
bzz://ab164cf37dc10647e43a233486cdeffa8334b026e32a480dd9cbd020c12d4581
Now that we have attached it to a name, it is much easier:
or, by search for "auction.ethereumbook.eth" in any ENS compatible wallet or DApp browser (e.g. Mist).
From App to DApp
Over the past several sections, we have gradually built a Decentralized Application. We started with a pair of smart contracts to run an auction for ERC721 deeds.  We added a front-end, implemented in JavaScript, that offers a convenient and user friendly interface to our DApp. We added a decentralized storage system with Swarm, to store application resources such as images. We added a decentralized communication system using Whisper, to deliver a chat room function for each auction, without any central servers.
Next, we uploaded the entire front-end to Swarm, so that our DApp doesn’t rely on any web servers to serve the files. Finally, we use allocated a name for our DApp using ENS, connecting it to the Swarm hash of the front-end, so that users can access it with a simple and easy-to-remember human-readable name.
With each of these steps, we increased the decentralization of our application. The final result is a DApp the has no central point of authority, no central point of failure and expresses the "web3" vision.
Here’s the final Auction DApp architecture:
Conclusions
Decentralized applications are the culmination of the Ethereum vision, as expressed by the founders from the very earliest designs. While a lot of applications call themselves "DApps" today, most are not fully decentralized. However, it is already possible to construct applications that are almost completely decentralized. Over time, as the technology matures further, more and more of our applications can be decentralized, resulting in a more resilient, censorship resistant and free web.


Free Web Demo
LOHAE is the tale of Zawhei Bacama, who discovers herself to be the foretold Life Reaper.
The thwapping beavers of her Land excitedly explain that they have been gnawing down each tree as it grows to avoid awakening the Titan, Nidhogg. They hope their prophesied hero can manage to grow the trees without ruining everything forever!
Breed trees together to unlock new types of fruits, and make progress on the mysterious journey to collecting enough Essences for ... hrrrm... is that...supposed to be happening? There's a flash light in this game? What happens if you...
Breed Procedural Trees: Each tree has a simple genetic code that can be combined in various ways with other trees to form offspring.
Over 85 Fruit Forms: Collect various colors of over 85 base fruit types, from apples to skulls.
Definitely no Secrets???:  Who even cares about Nidhogg, honestly?
Music by


Small - $7
Medium - $9
Large - $11
Salami, Pepperoni, Pepperoncini, Jalepeño, Black olives, Mushrooms, Onions, Sausage, Bacon, Extra Cheese, Green peppers, Pineapple, Spinach


Typography
Heading, paragraphs, contextual classes and other typo elements
This is sample title
Secondary text
This is sample title
Secondary text
This is sample title
Secondary text
This is sample title
Secondary text
This is sample title
Secondary text
This is a lead parapraph.
Neglected principle ask rapturous consulted. Object remark lively all did feebly excuse our wooded. Old her object chatty regard vulgar missed. Speaking throwing breeding betrayed children my to.  Sufficient unpleasing an insensible motionless if introduced ye. Now give nor both come near many late.
Believing neglected so so allowance existence departure in. In design active temper be uneasy. Thirty for remove plenty regard you summer though. He preference connection astonished on of ye. Partiality on or continuing in particular principles as. Do believing oh disposing to supported allowance we.
As am hastily invited settled at limited civilly fortune me. Really spring in extent an by.  Of so am he remember although required. Bachelor unpacked be advanced at. Confined in declared marianne is vicinity.
Last paragraph has no bottom margin always.
Contextual Backgrounds
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Contextual Text Colors
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Way now instrument had eat diminution melancholy expression.
Text Positions
Text aligned to the left
Text aligned in the center
Text aligned to the right


You need to enable JavaScript to run this app.
Development
X
change topic
change to handicap
change to netzkarte
change vectorTilesUrl to http://foo.ch
change apiKey to 'abcdefgh'
change vectorTilesKey to 'abcdefgh'
change geoserverUrl to http://foo.ch
change cartaroUrl to http://foo.ch
change center to '[950000, 5900000]'
change zoom to 16
change max extent to "502649.8980,5655117.1007,1352629.6525,6141868.0968"


@include("/fragments/bk-header.html"){} @include("/fragments/bk-leftmenu.html"){}
${layoutContent}
@include("/fragments/bk-footer.html"){}


Be enthusiastic! Find a subject that you enjoy and people will pick up on your passion.
Use the book theme or author as a starting point, but be sure to listen for a cue from your conversation partner that is less banal. "I read a book about chili peppers." "Oh, I love to cook!" and thus, the conversation gets real.
Don't yuck someone's yum. Not everyone has the same tastes as you. Be engaging and encouraging instead of putting someone down.


The Summer Tournament Has Bugun!
This is a randomizer for Dragon Warrior for NES.
If you enjoy Dragon Warrior Randomizer, come join our discord community!
Random overworld map generation
A new overworld map is generated with each seed. Checks are used to make sure all towns and caves are accessible. On generated maps, the Rainbow Drop is used just outside Charlock to create a bridge over the moat.
Random chest contents
Chest contents throughout the game are randomized. Checks are used to ensure that quest items (Staff of Rain, Silver Harp, Stones of Sunlight) are not located in Charlock castle. Erdrick's Tablet is removed.
Random enemy attack patterns
This will give some enemies spells they did not originally have. This means you could have a Red Slime with SLEEP, a Wizard with Fire Breath, or any other combination!
Random enemy zones
The locations of enemies will be changed. Randomizer ensures that enemies near Tantegel Castle are not too tough to defeat at low levels, but beyond that, anything goes.
Random enemy stats, XP, and gold
Enemy statisics (strength, agility, HP) can be randomized, as can the amount of gold and experience you receive from them.
Boosted XP/gold drops
Enemies will now give you more XP and Gold, in line with the SNES remake of the game. XP and gold drops are limited to 255 due to game engine limitations.
Lower MP requirements
MP requirements for spells are adjusted to be the same as those in the remake.
Random weapon shops
Weapon shop inventory will now be random. Every shop will have 5-6 random items.
Random XP requirements
Experience requirements to obtain a new level can be randomized.
Random weapon prices
Weapon prices can be randomized. This does not affect their capability.
Shuffled "searched for" items
The Fairy Flute, Erdrick's Armor, and Erdrick's Token will now be shuffled, so for example the token could be in Kol instead of the flute, and the armor on the overworld. Erdrick's Token or the Flute could also be in a random chest instead of on the ground. In addition, the item's location on the overworld is random. The NPC in Cantlin can tell you where it is.
Randomized player attributes
Your character's Strength, Agility, HP and MP are randomly generated.
Randomized spell learning
Spells learning is now randomized. Any spell can be learned anywhere from level 1 to level 16.
Buffed HEAL and HURT
The HEAL spell has a range from 17-25. The HURT spell has a range from 9-16.
Faster leveling
The number of experience points required for level ups can be adjusted with the fast leveling and very fast leveling options. These require 75% and 50% of the normal requirements for the game, respectively.
Cursed Princess mode
Get Princess Gwaelin to take a cursed belt from your inventory when you bring her to the king to win the game. The game can also still be completed in the normal manner.
Three's Company mode
Bring Princess Gwaelin to the Dragonlord and agree to join him in ruling the world to win in this mode. The game can also still be completed in the normal manner.
Alternate player sprites
Over 60 alternate sprites to choose from for the main character.
Other changes
The Death Necklace is always available in a chest. Putting it on gives you +10 attack power at the cost of 25% of your max HP and being cursed. The Fighter's Ring works (+2 ATK). Other options include faster text, open Charlock (no Rainbow Drop required) shortened Charlock dungeon, disabling magic keys, or more swamp on the overworld.


*2011-12: Students were tested only at minimum reading level, minimum and average maths level       *2012-13: Students were tested at these level including average reading level        #overall: Represents students who acquired atleast basic ASER skills


Enhanced Camera UX
We have updated our prepackaged camera controller with a new UI/UX. There are changes to the graphics, the messaging, the animations, and some added features. To test it out try this:
- (IBAction)btnTouched:(id)sender {
BRScanOptions *scanOptions = [BRScanOptions new];
[[BRScanManager sharedManager] startStaticCameraFromController:self
cameraType:BRCameraUXEnhanced
scanOptions:scanOptions
withDelegate:self];
}
Data Chips
The enhanced UX supports 3 “chips” which indicate to the user whether the date, total, or merchant has been successfully detected in the receipt. By default, all these chips are disabled. You can enable them by setting their respective properties in the BRScanOptions
object:
Note
Certain methods for detecting merchant are only performed at the end of the scan session so it will occasionally occur that the merchant chip is not filled in, but when the user ends the scan session, a merchant will then be detected and returned in the BRScanResults
object


Related Jobs See more {{job_post.get_job_category_display}} jobs→ {% include "jobs/job_posts.html" %}


--- layout: post title: Mobile links date: 2006-10-07 00:00:00 category: mobile ---
It's NetNewsWire clean-out day... Some mobile links I've not gotten around to writing about in more depth:


Pair programming is an agile software development technique in which two programmers work together at one workstation. One, the driver, writes code while the other, the observer, pointer or navigator, reviews each line of code as it is typed in. The two programmers switch roles frequently. While reviewing, the observer also considers the "strategic" direction of the work, coming up with ideas for improvements and likely future problems to address. This frees the driver to focus all of his or her attention on the "tactical" aspects of completing the current task, using the observer as a safety net and guide.
- Start with a well-defined task
- Agree on one tiny goal at a time
- Rely on your partner, support your partner
Steps to Pair Program Well
Reflection
Pairing for the first time was a little odd. The Driver/Navigator mentality is not something I am used to. I enjoyed it though and can see how useful it may be when it comes to learning. When you split the task, one person can really focus on the techiniques and the other can really focus on the syntax. I'm sure this helps with learning and remembering. I think, trying to solve a problem didn't work so well because I didn't feel like I had the chance to try everything. I felt like there was pressure to get the most logical solution, rather than to try a variety of techniques.


Announcing .NET Core 3.1 Preview 2
by msgeekWe’re announcing .NET Core 3.1 Preview 2. .NET Core 3.1 will be a small and short release focused on key improvements in Blazor and Windows desktop, the two big additions in .NET Core 3.0.. It will be a long term support (LTS) release with an expected final ship date of December 2019.
You can download .NET Core 3.1 Preview 2 on Windows, macOS, and Linux.
ASP.NET Core and EF Core are also releasing updates today.
Visual Studio 16.4 Preview 3 and Visual Studio for Mac 8.4 Preview 3 are also releasing today. They are required updates to use .NET Core 3.1 Preview 2. Visual Studio 16.4 includes .NET Core 3.1, so just updating Visual Studio will give you both releases.
Details:
Improvements
The biggest improvement in this release is support for C++/CLI (AKA «managed C++»). C++/CLI is only enabled on Windows. The changes for C++/CLI are primarily in Visual Studio. You need to install the «Desktop development with C++» workload and the «C++/CLI support» component in order to use C++/CLI. You can see this component selected (it is the last one displayed) in the image below.
This component adds a couple templates that you can use:
- CLR Class Library (.NET Core)
- CLR Empty Project (.NET Core)
If you cannot find them, just search for them in the New Project dialog.
Closing
The primary goal of .NET Core 3.1 is to polish the features and scenarios we delivered in .NET Core 3.0. .NET Core 3.1 will be a long term support (LTS) release, supported for at least 3 years.
Please install and test .NET Core 3.1 Preview 2 and give us feedback. It is not yet supported or recommended for use in production.
If you missed it, check out the .NET Core 3.0 announcement from last month.


John Joe Nevin wins WBA Super Featherweight International title
Nevin defeated the Nicaraguan via a unanimous decision over 10 rounds at York Hall on Saturday night
by Robert HynesJohn Joe Nevin has extended his professional record to 14-0 after defeating Freddy Fonseca to claim the WBA Super Featherweight International title.
Nevin defeated the Nicaraguan via a unanimous decision over 10 rounds at York Hall on Saturday night.
Meanwhile in Glasgow, Paddy Donovan tasted victory in his second professional bout.
He won all six rounds against Danny Mendoza at the Emirates Arena in the east end of the city.
On the same card, Pierce O'Leary beat England's Chris Adaway over four rounds.
If you haven't already, be sure to like our Irish Mirror Sport and Irish Mirror GAA pages on Facebook and follow us on Twitter.
How to follow the Irish Mirror on social media
You can like our main Facebook page here.
Our Irish Mirror Sports page - which brings you all your Irish and UK sports news - can be found here.
You can also check out our Irish Mirror GAA sports page.
The Irish Mirror Twitter account is @IrishMirror while our sports account is @MirrorSportIE.
Our Instagram account can be found here.


I can create a simple and pleasent modern design. Also by using cutting edge technologies I can develop your solution. Building remarkable website or poket mobile application for your bussines.
C# Java swift Java Script Python JSON, XML HTML, CSS
Help with planning the scope, data analysis and provide reach documentation for your projects. I will use latest modern feautures to handle all of your important information.
Google APIs Git
Android, service
Google PlayKodi, add-on, IPTV, bulsat.com
GitHubASP.NET, ERP, VPN, service


@govukFileUpload(FileUpload(
id = "file-upload-1",
name = "file-upload-1",
hint = Some(Hint(
content = Text("You can upload your receipt as a scanned copy or photo of the original. The selected file must be smaller than 100MB.")
)),
label = Label(
content = Text("Upload invoice"),
classes = "govuk-label--xl",
isPageHeading = true
)
))
1 of 1 files uploaded.
Refresh page to update file upload progress
@govukSummaryList(SummaryList(
classes = "govuk-summary-list--long-key",
rows = Seq(
SummaryListRow(
key = Key(content = HtmlContent("""
declaration.jpgDeclaration
""")),
value = Value(content = HtmlContent(
govukTag(Tag(content = Text("uploaded"), classes = "govuk-tag--green"))
)),
actions = Some(Actions(
items = Seq(
ActionItem(
href = "#",
content = Text("Remove"),
visuallyHiddenText = Some("declaration.jpg")
)
)
))
)
)
))
@govukRadios(Radios(
name = "add-a-different-type-of-evidence",
fieldset = Some(Fieldset(
legend = Some(Legend(
content = Text("Add a different type of supporting evidence to your claim?"),
classes = "govuk-fieldset__legend govuk-fieldset__legend--m"
)),
)),
items = Seq(
RadioItem(content = Text("Yes"), value = Some("yes")),
RadioItem(content = Text("No"), value = Some("no"))
)
))
@govukButton(Button(
content = Text("Continue")
))