How did I set up multiple flavors for an Android App under 5 minutes
Posted on July 18, 2017 in Development
Let's start with understanding few key terms.
Understanding differences between "Build Types", "Flavor" and "Build Variant"
***Build Types: Build Type refers to build and packaging settings like signing configuration for a project.
***Flavor: A flavor is used to specify custom features, minimum and target API levels, device and API requirements like layout, drawable and custom code (for example, if production code is slightly different than development code).
***Build Variant: The combination of Build Type and Flavor is known as Build Variant.
And, now time to dig deeper !
Android Apps: Flavors
Motivation
The motivation behind Android Flavors is code reuse and code maintainability. Time to time, we might want to publish different versions of the same app with slight changes in assets or functionality. For example, in free version of the app, you may want to show ads while in paid version, you may decide not to show ads and integrate in-app purchase or upfront price rather. That's where Android Flavors help us to achieve this flexibility.
Setting up Flavors in build.gradle
android {
flavorDimensions "version"
productFlavors {
freeVersion {
dimension "version"
}
paidVersion {
dimension "version"
}
}
}
These newly created flavors appears in "Build Variants" tab of Android Studio:
Note 1: You'll have to choose the configuration from "Build Variants" drop down menu before runnind the app on device/emulator.
Note 2: Starting Android Studion 3.0,
flavorDimension
attribute needs to be added.
Application Id
Each flavor can have its own application Id. An 'applicationId' makes a app in Play Store unique.
In this example, the free version will be published on Play Store with packageId/applicationId as com.pcc.flavors.free
and paid one will have com.pcc.flavors.paid
.
Note: I'll be showing build.gradle
with all the configuration until this point.
android {
flavorDimensions "version"
productFlavors {
freeVersion {
dimension "version"
applicationId "com.pcc.flavors.free"
}
paidVersion {
dimension "version"
applicationId "com.pcc.flavors.paid"
}
}
}
Configuring App's name
Each flavor can have its own name as well. For example, free version has app name shown to users
in Play Store as "Free Great App" and paid version has its name displayed in Play Store as "Paid Great App".
Let's see how this can be configured in build.gradle
.
android {
flavorDimensions "version"
productFlavors {
freeVersion {
//select the dimension of flavor
dimension "version"
//configure applicationId for app published to Play store
applicationId "com.pcc.flavors.free"
//Configure this flavor specific app name published in Play Store
resValue "string", "flavored_app_name", "Free Great App"
}
paidVersion {
dimension "version"
applicationId "com.pcc.flavors.paid"
resValue "string", "flavored_app_name", "Paid Great App"
}
}
}
Don't forget to use flavored_app_name
string resource from AndroidManifest.xml
to defined app's name:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.pcc.flavors">
<application
android:label="@string/flavored_app_name"
</application>
</manifest>
Flavor specific Icons for apps
Each differently named/flavored app may want to have its own icon. Lets see how would we achieve this.
First we have to create a flavor specific directory at the same level of main
. Basically, we need to mimic
the main
directory for each flavor to support fully functional flavors (when there's code changes are involved).
These directories must be named same as its flavor definition names. In our example, these two additional
directories are : freeVersion
and paidVersion
.
Make sure that you've the icon's name same as referenced from AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.pcc.flavors">
<application
android:icon="@mipmap/ic_launcher"
</application>
</manifest>
Finally, flavor some code !
It's very similar to flavoring icons for specific app. Remember that you've the same directory/package
structure across all the flavors. That's how the changes are overridden.
For demonstration purposes, I'll update TextView
widget text differently for each app. Free version's
TextView
will read "Hello Free Great App !", and Paid version will read : "Hello Paid App !".
It involves two steps:
1. Make sure that you've the same code directory structure.
2. Write your custom code !
Note: There's one gotcha though. You can't have the same class defined in src/main/java
and src/<flavorNmae>/java
directories. Gradle will throw Duplicate class error while building. Either you can have one class in src/main/java
or in other flavors. I've MainActivity2
in src/freeVersion/java
and src/paidVersion/java
, but not in src/main/java
. AndroidManifest.xml
has reference to MainActivity2
, so it picks MainActivity2
for a selected build variant's flavor.
Project structure would look like this:
Checkout the demo app in Github
Checkout this article on my blog


Joseph Hobbs
About
Portfolio
Contact
Portfolio
Hangman
RPG Game
Trivia Game
Nature Gifs
Train Schedule
LIRI Node App
Bamazon
Friend Finder
KC Star Article Scraper
Waterfall Clicky Game
Pet Purfect
Connect with Me


Hi, I'm Siddharth. I’m a high school senior student at Delhi Public School Bangalore South currently working as a Chief Engineering Officer [intern] at Foretag Inc. I contribute to back-end development at Foretag using Crystal, GraphQL, Javascript, etc. I want to integrate technology with our health care system with the help of drones. I love computers, physics, electronics and I want to be an innovator to make this world a better place.
- Name: Siddharth Iyer
- Age: 17 Years
- Citizenship: Indian
- Residence: Bangalore
- E-mail: siddharth@itsezsid.com


Denann provides the most intutive designs suited to your needs at very competitive rates
Denann provides the most intutive designs suited to your needs at very competitive rates
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in.


DfE enquiries
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Press release
The Education Secretary and children’s author issue a call to publishers and schools to make English pupils Europe’s most literate.
Education Secretary Nicky Morgan and children’s author and comedian David Walliams today issued a rallying cry to leading publishers, schools and early years providers to join forces in a bid to make English pupils the most literate in Europe in 5 years.
Above all, the role of parents in getting their children reading is critical. To help parents get more children reading before they start school, the Department for Education has created new resources in conjunction with 4Children to equip parents and early years providers with high-quality activities and resources that help their children master the essentials of language.
To ensure all children have access to our nation’s vast literary heritage, Nicky Morgan today (24 September 2015) also called on leading publishers to give secondary schools access to classic novels by great English authors such as Jane Austen, Charles Dickens or Emily Bronte at low cost, making sure every young person can discover and enjoy these classic works.
These measures build on successful government reforms that have seen substantial and rapid progress towards tacking illiteracy since 2010. A strong emphasis on high-quality phonics teaching has enabled more children to master the essentials of reading quickly.
At a speech made during a visit to Charles Dickens Primary School in London today, Education Secretary Nicky Morgan said:
If a child fails to learn how to read, the consequences can be nothing short of devastating, holding them back for the rest of their lives.
I am absolutely determined to make sure that every child, no matter where they live or what their background, learns to read, to read widely and to read well - giving them the best opportunity to get on in life.
In fact, we’re going further than that - in the next 5 years, I want children in this country to become the best readers in Europe.
David Walliams said:
At the heart of this campaign is a very simple shared ambition - to get more children reading.
Few things can compete with the joy of getting stuck into a good book and I believe that is something no child should miss out on.
International surveys show that 9- and 10-year-olds in England are currently ranked sixth in Europe - although the best readers in this country are already the best readers in Europe. Nicky Morgan has said she wants to tackle the ‘long tail of underachievement’ which is still leaving too many children behind, in particular the most disadvantaged.
The ambition set out today represents the next phase of an ambitious literacy campaign first launched in August. The campaign also includes partnering with the Reading Agency to extend its popular Chatterbooks model by creating at least 200 new book clubs across the country and a shared ambition to see every 8-year-old enrolled at their local library.
To improve collaboration between schools, the Department for Education will also identify top primary schools with effective strategies for getting young people reading so that every school can learn from their success. This will ensure literacy teaching across all schools is built on the best evidence from organisations such as the Education Endowment Foundation.
The literacy campaign is part of the government’s one nation approach to social justice which will ensure every child is able to reach their potential, regardless of birth or background.
Evidence shows that children who develop strong reading skills early on are more likely to succeed at school, achieve good qualifications and go on to succeed in their adult lives and the world of work.
Speaking today, Nicky Morgan added:
There is no silver bullet, no magic wand we can wave to magically transform literacy for every child in this country.
But we owe it to our young people to explore every possible path when it comes to getting them reading well, to break down any barriers, support any who are left behind - to introduce every child, from every background to our incredibly rich heritage of world-famous children’s literature. Then we can trust those books to do the rest.
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Published: 24 September 2015


Mohr'
Circle for Stress or for finite Strain
This
Program plots either Mohr's circle
for stress or Mohr's circle for
finite strain. When you click either 'Stress' or 'finite strain'
in the menu 'Mohr's circle', the button 'continue' becomes active.
Clicking this button brings you to the form for data input and
evaluation.


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.incometaxsubscriptioneligibilityfrontend.config.AppConfig @import uk.gov.hmrc.incometaxsubscriptioneligibilityfrontend.views.html.templates.principal_main_template @()(implicit request: Request[_], messages: Messages, appConfig: AppConfig) @principal_main_template(title = messages("cannot_sign_up.title")) {
@messages("cannot_sign_up.income.para")
@messages("cannot_sign_up.other.para")
@Html(messages("cannot_sign_up.send_self_assessment", {messages("cannot_sign_up.send_self_assessment.link")} ))
}


Documentation
We have created a documentation page for each feature in SODA. You can find the documentation site by clicking on the button below:
View Documentation


001package com.avaje.ebean.annotation; 002 003import java.lang.annotation.ElementType; 004import java.lang.annotation.Retention; 005import java.lang.annotation.RetentionPolicy; 006import java.lang.annotation.Target; 007 008import com.avaje.ebean.Query; 009 010/** 011 * Assign to a property to be based on a SQL formula. 012 *
 013 * This is typically a SQL Literal value, SQL case statement, SQL function or 014 * similar. 015 *
 016 *
 017 * Any property based on a formula becomes a read only property. 018 *
 019 *
 020 * You may also put use the Transient annotation with the Formula annotation. 021 * The effect of the Transient annotation in this case is that the formula will 022 * NOT be included in queries by default - you have to explicitly include 023 * it via {@link Query#select(String)} or {@link Query#fetch(String, String, com.avaje.ebean.FetchConfig)}. 024 * You may want to do this if the Formula is relatively expensive and only want 025 * it included in the query when you explicitly state it. 026 *
 027 * 028 *
 029 * // On the Order "master" bean 030 * // ... a formula using the Order details 031 * // ... sum(order_qty*unit_price) 032 * @Transient 033 * @Formula(select = "_b${ta}.total_amount", join = "join (select order_id, sum(order_qty*unit_price) as total_amount from o_order_detail group by order_id) as _b${ta} on _b${ta}.order_id = ${ta}.id") 034 * Double totalAmount; 035 * 036 *
 037 *
 038 * As the totalAmount formula is also Transient it is not included by default in 039 * queries - it needs to be explicitly included. 040 *
 041 * 042 *
{@code 043 * 044 * // find by Id 045 * Order o1 = Ebean.find(Order.class) 046 * .select("id, totalAmount") 047 * .setId(1).findUnique(); 048 * 049 * // find list ... using totalAmount in the where clause 050 * List<Order> list = Ebean.find(Order.class) 051 * .select("id, totalAmount") 052 * .where() 053 * .eq("status", Order.Status.NEW) 054 * .gt("totalAmount", 10) 055 * .findList(); 056 * 057 * // as a join from customer 058 * List<Customer> l0 = Ebean.find(Customer.class) 059 * .select("id, name") 060 * .fetch("orders", "status, totalAmount") 061 * .where() 062 * .gt("id", 0) 063 * .gt("orders.totalAmount", 10) 064 * .findList(); 065 * 066 * }
 067 */ 068@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE }) 069@Retention(RetentionPolicy.RUNTIME) 070public @interface Formula { 071 072 /** 073 * The SQL to be used in the SELECT part of the SQL to populate a property. 074 */ 075 String select(); 076 077 /** 078 * OPTIONAL - the SQL to be used in the JOIN part of the SQL to support the 079 * formula. 080 *
 081 * This is commonly used to join a 'dynamic view' to support aggregation such 082 * as count, sum etc. 083 *
 084 *
 085 * The join string should start with either "left join" or "join". 086 *
 087 * 088 *
 089 * You will almost certainly use the "${ta}" as a place holder for the table 090 * alias of the table you are joining back to (the "base table" of the entity 091 * bean). 092 *
 093 *
 094 * The example below is used to support a total count of topics created by a 095 * user. 096 *
 097 * 098 *
{@code 099 * 100 * join (select user_id, count(*) as topic_count from f_topic group by user_id) as _tc on _tc.user_id = ${ta}.id 101 * 102 * }
 103 */ 104 String join() default ""; 105 106}


