The carnival in São Paulo takes place in the Anhembi Sambadrome on the Friday and Saturday night of the week of Carnival, as opposed to Rio's Carnival, which is held on Sunday and Monday night.
Various "samba schools" compete in a huge parade. Each school presents a different theme, which they expose through their costumes, dance, music, and the allegorical cars or "carros alegóricos", huge vehicles decorated according to the theme designed specifically for the parade.
The schools are responsible for choosing their own themes, which usually revolve around historical happenings or some sort of cultural or political movement.
The most famous (and usually the winners) samba schools are: Nenê de Vila Matilde, Gaviões da Fiel, Vai-Vai, Camisa Verde Branco, Peruche, Mocidade Alegre, Rosas de Ouro, Vila Maria, Mancha Verde, Tatuape, and Império da Casa Verde
Vai-Vai is the oldest school and has been the Special Group champion most times (15 total, including the 2015 championship). It also is the most popular, for it has a larger fanbase and many supporters among the people of the city.
Back


WITNESS LIST Agriculture & Livestock Committee February 11, 1997-8:30A Agricultural State Agencies For: Hutchins, Mr. Elbert C. (Vet Medical Association) On: Allen, Mr. Ron (Vet Examiners Board) Beals, Dr. Terry (Animal Health Commissio) Buckley, Mr. Robert G. (Soil & Water Board) Mathis, Mr. Benny (Pest Control Board) Soward, Mr. Larry R. (Agriculture Department) Verett, Mr. Steve (Food & Fibers Commissio)


Irish Terrier
| Irish Terrier Picture | |
| Breed Information | |
|---|---|
| Popularity | 2017: #1142016: #1152015: #113 |
| Name | Irish Terrier |
| Other names | Irish Red Terrier, Daredevil |
| Origin | Ireland |
| Breed Group | Terrier (AKC:1885)(UKC) |
| Size | Medium |
| Type | Purebred |
| Life span | 12-15 years |
| Temperament | DominantIntelligentLivelyProtectiveRespectfulTrainable |
| Height | 18 inches (43 cm) |
| Weight | 25-27 pounds (11-12 kg) |
| Colors | RedRed WheatenWheaten |
| Litter Size | 4-6 puppies |
| Puppy Price | Average $600 - $800 USD |
| Breed Characteristics | |
| Adaptability | 5 stars |
| Apartment Friendly | 3 starsThe Irish Terrier will do okay in an apartment if it is sufficiently exercised; a small yard will do. If given sufficient exercise, it is surprisingly well-mannered and dignified indoors. |
| Barking Tendencies | 3 starsOccassional |
| Cat Friendly | 2 stars |
| Child Friendly | 4 starsGood with Kids: This is a suitable dog breed for kids. It is also shy toward other pets and shy toward strangers. |
| Dog Friendly | 2 stars |
| Exercise Needs | 4 starsSince Irish Terriers were bred for active work, these dogs need plenty of regular exercise. They need at least a daily long, brisk walk, where the dog is made to heel beside or behind the human holding the lead. Do not let this terrier walk in front, as in a dog's mind the leader leads the way, and that leader needs to be the human. |
| Grooming | 4 starsHigh Maintenance: The Irish Terrier is a fairly low-maintenance breed that requires regular brushing with a stiff bristled brush. A fine tooth comb should be used to remove the dead hairs after brushing. Hand-plucking of the hairs of the Irish Terrier is necessary twice a year. Excessive hair around the pads of the feet must be trimmed and the ears must be kept clean. |
| Health Issues | 2 starsThe proportions are not exaggerated in any way and thus eye or breathing problems are rare. Most Irish Terriers do not show signs of allergies towards foods. As they are small dogs, the breed has a very low incidence of hip dysplasia.Hypoallergenic: Yes |
| Intelligence | 4 starsRanking: #53. (See All Rankings) |
| Playfulness | 4 stars |
| Shedding Level | 1 starsMinimal Shedding: A properly cared-for Irish Terrier does not shed either. The wiry coat is fairly easy to groom, pet dogs (rather than show dogs) needing stripping only once or twice a year. |
| Stranger Friendly | 2 stars |
| Trainability | 3 starsModerately Easy Training: The Irish Terrier is a very willful and stubborn dog that will require a firm and consistent pack leader. The Irish Terrier is known to be quite a handful and will likely show difficulty with housebreaking. This is not the dog for the meek or passive owner. |
| Watchdog Ability | 5 starsGreat Watchdog Ability: This dog will bark and alert its owners when an intruder is present. It exhibits very protective behavior, acts fearless toward any aggressor, and will do what it takes to guard and protect its family. |
| Irish Terrier Puppy Picture | ||
| Puppy Names | ||
|---|---|---|
| Rank | Male | Female |
| 01 | Charlie | Bella |
| 02 | Buddy | Molly |
| 03 | Jack | Lola |
| 04 | Finn | Coco |
| 05 | Tucker | Maya |
| 06 | Zeus | Sophie |
| 07 | Beau | Dixie |
| 08 | Dexter | Chloe |
| 09 | Lucky | Nala |
| 10 | Murphy | Sasha |
| See All Names › |
| Overview |
|---|
|
The Irish terrier has a graceful, racy outline, with a moderately long body. It should not have the short back characteristic of so many of the long legged terriers. It is sturdy and strong in substance, but it is also active and lithe in movement. This is an all-round terrier that must combine speed, endurance, agility and power to perform a great variety of jobs. Its broken coat is dense and wiry, never so long as to obscure the body shape. Its expression, like its nature, is intense. Called the daredevil of dogdom, the Irish terrier is brash, bold, assertive, playful, inquisitive, independent, strong-willed and ever ready for action and adventure. It is usually aggressive toward other dogs and small animals and tends to be reserved with strangers.  Given sufficient exercise, it is surprisingly well-mannered and dignified indoors. It is a loyal and entertaining companion. |
| History |
| The Irish Terrier is one of four terrier breeds developed in Ireland, and it may be the oldest. He was a dog of the common, used as an all around farm dog and hunter. Originally, there were black and tan and brindle, as well as red, Irish Terriers, but by the 20th Century, the breed was only red in color. The Irish Terrier was the first breed to be recognized by the English Kennel Club as a native Irish breed. During the First World War, they were used as messenger dogs during trench warfare, proving their intelligence and usefulness. The Irish Terrier was recognized by the AKC in 1885 and a United States' breed club was started in 1896. Some of the Irish Terrier's talents include: hunting, tracking, retrieving, ratter, watchdog, guarding, police work and military work. |


This directive has no dependencies other than Angular itself. Version 1.3.11 was used. It was designed to compose a lightweight dashboard and now can be freely downloaded and used in whatever purpose its MIT licence allows.
| World Demographics | |||
|---|---|---|---|
| Males | Urban | Seniors | Literacy |
|
|
|
|
|
| Source: Index Mundi |
The example above shows how easy it is to present nice looking statistical data in a static manner. Below is the code used to achieve this result:
<canvas-gauge width="160" under-color="#EFEFEF" over-color="#FFD700" value="males" mask="(@)%"
style="color: gray"></canvas-gauge>
<canvas-gauge width="160" under-color="#EFEFEF" over-color="#FF4500" value="urban" mask="(@)%"
style="color: gray"></canvas-gauge>
<canvas-gauge width="160" under-color="#EFEFEF" over-color="#663399" value="seniors" mask="(@)%"
style="color: gray"></canvas-gauge>
<canvas-gauge width="160" under-color="#EFEFEF" over-color="#2E8B57" value="literacy" mask="(@)%"
style="color: gray"></canvas-gauge>
| Population by Age Structure | |||
|---|---|---|---|
| Males | Females | ||
|
|
|
||
| Source: Wikipedia |
The example above shows the same kind of presentation but with dynamic data. Change the age structure dropdown and the gauges change accordingly
<canvas-gauge width="300" under-color="#EFEFEF" over-color="#6495ED" value="malestat" mask="(@)%"
style="color: gray"></canvas-gauge>
<canvas-gauge width="300" under-color="#EFEFEF" over-color="#E9967A" value="femalestat" mask="(@)%"
style="color: gray"></canvas-gauge>
Element <canvas-gauge>
Used to generate the gauge. Will calculate the necessary height based on the given width. The ratio is 55%.
Attribute width
Sets the gauge's width in pixels. It's height will be calculated and is always 55% of its width. Default is 100. Plain attribute.
Attribute over-color
Sets the gauge's value color. This color is used to paint over the base semi-circle, up to the point calculated by the value supplied. It is also the color used to paint the value in the middle of the gauge. The shadow color used is over-color 30% darkened. Plain attribute.
Attribute under-color
Sets the gauge's primer, or under, color. This color is used to paint the base semi-circle. Plain attribute.
Attribute value
Sets the gauge's value. This attribute works with min and max to calculate up to what point the gauge should be painted. It is a model attribute that updates the gauge when its value change.
Attribute min
Sets the gauge's minimum value used to calculate the gauge's painting. This value is shown below the left base of the gauge's semi-circle. Default is 0. Plain attribute.
Attribute max
Set the gauge's maximum value used to calculate the gauge's painting. This value is shown below the right base of the gauge's semi-circle. Default is 100. Plain attribute.
Attribute placeholder
It is used along with the mask attribute to set an expression to be shown in the bottom center of the gauge. The placeholder will be replaced with the value of the value attribute. Default is (@). Plain attribute.
Attribute mask
Is used to let other characters be composed with the value shown. To use it from your expression, make sure the placeholder value is somewhere in it. For instance, to show percentage use mask="(@)%"
. To show a dollar value use mask="$ (@)"
. Default is the value of placeholder attribute. Plain attribute.


Trees bring rainfall,so people should be encouraged to plant more trees.
people should be encouraged to protect water sources.ex, not to lead untreated sewages to rivers.(2)not to bathe or wash clothes in water sources to prevent contamination.
people should be encouraged not to cut down trees since trees are sources of rain.
the government should employ some qualified personels to teach people on environment conservation.
div>


Create a service subclass under the work1_sc service super class that was created in a prior section.
The service super class work1_sc is the service class that the activities will be mapped to through the workloads. The service subclass work1_sc_read is the service class that the read activities will be mapped to through the work action.


§652-10 Debts payable in future. If upon disclosure made on oath by the debtor it appears that the garnishee is indebted to the defendant, but that the debt is not payable and will not become due until some future time, then such judgment as the plaintiff may recover shall constitute a lien upon the debt until and at the time it becomes due and payable. [L 1876, c 35, §12; RL 1925, §2840; RL 1935, §4279; RL 1945, §10310; RL 1955, §237-10; HRS §652-10]
Case Notes
Section held inapplicable under the circumstances. 10 H. 499, 504 (1896).
Cited: 48 H. 68, 76, 395 P.2d 691 (1964).