{% extends "settings/settings_base.html" %} {% block settings_tabs %}
{{error}}
{{ form.about.errors }}
Briefly tell us about yourself
Example:
No highlighting
{{ form.rules.errors }}
Any special requirements when people rent your book?
(You can also edit this for individual books)


Contains methods for creating multivariate interpolations of functions on a hypercube. If available through fftw3, the DCT-II/FFT is used to compute coefficients for a Chebyshev interpolation. Other interpolation methods for arbitrary Cartesian grids are also provided, a piecewise multilinear, and the Floater-Hormann barycenter method. For scattered data polyharmonic splines with a linear term is provided. The time-critical parts are written in C for speed. All interpolants are parallelized if used to evaluate more than one point.
| Version: | 2.0 |
| Imports: | compiler, stats, geometry |
| Suggests: | lattice, knitr, cubature, plot3D |
| Published: | 2018-09-15 |
| Author: | Simen Gaure [aut, cre] (Ragnar Frisch Centre for Economic Research) |
| Maintainer: | Simen Gaure <Simen.Gaure at frisch.uio.no> |
| BugReports: | https://github.com/sgaure/chebpol/issues |
| License: | Artistic-2.0 |
| Copyright: | 2013-2018, Simen Gaure |
| URL: | https://github.com/sgaure/chebpol |
| NeedsCompilation: | yes |
| SystemRequirements: | fftw3 (>= 3.1.2), gsl |
| Classification/ACM: | G.1.2 |
| Classification/MSC: | 41A05, 41A10, 41A50, 41A63, 65D05, 65T40 |
| Materials: | NEWS |
| In views: | NumericalMathematics |
| CRAN checks: | chebpol results |
| Reference manual: | chebpol.pdf |
| Vignettes: |
Details of package chebpol Usage notes for package chebpol Description of the stalker spline |
| Package source: | chebpol_2.0.tar.gz |
| Windows binaries: | r-devel: chebpol_2.0.zip, r-release: chebpol_2.0.zip, r-oldrel: chebpol_2.0.zip |
| OS X binaries: | r-release: chebpol_2.0.tgz, r-oldrel: chebpol_2.0.tgz |
| Old sources: | chebpol archive |
Please use the canonical form https://CRAN.R-project.org/package=chebpol to link to this page.


AWS ECS Load Balanced Autoscaling CICD
index.html
AWS > ECS > Load Balanced with phpsdk installed .
Reading Data from RDS:
SELECT * FROM readreplica1.profiles;
Thanks to..
https://github.com/awslabs/ecs-refarch-continuous-deployment
phpinfo
insert


After helping you declutter, Marie Kondo wants you to buy a homeware collection
Marie Kondo made her name by advising people how to declutter. If it doesn’t ‘spark joy’, get rid of it.
But now she’s encouraging fans to buy items from her online store.
The author and TV star has created an online shop with 125 home and self-care products.
In a message on her KonMari website, she said that it ‘is a collection of my favourite things and items that spark joy for me.’
She added that once people declutter their lives, they should add ‘meaningful objects, people and experiences’ into their lives.
‘Meaningful objects’ in the range include a $52 (£40.21) tea scoop, $24 (£18.56) crumb brush, and a $42 (£32) specifically shaped to carry a bouquet of flowers.
You can also get $206 (£159) leather room shoes and a $115 (£88) linen kimono robe.
For $75 (£58), you can get a tuning fork and clear quartz crystal that apparently ‘creates pure tones that help to restore a sense of balance.’
Advertisement Advertisement
Speaking to the Wall Street Journal, Marie said it’s not about replacing the items you already have, but just about showing people what she likes to have in her own home.
She said: ‘What’s most important to me is that you surround yourself with items that spark joy.
‘If the bowl that you’re using currently sparks joy for you, I don’t encourage replacing it at all.’
The post on her website adds that her method isn’t about getting rid of things but realising what is and isn’t giving you joy.
Speaking about her collection, she added: ‘I hope these items spark joy for you – and for your loved ones! They make beautiful gifts for anyone seeking to establish new routines, elevate their everyday tasks or create a joyful home.
‘Just remember to complete your tidying and to use that experience to purchase mindfully. My intention is that you will cherish these items and use them for years to come.’


Package big_query_write (2.4.0)
API documentation for bigquery_storage_v1.services.big_query_write
package.
Classes
BigQueryWriteAsyncClient
BigQuery Write API. The Write API can be used to write data to BigQuery. For supplementary information about the Write API, see: https://cloud.google.com/bigquery/docs/write-api
BigQueryWriteClient
BigQuery Write API. The Write API can be used to write data to BigQuery. For supplementary information about the Write API, see: https://cloud.google.com/bigquery/docs/write-api


Post a bid, and find people in your community to perform odd jobs for you.
Bidders post odd jobs and what they are willing to pay.
Jobbers let Bidders know they are interested in offering their services.
Bidders contact interested jobbers to get the job done!


PostgreSQL can be extended to run user-supplied code in separate processes. Such processes are started, stopped and monitored by postgres, which permits them to have a lifetime closely linked to the server's status. These processes have the option to attach to PostgreSQL's shared memory area and to connect to databases internally; they can also run multiple transactions serially, just like a regular client-connected server process. Also, by linking to libpq they can connect to the server and behave like a regular client application.
| Warning |
There are considerable robustness and security risks in using background worker processes because, being written in the C language, they have unrestricted access to data. Administrators wishing to enable modules that include background worker process should exercise extreme caution. Only carefully audited modules should be permitted to run background worker processes. |
Background workers can be initialized at the time that
PostgreSQL is started by including the module name in
shared_preload_libraries. A module wishing to run a background
worker can register it by calling
RegisterBackgroundWorker(BackgroundWorker *worker)
from its _PG_init()
. Background workers can also be started
after the system is up and running by calling the function
RegisterDynamicBackgroundWorker(BackgroundWorker
*worker, BackgroundWorkerHandle **handle)
. Unlike
RegisterBackgroundWorker
, which can only be called from within
the postmaster, RegisterDynamicBackgroundWorker
must be
called from a regular backend.
The structure BackgroundWorker is defined thus:
typedef void (*bgworker_main_type)(void *main_arg); typedef struct BackgroundWorker { char bgw_name[BGW_MAXLEN]; int bgw_flags; BgWorkerStartTime bgw_start_time; int bgw_restart_time; /* in seconds, or BGW_NEVER_RESTART */ bgworker_main_type bgw_main; char bgw_library_name[BGW_MAXLEN]; /* only if bgw_main is NULL */ char bgw_function_name[BGW_MAXLEN]; /* only if bgw_main is NULL */ Datum bgw_main_arg; int bgw_notify_pid; } BackgroundWorker;
bgw_name is a string to be used in log messages, process listings and similar contexts.
bgw_flags is a bitwise-or'd bitmask indicating the capabilities that the module wants. Possible values are BGWORKER_SHMEM_ACCESS (requesting shared memory access) and BGWORKER_BACKEND_DATABASE_CONNECTION (requesting the ability to establish a database connection, through which it can later run transactions and queries). A background worker using BGWORKER_BACKEND_DATABASE_CONNECTION to connect to a database must also attach shared memory using BGWORKER_SHMEM_ACCESS, or worker start-up will fail.
bgw_start_time is the server state during which postgres should start the process; it can be one of BgWorkerStart_PostmasterStart (start as soon as postgres itself has finished its own initialization; processes requesting this are not eligible for database connections), BgWorkerStart_ConsistentState (start as soon as a consistent state has been reached in a hot standby, allowing processes to connect to databases and run read-only queries), and BgWorkerStart_RecoveryFinished (start as soon as the system has entered normal read-write state). Note the last two values are equivalent in a server that's not a hot standby. Note that this setting only indicates when the processes are to be started; they do not stop when a different state is reached.
bgw_restart_time is the interval, in seconds, that postgres should wait before restarting the process, in case it crashes. It can be any positive value, or BGW_NEVER_RESTART, indicating not to restart the process in case of a crash.
bgw_main is a pointer to the function to run when the process is started. This function must take a single argument of type void * and return void. bgw_main_arg will be passed to it as its only argument. Note that the global variable MyBgworkerEntry points to a copy of the BackgroundWorker structure passed at registration time. bgw_main may be NULL; in that case, bgw_library_name and bgw_function_name will be used to determine the entrypoint. This is useful for background workers launched after postmaster startup, where the postmaster does not have the requisite library loaded.
bgw_library_name is the name of a library in which the initial entrypoint for the background worker should be sought. It is ignored unless bgw_main is NULL. But if bgw_main is NULL, then the named library will be dynamically loaded by the worker process and bgw_function_name will be used to identify the function to be called.
bgw_function_name is the name of a function in a dynamically loaded library which should be used as the initial entrypoint for a new background worker. It is ignored unless bgw_main is NULL.
bgw_notify_pid is the PID of a PostgreSQL backend process to which the postmaster should send SIGUSR1 when the process is started or exits. It should be 0 for workers registered at postmaster startup time, or when the backend registering the worker does not wish to wait for the worker to start up. Otherwise, it should be initialized to MyProcPid.
Once running, the process can connect to a database by calling
BackgroundWorkerInitializeConnection(char *dbname, char *username)
.
This allows the process to run transactions and queries using the
SPI interface. If dbname is NULL,
the session is not connected to any particular database, but shared catalogs
can be accessed. If username is NULL, the process will run as
the superuser created during initdb.
BackgroundWorkerInitializeConnection can only be called once per background
process, it is not possible to switch databases.
Signals are initially blocked when control reaches the
bgw_main function, and must be unblocked by it; this is to
allow the process to customize its signal handlers, if necessary.
Signals can be unblocked in the new process by calling
BackgroundWorkerUnblockSignals
and blocked by calling
BackgroundWorkerBlockSignals
.
Background workers are expected to be continuously running; if they exit
cleanly, postgres will restart them immediately. Consider doing
interruptible sleep when they have nothing to do; this can be achieved by
calling WaitLatch()
. Make sure the
WL_POSTMASTER_DEATH flag is set when calling that function, and
verify the return code for a prompt exit in the emergency case that
postgres itself has terminated.
When a background worker is registered using the
RegisterDynamicBackgroundWorker
function, it is
possible for the backend performing the registration to obtain information
regarding the status of the worker. Backends wishing to do this should
pass the address of a BackgroundWorkerHandle * as the second
argument to RegisterDynamicBackgroundWorker
. If the
worker is successfully registered, this pointer will be initialized with an
opaque handle that can subsequently be passed to
GetBackgroundWorkerPid(BackgroundWorkerHandle *, pid_t *)
or
TerminateBackgroundWorker(BackgroundWorkerHandle *)
.
GetBackgroundWorker
can be used to poll the status of the
worker: a return value of BGWH_NOT_YET_STARTED indicates that
the worker has not yet been started by the postmaster;
BGWH_STOPPED indicates that it has been started but is
no longer running; and BGWH_STARTED indicates that it is
currently running. In this last case, the PID will also be returned via the
second argument.
TerminateBackgroundWorker
causes the postmaster to send
SIGTERM to the worker if it is running, and to unregister it
as soon as it is not.
In some cases, a process which registers a background worker may wish to
wait for the worker to start up. This can be accomplished by initializing
bgw_notify_pid to MyProcPid and
then passing the BackgroundWorkerHandle * obtained at
registration time to
WaitForBackgroundWorkerStartup(BackgroundWorkerHandle
*handle, pid_t *)
function.
This function will block until the postmaster has attempted to start the
background worker, or until the postmaster dies. If the background runner
is running, the return value will BGWH_STARTED, and
the PID will be written to the provided address. Otherwise, the return
value will be BGWH_STOPPED or
BGWH_POSTMASTER_DIED.
The worker_spi contrib module contains a working example, which demonstrates some useful techniques.
The maximum number of registered background workers is limited by max_worker_processes.


Hi! My name is Anne Wangari. I am Web Developer and soccer player by proffesion, i'm very passionate and dedicated to my work.From a young age. I have been a tech enthusiast. I am extremly motivated to constantly develop my software development skills and grow professionally. I am someone who's persistant,a quick learner and loves problem solving by using simple and scalable solutions. I believe everything on this planet is Art!
254 Spine Road
Komarocks, Nairobi
+254 704326658
+254 786820078
annekare3@gmail
mwaswanga@gmail.com


@() @main("Welcome!", 8){
This is a simple web based UI for working with programming courses database. This project is created as a course work for database and databanks subject at TTI.
Available Exclusively for Premium Members
My name is Vladislav. I am second year student in computer science at TSI. I am passionate about software development and Java.
I have chosen to create web for user interface because at the moment I am investing my time into studying libraries and frameworks for creating web based solutions with Java. For this project I decided to try Play Framework for implementing MVC model.
Presented by Vladislav Yakushin


--- layout: default title: "404: Page not found" date: 2017-10-20 permalink: 404.html ---
The requested page could not be found. Could it be somewhere else? Not in the freezer though...
Head back home and try to find it again.


HI I'M A TEST
Pleased to meet you, obviously I haven't got much to say other than that I'm a test page.


Toggle navigation
Menu
About
Apps
Contact
DXC Digital Health Platform
Accelerating digital health transformations
Find Out More
DXC Digital Health Platform
Components
Lorenzo EMR
Better, safer care.
Lorenzo BI
Discover the stories inside your data.
Lorenzo Care Logistics
Scheduling and healthcare resource management.
ClinicalAide
Clinician Engagement - patients records at your fingertips
PatientAide
Patient Engagement - patients and their carers access to their own record
Lorenzo Medication Management
Reduce medication errors and improve patient outcomes.
Open Health Connect - Analytics Workbench
Leveraging data across the healthcare enterprise.
Open Health Connect - Insight Workbench
Leveraging data across the healthcare enterprise.
ManageMyHealth
Secure personal health portal.
Ready to start your digital health journey?
Contact us today.
healthsolutions@dxc.com


My name is Ahmad Shalan, I was porn in June 10th 1988. I am married and have one daughter called Ghena. I live in Amman, Jordan. I studied Electrical Engineering in Just University.
my email adress is<EMAIL_ADDRESS>I worked in different companies for the last 10 years and currently I joined this course to get new career as software proffeional developer.


Given scores of N athletes, find their relative ranks and the people with the top three highest scores, who will be awarded medals: “Gold Medal”, “Silver Medal” and “Bronze Medal”.
Example 1:
1 2 3 4
Input: [5, 4, 3, 2, 1] Output: ["Gold Medal", "Silver Medal", "Bronze Medal", "4", "5"] Explanation: The first three athletes got the top three highest scores, so they got "Gold Medal", "Silver Medal" and "Bronze Medal". For the left two athletes, you just need to output their relative ranks according to their scores.
Note:
N is a positive integer and won’t exceed 10,000.
All the scores of athletes are guaranteed to be unique.
Given the root of a tree, you are asked to find the most frequent subtree sum. The subtree sum of a node is defined as the sum of all the node values formed by the subtree rooted at that node (including the node itself). So what is the most frequent subtree sum value? If there is a tie, return all the values with the highest frequency in any order.
Examples 1 Input:
1 2 3
5 / \ 2 -3
return [2, -3, 4], since all the values happen only once, return all of them in any order.
Examples 2 Input:
1 2 3
5 / \ 2 -5
return [2], since 2 happens twice, however -5 only occur once.
Note: You may assume the sum of values in any subtree is in the range of 32-bit signed integer.


|
»Home
|
llvm-py: Python Bindings for LLVMllvm-py provides Python bindings for LLVM. It’s goal is to expose enough of LLVM APIs to implement a compiler backend or a VM in pure Python. llvm-py consists of Python and C modules that wrap over the native C++/C bindings of LLVM, and does not use / have dependencies on "glue utilities" like Boost.Python, swig etc. llvm-py is available as a source package (only). It works / should work with GNU/Linux, *BSD and Mac OS X platforms, on both 32-bit and 64-bit architectures. Python 2.4 or better (but 3.x is untested) is required. The SVN HEAD usually works with the latest released LLVM. In case you discover that any of these claims are wrong, feel free to send across a patch. News
|


Echarts is a JavaScript toolkit for creating interactive time series graphs. Echarts provides the elements you need to create interactive graphs: renderers, legends, hovers, range selectors, etc. You put the pieces together.
Echarts: JavaScript toolkit for creating interactive time series graphs.
View the official
documentation
This project is an attempt to build re-usable charts and chart components for d3.js without taking away the power that d3.js gives you. This is a very young collection of components, with the goal of keeping these components very customizeable, staying away from your standard cookie cutter solutions.
NVD3: Re-usable charts for d3.js
View the official
documentation
Echarts plugin generates sparklines (small inline charts) directly in the browser using data supplied either inline in the HTML, or via typescript. The plugin is compatible with most modern browsers and has been tested with Firefox 2+, Safari 3+, Opera 9, Google Chrome and Internet Explorer 9 & 10 as well as iOS and Android.
Echarts Sparkline
View the official
documentation


This appendix describes an extension to Scheme that allows programs to define and use new derived expression types. A derived expression type that has been defined using this extension is called a macro.
Derived expression types introduced using this extension have the syntax
(<keyword> <datum>*)
where <keyword> is an identifier that uniquely determines the expression type. This identifier is called the syntactic keyword, or simply keyword, of the macro. The number of the <datum>s, and their syntax, depends on the expression type.
Each instance of a macro is called a use of the macro. The set of rules, or more generally the procedure, that specifies how a use of a macro is transcribed into a more primitive expression is called the transformer of the macro.
The extension described here consists of three parts:
With this extension, there are no reserved identifiers. The syntactic keyword of a macro may shadow variable bindings, and local variable bindings may shadow keyword bindings. All macros defined using the pattern language are "hygienic" and "referentially transparent":
This appendix is divided into three major sections. The first section describes the expressions and definitions used to introduce macros, i.e. to bind identifiers to macro transformers.
The second section describes the pattern language. This pattern language is sufficient to specify most macro transformers, including those for all the derived expression types from section 4.2 Derived expression types. The primary limitation of the pattern language is that it is thoroughly hygienic, and thus cannot express macros that bind identifiers implicitly.
The third section describes a low-level macro facility that could be used to implement the pattern language described in the second section. This low-level facility is also capable of expressing non-hygienic macros and other macros whose transformers cannot be described by the pattern language, and is important as an example of a more powerful facility that can co-exist with the high-level pattern language.
The particular low-level facility described in the third section is but one of several low-level facilities that have been designed and implemented to complement the pattern language described in the second section. The design of such low-level macro facilities remains an active area of research, and descriptions of alternative low-level facilities will be published in subsequent documents.
`Define-syntax', `let-syntax', and `letrec-syntax' are analogous to `define', `let', and `letrec', but they bind syntactic keywords to macro transformers instead of binding variables to locations that contain values. Furthermore, there is no `define-syntax' analogue of the internal definitions described in section 5.2.2 Internal definitions.
Rationale: As discussed below, the syntax and scope rules for definitions give rise to syntactic ambiguities when syntactic keywords are not reserved. Further ambiguities would arise if `define-syntax' were permitted at the beginning of a <body>, with scope rules analogous to those for internal definitions.
These new expression types and the pattern language described in section Pattern language are added to Scheme by augmenting the BNF in section 7.1 Formal syntax with the following new productions. Note that the identifier `...' used in some of these productions is not a metasymbol.
<expression> --> <macro use> | <macro block> <macro use> --> (<keyword> <datum>*) <keyword> --> <identifier> <macro block> --> (let-syntax (<syntax spec>*) <body>) | (letrec-syntax (<syntax spec>*) <body>) <syntax spec> --> (<keyword> <transformer spec>) <transformer spec> --> (syntax-rules (<identifier>*) <syntax rule>*) <syntax rule> --> (<pattern> <template>) <pattern> --> <pattern identifier> | (<pattern>*) | (<pattern>+ . <pattern>) | (<pattern>* <pattern> <ellipsis>) | <pattern datum> <pattern datum> --> <vector> | <string> | <character> | <boolean> | <number> <template> --> <pattern identifier> | (<template element>*) | (<template element>+ . <template>) | <template datum> <template element> --> <template> | <template> <ellipsis> <template datum> --> <pattern datum> <pattern identifier> --> <any identifier except `...'> <ellipsis> --> <the identifier `...'> <command or definition> --> <syntax definition> <syntax definition> --> (define-syntax <keyword> <transformer spec>) | (begin <syntax definition>*)
Although macros may expand into definitions in any context that permits definitions, it is an error for a definition to shadow a syntactic keyword whose meaning is needed to determine whether some definition in the group of top-level or internal definitions that contains the shadowing definition is in fact a definition, or is needed to determine the boundary between the group and the expressions that follow the group. For example, the following are errors:
(define define 3) (begin (define begin list)) (let-syntax ((foo (syntax-rules () ((foo (proc args ...) body ...) (define proc (lambda (args ...) body ...)))))) (let ((x 3)) (foo (plus x y) (+ x y)) (define foo x) (plus foo x)))
Syntax: <Bindings> should have the form
((<keyword> <transformer spec>) ...)
Each <keyword> is an identifier, each <transformer spec> is an instance of `syntax-rules', and <body> should be a sequence of one or more expressions. It is an error for a <keyword> to appear more than once in the list of keywords being bound.
Semantics: The <body> is expanded in the syntactic environment obtained by extending the syntactic environment of the `let-syntax' expression with macros whose keywords are the <keyword>s, bound to the specified transformers. Each binding of a <keyword> has <body> as its region.
(let-syntax ((when (syntax-rules () ((when test stmt1 stmt2 ...) (if test (begin stmt1 stmt2 ...)))))) (let ((if #t)) (when if (set! if 'now)) if)) ==> now (let ((x 'outer)) (let-syntax ((m (syntax-rules () ((m) x)))) (let ((x 'inner)) (m)))) ==> outer
Syntax: Same as for `let-syntax'.
Semantics: The <body> is expanded in the syntactic environment obtained by extending the syntactic environment of the `letrec-syntax' expression with macros whose keywords are the <keyword>s, bound to the specified transformers. Each binding of a <keyword> has the <bindings> as well as the <body> within its region, so the transformers can transcribe expressions into uses of the macros introduced by the `letrec-syntax' expression.
(letrec-syntax ((or (syntax-rules () ((or) #f) ((or e) e) ((or e1 e2 ...) (let ((temp e1)) (if temp temp (or e2 ...))))))) (let ((x #f) (y 7) (temp 8) (let odd?) (if even?)) (or x (let temp) (if y) y))) ==> 7
Syntax: The <keyword> is an identifier, and the <transformer spec> should be an instance of `syntax-rules'.
Semantics: The top-level syntactic environment is extended by binding the <keyword> to the specified transformer.
(define-syntax let* (syntax-rules () ((let* () body1 body2 ...) (let () body1 body2 ...)) ((let* ((name1 val1) (name2 val2) ...) body1 body2 ...) (let ((name1 val1)) (let* ((name2 val2) ...) body1 body2 ...)))))
Syntax: <Literals> is a list of identifiers, and each <syntax rule> should be of the form
(<pattern> <template>)
where the <pattern> and <template> are as in the grammar above.
Semantics: An instance of `syntax-rules' produces a new macro transformer by specifying a sequence of hygienic rewrite rules. A use of a macro whose keyword is associated with a transformer specified by `syntax-rules' is matched against the patterns contained in the <syntax rule>s, beginning with the leftmost <syntax rule>. When a match is found, the macro use is transcribed hygienically according to the template.
Each pattern begins with the keyword for the macro. This keyword is not involved in the matching and is not considered a pattern variable or literal identifier.
Rationale: The scope of the keyword is determined by the expression or syntax definition that binds it to the associated macro transformer. If the keyword were a pattern variable or literal identifier, then the template that follows the pattern would be within its scope regardless of whether the keyword were bound by `let-syntax' or by `letrec-syntax'.
An identifier that appears in the pattern of a <syntax rule> is a pattern variable, unless it is the keyword that begins the pattern, is listed in <literals>, or is the identifier "`...'". Pattern variables match arbitrary input elements and are used to refer to elements of the input in the template. It is an error for the same pattern variable to appear more than once in a <pattern>.
Identifiers that appear in <literals> are interpreted as literal identifiers to be matched against corresponding subforms of the input. A subform in the input matches a literal identifier if and only if it is an identifier and either both its occurrence in the macro expression and its occurrence in the macro definition have the same lexical binding, or the two identifiers are equal and both have no lexical binding.
A subpattern followed by `...' can match zero or more elements of the input. It is an error for `...' to appear in <literals>. Within a pattern the identifier `...' must follow the last element of a nonempty sequence of subpatterns.
More formally, an input form F matches a pattern P if and only if:
It is an error to use a macro keyword, within the scope of its binding, in an expression that does not match any of the patterns.
When a macro use is transcribed according to the template of the matching <syntax rule>, pattern variables that occur in the template are replaced by the subforms they match in the input. Pattern variables that occur in subpatterns followed by one or more instances of the identifier `...' are allowed only in subtemplates that are followed by as many instances of `...'. They are replaced in the output by all of the subforms they match in the input, distributed as indicated. It is an error if the output cannot be built up as specified.
Identifiers that appear in the template but are not pattern variables or the identifier `...' are inserted into the output as literal identifiers. If a literal identifier is inserted as a free identifier then it refers to the binding of that identifier within whose scope the instance of `syntax-rules' appears. If a literal identifier is inserted as a bound identifier then it is in effect renamed to prevent inadvertent captures of free identifiers.
(define-syntax let (syntax-rules () ((let ((name val) ...) body1 body2 ...) ((lambda (name ...) body1 body2 ...) val ...)) ((let tag ((name val) ...) body1 body2 ...) ((letrec ((tag (lambda (name ...) body1 body2 ...))) tag) val ...)))) (define-syntax cond (syntax-rules (else =>) ((cond (else result1 result2 ...)) (begin result1 result2 ...)) ((cond (test => result)) (let ((temp test)) (if temp (result temp)))) ((cond (test => result) clause1 clause2 ...) (let ((temp test)) (if temp (result temp) (cond clause1 clause2 ...)))) ((cond (test)) test) ((cond (test) clause1 clause2 ...) (or test (cond clause1 clause2 ...))) ((cond (test result1 result2 ...)) (if test (begin result1 result2 ...))) ((cond (test result1 result2 ...) clause1 clause2 ...) (if test (begin result1 result2 ...) (cond clause1 clause2 ...))))) (let ((=> #f)) (cond (#t => 'ok))) ==> ok
The last example is not an error because the local variable `=>' is renamed in effect, so that its use is distinct from uses of the top level identifier `=>' that the transformer for `cond' looks for. Thus, rather than expanding into
(let ((=> #f)) (let ((temp #t)) (if temp ('ok temp))))
which would result in an invalid procedure call, it expands instead into
(let ((=> #f)) (if #t (begin => 'ok)))
Although the pattern language provided by `syntax-rules' is the preferred way to specify macro transformers, other low-level facilities may be provided to specify more complex macro transformers. In fact, `syntax-rules' can itself be defined as a macro using the low-level facilities described in this section.
The low-level macro facility described here introduces `syntax' as a new syntactic keyword analogous to `quote', and allows a <transformer spec> to be any expression. This is accomplished by adding the following two productions to the productions in section 7.1 Formal syntax and in section Binding syntactic keywords above.
<expression> --> (syntax <datum>) <transformer spec> --> <expression>
The low-level macro system also adds the following procedures:
unwrap-syntax identifier->symbol identifier? generate-identifier free-identifier=? construct-identifier bound-identifier=?
Evaluation of a program proceeds in two logical steps. First the program is converted into an intermediate language via macro-expansion, and then the result of macro expansion is evaluated. When it is necessary to distinguish the second stage of this process from the full evaluation process, it is referred to as "execution."
Syntax definitions, either lexical or global, cause an identifier to be treated as a keyword within the scope of the binding. The keyword is associated with a transformer, which may be created implicitly using the pattern language of `syntax-rules' or explicitly using the low-level facilities described below.
Since a transformer spec must be fully evaluated during the course of expansion, it is necessary to specify the environment in which this evaluation takes place. A transformer spec is expanded in the same environment as that in which the program is being expanded, but is executed in an environment that is distinct from the environment in which the program is executed. This execution environment distinction is important only for the resolution of global variable references and assignments. In what follows, the environment in which transformers are executed is called the standard transformer environment and is assumed to be a standard Scheme environment.
Since part of the task of hygienic macro expansion is to resolve identifier references, the fact that transformers are expanded in the same environment as the program means that identifier bindings in the program can shadow identifier uses within transformers. Since variable bindings in the program are not available at the time the transformer is executed, it is an error for a transformer to reference or assign them. However, since keyword bindings are available during expansion, lexically visible keyword bindings from the program may be used in macro uses in a transformer.
When a macro use is encountered, the macro transformer associated with the macro keyword is applied to a representation of the macro expression. The result returned by the macro transformer replaces the original expression and is expanded once again. Thus macro expansions may themselves be or contain macro uses.
The syntactic representation passed to a macro transformer encapsulates information about the structure of the represented form and the bindings of the identifiers it contains. These syntax objects can be traversed and examined using the procedures described below. The output of a transformer may be built up using the usual Scheme list constructors, combining pieces of the input with new syntactic structures.
Syntax: The <datum> may be any external representation of a Scheme object.
Semantics: `Syntax' is the syntactic analogue of `quote'. It creates a syntactic representation of <datum> that, like an argument to a transformer, contains information about the bindings for identifiers contained in <datum>. The binding for an identifier introduced by `syntax' is the closest lexically visible binding. All variables and keywords introduced by transformers must be created by `syntax'. It is an error to insert a symbol in the output of a transformation procedure unless it is to be part of a quoted datum.
(symbol? (syntax x)) ==> #f (let-syntax ((car (lambda (x) (syntax car)))) ((car) '(0))) ==> 0 (let-syntax ((quote-quote (lambda (x) (list (syntax quote) 'quote)))) (quote-quote)) ==> quote (let-syntax ((quote-quote (lambda (x) (list 'quote 'quote)))) (quote-quote)) ==> error
The second `quote-quote' example results in an error because two raw symbols are being inserted in the output. The quoted `quote' in the first `quote-quote' example does not cause an error because it will be a quoted datum.
(let-syntax ((quote-me (lambda (x) (list (syntax quote) x)))) (quote-me please)) ==> (quote-me please) (let ((x 0)) (let-syntax ((alpha (lambda (e) (syntax x)))) (alpha))) ==> 0 (let ((x 0)) (let-syntax ((alpha (lambda (x) (syntax x)))) (alpha))) ==> error (let-syntax ((alpha (let-syntax ((beta (syntax-rules () ((beta) 0)))) (lambda (x) (syntax (beta)))))) (alpha)) ==> error
The last two examples are errors because in both cases a lexically bound identifier is placed outside of the scope of its binding. In the first case, the variable `x' is placed outside its scope. In the second case, the keyword `beta' is placed outside its scope.
(let-syntax ((alpha (syntax-rules () ((alpha) 0)))) (let-syntax ((beta (lambda (x) (alpha)))) (beta))) ==> 0 (let ((list 0)) (let-syntax ((alpha (lambda (x) (list 0)))) (alpha))) ==> error
The last example is an error because the reference to `list' in the transformer is shadowed by the lexical binding for `list'. Since the expansion process is distinct from the execution of the program, transformers cannot reference program variables. On the other hand, the previous example is not an error because definitions for keywords in the program do exist at expansion time.
Note: It has been suggested that `#'<datum>' and `#`<datum>' would be felicitous abbreviations for `(syntax <datum>)' and `(quasisyntax <datum>)', respectively, where `quasisyntax', which is not described in this appendix, would bear the same relationship to `syntax' that `quasiquote' bears to `quote'.
Returns #t if syntax-object represents an identifier, otherwise returns #f.
(identifier? (syntax x)) ==> #t (identifier? (quote x)) ==> #f (identifier? 3) ==> #f
If syntax-object is an identifier, then it is returned unchanged. Otherwise `unwrap-syntax' converts the outermost structure of syntax-object into a data object whose external representation is the same as that of syntax-object. The result is either an identifier, a pair whose car and cdr are syntax objects, a vector whose elements are syntax objects, an empty list, a string, a boolean, a character, or a number.
(identifier? (unwrap-syntax (syntax x))) ==> #t (identifier? (car (unwrap-syntax (syntax (x))))) ==> #t (unwrap-syntax (cdr (unwrap-syntax (syntax (x))))) ==> ()
Returns #t if the original occurrences of id1 and id2 have the same binding, otherwise returns #f. `free-identifier=?' is used to look for a literal identifier in the argument to a transformer, such as `else' in a `cond' clause. A macro definition for `syntax-rules' would use `free-identifier=?' to look for literals in the input.
(free-identifier=? (syntax x) (syntax x)) ==> #t (free-identifier=? (syntax x) (syntax y)) ==> #f (let ((x (syntax x))) (free-identifier=? x (syntax x))) ==> #f (let-syntax ((alpha (lambda (x) (free-identifier=? (car (unwrap-syntax x)) (syntax alpha))))) (alpha)) ==> #f (letrec-syntax ((alpha (lambda (x) (free-identifier=? (car (unwrap-syntax x)) (syntax alpha))))) (alpha)) ==> #t
Returns #t if a binding for one of the two identifiers id1 and id2 would shadow free references to the other, otherwise returns #f. Two identifiers can be `free-identifier=?' without being `bound-identifier=?' if they were introduced at different stages in the expansion process. `Bound-identifier=?' can be used, for example, to detect duplicate identifiers in bound-variable lists. A macro definition of `syntax-rules' would use `bound-identifier=?' to look for pattern variables from the input pattern in the output template.
(bound-identifier=? (syntax x) (syntax x)) ==> #t (letrec-syntax ((alpha (lambda (x) (bound-identifier=? (car (unwrap-syntax x)) (syntax alpha))))) (alpha)) ==> #f
Returns a symbol representing the original name of id. `Identifier->symbol' is used to examine identifiers that appear in literal contexts, i.e., identifiers that will appear in quoted structures.
(symbol? (identifier->symbol (syntax x))) ==> #t (identifier->symbol (syntax x)) ==> x
Returns a new identifier. The optional argument to `generate-identifier' specifies the symbolic name of the resulting identifier. If no argument is supplied the name is unspecified.
`Generate-identifier' is used to introduce bound identifiers into the output of a transformer. Since introduced bound identifiers are automatically renamed, `generate-identifier' is necessary only for distinguishing introduced identifiers when an indefinite number of them must be generated by a macro.
The optional argument to `generate-identifier' specifies the symbolic name of the resulting identifier. If no argument is supplied the name is unspecified. The procedure `identifier->symbol' reveals the symbolic name of an identifier.
(identifier->symbol (generate-identifier 'x)) ==> x (bound-identifier=? (generate-identifier 'x) (generate-identifier 'x)) ==> #f (define-syntax set*! ; (set*! (<identifier> <expression>) ...) (lambda (x) (letrec ((unwrap-exp (lambda (x) (let ((x (unwrap-syntax x))) (if (pair? x) (cons (car x) (unwrap-exp (cdr x))) x))))) (let ((sets (map unwrap-exp (cdr (unwrap-exp x))))) (let ((ids (map car sets)) (vals (map cadr sets)) (temps (map (lambda (x) (generate-identifier)) sets))) `(,(syntax let) ,(map list temps vals) ,@(map (lambda (id temp) `(,(syntax set!) ,id ,temp)) ids temps) #f))))))
Creates and returns an identifier named by symbol that behaves as if it had been introduced where the identifier id was introduced.
`Construct-identifier' is used to circumvent hygiene by creating an identifier that behaves as though it had been implicitly present in some expression. For example, the transformer for a structure definition macro might construct the name of a field accessor that does not explicitly appear in a use of the macro, but can be constructed from the names of the structure and the field. If a binding for the field accessor were introduced by a hygienic transformer, then it would be renamed automatically, so that the introduced binding would fail to capture any references to the field accessor that were present in the input and were intended to be within the scope of the introduced binding.
Another example is a macro that implicitly binds `exit':
(define-syntax loop-until-exit (lambda (x) (let ((exit (construct-identifier (car (unwrap-syntax x)) 'exit)) (body (car (unwrap-syntax (cdr (unwrap-syntax x)))))) `(,(syntax call-with-current-continuation) (,(syntax lambda) (,exit) (,(syntax letrec) ((,(syntax loop) (,(syntax lambda) () ,body (,(syntax loop))))) (,(syntax loop)))))))) (let ((x 0) (y 1000)) (loop-until-exit (if (positive? y) (begin (set! x (+ x 3)) (set! y (- y 1))) (exit x)))) => 3000
The extension described in this appendix is the most sophisticated macro facility that has ever been proposed for a block-structured programming language. The main ideas come from Eugene Kohlbecker's PhD thesis on hygienic macro expansion [Kohlbecker86], written under the direction of Dan Friedman [hygienic], and from the work by Alan Bawden and Jonathan Rees on syntactic closures [Bawden88]. Pattern-directed macro facilities were popularized by Kent Dybvig's non-hygienic implementation of `extend-syntax' [Dybvig87].
At the 1988 meeting of this report's authors at Snowbird, a macro committee consisting of Bawden, Rees, Dybvig, and Bob Hieb was charged with developing a hygienic macro facility akin to `extend-syntax' but based on syntactic closures. Chris Hanson implemented a prototype and wrote a paper on his experience, pointing out that an implementation based on syntactic closures must determine the syntactic roles of some identifiers before macro expansion based on textual pattern matching can make those roles apparent. William Clinger observed that Kohlbecker's algorithm amounts to a technique for delaying this determination, and proposed a more efficient version of Kohlbecker's algorithm. Pavel Curtis spoke up for referentially transparent local macros. Rees merged syntactic environments with the modified Kohlbecker's algorithm and implemented it all, twice [macrosthatwork].
Dybvig and Hieb designed and implemented the low-level macro facility described above. Recently Hanson and Bawden have extended syntactic closures to obtain an alternative low-level macro facility. The macro committee has not endorsed any particular low-level facility, but does endorse the general concept of a low-level facility that is compatible with the high-level pattern language described in this appendix.
Several other people have contributed by working on macros over the years. Hal Abelson contributed by holding this report hostage to the appendix on macros.


Hope you are doing well!
Welcome to the travel blogs by Aparajita
Please follow this link →
Kashid : a weekend tourist spot near Mumbai and Pune
a travel blog based on my visit to the Kashid beach town (Raigad, Maharashtra) with my friends on Feb, 2019
In picture, a local beach in Kashid
Raigad, Konkan region, Maharashtra, India


?Herbarium
of
the
Arnold
Arboretum
Harvard
University
PLANTS
OF
Antigua
No.
391
Johns.
Beard
0ct
^
gg
19^
)
a.
0c.
“Boxwood."
Tree
10
m.
high;
trunk
15
om.
dlara.
In
dry
woodlands
of
limestone
hills;
common,
and
also
on
Barbuda.
Half-Moon
Bay.
.
-
BOTANIHA,
01443634™"
01443634
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


--- layout: post status: publish published: true title: Random but Evenly Distributed Sets of Numbers author: display_name: Geoff Lane login: admin email<EMAIL_ADDRESS>url: http://www.zorched.net author_login: admin author_email<EMAIL_ADDRESS>author_url: http://www.zorched.net date: '2010-04-17 16:18:27 -0400' date_gmt: '2010-04-17 22:18:27 -0400' categories: - Code - Python tags: [] comments: - id: 18067 author: Cara author_email<EMAIL_ADDRESS>author_url: '' date: '2012-07-23 11:48:14 -0400' date_gmt: '2012-07-23 17:48:14 -0400' content: "I am curious if this would be a solution for my problem; would this work for me?\r\nI have X number of groups to make (X changes based on the number of participants I have vs the number allowed per group - in my case 10 are allowed per group with an unknown number of participants.) I have it set up to take the number of participants divided by the number allowed per group to give me the number of groups that I have. (Let's say that number is 5) - So now I have (let's say) 50 participants and 5 groups - I need these participants to be split evenly and randomly among the 5 groups.\r\nWould this work for me and could you help me to set this up? I am new at Excel and doing this project for free for our local soccer association.\r\nThank you!" - id: 18068 author: Geoff Lane author_email<EMAIL_ADDRESS>author_url: http://www.zorched.net date: '2012-07-23 12:12:08 -0400' date_gmt: '2012-07-23 18:12:08 -0400' content: "Cara,\r\nYour problem is actually easier than this I think. If you have 50 participants (1-50) you just need to randomly order that set of 50. You then take the first 10 and assign them to group 1, the next 10 to group 2, etc. \r\n\r\nFor a completely non-technical way to do it, you can put 50 numbered pieces of paper in a hat and draw them out. First 10 go into group 1, etc.\r\n\r\nHope that helps." ---
Let's say one is a computer programmer and let's say one's wife (or roommate; or significant other) does social science research (a totally hypothetical scenario of course). When doing social science research one needs to create randomized groups of participants.
So in a group you might be testing a variable X and you need to divide the group in half to test that variable with a number of control subjects. In this scenario, one needs to create groups A and B (or 1 and 2) such that there are the same number of A and B in a given set.
Now normally when generating random numbers you can just generate an arbitrary set of random numbers. But if you need a set of 10 numbers with 5 1's and 5 2's then that's a different problem. You could of course generate a set and test to make sure it's evenly distributed and then throw it away if it doesn't meet this constraint. That of course is an inefficient way of generating your sets because you would likely have to throw a lot of them away.
The solution to this conundrum is to use random numbers not to create your set, but to shuffle it. Luckily other smart people have proven ways to do this already. The Fisher-Yates shuffle is the technique that I used.
{% highlight python %} from random import randrange items = [1,1,1,1,1,2,2,2,2,2]
# Fisher-Yates shuffle, Durstenfeld in-place implementation n = len(items) while n > 1: k = randrange(n) # 0..n-1 n = n - 1 items[k], items[n] = items[n], items[k]
print items # e.g. [2, 1, 2, 1, 1, 2, 1, 2, 2, 1] {% endhighlight %}
Basically the Fisher-Yates shuffle shuffle picks a random item and puts it at the end of the list by swapping the end with the randomly selected item. It then continues with the 'unpicked' numbers and puts them at the end of the unpicked set until it reaches the beginning of the list. Once it's traveled through, you have a randomly sorted set.
That's fine if you're a programmer and want to run python from the command line and change your items set if you need a different size, etc. But if you want an end-user who's not a programmer to use it, you better come up with something a bit configurable. So I need to allow for some variation to the sets that will be generated and shuffled.
Based on this information I created a simple class that would allow you to specify 3 properties that would define the random sets to generate: blocks, the number of individual sets; size, the number of numbers in each block; and groups, the number of variants within each block. So now you could generate a set of 10 blocks, with 12 numbers in each containing 1, 2, and 3 evenly distributed (i.e. 4 of each number).
{% highlight python %} from random import randrange
class Shuffler(object): def __init__(self, blocks, blockSize, groups): self.blocks = blocks self._groups = groups self._blockSize = blockSize self.deck = self.make_deck()
@property def blockSize(self): return self._blockSize
# BlockSize setter also initializes deck @blockSize.setter def blockSize(self, value): self._blockSize = value self.deck = self.make_deck()
@property def groups(self): return self._groups
# Groups setter also initializes deck @groups.setter def groups(self, value): self._groups = value self.deck = self.make_deck()
def is_valid_group_size(self): return self.blockSize % self.groups == 0
# Fisher-Yates shuffle, Durstenfeld in-place implementation def shuffle(self): items = self.deck[:] # copy deck for in-place shuffle n = len(items) while n > 1: k = randrange(n) # 0..n-1 n = n - 1 items[k], items[n] = items[n], items[k] return items
def make_deck(self): result = [] for i in range(self.blockSize): result.append(i % self.groups + 1) return result {% endhighlight %}
Finally to wrap the shuffler in a nice command-line interface I created a simple specialization of the Shuffler class that would take command line arguments to generate blocks of specific properties.
{% highlight python %}
#!/usr/bin/env python
"""
Usage: %(program)s [options] ... [-b
import random, sys, getopt import shuffle
program = sys.argv[0]
class CliShuffler(shuffle.Shuffler): def __init__(self): shuffle.Shuffler.__init__(self, 20, 10, 2)
def print_results(self): for i in range(self.blocks): print ' '.join([str(i) for i in self.shuffle()])
def usage(self): print >> sys.stderr, __doc__ % globals() sys.exit()
def run(self, argv): try: opts, args = getopt.getopt(sys.argv[1:], "hg:s:b:", ["help", "groups=", "size=", "blocks="]) except getopt.GetoptError, err: # print help information and exit: print str(err) # will print something like "option -a not recognized" self.usage() sys.exit(2)
for opt, arg in opts: if opt in ("-b", "--blocks"): try: self.blocks = int(arg) except ValueError: self.usage() elif opt in ("-s", "--size"): try: self.blockSize = int(arg) except ValueError: self.usage() elif opt in ("-g", "--groups"): try: self.groups = int(arg) except ValueError: self.usage() elif opt in ("-h", "--help"): self.usage() else: assert False, "unhandled option"
if not self.is_valid_group_size(): print("Block Size must be evenly divisible by groups to get an even grouping.") self.usage() sys.exit()
self.print_results()
if __name__ == "__main__": shuffler = CliShuffler() shuffler.run(sys.argv[1:]) {% endhighlight %}
Happy shuffling...


--- title: updates - Strategies for updating parameters keywords: fastai sidebar: home_sidebar nb_path: "02_updates.ipynb" ---
A collection of various update rules that can be used by the GradientDescent
optimizer are collected here.
GradientDescent
uses two kinds of update rules
GradientDescent
always rejects parameter updates that yield an invalid cost (i.e. nan
or inf
), but additional rules be provided.Many of the update steps are implemented based on this review
GradientDescent
expects update steps to be instances of a class with an evaluate
method that takes as input a gradient estimate, a learning rate, and the current iteration (Comment: this seems like a suboptimal requirement), and returns a proposed parameter update. The reason update rules are required to be structured as classes is so that they can store any information they need to update the parameters. All update rules should return a numpy array of floats to be used as a step to update the model parameters.
ADAGRAD
The update rule is {% raw %} $$G_0=0$$ {% endraw %} {% raw %} $$G_t=G_{t-1}+(\hat{g}_t)^2$$ {% endraw %} {% raw %} $$\theta_{t+1}=\theta_t - a_t \frac{\hat{g}_t}{\sqrt{G_t}+\epsilon} $$ {% endraw %}
This step update requires a small term eps
be defined to prevent divide be zero errors. By default this is set to 1e-8
Adaptive Moment Estimation (Adam)
An acceptance criterion evaluates the cost after an update step and compares it to past evaluations of the cost function to decide whether it should be accepted or rejected. GradientDescent
expects acceptance criteria to be objects of a class with two required methods:
initialize
: This is called when a GradientDescent
object is initialized and performs any routines needed to set-up the acceptance criteria. For example, an acceptance criterion based on the amount of noise in the cost function might evaluate the cost function some number ot times and compute its standard deviation. This method will be passed the entire GradientDescent
object, so it has access to all information stored therein.evaluate
: This


=== Test case: lasp_peer_to_peer_game_tournament_SUITE:peer_to_peer_state_based_tree_test/1 (click for source code)
=== Config value:
[{watchdog,<0.449.0>},
<EMAIL_ADDRESS>{tc_group_properties,[]},
{tc_group_path,[]},
{data_dir,"/Users/anne-francevanswieten/lasp/_build/test/lib/lasp/test/lasp_peer_to_peer_game_tournament_SUITE_data/"},
<EMAIL_ADDRESS>=== Current directory is<EMAIL_ADDRESS>=== Started at 2017-04-18 17:19:40
*** User 2017-04-18 17:19:40.044 ***
Beginning test case peer_to_peer_state_based_tree_test
*** User 2017-04-18 17:19:40.053 ***
Running peer_to_peer_game_tournament_state_based_tree_test with nodes [server,
client_1,
client_2,
client_3]
*** User 2017-04-18 17:19:40.053 ***
Launching Erlang distribution...

*** User 2017-04-18 17:19:46.160 ***
Custering nodes...
*** User 2017-04-18 17:19:46.161 ***
Joining node: server@MBPdeAnneFrance to client_1@MBPdeAnneFrance at port 59194
*** User 2017-04-18 17:19:46.161 ***
Joining node: server@MBPdeAnneFrance to client_2@MBPdeAnneFrance at port 59196
*** User 2017-04-18 17:19:46.164 ***
Joining node: server@MBPdeAnneFrance to client_3@MBPdeAnneFrance at port 59198
*** User 2017-04-18 17:19:46.166 ***
Joining node: client_1@MBPdeAnneFrance to server@MBPdeAnneFrance at port 59192
*** User 2017-04-18 17:19:46.170 ***
Joining node: client_1@MBPdeAnneFrance to client_2@MBPdeAnneFrance at port 59196
*** User 2017-04-18 17:19:46.171 ***
Joining node: client_1@MBPdeAnneFrance to client_3@MBPdeAnneFrance at port 59198
*** User 2017-04-18 17:19:46.172 ***
Joining node: client_2@MBPdeAnneFrance to server@MBPdeAnneFrance at port 59192
*** User 2017-04-18 17:19:46.174 ***
Joining node: client_2@MBPdeAnneFrance to client_1@MBPdeAnneFrance at port 59194
*** User 2017-04-18 17:19:46.175 ***
Joining node: client_2@MBPdeAnneFrance to client_3@MBPdeAnneFrance at port 59198
*** User 2017-04-18 17:19:46.178 ***
Joining node: client_3@MBPdeAnneFrance to server@MBPdeAnneFrance at port 59192
*** User 2017-04-18 17:19:46.179 ***
Joining node: client_3@MBPdeAnneFrance to client_1@MBPdeAnneFrance at port 59194
*** User 2017-04-18 17:19:46.180 ***
Joining node: client_3@MBPdeAnneFrance to client_2@MBPdeAnneFrance at port 59196
*** User 2017-04-18 17:19:46.180 ***
Lasp fully initialized.
*** User 2017-04-18 17:19:46.180 ***
Waiting for simulation to end
*** User 2017-04-18 17:20:35.928 ***
Simulation ended with success
*** User 2017-04-18 17:20:43.926 ***
Ending test case peer_to_peer_state_based_tree_test
=== Ended at 2017-04-18 17:20:43
=== successfully completed test case
=== Returned value: ok
Test run history
| Top level test index


Join the movement to build a crowdsourced map of the country that is free and open source using the OpenStreetMap Project. What is OpenStreetMap?
Map contributions #qikpikmp1 Live edits Activity Changeset list
Livestream
A fun way to learn to contribute is by joining a virtual mapping party where members of the India mapping community are available to collaborate and guide beginners interested in mapping their neighborhood.
Cancel


PEPPERONI PASSION
Extra Cheese. Extra Pepperoni. Extra Passion!
Click to Email us your query!
Click to give us a call!
Back to Home


Creating Metapackages
A metapackage (.mpkg) is appropriate for installing a multiple items. Before creating your metapackage, you must create a package for each item.
A metapackage (.mpkg) is appropriate for installing a multiple items. Before creating your metapackage, you must create a package for each item.


EPICORE
Dear [NAME],
We miss you!
You only have ONE step before becoming a certified EpiCore member!
Set your passwordWe can’t wait to start working with you!
If you have any questions, please contact us at<EMAIL_ADDRESS>Sincerely,
The EpiCore Team
* If the SET YOUR PASSWORD link does not work, please try one or a combination of the following:
1. Update your browser to the latest version.
2. Open a different browser than the one you used and copy/paste your personalized link:
[LINK]
3. Open an incognito / InPrivate tab on your browser and paste your personalized link
4. If you are using an iPhone or iPad update iOS to the latest version


Face Detection
Face API Key:
Face ID
Face Landmarks
Face Attributes
Age
Gender
Head pose
Smile
Facial hair
Glasses
Select a photo：
Raw logs


Symbol Index for "Phenomenon Qualifier"
Symbol Index for diagram
"Phenomenon Qualifier"
Activity Qualifier (Class)
Category Valued Qualifier (Class)
classifier (Association)
focus for qualification (Association)
Image Valued Qualifier (Class)
Measured Qualifier (Class)
Phenomenon Or Qualifier (Class)
Phenomenon Qualifier (Class)
Phenomenon Qualifier Type (Class)
PhenQ/Value Type (Generalization Node)
PhOQ/Direction (Generalization Node)
PhQ/Qualification (Generalization Node)
Subject Phenomenon (Class)
Subject Property Qualifier (Class)
Temporal Phenomenon Link (Class)
Text Valued Qualifier (Class)
Timepoint Valued Qualifier (Class)


Some boards in different styles
Displays some boards in different styles. See the sources for to see the different styles there.
Theme: Green
Style: Alpha
Style: USCF, Theme: Zeit
Theme: Blue
Style: Chess.com, Theme: Chess.com
Style: Merida
Style: Condal, Theme: Blue
Style: Leipzig
Style: Case
Style: Maya


{% extends 'core/base.html' %} {% load static %} {% block style %} {% endblock %} {% block script %} {% endblock %} {% block main %}
Download file sizes can be reduced by either cutting out an area of a large file or by masking all data outside of a certain country, bounding box or by applying a land-sea-mask. This process is performed on the server and the download starts when the files are ready.
Alternatively, if you are interested in a time series of a variable at a single point or avaraged over a country or bounding box, a CSV file can be created.
Please note that this process can take a considerable amount of time. Depending on the size of the dataset, it can take tens of minutes to create the download. It is only possible to cut out global NetCDF files.
No files where provided as POST data and no job id was given. Please note that this page needs to be accessed from a dataset or file metadata page, or directly from the search interface.


F#$%^ The Beattles! We are the
Walrus
!!!
City
Month
Date
Seattle, WA
December
21
Portland. OR
January
1
Austin,TX
January
06


by AbhishekKr / @abionic
Some of the largest datasets have strong time components...
like stock market data, server logs, weather data, or even just the temperature in the server room.
TimeSeries Databases
Some analysis are simple
(image-courtesy: Spurious Correlations)
(image-courtesy: /var/log)
(image-courtesy: histography.io)
(image-courtesy: dilbert)
(image-courtesy: xkcd)
(image-courtesy: xkcd)
(image-courtesy: Yahoo! Finance)
(image-courtesy: Yahoo! Finance)
(image-courtesy: Google Weather)
(image-courtesy: Environment Canada)
Many kinds of analysis require keeping track of
multiple factors over a period of time.
Like...
Example: Finding out pattern of specific time-periods
when resource load is more or less.
Manage infrastructure costs
by using influenced elastic cloud.
Example: What marketing decisions were taken
at what time?
State of target customer class economy.
Any impact on sale of any influencing data.
Example: Which public company related event
had what impact?
Just general trend in competitors stock health
co-related with of your own.
Example: Users average heartbeat
co-related with exercise done.
Warning based on old health issues
with current blood pressure trend.
Example: Seasonality of user requests
and trend of traffic increase.
Significant anomaly in such
can be used by IDS to predict attacks.
To analyze the data based on the time dimension,
keep arrival time of each feed and
optimize queries by it.
Storing and Retrieval of Primary Data Points indexed by their TimeStamps.
One of the earliest and most popular TimeSeries DataStore.
Has persistence, in-memory caching & concurrent tasks.
A circular-buffer based store. Bad at Sparse Metrics.
No partition, replication or atomic integrity.
Carbon: Twisted powered metrics processing daemon.
Whisper: time-series db library based on RRD principles.
Timestamp value is verified for its position while retrieval.
Multi-Archive Storage and Retrieval Behavior.
File per time-series.
Doesn't scale well as more file-descriptors per series.
Runs on Hadoop and HBase. Highly Scalable.
Since v2.0 provides good Plug-in architecture.
Involves lot of moving parts (Hadoop, HBase, Zookeeper).
All need to be managed.
DownSampling for graphs; not to feed into calculations.
Kind of re-write of OpenTSDB (not a fork) that runs on Cassandra. Highly Scalable.
Keep data and presentation of data separate.
Series of Measurements + Unique Tagset.
Datapoints have fields and timestamp in nano epoch.
No external dependencies. Ordered k/v.
Started with LevelDB, then RocksDB.
Default to BoltDB currently (v0.9.1 I think).
WAL to enable BoltDB manage its memory swiftly.
Over HTTP. Useful SQL-ish language for data query.
Had Protobufs now Raw Bytes.
Near real-time graphing for operational insights at scale.
Predictable Alerting (like lot less traffic than predicted)
Netflix handles more than 1TB analytics data/day with it.
In-memory (complete for 6hrs, roll-ups for 2 weeks). Pain.
Persists raw data in S3. Uses Hive to process old data.
A Service Monitoring System with built-in TSDB
by SoundCloud.
Has a query language, alerting and visualization.
Data-model as OpenTSDB. Metric names,
labelled with key-values.
Can tweak data handled in RAM and Disk (LevelDB).
By RackSpace Cloud Monitoring Team
for RealTime Analytics.
Auto-purges, not ideal for Batch Tasks on old data.
Uses Cassandra for datastorage.
Optional support of Zookeeper and ElasticSearch.
Columnar High Performance DB.
Built-in array language 'q' to work directly on data.
Can be used for streaming, real-time and historical data.
OLTP from 100 thousand to 1 million records/second/cpu.
OLAP from 1 million to 100 million records/second/cpu.
Popular in Financial Sectors.
Customers: Goldman Sachs, JP Morgan, Deutsche Bank, etc.
Also in Utilities, Telecom, Pharamceuticals, Oil-n-Gas sectors.
SaaS model over Kdb+ at TimeSeries.guru
32bit Free for Dev/PoC tasks not commercial. (1GB RAM)
It runs on MongoDB or Hadoop/HBase.
Provides 'Complex Event Processing' via Siddhi.
Provides search and analytics via Apache Solr.
Connect devices with MQTT, AMQP, Stomp, other protocols.
SaaS; IoT focussed; REST registration; Arduino and Android
legacy: tempodb, @gigaom; (commercial)
Focussed on IoT sensors data
for analysis, dashboarding and reporting.
Connect anything with flexible event data model, HTTPs, MQTT
- Ranking of TimeSeries DBEngines
- feedback/contributions 'MomentDB/Goshare'
- this presentation @quick link WIP


"""HVAC diagrams"""
'HVAC diagrams'
# you would normaly install eppy by doing
# python setup.py install
# or
# pip install eppy
# or
# easy_install eppy
# if you have not done so, uncomment the following three lines
import sys
# pathnameto_eppy = 'c:/eppy'
pathnameto_eppy = '../'
sys.path.append(pathnameto_eppy)
from eppy import modeleditor
from eppy.modeleditor import IDF
iddfile = "../eppy/resources/iddfiles/Energy+V8_0_0.idd"
fname = "../eppy/resources/idffiles/V8_0_0/5ZoneSupRetPlenRAB.idf"
IDF.setiddname(iddfile)
idf = IDF(fname)
# idf.model
from eppy.EPlusInterfaceFunctions import readidf
from eppy.ex_loopdiagram import makeairplantloop, makediagram
print "readingfile"
data, commdct = readidf.readdatacommdct(fname, iddfile=iddfile)
print "constructing the loops"
edges = makeairplantloop(data, commdct)
print "making the diagram"
g = makediagram(edges)
dotname = "a.dot"
pngname = "a.png"
# dotname = '%s.dot' % (os.path.splitext(fname)[0])
# pngname = '%s.png' % (os.path.splitext(fname)[0])
g.write(dotname)
g.write_png(pngname)
readingfile
constructing the loops
making the diagram
True


DEB-REVERSION(1) [FIXME: manual] DEB-REVERSION(1) NAME deb-reversion - simple script to change the version of a .deb file. SYNOPSIS deb-reversion [options] .deb-file [log message...] DESCRIPTION deb-reversion unpacks the specified .deb file, changes the version number in the relevant locations, appends a Debian changelog entry with the specified contents, and creates a new .deb file with the updated version. By default, the tool creates a new version number suitable for local changes, such that the new package will be greater than the current one, but lesser than any future, official Debian packages. With -v version, the version number can be specified directly. On the other hand, the -c simply calculates the new version number but does not generate a new package. When building a .deb file, root privileges are required in order to have the correct permissions and ownerships in the resulting .deb file. This can be achieved either by running deb-reversion as root or running under fakeroot(1), as 'fakeroot deb-reversion foo.deb'. With -k hook, a hook script may be specified, which is run on the unpacked binary packages just before it is repacked. If you want to write changelog entries from within the hook, use 'dch -a -- your message'. (Alternatively, do not give a changelog entry on the deb-reversion command line and dch will be called automatically.) The hook command must be placed in quotes if it has more than one word; it is called via sh -c. OPTIONS -v new-version, --new-version new-version Specifies the version number to be used for the new version. Passed to dch(1). -o old-version, --old-version old-version Specifies the version number to be used as the old version instead of the version stored in the .deb's control file. -c, --calculate-only Only calculate and display the new version number which would be used; do not build a new .deb file. Cannot be used in conjunction with -v. -s string, --string string Instead of using 'LOCAL.' as the version string to append to the old version number, use string instead. -k hook-command, --hook hook-command A hook command to run after unpacking the old .deb file and modifying the changelog, and before packing up the new .deb file. Must be in quotes if it is more than one (shell) word. Only one hook command may be specified; if you want to perform more than this, you could specify 'bash' as the hook command, and you will then be given a shell to work in. -D, --debug Pass --debug to dpkg-deb(1). -b, --force-bad-version Pass --force-bad-version to dch(1) -h, --help Display usage information. -V, --version Display version information. SEE ALSO dch(1), fakeroot(1), dpkg-deb(1). DISCLAIMER deb-reversion is a tool intended to help porters (e.g. amd64) with modifying packages for other architectures, and to augment deb-repack, which creates modified packages with identical version numbers as the official packages. Chaos will ensue! With deb-reversion, a proper version number can be selected, which does not obstruct the next official release but can be specifically pinned with APT or held with dpkg. Please take note that deb-reversion does not come without problems. While it works fine in most cases, it may just not in yours. Especially, please consider that it changes binary packages (only!) and hence can break strict versioned dependencies between binary packages generated from the same source.  AUTHOR deb-reversion is Copyright 2004-5 by martin f. krafft<EMAIL_ADDRESS>and modifications are Copyright 2006 by Julian Gilbey<EMAIL_ADDRESS>Permission is granted to copy, distribute and/or modify this document under the terms of the Artistic License: http://www.opensource.org/licenses/artistic-license.php On Debian systems, the complete text of the Artistic License can be found in /usr/share/common-licenses/Artistic. This manual page was written by martin f. krafft<EMAIL_ADDRESS>and modified by Julian Gilbey<EMAIL_ADDRESS>NOTES 1. http://www.opensource.org/licenses/artistic-license.php [FIXME: source] Feb 13, 2006 DEB-REVERSION(1)


Diff: File A
Put PFIF XML here to validate it:
Or, upload a file:
Or, choose the URL of a PFIF XML file:
Diff: File B
Put PFIF XML here to validate it:
Or, upload a file:
Or, choose the URL of a PFIF XML file:
Group Messages by Record
Case Sensitive Diff?
Omit Blank Fields. Normally, a blank field is different from if that field is not present at all. If you check this box, they will be the same.
Ignore these fields. They will not count as added, removed, or changed. Use a space-delimited list of fields (ie, "source_date age photo_url" without the quotes).


Peter Crouch provides unique response to Roberto Firmino's 'armpit' VAR call
The former Liverpool forward seems to be happy that he retired shortly before VAR came into the Premier League
by Mark Jones, https://www.mirror.co.uk/authors/mark-jones/Former Liverpool forward Peter Crouch has given his unique take on Roberto Firmino's controversial disallowed goal at Aston Villa.
Reds forward Firmino saw what would have been an equalising goal ruled out on Saturday when the assistant referee deemed him to be offside.
However, a VAR review showed that the Brazilian was as good as level with Villa defender Tyrone Mings, before ultimately deciding that he should be given offside.
The Premier League put out a tweet clarifying why the decision was made at half-time of the game, which Liverpool went on to win 2-1 to preserve their six-point lead at the top of the table.
It read: "Liverpool's Roberto Firmino was flagged offside before putting the ball in the net against Aston Villa and the decision was confirmed by VAR.
"The red line signifies Firmino and was aligned to his armpit, which was marginally ahead of the last Villa defender."
Pundits including Sky Sports' Chris Kamara and beIN Sports' Andy Gray have found fault with the decision-making process though, citing that prior to the offside decision being made two other lines were drawn that showed Firmino behind Mings and therefore onside.
Many fans also found the fact that Firmino's armpit was mentioned in the decision to be somewhat laughable.
Crouch, who also played for Villa during a long career in the top-flight which ended this summer, seems to agree, and says that he'd have faced issues with VAR had it have been in action when he played.
Tweeting to his 732,000 followers, the 6ft 7ins former forward wrote: "If I’d have been playing in the VAR era my long arms would have been offside for about 50 goals."
Luckily for him it wasn't though, with Crouch managing 108 Premier League strikes in his career, including six for Aston Villa and 22 for Liverpool.


nouvEnergyHomeBrowse ProductsUsage CalculatorAbout ThisWelcome to nouvEnergy,an application that spreads awareness of reducing fossil fuel reliance.What are Fossil Fuels?Substances that formed underground millions of years ago from dead plants and animals. Typical types of fossil fuels include coal, petroleum (oil), and natural gas.How do Fossil Fuels contribute to Global Warming?Combustion of fossil fuels produces carbon monoxide, a toxic compound that is recognized as a greenhouse gas. Greenhouse gasses float and stay in the atmosphere of the Earth, preventing the heat on Earth from escaping into space.
"Fossil Fuels." Alternative Energy, edited by Neil Schlager and Jayne Weisblatt, vol. 1: Fossil Fuels, Bioenergy, Geothermal Energy, UXL, 2006, pp. 1-55. Gale Virtual Reference LibraryHow can we use less Fossil Fuels?Explore what products you use consume fossil fuels the most, switch to one of their alternatives, and spread the awareness!Browse[[name]][[sev-text]][[desc]]Read more
[[display]]
[[tip]][[tip]]nouvEnergy,an Innovation Convention project. nouvEnergy is a project of Michael Peng, an 8th-grade student at Kent Middle School, California. Source code is available here.


Elaine Marie Brett
Democrat
Retired
B.S. Biology/Medical Technology; M.S. Analytical Chemistry; Certificates in Organizational Development and Change Leadership
81428
Mostly I have been involved on a local/regional level with small donations (less than $250). District 3 Diane Mitsch Bush; Delta County Commissioner, Jere Lowe; Paonia Mayor, Mary Bachran
Board of Directors: West Elk Community Fund, Western Colorado Community Foundation, Downtown Colorado, Inc., Friends of the Paradise Theatre, Black Canyon Regional Land Trust, Hawks Haven Homeowners Association Advisor: Orton Family Foundation (Community Heart & Soul), Elsewhere Studios Artist Residency, North Fork Valley Creative Coalition. Volunteer: North Fork Senior Connections, North Fork Children's Christmas Party, Western Slope Rural Philanthropy Days (Co-Chair), Town of Paonia, Citizens for a Healthy Community, Delta County Election Judge
In my 15 years as a Colorado resident, I have intentionally involved myself in a wide variety of organizations and agencies in order to get a good understanding of the dynamics of my Community as well as other Colorado communities. I have been a founder of several nonprofits. I have been appointed to Boards including a land trust, a county area planning committee, cultural organizations, a state-wide advocacy group for small businesses. I have served in leadership roles as Board Chair or Officer. I have been in organizing roles for events and projects including co-Chair for the 2019 Western Slope Rural Philanthropy days. Additionally, I have used my organizational consulting skills in small town communities on the Western Slope working with Downtown Colorado Inc. and Community Heart and Soul projects. In the North Fork Valley, I have worked as an advisor and facilitator for Board and Staff retreats and a volunteer grant writer for the Town of Paonia.
There is no question that the population and the demographics of Colorado are changing. It is vitally important that the districting of our elected officials adequately represent constituents. It is honorable that Colorado is engaging in a process that is intended to be nonpartisan, inclusive and fair. Personally, serving on the commission would be a great learning experience an allow me to gain a better understanding of state residents, the political process, and issues that important to our future. I believe that I can offer the commission my scientific and analytical skills, my knowledge of state demographics and, my experience as an organizational consultant in community engagement and facilitation. I spent over 20 years in non political roles in Washington DC prior to moving to Colorado where I learned to negotiate contracts with diverse groups (including medical centers and government agencies) and to facilitate within bureaucracies (including the Department of Defense). My experiences prior to living in Colorado combined with my involvement in the Western Slope and statewide initiatives give me a unique perspective to look at the big picture while paying attention to the needs of the local population.
"First seek to understand, then to be understood." The ability to promote consensus and create agreement is based on the extent to which one can actively listen to gain a clear understanding of the positions presented. Consensus is not about everyone agreeing. Consensus is giving a fair opportunity for everyone to express themselves, then form an opinion that can be acceptable and that the majority "can live with." Working as an organizational and process consultant taught me to "seek to understand." A good facilitator can guide a group to a place of understanding and consensus but it is the responsibility of each member of the team to commit to having an open mind, to listening to diverse points of view and to expressing points that represent their constituents. I believe these are areas of strength for me.
My early career was as a Clinical Chemist where I was responsible for analyzing complex medical data and forming conclusions about health outcomes. My middle career in regional sales management with a large corporation, gave experience in goal setting, in analyzing state and regional territory data and in making quarterly and annual projections. My later career in organizational consulting enhanced my interpersonal skills, maximizing team performance and evaluating individual and team behaviors. In recent years, I have worked on projects that required researching and analyzing data from the Colorado State Demographers' Office. I found the SDO to be a tremendous resource for responding to grant applications, helping municipalities with strategic planning and working with businesses on marketing plans.
Female


-
Configures the timeout used when awaiting a response from the remote that a request to close
a
Session
as been honored.
Configures the timeout used when awaiting a response from the remote that a request to close
a resource such as a
Session
,
Sender
or
Receiver
h as been honored.
Copy all options from this
SessionOptions
instance into the instance
provided.
Configures the default next receiver policy for the session created with these
configuration options.
Sets the drain timeout (in milliseconds) after which a
Receiver
request to drain
link credit is considered failed and the request will be marked as such.
Sets the drain timeout value after which a
Receiver
request to drain
link credit is considered failed and the request will be marked as such.
Sets the incoming capacity for a
Session
created with these options.
Configures the timeout used when awaiting a response from the remote that a request to open
a
Session
has been honored.
Configures the timeout used when awaiting a response from the remote that a request to open
a resource such as a
Session
,
Sender
or
Receiver
has been honored.
Sets the outgoing capacity for a
Session
created with these options.
Configures the timeout used when awaiting a response from the remote that a request to
perform some action such as starting a new transaction.
Configures the timeout used when awaiting a response from the remote that a request to
perform some action such as starting a new transaction.
Configures the timeout used when awaiting a send operation to complete.
Configures the timeout used when awaiting a send operation to complete.
Copy all options from this
SessionOptions
instance into the instance
provided.
Creates a new
Session
instance for use by the client application.
Create a new SessionOptions instance that copies the configuration from the specified source options.
-