--- layout: blog title: Blog permalink: /blog/ --- {% include head.html %} Toggle navigation {{ site.name }} Back Home


{% extends "projects/project_edit_base.html" %} {% load i18n %} {% block title %}{% trans "Email Notifications" %}{% endblock %} {% block nav-dashboard %} class="active"{% endblock %} {% block editing-option-edit-proj %}class="active"{% endblock %} {% block project-notifications-active %}active{% endblock %} {% block project_edit_content_header %}{% trans "Email Notifications" %}{% endblock %} {% block project_edit_content %}
{% trans "Configure email notifications to be sent on build failures." %}
{% if has_old_webhooks %}{% url 'projects_webhooks' project.slug as webhooks_url %} {% blocktrans trimmed with webhooks_url=webhooks_url %} Webhooks have been moved to their own page. Go to the Webhooks page if you are looking for your webhooks. {% endblocktrans %}
{% endif %} {% if emails or urls %}{% if emails %}
{% endif %}
{% trans "Add an email address to notify" %}
{% endblock %}


|
|
Trunk: Main development line Branch: Start a new line to develop on. Commit: Save a version of your work Merge: Join your branch back to the Trunk Checkout: Create a local working copy update: Merge changes from the trunk to a local working copy Conflict: Changes are made by different users that cannot be merged until they are resolved Tag: Snapshot in time. For example, a release Fork: To create a branch |
Simple, easy, and provides backup for the project
We can share catalogs, code, paper text, and archive material
Sharing, commenting, reviewing of code, tracking progress, documentation, automatic builds, and writing papers


QOpenGLPaintDevice Class
The QOpenGLPaintDevice class enables painting to an OpenGL context using QPainter. More...
| Header: | #include <QOpenGLPaintDevice> |
| qmake: | QT += gui |
| Since: | Qt 5.0 |
| Inherits: | QPaintDevice |
Public Functions
| QOpenGLPaintDevice() | |
| QOpenGLPaintDevice(const QSize &size) | |
| QOpenGLPaintDevice(int width, int height) | |
| virtual | ~QOpenGLPaintDevice() |
| QOpenGLContext * | context() const |
| qreal | dotsPerMeterX() const |
| qreal | dotsPerMeterY() const |
| virtual void | ensureActiveTarget() |
| bool | paintFlipped() const |
| void | setDevicePixelRatio(qreal devicePixelRatio) |
| void | setDotsPerMeterX(qreal dpmx) |
| void | setDotsPerMeterY(qreal dpmy) |
| void | setPaintFlipped(bool flipped) |
| void | setSize(const QSize &size) |
| QSize | size() const |
Reimplemented Public Functions
| virtual QPaintEngine * | paintEngine() const override |
- 14 public functions inherited from QPaintDevice
Reimplemented Protected Functions
| virtual int | metric(QPaintDevice::PaintDeviceMetric metric) const override |
- 1 protected function inherited from QPaintDevice
Detailed Description
The QOpenGLPaintDevice class enables painting to an OpenGL context using QPainter.
The QOpenGLPaintDevice uses the current QOpenGL context to render QPainter draw commands. The context is captured upon construction. It requires support for OpenGL (ES) 2.0 or higher.
Performance
The QOpenGLPaintDevice is almost always hardware accelerated and has the potential of being much faster than software rasterization. However, it is more sensitive to state changes, and therefore requires the drawing commands to be carefully ordered to achieve optimal performance.
Antialiasing and Quality
Antialiasing in the OpenGL paint engine is done using multisampling. Most hardware require significantly more memory to do multisampling and the resulting quality is not on par with the quality of the software paint engine. The OpenGL paint engine's strength lies in its performance, not its visual rendering quality.
State Changes
When painting to a QOpenGLPaintDevice using QPainter, the state of the current OpenGL context will be altered by the paint engine to reflect its needs. Applications should not rely upon the OpenGL state being reset to its original conditions, particularly the current shader program, OpenGL viewport, texture units, and drawing modes.
Mixing QPainter and OpenGL
When intermixing QPainter and OpenGL, it is important to notify QPainter that the OpenGL state may have been cluttered so it can restore its internal state. This is acheived by calling QPainter::beginNativePainting() before starting the OpenGL rendering and calling QPainter::endNativePainting() after finishing.
See also OpenGL Window Example.
Member Function Documentation
QOpenGLPaintDevice::QOpenGLPaintDevice()
Constructs a QOpenGLPaintDevice.
The QOpenGLPaintDevice is only valid for the current context.
See also QOpenGLContext::currentContext().
QOpenGLPaintDevice::QOpenGLPaintDevice(const QSize &size)
Constructs a QOpenGLPaintDevice with the given size.
The QOpenGLPaintDevice is only valid for the current context.
See also QOpenGLContext::currentContext().
QOpenGLPaintDevice::QOpenGLPaintDevice(int width, int height)
Constructs a QOpenGLPaintDevice with the given width and height.
The QOpenGLPaintDevice is only valid for the current context.
See also QOpenGLContext::currentContext().
[virtual]
QOpenGLPaintDevice::~QOpenGLPaintDevice()
Destroys the QOpenGLPaintDevice.
QOpenGLContext *QOpenGLPaintDevice::context() const
Returns the OpenGL context associated with the paint device.
qreal QOpenGLPaintDevice::dotsPerMeterX() const
Returns the number of pixels per meter horizontally.
See also setDotsPerMeterX().
qreal QOpenGLPaintDevice::dotsPerMeterY() const
Returns the number of pixels per meter vertically.
See also setDotsPerMeterY().
[virtual]
void QOpenGLPaintDevice::ensureActiveTarget()
This virtual method is provided as a callback to allow re-binding a target frame buffer object or context when different QOpenGLPaintDevice instances are issuing draw calls alternately.
beginNativePainting() will also trigger this method.
The default implementation does nothing.
[override virtual protected]
int QOpenGLPaintDevice::metric(QPaintDevice::PaintDeviceMetric metric) const
Reimplemented from QPaintDevice::metric().
[override virtual]
QPaintEngine *QOpenGLPaintDevice::paintEngine() const
Reimplemented from QPaintDevice::paintEngine().
bool QOpenGLPaintDevice::paintFlipped() const
Returns true
if painting is flipped around the Y-axis.
See also setPaintFlipped().
void QOpenGLPaintDevice::setDevicePixelRatio(qreal devicePixelRatio)
Sets the device pixel ratio for the paint device to devicePixelRatio.
void QOpenGLPaintDevice::setDotsPerMeterX(qreal dpmx)
Sets the number of pixels per meter horizontally to dpmx.
See also dotsPerMeterX().
void QOpenGLPaintDevice::setDotsPerMeterY(qreal dpmy)
Sets the number of pixels per meter vertically to dpmy.
See also dotsPerMeterY().
void QOpenGLPaintDevice::setPaintFlipped(bool flipped)
Sets whether painting should be flipped around the Y-axis or not to flipped.
See also paintFlipped().
void QOpenGLPaintDevice::setSize(const QSize &size)
Sets the pixel size of the paint device to size.
See also size().
QSize QOpenGLPaintDevice::size() const
Returns the pixel size of the paint device.
See also setSize().


Software Security
- Software security entails software that continues to function correctly under malicious attack.
- Most engineers acknowledge that security is important but don’t know the steps to tackle security
- Software security best practices leverage good software engineering practice
- Involve thinking about security early in the software lifecycle, knowing and understanding common threats
- Including language-based flaws and pitfalls
- designing for security
- Putting all software components thorough objective risk analyses and testing.
Difference between Software Security and Application Security
Gary McGraw maintains that application security is a reactive approach, taking place once software has been deployed. Software security, on the other hand, involves a proactive approach, taking place within the pre-deployment phase.
Difference between Software Security and Application Security
Software security (pre-deployment) activities include:
- Secure software design
- Development of secure coding guidelines for developers to follow
- Development of secure configuration procedures and standards for the deployment phase
- Secure coding that follows established guidelines
- Validation of user input and implementation of a suitable encoding strategy
- User authentication
- User session management
- Function level access control
- Use of strong cryptography to secure data at rest and in transit
- Validation of third-party components
- Arrest of any flaws in software design/architecture
Application security (post-deployment) activities include:
- Post deployment security tests
- Capture of flaws in software environment configuration
- Malicious code detection (implemented by the developer to create backdoor, time bomb)
- Patch/upgrade
- Meaning that situations like third party software or dependencies needing to be patched
- IP filtering
- White List Known Good IP addresses instead of leaving a bunch IP addresses open
- Lock down executables
- This in my mind goes more hand in hand with compiled languages but I could be wrong
- Monitoring of programs at runtime to enforce the software use policy
Language-Based Security
Language-based security (LBS) is a set of techniques that may be used to strengthen the security of applications on a high level by using the properties of programming languages. LBS is considered to enforce computer security on an application-level, making it possible to prevent vulnerabilities which traditional operating system security is unable to handle.
Objectives of Language Based Security
Objective of Language-based security:
- Prevent common programming errors such as allowing buffer overflows and illegal information flows to occur
Provide some proof to the consumer about the security properties of the software
- Helps the consumer trust the software without having to check source code for errors.
A compiler, taking source code as input, performs several language specific operations on the code
- Lexical analysis, preprocessing, parsing, semantic analysis, code generation, and code optimization
- By analyzing the source code and gathering best practices for the language
- The compiler will attempt to correctly translate the high-level code into low-level code
- Preserving the behavior of the program.
For Dynamic Libraries such as Javasript/Node.js you can use tools such as eslint that help with static analysis and best practices that you should follow
Application Level Security
Definition
- Encompasses measures taken to improve the security of an application
- By finding, fixing and preventing security vulnerabilities.
Terms
- Asset
- Data in a database, money in an account, file on the filesystem or any system resource.
- Vulnerability
- A gap in security program that can be exploited by threats to gain unauthorized access to an asset.
- Attack
- An action taken to harm an asset.
- Threat
- Anything that can exploit a vulnerability and obtain, damage, or destroy an asset.
Techniques
- Code review
- Security engineer who understands the application through manually reviewing the source code notices avenues of exploit.
- Blackbox security audit
- This is testing an application for security vulnerabilities not looking at source code
- Design review
- Thinking about possible threat models before writing code or using a spec that has it detailed.
- Tooling
- Automated tools that check security vulnerabilities
Application threats or attacks
Category |
Threats / Attacks |
|---|---|
| Input Validation | Buffer overflow; cross-site scripting; SQL injection; canonicalization |
| Software Tampering | Attacker modifies an existing application’s runtime behavior to perform unauthorized actions; exploited via binary patching, code substitution, or code extension |
| Authentication | Network eavesdropping ; Brute force attack; dictionary attacks; cookie replay; credential theft |
| Authorization | Elevation of privilege; disclosure of confidential data; data tampering; luring attacks |
| Configuration management | Unauthorized access to administration interfaces; unauthorized access to configuration stores; retrieval of clear text configuration data; lack of individual accountability; over-privileged process and service accounts |
| Sensitive information | Access sensitive code or data in storage; network eavesdropping; code/data tampering |
| Session management | Session hijacking; session replay; man in the middle |
| Cryptography | Poor key generation or key management; weak or custom encryption |
| Parameter manipulation | Query string manipulation; form field manipulation; cookie manipulation; HTTP header manipulation |
| Exception management | Information disclosure; denial of service |
| Auditing and logging | User denies performing an operation; attacker exploits an application without trace; attacker covers his or her tracks |
OWASP
The Open Web Application Security Project (OWASP)
Background on OWASP
- Mission is to make software security visible, so that individuals/organizations can make informed decisions.
- Operates as a community of security minded professionals
- OWASP issues software tools and knowledge-based documentation on application security.
- The OWASP Foundation came online on December 1st 2001 it was established as a not-for-profit charitable org
- In the United States on April 21, 2004 to ensure the ongoing availability and support for our work at OWASP.
- OWASP is an international organization and the OWASP Foundation supports OWASP efforts around the world.
OWASP Core Values
- OPEN Everything at OWASP is radically transparent from our finances to our code.
- INNOVATION OWASP encourages and supports innovation and experiments for solutions to software security challenges.
- GLOBAL Anyone around the world is encouraged to participate in the OWASP community.
- INTEGRITY OWASP is an honest and truthful, vendor neutral, global community.
OWASP Principles
- Free & Open
- Governed by rough consensus & running code
- Abide by a code of ethics (see ethics)
- Not-for-profit
- Not driven by commercial interests
- Risk based approach
OWASP Mailing Lists
OWASP Chapter
OWASP Membership
OWASP Projects
OWASP Github Organization
OWASP Member Portal
OWASP Top 10
We will be reviewing the OWASP top 10 list for this workshop
OWASP Top 10 Most Critical Web Application Security Risks (in the Release Candidate) are: * Injection * Broken Authentication and Session Management * Cross-Site Scripting (XSS) * Broken Access Control (As it was in 2004) * Security Misconfiguration * Sensitive Data Exposure * Insufficient Attack Protection (NEW) * Cross-Site Request Forgery (CSRF) * Using Components with Known Vulnerabilities * Underprotected APIs (NEW)
OWASP Top 10 2017 Release Candidate
OWASP Top 10 comparsion table for 2013 vs 2017
OWASP Top 10 – 2013 (Previous) |
OWASP Top 10 – 2017 (New) |
|---|---|
| A1 - Injection | A1 - Injection |
| A2 - Broken Authentication and Session Management | A2 - Broken Authentication and Session Management |
| A3 - Cross-Site Scripting (XSS) | A3 - Cross-Site Scripting (XSS) |
| A4 - Insecure Direct Object References - Merged with A7 | A4 - Broken Access Control (Original category in 2003⁄2004) |
| A5 - Security Misconfiguration | A5 - Security Misconfiguration |
| A6 - Sensitive Data Exposure | A6 - Sensitive Data Exposure |
| A7 - Missing Function Level Access Control - Merged with A4 | A7 – Insufficient Attack Protection (NEW) |
| A8 – Cross-Site Request Forgery (CSRF) | A8 – Cross-Site Request Forgery (CSRF) |
| A9 – Using Components with Known Vulnerabilities | A9 – Using Components with Known Vulnerabilities |
| A10 – Unvalidated Redirects and Forwards -Dropped | A10 – UnderprotectedAPIs (NEW)Release NotesRN |
Threat Agents |
Attack Vectors |
Weakness Prevalence |
Weakness Detectability |
Technical Impacts |
Business Impacts |
|---|---|---|---|---|---|
| App Specific | Easy | Widespread | Easy | Severe | App/Business Specific |
| App Specific | Average | Common | Average | Moderate | App/Business Specific |
| App Specific | Difficult | Uncommon | Difficult | Minor | App/Business Specific |
Github Repository
If you like this information then please star this repository on Github at Software Security


---
layout: post
title: Curry night
alias: /curry-night
published: true
---
As you will hopefully have seen on Twitter and the Google group, we're
having another IPRUG curry night tomorrow. Meet at 7.30 in the Plough,
then we'll head off to Zaika at about 8.


"You are an aperture through which the universe is looking at and exploring itself." – Alan Watts
Learn about time/space complexity theory and fundamental algorithm analysis techniques
Generate a random sample of complexity questions and test your time/space complexity skills
O(n) where n is the size of your ❤


Our publishing tool, KAWO, needed to show users how the content they were creating would be consumed, and since over 80% of Weibo usage is on mobile we decided to create a preview of the Weibo iOS app that updates as they create their post.
For the purpose of this demo, images cannot be selected by the user but will be show according to the number of images specified.
MIT © KAWO Technologies


College of Chemistry Course Guide
Majors
List of Courses
Resources
Student Life
Chemistry Course Map
'
Chemical Engineering Course Map
'


- [php] - Contains the jqDatepicker PHP class .
- [themes] - Contains the themes shipped with the product. Since jqDatepicker supports jQuery UI Themeroller, any theme compatible with jQuery UI ThemeRoller will work for jqDatepicker as well. Therefore, the package contains just one theme ("Redmond"). You can download any additional themes directly from jQuery UI's ThemeRoller site available here:
http://jqueryui.com/themeroller/
Just add "Redmond" theme in your PHP/HTML file.
<link rel="stylesheet" type="text/css" href="themes/redmond/jquery-ui.custom.css" />
- [js] - The javascript files of jqDatepicker (and the needed libraries). You need to include them in your PHP page.
The first file is "jquery.js" - this is the official jQuery library.
The second file is "jquery-ui.custom.min.js" - this is the jQuery UI library.
The final result you will have in an PHP page containing jqDatepicker would be something similar to that:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>My First PHP jqAutocomplete </title> <link rel="stylesheet" type="text/css" media="screen" href="themes/redmond/jquery-ui.custom.css" /> <script src="js/jquery.js" type="text/javascript"></script> <script src="js/jquery-ui-1.8.1.custom.min.js" type="text/javascript"></script> </head> <body> ...... <div class="ui-widget"> <label for="mydate">Date: </label> <input id="mydate" /> </div> <?php include "datepicker.php";?> ....... </body> </html>
Save the file as datepicker.php or any desired name in the root directory.
<?php // include the jqUtils Class. The class is needed in all jqSuite components. require_once "php/jqUtils.php"; // include the datepicker Class require_once "php/jqCalendar.php"; $dp = new jqCalendar(); // Set it to mydate element $dp->renderCalendar("#mydate"); ?>
Run the file index.php from your web browser.


3. PrivacyCred system¶
3.1. Requirements¶
The journey of a certificate is completed in 3 distinct steps:
the collection and registration of data about the citizen and her associated characteristics,
the issuance of certificate, and
the presentation of the certificate to a verifier for its verification.
A certificate should rely on a minimum dataset. Included in the minimum dataset is a Unique Certificate Identifier (UCI), which could be used as a link to the underlying data registry.
The verifier of a certificate should be able to establish that:
The certificate has been issued by an authorised entity;
The information presented on the certificate is authentic, valid, and has not been altered;
The certificate can be linked to the holder of the certificate;
3.1.1. Main design principles and business requirements¶
The design of the trust framework for interoperable issuing of certificates and verification of their integrity and authenticity relies on key design principles listed below. The list is not prioritised. Instead, the trust framework that is specified later in the document attempts to optimise as many of the key design principles as possible.
- Data protection (including data minimisation, purpose limitation, etc.)
The trust framework should protect the data of the involved individual stakeholders (most importantly, certificate holders). This covers several data protection dimensions catered by the General Data Protection Regulation, including purpose limitation and data minimisation. In practice, only the bare minimum set of data that is required for the supported use cases should be processed (data minimisation) and the purpose of data collection should be checked against the use cases (purpose limitation).
Similarly, only the bare minimum set of data that is required for the supported use cases should be presented to a specific verifier (data minimisation) and the purpose of data presentation should be checked against the use cases (purpose limitation).
In order to achieve the latter, the trust framework may support different presentation datasets for different verifier scenarios. The data protection principle has a strong impact on the specification of the Minimum Dataset and the design of the use cases of the trust framework.
- Data security and privacy by design and by default
Abuse of data by actors (especially, the certificate verifiers and holders) and forgery should be prevented by any reasonable means. The trust framework should by design and default ensure the security and the privacy of data in the compliant implementations, ensuring both security and privacy.
Available tools should be used for restricting access to data and preventing malicious use of data, while the establishing of the authenticity of data and its link to the certificate holder should be ensured. The design should prevent the collection of identifiers or other similar data which might be crossreferenced with other data and re-used for tracking (‘Unlinkability’).
- Inclusiveness (especially medium-neutrality)
The trust framework should be inclusive especially towards the individual citizen (‘no citizen left behind’).
The design of the trust framework should attempt to maximize its support for diverse contexts (e.g., high resource vs low resource contexts).
To enable this, the trust framework should support a spectrum of certificate presentation media from plain paper certificate to augmented paper certificates (e.g., paper certificate with printed machinereadable parts such as barcodes, QR codes, Machine Readable Zones) and to purely digital certificates (e.g., in-app certificates).
The PrivacyCred system supports paper certificates, augmented paper certificates, QR codes and purely digital certificates.
In addition, contrary to many SSI Verifiable Credentials implementations, the PrivacyCred system is implemented as a PWA (Progressive Web App) that can be used simply in a mobile browser (or tablet/PC) without installing anything in the device or registering for anything.
However, the user can install the PWA in the device if the user so wishes to facilitate future uses. In any case, the system does not require any type of registration of the identity of the user.
- Simplicity and user-friendliness
It is very important that the trust framework is designed with simplicity and user-friendliness of the possible implementation of digital certificate systems in mind.
More formally, the trust framework should not have features or functionalities that would unnecessarily complicate the resulting implementation of a digital certificate system or make them unnecessarily difficult to use. Lack of simplicity could increase the time it takes to implement the compliant digital certificate systems, while lack of user friendliness could hinder the uptake of the resulting implementations. User-friendliness is relevant for quick and easy processing, specifically to certificate holders and to verifiers.
The PrivacyCred system follows the rule of Occam’s Razor eliminating any feature or functionality which is not strictly required for the use case.
This not only provides simplicity and user-friendlyness but also provides a system easier to understand and maintain which is more secure and robust.
- Implementation flexibility
The trust framework specifications should provide implementers with a variety of options when developing digital certificate systems according to the trust framework specifications. This key design principle aims at reducing the implementation time and leveraging/reusing existing infrastructures in involved entities.
To satisfy this principle, the trust framework specifies, whenever possible, a list of alternative methods, flows, architectures and implementation options, for example alternative presentation media, verification options, implementation technologies, etc. whilst still guaranteeing the same level of trustworthiness.
- Modularity and scalability
This is strongly linked with the previous key design principle. The trust framework architecture should be modular and easily scalable, for instance, to additional usage scenarios, use cases and types of certificates.
The trust framework already supports different usage scenarios (e.g. alternative settings in which certificates may be requested or verification may take place).
- Open standards
The trust framework should rely for its implementations on open standards, to the extent that this is possible. This will greatly contribute to the interoperability of the resulting implementations, in addition combined with open governance and open source implementations, it will instil trust in the involved stakeholders.
- Cross-border interoperability
Implementations of certificates that comply with the specifications of the trust framework should be interoperable, and not only at the national level.
This means that if Countries A and B implement the specifications, it should be possible for a verifier in Country B to verify a digital vaccination certificate that has been issued in Country A.
Cross-border interoperability should be ensured across EU and EEA countries. The Trust Framework should not prevent interoperability with the solutions designed on a global level.
3.1.2. ID binding and verification¶
An important parameter of the trust framework pertains to the identity of the subject of the certificate i.e., the person for whom the certificate is issued. The identity of this subject shall be bound to a certificate when the latter is issued (ID binding) and has to be verified when the certificate is being presented and verified (ID verification). These two processes (ID binding at the Issuance step and ID verification at the Presentation and Verification step) prevent possible impersonation attempts (i.e., a person fraudulently presenting a certificate that has been issued to someone else as if it were their own), and are in line with the data security and privacy by design and default principles of the trust framework.
The processes of ID binding and/or verification shall rely on (nationally and/or internationally) established methods for ID binding and verification. In other words, the trust framework does not specify in its architecture dedicated components or modalities for undertaking the ID binding and verification process.
The recommended methods for performing ID binding and verification are based on nationally issued identity proof documents, such as national IDs and passports, and regulated customer onboarding processes (in the case of private companies). The binding is performed at the time of issuance (ID binding) and verification (ID verification) of the certificate and therein personally identifying information held in the syetems of the entities involved should be compared against the information in the certificate.
Contrary to many SSI Verifiable Credentials implementations, the PrivacyCred system does not require any registration on the part of the user like registering her DID in the blockchain or any other repository, as the system relies in pre-existing identification processes (e.g., KYC for private companies).
The only personal information managed by the system is the one in the minimum dataset as specified in this document. The personal data elements are incorporated to the certificate and not used for any other thing or purpose. It is assumed that the minimal person identification data specified in this document can be used to perform the ID binding with a national ID, passport or any other suitable nationally issued identity document.
3.2. PrivacyCred: General description of the system¶
3.2.1. Main components¶
The main components are the following:
- Issuer Entity
The juridical person that digitally signs and issues a credential to the User. The Issuer Entity employs or subcontracts the actual people performing the process called Issuer Operator in the diagram. The Issuer Entity assumes full responsibility for the legal implications of the issueance process, especially GDPR compliance. The Issuer Entity acts as a Data Controller with respect to the Personal Information collected from the Citizen when the certification is issued.
- Issuer Operator
The natural person that is employed/subcontracted by the Issuer Entity to actually drive the process of issuing the credential on behalf of the Issuer Entity.
- Issuer Operator App
This is the application used by the natural person that drives the issuance of the credential. The application allows the operator to enter the details of the user and of the credential and issues the credential to the user on behalf of the Issuer Entity. It is the responsibility of the Issuer Entity to ensure that the Operator performs the process in the right way.
- Citizen
This is the natural person that receives a credential and may present it when needed.
- Citizen WebApp
This is the application used by the end user to manage the credentials. The reference implementation is not a native application but rather a PWA (Progressive Web App), which can be used either as a normal web app (without installation) or it can be installed and used in a very similar way to a native mobile app. The characteristics of this app are explained later.
- Verifier Entity
A juridical person that verifies the credential. In the process of verification, the Verifier Entity receives personal data from the Citizen. The Verifier Entity is responsible for compliance of all applicable regulations, including GDPR.
- Verifier Operator
A natural person that verifies the credential. It is important to distinguish between natural and juridical persons in the verification process because the flows may be different as the regulatory implications may be different. The diagram does not explicitly mention the Verifier Person, but it will be described in detail later in the document.
- Verifier App
The application used to verify the credential presented by the user. The reference application can be used either by an employee of a Verifier Entity or by an individual natural person, as explained later.
- Blockchain
This should be a Public-Permissioned blockchain network as a general-purpose blockchain network which is used to implement the Trust Framework allowing the efficient and secure verification of credentials. It is never used to store personal information. Personal information management is the responsibility of the legal entities Issuer Entity and Verifier Entity, and they are responsible for compliance to applicable regulations, especially GDPR. There may be more than one blockchain network, and the system is very interoperable across networks. The specific interoperability features are describer in a specific section later in this document.
3.2.2. Main credential flow¶
Verification of User and Credential issuance
The Issuer Operator identifies the User (in the same way as an airline employee identifies passengers before boarding a plane) and uses her mobile app to enter the details of the User. In the initial implementation of the system the operator has also to enter manually the details of the Credential to be issued. It is the responsibility of the Issuer Operator (and ultimately of the Issuer Entity) to ensure the veracity of both the User details and the Credential details. This is a critical point in the system, as the level of trust in the credentials will depend on the level of trust of the issuance process.
Sending the Credential to the Citizen
The Credential is sent to the User. There are several possible flows, using different channels (email, QR, etc.). The main one is using QR codes and is the following:
The Issuer Operator displays the credential for the User in her mobile phone screen, in a QR format. More detaisl about the specific QR format later.
The User scans the QR using her mobile web app.
The mobile web app of the User gets the Credential and stores it in the storage of the mobile device.
Store the Credential
The Credential is stored in the mobile phone of the User. In the reference implementation it is stored in the IndexedDB local database. More than one credential can be stored in the mobile. A Citizen could for example store credentials of other persons of the family when traveling, or a history track of credentials received during a vacation. More details are given later in this document.
Present the Credential
When the Citizen has to prove something, she sends the Credential to the Verifier. As before, there are several possible flows, the main one using QR codes:
The User display the Credential in her mobile phone in QR format.
The Verifier scans the QR from the User mobile screen
The mobile app from the Verifier receives the Credential and verifies it.
Verify the Credential using the Trust Framework in the blockchain
The Verifier mobile app verifies formally the Credential with the signature, and then checks that the signature of the Credential corresponds to an authorized Issuer Entity registered in the Trust Framework in the blockchain. The verification process is essentially the one described in the W3C VC specifications.
3.3. The Trust Framework: bootstrapping the system¶
Before the issuance of credentials can take place, the system has to be bootstrapped and setup. There are two processes that have to be performed:
A One-time process at the beginning of the whole system: involves things like deploying Smart Contracts and initializing them with the parameters of the system.
A process for the onboarding of each new Issuer Entity and Verifier Entity. This process is basically generating and registering in the blockchain the Identity of the entity entering the system.
3.3.1. Public-Permissioned blockchain network¶
The system requires at least one Public-Permissioned blockchain network. The network should be trusted, efficient, publicly available and compliant with all applicable regulations.
The system is designed to be easily interoperable with other Public-Permissioned blockchain networks, like LACChain or EBSI. This is described in detail in the appropriate section of this document.
3.3.2. Information in the blockchain and Personal Identifiable Information (PII)¶
No personal information is ever recorded on the blockchain. The blockchain is only used to register the identities of the legal persons involved in the system. The information recorded for businesses and organizations includes:
Public identification information of the legal person in the current regulatory environment, like VAT number, LEI (Legal Entity Identifier), or any legally accepted identification in the countries implementing the the system.
Some commercial information, like the web site
The public key used to verify the Verifiable Credentials digitally signed by the legal entity
The diagram below shows the registration of a new Issuer Entity in the blockchain. There are two types of legal persons registered in the blockchain:
Issuer Entity: a legal person has to be properly registered before it can issue any credential that can be verified by other actors in the system.
Verifier Entity: a legal person that receives and verifies credentials from natural persons has to be registered in the blockchain. When the legal person receives the credential (which includes personal data), this fact is registered in order to enhance auditability of the system later. This registration is performed in a privacy-preserving and scalable way. The process is described in detail later in this document. Natural persons can also verify credentials, but the verification process is different in order to avoid pre-registration of natural persons. This is described in detail later.
3.3.3. Trust Framework: trusted registration process of legal entities¶
The trust framework is designed to be largely decentralised.
The identities of the legal persons involved in the ecosystem are registered in a common directory implemented in the blockchain following a hierarchical scheme very similar to the DNS (Domain Name Service) schema in the Internet. Once an entity is registered in the system, it is completely autonomous for adding other entities that are managed as child entities.
However, there is one centralised element: the root of trust at the top of the hierarchy should be a trusted entity in the ecosystem that is the one bootstraping the system. Typically it should be a regulatory body or a public administration.
The approach is described in the following figure.
<IP_ADDRESS>. Creating identities¶
A new identity can only be registered as a sub-node by an existing entity already registered in the system. The API used is /api/did/v1/identifiers
and its definition is the following:
-
POST
/api/did/v1/identifiers
Create an Identity anchored in the blockchain.
- Request JSON Object
DID (string) – the DID of the new identity, example: “did:elsi:VATES-B60645900”
domain_name (string) – Domain name to assign in the hierarchy, example: “in2.ala”
website (string) – Website of the entity, example: “www.in2.es”
commercial_name (string) – Commercial name, example: “IN2 Innovating 2gether”
new_privatekey (PrivatekeyJWK) – The private key of the new entity
parent_privatekey (PrivatekeyJWK) – The Private Key of caller (in this case the owner of “ala”)
An example of the data in the request body:
{ "DID": "did:elsi:VATES-B60645900", "domain_name": "in2.ala", "website": "www.in2.es", "commercial_name": "IN2 Innovating 2gether", "new_privatekey": { "kty": "EC", "crv": "secp256k1", "d": "Dqv3jmu8VNMKXWrHkppr5473sLMzWBczRhzdSdpxDfI", "x": "FTiW0a4r7S2SwjL7AlFlN1yJNWF--4_x3XTTxkFbJ9o", "y": "MmpxbQCOZ0L9U6rLLkD_U8LRGwYEHcoN-DPnEdlpt6A" }, "parent_privatekey": { "kty": "EC", "crv": "secp256k1", "d": "Dqv3jmu8VNMKXWrHkppr5473sLMzWBczRhzdSdpxDfI", "x": "NKW_0Fs4iumEegzKoOH0Trwtje1sXsG9Z1949sA8Omo", "y": "g4B3EI0qIdlcXTn-2RpUxgVX-sxNFdqCQDD0aHztVkk" } }
- Response JSON Object
didDocument (DIDDocument) – The DID document associated to the input DID
A more detailed explanation of each field follows:
DID
is the DID of the new entity. We support ELSI DID method (ELSI_DID_Method) and AlastriaID. The DID has to be created before the call to the API with the appropriate method for the DID. In the case of ELSI this is trivial and described in the section mentioned above.
domain_name
the domain name for the new entity in the Trust Framework. In the example it is in2.ala because it will be a sub-node of the Alastria one. The new identity will be created as a child node of the existing node owned by the entity controlling the
parent_privatekey
. If the parent domain name specified here is not owned by the entity controlling theparent_privatekey
, an error is returned and no action is taken.website
the website address in the off-chain world, so other participants can look more information about the entity. This field is informational only. However, it can be used by external appications to check that the entity in th ereal world corresponds to the one registered in th eblockchain.
commercial_name
the name of the company as it appears in the official register of the country/region. For example, in the case of IN2 (a Spanish business), the name should be the one registered in the Business Registry of Spain.
new_privatekey
is the Private Key of the new entity, in JWK format. In this case the new entity is IN2. Please make sure the server being called is highly trusted.
parent_privatekey
is the Private Key of the entity owning/controlling the parent node in the domain name, in JWK format. In this case the parent node is ala, corresponding to Alastria. Please make sure the server being called is highly trusted. Ideally, the server has to be operated by the same entity calling the API.
3.4. Credential flows¶
3.4.1. Credential Issuance¶
The figure below describes the interaction flows between the Issuer and the Citizen. Here the term Issuer includes the mobile application of the Issuer Operator and the associated backend system of the Issuer Entity.
The main interaction consists on the transmission of the Verifiable Credential from the Issuer to the mobile of the Citizen. The transmission is initiated with a QR.
The flows and the APIs used are described in detail below.
The credential issuance process is the following:
Credential generation
The diagram assumes that the Issuer Operator starts the process for th ecreation of the credential, but other initiation mechanisms could be used depending on the context.
The system gathers existing data from the citizen from a previous identification process, like KYC.
The system stores the information and generates a credential in the standard W3C Verifiable Credential format.
The system then generates and displays a QR code that will be scanned by the Citizen to receive the Credential. The QR contains the URL in the Issuer’s system where the credential can be retrieved.
Citizen receives the Credential
The Citizen uses the webapp to scan the QR code displayed by the Issuer Operator
The Citizen mobile webapp uses the URL in the QR to get the credential in JWT format, signed by the Issuer.
Citizen webapp verifies the credential and signature of Issuer
The credential is verified as per the standard W3C Verifiable Credentials Implementation Guidelines.
The verification includes resolving in the blockchain the identity of the Issuer Entity specified by the Issuer DID in the credential. The Issuer DID is registered in the blockchain and it includes the Public Key used by the Issuer Entity to digitally sign the credential.
The Citizen mobile webapp uses a Universal Resolver to make this DID resolution and access the blockchain in read mode. The Universal Resolver is described in detail later in this document.
After verification the credential is stored in the local storage of the Citizen mobile device. The user has also the option to store the credential in encrypted form in one or more of the personal cloud storage systems she has (Google Drive, MS Onedrive, Dorpbox, …).
3.4.2. Credential Verification¶
The system supports the standard online verification process as is common in most implementations of an SSI system. But in addition it supports a special flow for on-person verification of credentials, for example when the credential has to be presented to a Verifier Operator in-person and it has to be verified by the Operator. This flow is useful when some process has to be performed in-person in the offices of the Verifier Entity, or even when for some reason it has to be performed out of the offices. In other words, when the citizen is not interacting directly with a web page of the Verifier Entity.
This is the flow represented in the following diagram.
3.5. ELSI: a DID Method for legal entities¶
The system supports several DID Methods using the Universal Resolver to resolve each DID into a corresponding DID Document. But the main DID Method used for legal persons, anchored into a Public-Permissioned blockchain, is ELSI: did:elsi.
3.5.1. ELSI DID syntax¶
The name ELSI stands for ETSI Legal person Semantics Identifier, because it is based on the Legal person semantic identifier defined in the European Norm ETSI EN 319 412-1, related to digital signatures, peer entity authentication, data authentication as well as data confidentiality.
The ELSI DID Method refers only to legal persons, so we are using the id-etsi-qcs-SemanticsId-Legal definition described in Section 5.1 of ETSI EN 319 412-1.
Creating a DID is extremely simple and fully decentralized (does not require participation of any central authority), assuming that the legal person already exists. Its definition using ABNF syntax is:
did = "did:elsi:" id-etsi-qcs-SemanticsId-Legal
Which is the concatenation of the prefix did:elsi: with the legal person identifier defined in ETSI EN 319 412-1. For the full syntax, please refer to the standards document, but for the two most common basic identifiers (VAT and LEI) the identifier is composed of:
3 character legal person identity type reference, like VAT for identification based on a national value added tax identification number or LEI for the Legal Entity Identifier.
2 character ISO 3166 [2] country code;
hyphen-minus “-” (0x2D (ASCII), U+002D (UTF-8)); and
identifier (according to country and identity type reference).
Some examples of DIDs are the following:
Name |
DID |
|---|---|
ENDESA ENERGÍA (www.endesa.com) |
did:elsi:VATES-A81948077 |
Ayuntamiento de Malaga (www.malaga.eu) |
did:elsi:VATES-P2906700F |
IN2 (www.ins.es) |
did:elsi:VATES-B60645900 |
Inter-American Development Bank (www.iadb.org) |
did:elsi:LEIXG-VKU1UKDS9E7LYLMACP54 |
DAA plc (Dublin Airport Authority) (www.daa.ie) |
did:elsi:LEIXG-635400HRFGVKXFHZ8O77 |
3.5.2. ELSI DID Document¶
An example DID Document is the following:
{
"payload": {
"@context": [
"https://www.w3.org/ns/did/v1",
"https://w3id.org/security/v1"
],
"id": "did:elsi:VATES-B60645900",
"verificationMethod": [
{
"id": "did:elsi:VATES-B60645900#key-verification",
"type": "JwsVerificationKey2020",
"controller": "did:elsi:VATES-B60645900",
"publicKeyJwk": {
"kid": "key-verification",
"kty": "EC",
"crv": "secp256k1",
"x": "3K4iNuzPkcrHlEbhHE8vYXlF6K5xGZ2rdOrn3cQ-LnQ",
"y": "9Z_l_hQLkq6aLuZz8gheq7R_o5ZUHUlxZ3IBGHsdzaA"
}
}
],
"service": [
{
"id": "did:elsi:VATES-B60645900#info",
"type": "EntityCommercialInfo",
"serviceEndpoint": "www.in2.es",
"name": "IN2 Innovating 2gether"
},
{
"id": "did:elsi:VATES-B60645900#sms",
"type": "SecureMessagingService",
"serviceEndpoint": "https://privatecred.hesusruiz.org/api"
}
],
"anchors": [
{
"id": "redt.alastria",
"resolution": "UniversalResolver",
"domain": "in2.ala",
"ethereumAddress": "0x8CDA8113567e633805e48c87747257E9FFAAdDF5"
}
],
"created": "2021-02-08T06:53:08Z",
"updated": "2021-02-08T06:53:08Z"
}
}
3.6. PrivacyCred Verifiable Credentials¶
3.6.1. Data Model¶
The PrivacyCred credential uses the standard W3C Verifiable Credentials Data Model for its representation, with some extensions to fit the requirements of this use case.
The specific credential data is encoded in the credentialSubject field of the VC. The following two figures represent the complete VC, where it has been divided in two parts to facilitate visualization.
The figure above represents the VC with standard fields and some extensions.
The iss field (issuer in VC terminology), uses the DID method
elsi
, specific for legal persons and explained in a section below.There is an extension to specify the blockchain network (or networks) where the VC can be verified. More precisely, the
issuedAt
field ofcredentialSubject
specifies the networks where the identity for the legal person that issued the credential can be verified.A legal person can have its elsi DID registered in one or more networks, and the same credential can be verified using any of those networks. The trust on the credential depends on the trust on the registration procedure of the identity of the signer. The Verifier entity can choose to verify the credential in whatever network is trusted to the Verifier.
This mechanism provides a lot of flexibility in interoperability schemes across networks. More details are described in the section on interoperability.
3.6.2. Example of Verifiable Credential¶
{
"exp":<PHONE_NUMBER>,
"iat":<PHONE_NUMBER>,
"iss": "did:elsi:VATES-X12345678X",
"sub": "46106508H",
"uuid": "829588b3162249d28f3eae5e84349777",
"vc": {
"@context": [
"https://www.w3.org/2018/credentials/v1",
"https://alastria.github.io/identity/credentials/v1",
"https://privacycred.org/.well-known/privacycred/v1"
],
"type": [
"VerifiableCredential",
"AlastriaVerifiableCredential",
"PrivacyCredential"
],
"credentialSchema": {
"id": "PrivacyCredential",
"type": "JsonSchemaValidator2018"
},
"credentialSubject": {
"privacyCredential": {
"citizen": {
"dob": "27-04-1982",
"idnumber": "46106508H",
"name": "COSTA/ALBERTO",
"type": "atRisk"
},
"comments": "These are some comments",
},
"issuedAt": [
"redt.alastria"
],
"levelOfAssurance": 2
}
}
}
3.7. Verification of the credentials¶
The system includes two APIs to help client applications with the verification of credentials received from other actors in the ecosystem. The choice of API depends on the trust level of the client application on the server implementing the APIs
-
GET
/api/did/v1/identifiers/
(string: DID) Resolves a DID and returns the DID Document (JSON format), if it exists. It supports four DID methods: ebsi, elsi, ala, peer.
Only PEER and ELSI (https://github.com/hesusruiz/SafeIsland#62-elsi-a-novel-did-method-for-legal-entities) are directly implemented by this API. The others are delegated to be resolved by their respective implementations.
For example, for EBSI we call the corresponding Universal Resolver API, currently in testing and available at https://api.ebsi.xyz/did/v1/identifiers/{did}
- Query Parameters
DID (string) – The DID to resolve into a DID Document.
- Response JSON Object
didDocument (payload) – The DID document associated to the input DID
- Status Codes
200 OK – no error
404 Not Found – error resolving the DID
Example request:
GET /api/did/v1/identifiers/did:elsi:VATES-B60645900 HTTP/1.1 Host: example.com Accept: application/json
Example response:
HTTP/1.1 200 OK Vary: Accept Content-Type: text/javascript { "payload": { "@context": [ "https://www.w3.org/ns/did/v1", "https://w3id.org/security/v1" ], "id": "did:elsi:VATES-B60645900", "verificationMethod": [ { "id": "did:elsi:VATES-B60645900#key-verification", "type": "JwsVerificationKey2020", "controller": "did:elsi:VATES-B60645900", "publicKeyJwk": { "kid": "key-verification", "kty": "EC", "crv": "secp256k1", "x": "3K4iNuzPkcrHlEbhHE8vYXlF6K5xGZ2rdOrn3cQ-LnQ", "y": "9Z_l_hQLkq6aLuZz8gheq7R_o5ZUHUlxZ3IBGHsdzaA" } } ], "service": [ { "id": "did:elsi:VATES-B60645900#info", "type": "EntityCommercialInfo", "serviceEndpoint": "www.in2.es", "name": "IN2 Innovating 2gether" }, { "id": "did:elsi:VATES-B60645900#sms", "type": "SecureMessagingService", "serviceEndpoint": "https://privatecred.hesusruiz.org/api" } ], "anchors": [ { "id": "redt.alastria", "resolution": "UniversalResolver", "domain": "in2.ala", "ethereumAddress": "0x8CDA8113567e633805e48c87747257E9FFAAdDF5" } ], "created": "2021-02-08T06:53:08Z", "updated": "2021-02-08T06:53:08Z" } }
In general, validating a credential involves the following:
Deserialize the JWT without verifying it (we do not yet have the public key).
Get the
kid
property from the header (the JOSE header of the JWT).The
kid
has the format did#id wheredid
is the DID of the issuer andid
is the identifier of the key in the DIDDocument associated to the DID.Perform resolution of the DID of the issuer with the Universal Resolver API.
Get the public key specified inside the DIDDocument.
Verify the JWT using the public key associated to the DID.
Verify that the DID in the
iss
field of the JWT payload is the same as the one that signed the JWT.
-
POST
/api/verifiable-credential/v1/verifiable-credential-validations
Is the easiest one to use and the one requiring higher level of trust. The client app just passes the JWT in the JWS Compact Serialization format (RFC 7519) as the body of a POST request and the server verifies the credential and credential signature using internally the Universal Resolver API for resolving the DID of the Issuer and checking its digital signature.
- Request JSON Object
credential (JWT) – The credential in JWT format.
- Response JSON Object
claims (object) – The JSON object with the verified claims in the JWT. Otherwise, an error
- Status Codes
200 OK – no error
404 Not Found – error resolving the DID
The easiest one to use is /api/verifiable-credential/v1/verifiable-credential-validations
, and it is the one requiring higher level of trust. The client app just passes the JWT in the JWS Compact Serialization format (RFC 7519) as the body of a POST request and the server verifies the credential and credential signature using internally the Universal Resolver API for resolving the DID of the Issuer and checking its digital signature.
/api/did/v1/identifiers/(string:DID)
is the Universal Resolver API. The client application will have to perform the validations that the server does in the previous call.


liver cells ACE TROP human TMPRSS expression SARS-CoV- progenitor cell epithelial fate fetal cluster high progenitors Expression Louvain patients Figure normal EPCAM cholangiocyte liver. cluster. clusters specific COVID- OpenUrl cells. infection analysis clustering using (blue) Cell KRT Note api. express expressed markers respiratory scanpy. tissue type types. viral hepatocyte low sc-RNA-seq (A) (B) (C) (D) (circled Liver colored entry genes indicating libraries receptor red). sample scRNA-seq study tumor used A.S., Engl Research associated bi-potent biased co-expression coronavirus enzyme gene heterogeneity highest infect investigated presence recent reported results solution tl. understand (E) (green) (orange), (red) ACE, Aizarani Cat#: CrossRef Dot-plot F.G., Figure- Importantly, Lancet P.K.H.C., PBS SOX Singapore Tissue Wang, co-express converting depicting followed identifies important level multiple novel observed priming reveals study. tract


makeweb: A static website generator
Makeweb is a simple Makefile-based static website generator designed to work on a modern UNIX system. The generator parses Markdown files into HTML5 documents, which can be hosted with any web server. Major features of makeweb include:
- Incremental build system;
- Makefile-based configuration;
- Markdown-based source files;
- Perl-based template and seperate CSS stylesheet.
This utility was originally based on John Hawthorn's This Website is a Makefile article.
Prerequisites
A modern UNIX system should have all of the required software pre-installated. However, ensure the following software is installed before proceeding:
Note that a web server, such as httpd(8), is needed to serve the HTML documents that are generated. Configuring a web server is not covered in this documentation.
This software was developed and tested using OpenBSD 6.7.
Usage
For every file with the .md
extension in the src/
tree, an index.html
HTML
document is generated in the htdocs/
tree. This document will be located in a
folder with the same name as the Markdown file. For example, src/foo/bar.md
will produce htdocs/foo/bar/index.html
. One exception to this rule is
src/index.md
, which generates htdocs/index.html
.
Any non-.md
file in the src/
tree will be copied to the htdocs/
tree
during the normal build process.
HTML documents are generated and published by using make(1). The following targets are available for use:
all
(default)Generates all HTML documents and copies all assets in the
src/
directory tree to thehtdocs/
directory. This is the default target.clean
Empties the
htdocs/
directory.htdocs
Copies all non-Markdown files in the
src/
directory tree to thehtdocs/
directory.html
Generates HTML documents from Markdown files in the
src/
tree. All documents will be stored in thehtdocs/
as described above. During the build process,style.css
will be copied tohtdocs/style.css
.preview
Publishes
htdocs/
to the preview directory specified in theMakefile.site
configuration file. If no directory is specified, an error will occur.publish
Publishes
htdocs/
to the web root directory specified in theMakefile.site
configuration file. If no directory is specified, an error will occur.
Additional targets exist, which are triggered before each target listed above.
These can be customized in the Makefile.site
configuration file and are
described in more detail below.
Makeweb comes with a standard template.pl
and style.css
, which can be
modified as required. The publish
and preview
targets will trigger errors
unless they are defined and non-empty in the Makefile.site
configuration file.
Configuration
Makeweb can be configured by editing the Makefile.site
configuration file.
This file is able to set or override any variable used by the Makefile
recipe. The default Makefile.site
configuration file contains configuration
examples and documents all variables which can be overridden. The PREVIEW-DIR
and PUBLISH-DIR
variables must be set, otherwise the preview
and publish
targets will cause an error to occur.
Each target listed above has an additional target, which is trigged before
execution of the original target. Custom recipes for these targets can be
created in Makefile.site
in order to customize the build process. If a
custom target fails, then the primary target will not execute. The following
custom targets are available: on-all
, on-assets
, on-build
, on-clean
,
on-preview
, on-publish
.
The preview
and publish targets
use rsync and so both local and remote
directories can be used. Remote directories may require user interactive for
password input.
Template
The file template.pl
is a Perl script which generates an HTML5 document from
a Markdown file, passed as a command line argument to the script. The default
template includes basic breadcrumb
and datestamp
functions. Modifying this
file will cause all pages to be re-generated on the next build.
Note that this script uses the Text::Markdown Perl module to
convert Markdown syntax into HTML. This module is included in the perl5lib/
directory.
Stylesheet
The default template generates HTML documents which will link to the
src/style.css
CSS file. Modifying this file will affect the
presentation of each generated HTML document, however re-building all HTML
documents is not necessary.
Bugs
Bug reports should be sent to<EMAIL_ADDRESS>Please provide as many details (operating system, software versions, etc) as possible when reporting bugs.
Before submitting a report, be sure you are using the lastest release from https://kzoo.tech/makeweb.
Downloads
- makeweb1a.tgz (21 kB)
History
2020-Aug-30, Release 1a
Initial release.
Copyright
Copyright (c) 2020, Andrew Alm <https://kzoo.tech>
Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


Mechanical engineering student at UC Berkeley with innovative design experience in the aerospace industry.
UC Berkeley Private Pilot Ground School (CE 99)
Developed nose cone electromagnetic fastening and pneumatic separation mechanisms for suborbital rocket powered by 3D-printed engine. Designed mobile crane capable of lifting 1 ton for transporting rocket propellant tanks. Assisted with rocket tests, design for 3D printed parts, and machining through product assembly.
Project LightForce aims to perturb debris orbits using photon pressure from ground-based lasers. Integrated Java with C++ using MinGW and the JNI framework to prepare for a more efficient deorbit propagator written in Java.
Collaborated with the PhoneSat team on the Nodes SmallSat Network. Published hardware test analyses for the two Nodes flight modules launched in 2015. Proofread circuit diagrams, tested launch-approved satellite hardware in clean room, and designated flight, test, and EDU solar panels for Nodes satellites by mapping panel output data.
AutoCAD, Solidworks, Ansys, Matlab, LabVIEW, Python, Thermodynamics, Manufacturing, Signals and Systems, Microprocessor Systems and Interfacing, Airport Design, Sustainable Mobility, Java, Mobile Development
Civil Air Patrol, Bicycle Racing
When I'm not developing or machining, I enjoy biking, flying, and catching up on my favorite YouTube channels. My Pandora playlist includes Indie (REM, Bon Iver) and Spanish Guitar (Johannes Linstead, Ottmar Liebert). Fun fact: My cycling elevation gain totals 30,000 ft below the Karman line.


{% extends "base_template.html" %} {% block title %}Modelr · Sign in{% endblock %} {% block content %}
Don't have an account? Sign up


Vocabulary for RecommendDosageChangeTypeSnCT
Description:
Assigned OID: the OID for the UK subset of SnomedCT, q.v.
Codes taken from the UK subset of SnomedCT representing a recommendation that the dosage of an ongoing medication should be changed, e.g. from '1 tablet 3 times a day with food' to '2 tablets 3 times a day with food'. If required, it may change the recommeded site(s) of administration (e.g. left arm).
Legend:
A code of TBA indicates that the SnCT code is not yet available.
+ after a code indicates that descendants of the code shall be used.
Values:
|
Version: |
01 |
|
Date: |
07th Jan 2005 |
| Level |
Code |
Description |
Note |
| 1 | 395067002 | optimisation of drug dosage (procedure) | Shall be present. |
| 1 | TBA | recommend (qualifier value) | Shall be present. A kind of context value for actions. |
| 1 | Zero to many sites at which medication administration is now recommended. Each site will comprise:- | ||
| 2 | 363704007 | procedure site (attribute) | Shall be present |
| 2 | 91723000+ | a descendant of anatomical structure (body structure) | Shall be present: anatomical site at which medication may be administered. Note that many descendants of anatomical structure .are meaningless in the context of medication administration. Each code may include qualifiers (e.g. for laterality) if required |
| 1 The status of the recommendation. Choice of one of: | |||
| 2 | TBA | proposed (qualifier value) | The recommendation has been made. |
| or | |||
| 2 | 385645004 | accepted (qualifier value) | The recommendation has been accepted. It is intended to change the dosage as recommended . and the recommendation should be related to the revised medication administration being recommended. |
| or | |||
| 2 | TBA | rejected (qualifier value) | The ecommendation has been rejected by person(s) to whom it was addressed. The recommended dosage change will not be made. |
| or | |||
| 2 | 89925002 | cancelled (qualifier value) | The recommendation has been withdrawn by its author. The recommended dosage change will not be made. |
| 1 End of choice |


BBC Radio on Spotify!
BBC Radio 1
BBC Radio 2
BBC 1Xtra
BBC 6 Music
Reviews
Related Artists
Clips
Votes!
Song 1
Song 2
Song 3


{% extends 'layout/stroe_layout.html' %} {% block content %}
Thank you. Your order has been received.


classdesc [-workdir directory] [-include include-file] [-I directory] [-nodef] [-respect_private] [-typeName] [-onbase] descriptors...
classdesc takes as its input the preprocessed model definition file, that contains all class definitions available to the model. It outputs a functor definition that recursively calls itself for each of the members of that class. If -workdir is specified, the functor definitions are written to the specified directory for later compilation into a library. The (pre-expanded) source header file should also be included via the -include switch so that all necessary types are defined. If -workdir is not specified, the functor definitions are output as inline declarations on standard output.
Normally, classdesc reads its input from standard input, but some operating systems have trouble with this (eg Windows, but not Cygwin). An alternative is to specify the input file using the -i flag.
If -I switches are specified, the specified directory will be added to the search path for the action base include files.
If a type has been forward declared (eg class foo;
), but not
defined in classdesc's input source, a dummy definition is emitted of
the form class foo {};
. The purpose of this is to ensure that
the action routines for types containing pointers to such declared
types will compile. This behaviour can be turned off by specifying the
-nodef
option to classdesc.
By default, classdesc will generate descriptors that access private
and protected members. If a class has private or protected members, a
CLASSDESC_ACCESS declaration needs
to be given to allow access to the private members. Alternatively, it
may be undesirable to expose the internals of an object, for example
if the object is being exposed to a different programming
environment. In such a case, the
-respect_private
can be used to
suppress the accessing of private or protected members.
By default, enums are treated as integers. Sometimes it is desirable
to treat them symbolically, and
this is managed by the -typeName
option.
-onbase
turns on the ability to distinguish between an action
called on a base class and one called on a member. If your descriptor
does not require this distinction, simply provide a method that calls
to the original descriptor:
template <class T> void pack_onbase(pack_t& x,const string& d,T& a) {::pack(x,d,a);}


- getCity() - Method in class com.kyrio.services.shared.Address
-
Gets a city or town name.
- getClientId() - Method in class com.kyrio.services.KyrioAccount
-
Gets identifier to confirm client who accesses the API.
- getCode() - Method in exception com.kyrio.services.KyrioException
-
Gets a unique code that defines error type.
- getCountryCode() - Method in class com.kyrio.services.shared.Address
-
Gets a country code.
- getEnableQaEnvironment() - Method in class com.kyrio.services.KyrioAccount
-
Checks if enabled calls to QA environment.
- getEnableTestError() - Method in class com.kyrio.services.KyrioAccount
-
Checks if enabled random errors while making test calls.
- getEnableTestLocal() - Method in class com.kyrio.services.KyrioAccount
-
Checks if enabled local test calls to return random responses.
- getEnableTestMock() - Method in class com.kyrio.services.KyrioAccount
-
Checks if enabled remote test calls to return random responses.
- getId() - Method in class com.kyrio.services.shared.Provider
-
Gets a 4-digit identifier will be returned for each provider.
- getLine1() - Method in class com.kyrio.services.shared.Address
-
Gets a street number, pre-directional, street name, suffix, post-directional
- getLine2() - Method in class com.kyrio.services.shared.Address
-
Gets a secondary address line such as Apt, Suite or Lot
- getLocationId() - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Gets unique location identifier (aka housekey) for the address.
- getLocationType() - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Gets a location type that contain the value ‘residential’ or ‘business’
if the provider characterizes the location.
- getName() - Method in class com.kyrio.services.shared.Provider
-
Gets a company name associated with the provider id.
- getPostalCode() - Method in class com.kyrio.services.shared.Address
-
Gets postal or zip code.
- getProvider() - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Gets company name associated with the provider id.
- getProviderId() - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Gets a 4-digit identifier will be returned for each provider.
- getServerUrl() - Method in class com.kyrio.services.KyrioAccount
-
Gets base url to connect to Kyrio servers.
- getSiteStatus() - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Gets a service status for the location (site).
- getState() - Method in class com.kyrio.services.shared.Address
-
Gets a state abbreviation or name.
- getStatus() - Method in exception com.kyrio.services.KyrioException
-
Gets HTTP response code returned by server.
- ServiceabilityClient - Class in com.kyrio.services.serviceability
-
Client to access Kyrio Serviceability API
- ServiceabilityClient(KyrioAccount) - Constructor for class com.kyrio.services.serviceability.ServiceabilityClient
-
Default client constractor.
- ServiceabilityResult - Class in com.kyrio.services.serviceability
-
Response from cable provider with service status for requested location.
- ServiceabilityResult() - Constructor for class com.kyrio.services.serviceability.ServiceabilityResult
-
Default constructor
- setCity(String) - Method in class com.kyrio.services.shared.Address
-
Sets a city or town name.
- setClientId(String) - Method in class com.kyrio.services.KyrioAccount
-
Sets identifier to confirm client who accesses the API.
- setCountryCode(String) - Method in class com.kyrio.services.shared.Address
-
Sets a country code.
- setEnableQaEnvironment(boolean) - Method in class com.kyrio.services.KyrioAccount
-
Enables calls to QA environment and sets default ServerUrl to QA servers.
- setEnableTestError(boolean) - Method in class com.kyrio.services.KyrioAccount
-
Enables random errors while making test calls.
- setEnableTestLocal(boolean) - Method in class com.kyrio.services.KyrioAccount
-
Enables local test calls and returns random responses.
- setEnableTestMock(boolean) - Method in class com.kyrio.services.KyrioAccount
-
Enables remote test calls and returns random responses.
- setId(String) - Method in class com.kyrio.services.shared.Provider
-
Sets a 4-digit identifier will be returned for each provider.
- setLine1(String) - Method in class com.kyrio.services.shared.Address
-
Sets a street number, pre-directional, street name, suffix, post-directional
- setLine2(String) - Method in class com.kyrio.services.shared.Address
-
Sets a secondary address line such as Apt, Suite or Lot
- setLocationId(String) - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Sets unique location identifier (aka housekey) for the address.
- setLocationType(LocationType) - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Sets a location type.
- setName(String) - Method in class com.kyrio.services.shared.Provider
-
Sets a company name associated with the provider id.
- setPostalCode(String) - Method in class com.kyrio.services.shared.Address
-
Sets a postal or zip code.
- setProvider(String) - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Sets a company name associated with the provider id.
- setProviderId(String) - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Sets a 4-digit identifier will be returned for each provider.
- setServerUrl(String) - Method in class com.kyrio.services.KyrioAccount
-
Sets base url to connect to Kyrio servers.
- setSiteStatus(SiteStatus) - Method in class com.kyrio.services.serviceability.ServiceabilityResult
-
Sets a service status for the location (site).
- setState(String) - Method in class com.kyrio.services.shared.Address
-
Sets a state abbreviation or name.
- SiteStatus - Enum in com.kyrio.services.serviceability
-
Determines service status of a site (location).


The $k$-means algorithm is an iterative method for clustering a set of $N$ points (vectors) into $k$ groups or clusters of points.
Algorithm
Repeat until convergence:
Find closest centroid
Find the closest centroid to each point, and group points that share the same closest centroid.
Update centroid
Update each centroid to be the mean of the points in its group.
Find closest centroid


{% extends "hint.html" %} {% block hint %}
Liberatore has encrypted his secret using a hash function! Luckily, he chose very weak hash function. Given the hashed flag, reverse-engineer the function to find the original value!
#!/usr/bin/env python3 from functools import reduce from base64 import b64encode def sweet_hash(string): x = 42 byte = [] for char in string: byte.append(x ^ ord(char)) x ^= ord(char) return b64encode(bytes(byte))
b'TCBBJl06WylQfRRzHXwIYRRnSj5bOlg3UypX'{% endblock %}


Back-end developer with 9+ years in IT background and 5 years in development. I am a programmer polyglot always eager to learn new technologies. Most recently I've been working with Ruby and JavaScript and now curious about Go and DevOps/System Administration. Problem solver, result-oriented and self-starter. Comfortable working remotely with teammates. But I can also work independently on a given task or project. Proven multitasking ability.


Stay up to date with ecommerce trends with Shopify's newsletter
Subscribe for free marketing tips
Interested in..
Marketing
Sales
Logistics
Oberloo


|
| virtual string | DragText [get, set] |
| |
| virtual bool | AllowParentInserts [get, set] |
| | Allow inserting a dragged node between an expanded parent node and its first child that will become a sibling of the parent when dropped. More...
|
| |
| virtual bool | AllowContainerDrops [get, set] |
| | True if drops on the tree container (outside of a specific tree node) are allowed. More...
|
| |
| virtual ? bool | AllowCopy [get, set] |
| | Set as true to allow the user to hold down the control key at the start of the drag operation and copy the dragged records between grids. Otherwise, dragged records will be moved. More...
|
| |
| virtual bool | ContainerScroll [get, set] |
| | True to register this container with the Scrollmanager for auto scrolling during drag operations. More...
|
| |
| virtual ? bool | Copy [get, set] |
| | Set as true to copy the records from the source grid to the destination drop grid. Otherwise, dragged records will be moved. More...
|
| |
| virtual string | DDGroup [get, set] |
| | A named drag drop group to which this object belongs. If a group is specified, then both the DragZones and DropZone used by this plugin will only interact with other drag drop objects in the same group. Defaults to: "TreeDD" More...
|
| |
| virtual string | DragGroup [get, set] |
| | The ddGroup to which the DragZone will belong. This defines which other DropZones the DragZone will interact with. Drag/DropZones only interact with other Drag/DropZones which are members of the same ddGroup. More...
|
| |
| virtual string | DropGroup [get, set] |
| | The ddGroup to which the DropZone will belong. This defines which other DragZones the DropZone will interact with. Drag/DropZones only interact with other Drag/DropZones which are members of the same ddGroup. More...
|
| |
| virtual bool | EnableDrag [get, set] |
| | Set to false to disallow dragging items from the View. Defaults to: true More...
|
| |
| virtual bool | EnableDrop [get, set] |
| | Set to false to disallow the View from accepting drop gestures. Defaults to: true More...
|
| |
| virtual bool | AppendOnly [get, set] |
| | True if the tree should only allow append drops (use for trees which are sorted). Defaults to: false More...
|
| |
| virtual int | ExpandDelay [get, set] |
| | The delay in milliseconds to wait before expanding a target tree node while dragging a droppable node over the target. Defaults to: 1000 More...
|
| |
| virtual string | NodeHighlightColor [get, set] |
| | The color to use when visually highlighting the dragged or dropped node (default value is light blue). The color must be a 6 digit hex value, without a preceding '#'. See also nodeHighlightOnDrop and nodeHighlightOnRepair. Defaults to: "c3daf9" More...
|
| |
| virtual bool | NodeHighlightOnDrop [get, set] |
| | Whether or not to highlight any nodes after they are successfully dropped on their target. Defaults to the value of Ext.enableFx. See also nodeHighlightColor and nodeHighlightOnRepair. More...
|
| |
| virtual bool | NodeHighlightOnRepair [get, set] |
| | Whether or not to highlight any nodes after they are repaired from an unsuccessful drag/drop. Defaults to the value of Ext.enableFx. See also nodeHighlightColor and nodeHighlightOnDrop. More...
|
| |
| virtual bool | AllowLeafDrop [get, set] |
| | true to allow append to the leaf node More...
|
| |
| virtual bool | SortOnDrop [get, set] |
| | Configure as true to sort the target node into the current tree sort order after the dropped node is added. Defaults to false. More...
|
| |
| ConfigItemCollection | CustomConfig [get] |
| | Collection of custom js config More...
|
| |
| MessageBusListeners | MessageBusListeners [get] |
| |
| MessageBusDirectEvents | MessageBusDirectEvents [get] |
| |
| virtual string | ItemID [get, set] |
| | An itemId can be used as an alternative way to get a reference to a component when no object reference is available.


--- title: About layout: page description: Who I am header-img: img/about-bg.jpg ---
I am researcher Francesco Gadaleta, PhD.  I have been involved in several projects that have shaped my career as research scientist in different domains. As researcher in Computer Science at the University of Leuven I developed novel hypervisor-based approaches to computer security, some of which became core technology at VMWare. Download my dissertation
As member of the Statistical Genetics Unit at the Department of Electrical Engineering and Computer Science of the University of Liège, I have been searching for solutions to integrate heterogeneous data (OMICS) within common analytics framework, assembling networks and merging clinical and genetic data together to make predictions about the risk of diseases for patients in a pre-symptomatic fashion.
I have been research data scientist at the Gasthuisberg Research Hospital located in Leuven, Belgium - one of the largest research hospitals in Europe - and member of the Non-Invasive-Prenatal-Testing NIPT research group.
I have been member of the Advanced Analytics Team of Johnson & Johnson where I designed and implemented the most accurate predictive models for disease interception and drug recommendation. In addition, I have adviced a number of big data technologies and strategies that turned out to be essential to the organization on a global scale.
I am currently Chief Scientist and Founder of fitchain.io, the decentralized machine learning factory. I am also Senior Advisor at Abe.ai
I am currently based in Belgium, traveling extensively across Europe and USA. During my spare time I enjoy (a lot) reading books and (even more) long distance running and photography When I feel inspired and get the time I enjoy photography. Here are my photo streams on Flickr and Tumblr
If you are interested in hiring me for speaking, writing, machine learning and artificial intelligence consulting, or other opportunities, feel free to contact me.
Security is as important as confidentiality and privacy. If you need to contact me in a confidential and secure way, please follow the best practices of encrypted/signed communication. I engage confidential communications on secure channels like Signal and Telegram. This site has been proved by keybase.io
I have a public key with fingerprint 3CB8 C721 FE99 BC98 38DC F463 BFDC E4EC CE3B 7327
My keybase website here
If you use these channels with parsimony, you will likely get an answer. Spamming is never welcome.


| For immediate release |
|
The Federal Open Market Committee decided today to lower its target for the federal funds rate by 50 basis points to 4-1/2 percent. In a related action, the Board of Governors approved a 50 basis point reduction in the discount rate to 4 percent. The FOMC has reviewed prospects for the economy in light of the information that has become available since its March meeting. A significant reduction in excess inventories seems well advanced. Consumption and housing expenditures have held up reasonably well, though activity in these areas has flattened recently. Although measured productivity probably weakened in the first quarter, the impressive underlying rate of increase that developed in recent years appears to be largely intact. Nonetheless, capital investment has continued to soften and the persistent erosion in current and expected profitability, in combination with rising uncertainty about the business outlook, seems poised to dampen capital spending going forward. This potential restraint, together with the possible effects of earlier reductions in equity wealth on consumption and the risk of slower growth abroad, threatens to keep the pace of economic activity unacceptably weak. As a consequence, the Committee agreed that an adjustment in the stance of policy is warranted during this extended intermeeting period. The Committee continues to believe that against the background of its long-run goals of price stability and sustainable economic growth and of the information currently available, the risks are weighted mainly toward conditions that may generate economic weakness in the foreseeable future. In taking the discount rate action, the Federal Reserve Board approved requests submitted by the Boards of Directors of the Federal Reserve Banks of Boston, New York, Philadelphia, Cleveland, Atlanta, Minneapolis, Dallas, and San Francisco. |


Quan Zhou, D.H. Feng, T. Sun. "A Shapley Value based Method for Allocating Carbon Obligation in Demand Side,"
IEEE Trans. on Smart Grid, Peer Reviewed. (Abstract)
Quan Zhou, D.H. Feng, C.B. Xu, etc. "Methods for Allocating Carbon Obligation in Demand Side:
a Comparative Study,"
Automation of Electric Power Systems, 2015,39(17):153-159.(Chinese EI). (Full PDF)
Quan Zhou, D.H. Feng, C. Fang, etc. "An Incentive-based Nodal Pricing Method Under Multiple Dual Solutions,"
Automation of Electric Power Systems,2014,38(13):38-44.(Chinese EI). (Full PDF)
T. Sun, D.H. Feng, Quan Zhou, etc. "Multi-Objective Optimization for Coordinated Routing and Charging: A Framework of Electric Vehicle Navigation Systems" Applied Energy (SCI indexed), Extended Abstract Accepted. (Abstract)
Conference Papers
Quan Zhou, T. Sun, T. Ding, D.H. Feng. "Application of carbon intensity in generation expansion planning: A comparative study,"
Power & Energy Society General Meeting, 2015 IEEE, Denver, CO, Accepted. (Full PDF)
D.H. Feng, Quan Zhou, Liang Zhang. "Congestion surplus minimization pricing solutions when Lagrange multipliers are not unique,"
Power & Energy Society General Meeting, 2015 IEEE, Denver, CO, Accepted. (Abstract)


Problem Solving
Saturday 29th February 2020
A time I got blocked on a simple problem was just yesterday when I was trying to solve the whereAreYou challenge as part of the Built-in Functions kata.
I had to make it return a number and my code was currently returning a string. I played around for so long thinking it was something to do with my code, when in the end it turned out to be such a silly, simple mistake - I had put the "else" rule in my if/else function to equal "Scooby isn't here!".
I did this right at the beginning when I was first writing out my code as I thought I might need something in case Scooby wasn't behind any of the doors, and then kind of just forgot about it. When I was looking for what the issue could be, it never crossed my mind that it was that string, even though it was staring right at me!
To solve this problem, I tried many of the problem-solving techniques we've discussed at EDA. The main ones I used were pseudocode, trying something, googling and finally asking my facilitator for help. That was when I finally realised what I'd done!
Throughout the process I felt frustrated but I learnt that sometimes the bug in the code is a lot more obvious than you might think. The main lesson I took away was to go over my code throroughly and make sure it needs and uses every single thing in it.
This is a tricker one for me to answer because I don't feel like I've done a whole lot of elegant problem-solving so far... In saying that, when I was completing the JavaScript Olympics kata, I used some problem solving to successfully (and fairly easily) solve the Odds Out challenge.
First I wrote what I wanted my function to do out in pseudocode. I tried a few different things and then remembered we'd done something very similar in the Super FizzBuzz kata. I used this to guide me to write the code for this challenge and also used Google to help me along the way.
I felt pretty calm and happy throughout the process, and super satisfied when my code worked pretty much first try! It definitely felt like progress was being made. The biggest lesson I took away from this experience is to refer back to previous code we've written as this can often be altered to fit the current challenge you're working on.
I feel pretty confident using most of the problem-solving techniques we've learnt about so far. As you can see from what I've written above, the ones I most commonly use/feel are the most helpful to me are:
Thanks for reading!
Ellora


ppmshift(1) ppmshift(1) NAME ppmshift - shift lines of a portable pixmap left or right by a random amount SYNOPSIS ppmshift shift [ppmfile] DESCRIPTION Reads a portable pixmap as input. Shifts every row of image data to the left or right by a certain amount. The 'shift' parameter determines by how many pixels a row is to be shifted at most. Another one of those effects I intended to use for MPEG tests. Unfortu‐ nately, this program will not help me here - it creates too random pat‐ terns to be used for animations. Still, it might give interesting results on still images. EXAMPLE Check this out: Save your favourite model's picture from something like alt.binaries.pictures.supermodels (ok, or from any other picture source), convert it to ppm, and process it e.g. like this, assuming the picture is 800x600 pixels: # take the upper half, and leave it like it is pnmcut 0 0 800 300 cs.ppm >upper.ppm # take the lower half, flip it upside down, dim it and distort it a little pnmcut 0 300 800 300 cs.ppm | pnmflip -tb | ppmdim 0.7 | ppmshift 10 >lower.ppm # and concatenate the two pieces pnmcat -tb upper.ppm lower.ppm >newpic.ppm The resulting picture looks like the image being reflected on a water surface with slight ripples. SEE ALSO ppm(5), pnmcut(1), pnmflip(1), ppmdim(1), pnmcat(1) AUTHOR Copyright (C) 1993 by Frank Neumann 16 November 1993 ppmshift(1)


ST. FRANCIS INSTITUTE OF TECHNOLOGY
- ☞ Approved by AICTE
- ☞ ISO 9001:2008 Certified
- ☞ Permanently Affiliated to University of Mumbai
- ☞ All UG programme NBA Accredited
| News |
|---|
To transform the students to be intellectual coders and thinkers who can efficiently solve problems using state of art technology.
To transform the students to be intellectual coders and thinkers who can efficiently solve problems using state of art technology.
To transform the students to be intellectual coders and thinkers who can efficiently solve problems using state of art technology.
To transform the students to be intellectual coders and thinkers who can efficiently solve problems using state of art technology.


Netlify Optimized Images
/.netlify/functions/f_webp,w_450/img/test.jpg
/.netlify/functions/f_webp,w_450/img/https://images.unsplash.com/photo-1514888286974-6c03e2ca1dba


{% load i18n %} {#
{{record.body}}
{{record.response}}
No Elastic queries were recorded during this request.
DEBUG is set to False. This means that Elastic query logging is disabled.
DEBUG
False


{% extends "core/base.html" %} {% load static %} {% block content %}
Enter your coupon code if you have one!


- 控制面板
{include file="public/_left" /}
{block name="right" /}
{/block}
{include file="public/_header" /}