A designer knows he has achieved perfection not when there is nothing left to add, but when there is nothing left to take away
- Antoine de Saint-Exupery
On my journey of growing as a developer, I am consistently inspired by language features which seem incredibly simple but yield remarkable benefit. As I try to master F#, I am frequently surprised by how powerful the language is for expressing ideas while having so few features. Discussions frequently pop up about the need for ever more powerful abstractions, yet I find myself amazed by how far you can take the language with what is already there.
I am no programming language expert, but I admire languages that maintain a lean feature set. Every new feature added to a language makes it just a little bit more difficult to fully understand and a little more intimidating for new developers. It is an impressive design feat when a language can remain approachable for beginners but enable the flexibility that library authors need.
I am an Industrial Engineering turned Machine Learning Engineer, and I focus on the problem of maximizing the profitability and efficiency of companies. Often the solution involves a Mathematical Planning Model (aka Mathematical Programming). What I hope to do in the next few paragraphs is illustrate to you how some of the most basic features of F#, Discriminated Unions and Units of Measure, eliminate the most pernicious bugs when developing these models.
The Domain of Mathematical Planning
The domain of Mathematical Planning is made up of Decisions, Constraints, and Objectives. A Decision is a choice that a business needs to make. It can be how many of Item X do we buy, do we build in Location A or Location B, or how many people do we assign to each job. Constraints are the rules we need to abide by. They are the limitations on what is possible. A Constraint could be that we only have 10 people available, or we can only build in Seattle or Portland, or we only have $1,000,000 to invest. The Objective is how we measure success. It is the function we want to maximize or minimize. We could minimize waste, maximize profit, or minimize cost.
Many of my colleagues are building their models with Python. Python is a great language and I have been productive with it in the past. Here is a snippet of what a mathematical planning model may look like in Python:
# Define a list of items to optimize for
items = ["A", "B", "C"]
# Define a list of locations to assign items to
locations = ["Portland", "Seattle", "Detroit"]
# Define a dictionary of revenue associated with each item and location tuple
revenue = {("A","Portland"):1.5;, ("A","Seattle"):1.7 ... }
# Define a dictionary with the availability of each item
availability = {"A":10.0, "B":20.0, "C":14.0}
# Create a Decision for each Item, Location combination. This will be how much
# of a given item we decide to send to that location
allocation = LpVariable.dicts("AmountSent",(items,locations), 0)
# Create an instance of a `Problem` object and state that we want to maximize
# the objective we give it
problem = LpProblem("ItemAllocation", LpMaximize)
# We create an expression which evaluates the total revenue
revenue_expr =
lpSum([revenue[i][l] * allocation[i][l] for i in items for l in locations])
# We set the Objective of the Problem by adding it
problem += revenue_expr, "MaximizeRevenue"
# For each item in items, create a constraint which states that the total number
# of items that is allocated cannot exceed the availability of the item
for i in items:
problem += lpSum([allocation[l][i] for l in location] <= availability[i])
This is the beginning of a straightforward assignment problem. We have a list of items, items
. For each item
in items
, we must decide how many we send to each location
in locations
. There is a limit on how much of each item
is available for us to send. There is a revenue associated with sending a particular item
to a given location
. In this problem we want to maximize our revenue which is calculated by multiplying the decision
for a given item
and location
by the revenue
associated with it. Finally, we create a constraint for each item
in items
which states that the total number of a given item
that is allocated cannot exceed the total that is available.
This is only part of the problem. Normally there would be more constraints that would make it more interesting. This is enough of a problem to illustrate my case though. There are two errors in this model already. If you were paying close attention you may have found one. I promise you cannot detect the second.
The Power of Domain Modeling Using Discriminated Unions
F# provides two simple but powerful features which help ensure against the errors in the Python code. The first is Discriminated Unions. If we were to reformulate this problem using F#, the first thing we would do was define some simple types to model our domain.
type Item = Item of string
type Location = Location of string
Instead of just using strings to describe our Items and Locations, we create simple, single case Discriminated Unions (DU). These DUs provide context around what the strings are meant to represent. Let’s go ahead and create our item
and locations
lists again. This time, wrapping them in DUs.
let items =
["A"; "B"; "C"]
|> List.map Item
let locations =
["Portland"; "Seattle"; "Detroit"]
|> List.map Location
We will also update our availability
information to use these new types.
let availability =
[
Item "A", 10.0
Item "B", 20.0
Item "C", 14.0
] |> Map
We will create the Decisions for each item
and location
. We store these Decision
types in a Map
which is indexed by an (Item * Location)
tuple.
let allocation =
DecisionBuilder<Servings> "AmountSent" {
for i in items do
for l in locations ->
Continuous (0.0, infinity)
} |> Map
We now attempt to create the same constraints we did in Python with a direct translation.
let allocationContraints =
ConstraintBuilder "ItemLimit" {
for i in items ->
List.sum [for l in locations -> 1.0 * allocation[l, i]] <== availability.[i]
}
Except, the compiler is gives us an error on the indexing of allocation
.
What some of you may have noticed in the Python code is that the allocation
collection is indexed by an Item
then Location
. The original code was trying to access it by location
then by item
. This would have thrown an error at runtime due to a missing value. In F# this becomes a compiler error. The type system itself it is helping you. This may seem small, but this is one of the most painful types of errors when debugging a Mathematical Planning model.
Someone may say that this can be accomplished in other languages and I would agree. I believe where F# is unique is in the simplicity and ease of using single case Discriminated Unions for wrapping primitives. It is virtually no additional effort.
Units of Measure: The Achilles Heel of Numbers
There is an underappreciated problem in software development, numbers are rarely just numbers. They represent something: cm
, feet
, kg
, or meters
. Normally we do not care about a raw number. Our primary concern is with what the number represents. In most languages there are no easy mechanisms for tracking the Units of Measure associated with a number. F# on the other hand has baked the concept of a Unit of Measure into the type system.
The Units of Measure feature will reveal the second problem with the Python code that otherwise may remain undetected. Let’s update our domain with some new types to track the units on our numbers.
[<Measure>] type Servings
[<Measure>] type Kg
We now have units to represent Servings
and Kg
. Let’s update our availability
collection to store numbers with these units attached.
let availability =
[
Item "A", 10.0<Kg>
Item "B", 20.0<Kg>
Item "C", 14.0<Kg>
] |> Map
We have now provided more context around our availability numbers. We now know they are stored in units of Kg
. The F# compiler will enforce correct algebra as we work with them. We now update our Decisions to be in units of Servings
.
let allocation =
DecisionBuilder<Servings> "AmountSent" {
for i in items do
for l in locations ->
Continuous (0.0<Servings>, 1_000_000.0<Servings>)
} |> Map
With our Decisions updated, we go back to our constraint definition and we now see a new bug.
The important part of this message is at the bottom. The compiler is complaining that the left-hand is in units of Servings
and the right-hand side is in units of Kg
. It does not make sense to compare values that are in different units, so the compiler is throwing an error. In other languages this error would go undetected. Worse, it may not even be caught in unit testing because the math will still work, it just won’t give correct results.
Let’s go ahead and add some conversion data so that we can fix this.
let itemMass =
[
Item "A", 1.1<Kg/Servings>
Item "B", 2.0<Kg/Servings>
Item "C", 0.7<Kg/Servings>
] |> Map
We now have data which will allow us to convert from Serving
to Kg
. Let’s incorporate it into our constraint creation expression.
let allocationContraints =
ConstraintBuilder "ItemLimit" {
for i in items ->
List.sum [for l in locations -> itemMass[i] * itemAllocation[i, l]] <== availability[i]
}
Now the compiler is happy because the units are in Kg
on both sides. This simple feature of ensuring correct Units of Measure eliminates what is possibly the most nefarious bug in Mathematical Planning. It would be hard to calculate the number of hours wasted on badly formulated models due to mismatched Units of Measure.
Simple Building Blocks
F# is an incredibly expressive language while staying lean on the number of features. Other languages have taken the approach of throwing every possible feature in. F# is relatively slow to incorporate new features and they are always purposeful. Most of the time the feature is orthogonal to the rest of the language. This is keeping the language approachable for newcomers so the climb to mastery is not nearly as steep. I believe these two simple features, Discriminated Unions and Units of Measure, uniquely position F# as an awesome language for Mathematical Planning.


Unreferenced UploadedFiles documents in the database
{{construct_list_of_unreferenced_docs}}
{{#if waiting_for_list_unreferenced_docs}}
{{> Loading }}
{{else}}
{{#if list_of_unreferenced_docs.length}}
| Collection |
Document Id |
|
{{#each list_of_unreferenced_docs}}
{{> UnreferencedDocRow }}
{{/each}}
{{else}}
None found
{{/if}}
{{/if}}


thMessages
You may use a JavaScript structure called thMessages to define message values for use in templates:
var thMessages = [
...
["welcome", "Welcome to Thymeleaf (with Thymol)!"],
...
];
and refer to messages so defined by:

Welcome!

If you include parameter place-holders in your messages, you can control message content in the usual way.
For example, if you define:
var thMessages = [
...
["msg07", "We went to {1} to meet with {0} and share some {2}."]
...
];
var thVars = [
...
["var08", "#['Marie-Antoinette','France','cake']"],
["var09", "#['Wallace','62 West Wallaby Street','cheese']"],
["var10", "#['Mr. C. Monster','Sesame Street','cookies']"],
...
];
and refer to these messages in a template, parameterised correctly:
Some text

Some text

Some text

The result should be something like this:
We went to France to meet with Marie-Antoinette and share some cake.
We went to 62 West Wallaby Street to meet with Wallace and share some cheese.
We went to Sesame Street to meet with Mr. C. Monster and share some cookies.
locales
Thymol 2.0 introduces support for locales in message processing. Adding a group of messages to be used for a specific locale is simple, all you need to do is add a thMessages assignment with the given locale as it's array specifier.
For example, if you have a message group like this:
var thMessages = [
["msg01", "Hello!"],
["msg02", "Hello {0}!"],
["msg03", "Hello {0}, welcome to planet {1}!"],
["msg04", "Hello {0}, good evening and welcome to planet {1}!"]
];
You can easily add US specific variants like this:
thMessages["en_US"] = [
["msg01", "Howdy!"],
["msg02", "Howdy {0}!"],
["msg03", "Howdy {0}, welcome to planet {1}!"]
];


Plan Activity
The list below shows all configuration changes made by Apiman users associated with this plan.


CyprIoT update site
This URL is an Eclipse software repository, you must use it in Eclipse (see
how
).


# Copyright (c) 2021 - present / Neuralmagic, Inc. All Rights Reserved.
#
# 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.
"""
Modifiers for increasing / enforcing activation sparsity on models while training.
"""
from typing import List, Tuple, Union
import torch.nn.functional as TF
from torch import Tensor
from torch.nn import Module
from torch.optim.optimizer import Optimizer
from sparseml.pytorch.optim.modifier import ModifierProp, ScheduledModifier
from sparseml.pytorch.optim.sensitivity_as import ASLayerTracker
from sparseml.pytorch.utils import get_layer, get_terminal_layers
from sparseml.utils import ALL_TOKEN, convert_to_bool, validate_str_iterable
__all__ = ["ASRegModifier", "REG_FUNCTIONS", "REG_TENSORS"]
REG_FUNCTIONS = ["l1", "l2", "relu", "hs"]
REG_TENSORS = ["inp", "out"]
[docs]class ASRegModifier(ScheduledModifier):
"""
Add a regularizer over the inputs or outputs to given layers
(activation regularization).
This promotes larger activation sparsity values.
| Sample yaml:
| !ASRegModifier
| start_epoch: 0.0
| end_epoch: 10.0
| layers:
| - layer1
| -layer2
| alpha: 0.00001
| layer_normalized: True
| reg_func: l1
| reg_tens: inp
:param layers: str or list of str for the layers to apply the AS modifier to
can also use the token __ALL__ to specify all layers
:param alpha: the weight to use for the regularization,
ie cost = loss + alpha * reg
:param layer_normalized: True to normalize the values by 1 / L where L
is the number of layers
:param reg_func: the regularization function to apply to the activations,
one of: l1, l2, relu, hs
:param reg_tens: the regularization tensor to apply a function to,
one of: inp, out
:param start_epoch: The epoch to start the modifier at
:param end_epoch: The epoch to end the modifier at
"""
def __init__(
self,
layers: Union[str, List[str]],
alpha: Union[float, List[float]],
layer_normalized: bool = False,
reg_func: str = "l1",
reg_tens: str = "inp",
start_epoch: float = -1.0,
end_epoch: float = -1.0,
):
super().__init__(
start_epoch=start_epoch, end_epoch=end_epoch, end_comparator=-1
)
self._layers = validate_str_iterable(
layers, "{} for layers".format(self.__class__.__name__)
)
self._alpha = alpha
self._layer_normalized = convert_to_bool(layer_normalized)
self._reg_func = reg_func
self._reg_tens = reg_tens
self._trackers = [] # type: List[ASLayerTracker]
self.validate()
def __del__(self):
self._trackers.clear()
@ModifierProp()
def layers(self) -> Union[str, List[str]]:
"""
:return: str or list of str for the layers to apply the AS modifier to
can also use the token __ALL__ to specify all layers
"""
return self._layers
@layers.setter
def layers(self, value: Union[str, List[str]]):
"""
:param value: str or list of str for the layers to apply the AS modifier to
can also use the token __ALL__ to specify all layers
"""
self._layers = validate_str_iterable(
value, "{} for layers".format(self.__class__.__name__)
)
@ModifierProp()
def alpha(self) -> Union[float, List[float]]:
"""
:return: the weight to use for the regularization, ie cost = loss + alpha * reg
"""
return self._alpha
@alpha.setter
def alpha(self, value: Union[float, List[float]]):
"""
:param value: the weight to use for the regularization,
ie cost = loss + alpha * reg
"""
self._alpha = value
self.validate()
@ModifierProp()
def layer_normalized(self):
"""
:return: True to normalize the values by 1 / L where L is the number of layers
"""
return self._layer_normalized
@layer_normalized.setter
def layer_normalized(self, value):
"""
:param value: True to normalize the values by 1 / L
where L is the number of layers
"""
self._layer_normalized = value
self.validate()
@ModifierProp()
def reg_func(self) -> str:
"""
:return: the regularization function to apply to the activations,
one of: l1, l2, relu, hs
"""
return self._reg_func
@reg_func.setter
def reg_func(self, value: str):
"""
:param value: the regularization function to apply to the activations,
one of: l1, l2, relu, hs
"""
self._reg_func = value
self.validate()
@ModifierProp()
def reg_tens(self) -> str:
"""
:return: the regularization tensor to apply a function to,
one of: inp, out
"""
return self._reg_tens
@reg_tens.setter
def reg_tens(self, value: str):
"""
:param value: the regularization tensor to apply a function to, one of: inp, out
"""
self._reg_tens = value
self.validate()
[docs] def initialize(self, module: Module, optimizer: Optimizer):
"""
Grab the layer's to control activation sparsity for
:param module: module to modify
:param optimizer: optimizer to modify
"""
super(ASRegModifier, self).initialize(module, optimizer)
layers = (
get_terminal_layers(module)
if self._layers == ALL_TOKEN
else [get_layer(name, module) for name in self._layers]
)
for layer in layers:
self._trackers.append(
ASLayerTracker(
layer,
track_input=self._reg_tens == "inp",
track_output=self._reg_tens == "out",
input_func=self._regularize_tracked,
output_func=self._regularize_tracked,
)
)
[docs] def update(
self, module: Module, optimizer: Optimizer, epoch: float, steps_per_epoch: int
):
"""
Update the loss tracking for each layer that is being modified on start and stop
:param module: module to modify
:param optimizer: optimizer to modify
:param epoch: current epoch and progress within the current epoch
:param steps_per_epoch: number of steps taken within each epoch
(calculate batch number using this and epoch)
"""
super().update(module, optimizer, epoch, steps_per_epoch)
if self.start_pending(epoch, steps_per_epoch):
for tracker in self._trackers:
tracker.enable()
if self.end_pending(epoch, steps_per_epoch):
for tracker in self._trackers:
tracker.disable()
[docs] def loss_update(
self,
loss: Tensor,
module: Module,
optimizer: Optimizer,
epoch: float,
steps_per_epoch: int,
) -> Tensor:
"""
Modify the loss to include the norms for the outputs of the layers
being modified.
:param loss: The calculated loss tensor
:param module: module to modify
:param optimizer: optimizer to modify
:param epoch: current epoch and progress within the current epoch
:param steps_per_epoch: number of steps taken within each epoch
(calculate batch number using this and epoch)
:return: the modified loss tensor
"""
loss = super().loss_update(loss, module, optimizer, epoch, steps_per_epoch)
act_reg = 0.0
key = "cpu" if not loss.is_cuda else "cuda:{}".format(loss.get_device())
for index, tracker in enumerate(self._trackers):
if self._reg_tens == "inp":
tracker_reg = tracker.tracked_input[key]
elif self._reg_tens == "out":
tracker_reg = tracker.tracked_output[key]
else:
raise ValueError(
"unsupported reg_tens given of {}".format(self._reg_tens)
)
alpha = (
self._alpha if isinstance(self._alpha, float) else self._alpha[index]
)
act_reg += tracker_reg * alpha
if self._layer_normalized:
# normalize across the number of layers we are tracking
act_reg = act_reg / len(self._trackers)
return loss + act_reg
[docs] def optimizer_post_step(
self, module: Module, optimizer: Optimizer, epoch: float, steps_per_epoch: int
):
"""
be sure to clear out the values after the update step has been taken
:param module: module to modify
:param optimizer: optimizer to modify
:param epoch: current epoch and progress within the current epoch
:param steps_per_epoch: number of steps taken within each epoch
(calculate batch number using this and epoch)
"""
super().optimizer_post_step(module, optimizer, epoch, steps_per_epoch)
for tracker in self._trackers:
tracker.clear()
[docs] def validate(self):
"""
Validate the values of the params for the current instance are valid
"""
if not isinstance(self._alpha, float) and self._layers == ALL_TOKEN:
raise TypeError(
"list of alphas {} is not supported with {} for layers in {}".format(
self._alpha, ALL_TOKEN, self.__class__.__name__
)
)
if not isinstance(self._alpha, float) and len(self._alpha) != len(self._layers):
raise ValueError(
"len(alphas) of {} must match len(layers) of {} in {}".format(
len(self._alpha), len(self._layers), self.__class__.__name__
)
)
if self._reg_func not in REG_FUNCTIONS:
raise ValueError(
"{} is not a supported reg_func, available are {} for {}".format(
self._reg_func, REG_FUNCTIONS, self.__class__.__name__
)
)
if self._reg_tens not in REG_TENSORS:
raise ValueError(
"{} is not a supported reg_tens, available are {} for {}".format(
self._reg_tens, REG_TENSORS, self.__class__.__name__
)
)
def _regularize_tracked(self, tens: Union[Tuple[Tensor, ...], Tensor]):
if isinstance(tens, Tensor):
tens = (tens,)
reduced = 0.0
for ten in tens:
if self._reg_func == "l1":
tens_reduced = ten.abs().sum()
elif self._reg_func == "l2":
tens_reduced = ten.pow(2).sum()
elif self._reg_func == "relu":
tens_reduced = TF.relu(reduced).sum()
elif self._reg_func == "hs":
tens_reduced = ten.abs().sum().pow(2) / ten.pow(2).sum()
else:
raise ValueError(
"unsupported reg_func given of {}".format(self._reg_func)
)
# normalize by batch size
reduced += tens_reduced / ten.shape[0]
# normalize across all the tensors that were inputs or outputs for the layer
reduced = reduced / len(tens)
return reduced


This article is a translation of a French article, written by Julien Rigoulay.
Benevolent leadership is a concept at the heart of discussions in companies that want to innovate and boost productivity. Initially seen as naive or just a trend following on from the humanist movement, benevolence in the workplace is now considered a “strong lever” for attracting employees.
With the massive retirement of the baby boom generation, wage portage, and young executives increasingly attracted by positions abroad, the current context forces companies to review their management style. Indeed, in order to recruit reliable and motivated employees, companies must adopt a different, more ethical and attractive policy.
This is where benevolence comes into play: it breaks the hierarchical structure that reflects aggressive practices in the corporate world. When each individual feels at ease in their work environment, they become more productive and feel more involved. But before we go any further, let’s take a closer look at this concept to make it really beneficial for your company.
Benevolent leadership, what is it exactly?
To boil it right down, here are the main points that make the difference in a benevolently-managed company:
Inviting collaborators to take part in major decisions
When managers promote discussion around major decisions within their company, they empower their team members. This is an effective strategy to make employees feel more involved. Indeed, when each individual feels that they are contributing to the company’s development, it creates attachment. Note that management itself doesn’t have to be collaborative, but discussion is always important before making any major decisions.
Adopting a caring attitude and always being attentive
A manager who’s not afraid to smile is like a breath of fresh air in the workplace. Not only does it make team members more relaxed, but it also makes them more likely to share crucial information should a problem arise, helping to reach a resolution more quickly. Indeed, a stern-faced manager can put employees off from sharing their thoughts.
It’s also vital for managers to have good listening skills. Not only is the information provided by the teams always important for making good decisions, but their active participation also motivates them. When a manager pays attention and acts on the recommendations of a team member, the latter will feel more motivated.
A benevolent manager, but no “cronyism”
To be a good manager, you have to treat all your employees equally. Indeed, benevolence does not mean being “buddies” with everyone. We must not lose sight of the ultimate aim: to serve the interests of the company. To achieve this, the manager must manage team members equally without playing favourites.
Recognizing that mistakes happen and promoting communication
Employees learn and forge themselves in part by making mistakes. A benevolent manager must accept that to err is human and recognize that people are bound to mess up from time to time. This kind of mindset fosters confidence within a team by taking the pressure off and promoting a good atmosphere at work. However, benevolence does not mean that there are no consequences, but they must be proportional to the mistake made.
Communication plays a vital role in benevolent management. A manager with strong communication skills can share information or announce decisions with ease. For example, if salary increases are to reflect individual performance, this detail must be communicated from the beginning. That being said, it will be easier for the manager to explain if some team members don’t get an increase. However, bad news must always be announced with respect and finesse.
How to manage with kindness?
Although the concept of benevolent leadership is on the lips of business leaders and heads of department everywhere, it seems to be little more than a good intention. Indeed, most who try to implement it tend to forget that it requires a real implementation plan. A profound change must be made in order to get results.
Company leaders must define a new management approach, possibly with the help of a specialized coach. The organization must also evolve to promote benevolence within the company while respecting the specificities of the company. A dynamic and solid balance must be created and maintained within a positive environment that promotes efficiency and energy. Here are some recommendations that will help you achieve a genuine transformation.
The process must be global
The project must come from the top of the hierarchy and encompass each and every one of the company’s departments and teams. Indeed, if benevolent management is practiced by only one manager, it won’t affect the whole organization.
Benevolence needs to be more than just a Human Resources Department project. It must become a source of motivation for each individual. Employees need to be involved and motivated to help managers move forward, especially in times of crisis. Indeed, when teams are loyal, there is less turnover: the presence of each individual contributes to the smooth overall running of the company and boosts productivity.
Every employee counts
The concept of corporate benevolence implies that a radically individual-oriented policy be established. Each person must feel useful and special. The professional and personal lives of every team member matters. Some leaders think that giving more time to the personal life of an employee will make him or her less productive. On the contrary! If managers give more importance to employees’ personal life and well-being, they will be more productive.
Fostering this perspective requires managers who know how to listen. When an employee makes an effort, they must be recognized for their true value. This encourages them to be more creative and to feel more involved in the company life, which automatically fosters a feeling of belonging.
A recent study revealed that over the next decade, it’s the candidates who will choose which company they want to work for rather than the other way around. Managers will have to set up a recruitment system that attracts the profiles they want.
Many changes have to be made before benevolent leadership can become more than just a good intention. The outdated practices of previous generations will no longer suffice. If companies fail to adapt their approach, productivity will decline. Balance has become all important in the employee-company relationship: managers will have to step up their efforts to implement benevolence if they want to grow company profits!
What about you, have you taken the plunge? Share your experience in the comments section below!


Copyright © 2014 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved. W3C liability, trademark and document use rules apply.
This module introduces cascading variables as a new primitive value type that is accepted by all CSS properties, and custom properties for defining them. CSS is a language for describing the rendering of structured documents (such as HTML and XML) on screen, on paper, in speech, etc.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
Publication as a Last Call Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
The (archived) public mailing list<EMAIL_ADDRESS>(see instructions) is preferred for discussion of this specification. When sending e-mail, please put the text “css-variables” in the subject, preferably like this: “[css-variables] …summary of comment…”
This document was produced by the CSS Working Group (part of the Style Activity).
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This specification is a Last Call Working Draft. All persons are encouraged to review this document and send comments to the www-style mailing list as described above. The deadline for comments is 3 June 2014.
This is the second last call. See the Changes section for the differences with the previous draft.
This section is not normative.
Large documents or applications (and even small ones) can contain quite a bit of CSS. Many of the values in the CSS file will be duplicate data; for example, a site may establish a color scheme and reuse three or four colors throughout the site. Altering this data can be difficult and error-prone, since it’s scattered throughout the CSS file (and possibly across multiple files), and may not be amenable to Find-and-Replace.
This module introduces a family of custom author-defined properties known collectively as custom properties, which allow an author to assign arbitrary values to a property with an author-chosen name, and the var() function, which allow an author to then use those values in other properties elsewhere in the document. This makes it easier to read large files, as seemingly-arbitrary values now have informative names, and makes editing such files much easier and less error-prone, as one only has to change the value once, in the custom property, and the change will propagate to all uses of that variable automatically.
This specification defines an open-ended set of properties called custom properties, which, among other things, are used to define the substitution value of var() functions.
| Name: | --* |
|---|---|
| Value: | <any-value> |
| Initial: | (nothing, see prose) |
| Applies to: | all elements |
| Inherited: | yes |
| Media: | all |
| Computed value: | specified value with variables substituted (but see prose for "invalid variables") |
| Animatable: | no |
A custom property is any property whose name starts with two dashes (U+002D HYPHEN-MINUS), like --foo. The <custom-property-name> production corresponds to this: it’s defined as any valid identifier that starts with two dashes. Custom properties are solely for use by authors and users; CSS will never give them a meaning beyond what is presented here.
:root { --main-color: #06c; --accent-color: #006; } /* The rest of the CSS file */ #foo h1 { color: var(--main-color); }
The naming provides a mnemonic for the colors, prevents difficult-to-spot typos in the color codes, and if the theme colors are ever changed, focuses the change on one simple spot (the custom property value) rather than requiring many edits across all stylesheets in the webpage.
Unlike other CSS properties, custom property names are case-sensitive.
Custom properties are not reset by the all property. We may define a property in the future that resets all variables.
The CSS-wide keywords can be used in custom properties, with the same meaning as in any another property.
Note: That is, they’re interpreted at cascaded-value time as normal, and are not preserved as the custom property’s value, and thus are not substituted in by the corresponding variable.
Note: While this module focuses on the use of custom properties with the var() function to create “variables”, they can also be used as actual custom properties, parsed by and acted on by script. It’s expected that the CSS Extensions spec [CSS-EXTENSIONS] will expand on these use-cases and make them easier to do.
The allowed syntax for custom properties is extremely permissive. The <any-value> production matches any sequence of one or more tokens, so long as the sequence does not contain <bad-string-token>, <bad-url-token>, unmatched <<)-token>>, <<]-token>>, or <<}-token>>, or top-level <semicolon-token> tokens or <delim-token> tokens with a value of "!".
Note: This definition, along with the general CSS syntax rules, implies that a custom property value never includes an unmatched quote or bracket, and so cannot have any effect on larger syntax constructs, like the enclosing style rule, when reserialized.
Note: Custom properties can contain a trailing !important, but this is automatically removed from the property’s value by the CSS parser, and makes the custom property "important" in the CSS cascade. In other words, the prohibition on top-level "!" characters does not prevent !important from being used, as the !important is removed before syntax checking happens.
Note: While <any-value> must represent at least one token, that one token may be whitespace. This implies that --foo: ; is valid, and the corresponding var(--foo) call would have a single space as its substitution value, but --foo:; is invalid.
--foo: if(x > 5) this.width = 10;
While this value is obviously useless as a variable, as it would be invalid in any normal property, it might be read and acted on by JavaScript.
The values of custom properties, and the values of var() functions substituted into custom properties, are case-sensitive, and must be preserved in their original author-given casing. (Many CSS values are case-insensitive, which user agents can take advantage of by "canonicalizing" them into a single casing, but that isn’t allowed for custom properties.)
The initial value of a custom property is an empty value; that is, nothing at all. This initial value has a special interaction with the var() notation, which is explained in the section defining var().
Custom properties are ordinary properties,
so they can be declared on any element,
are resolved with the normal inheritance and cascade rules,
can be made conditional with @media and other conditional rules,
can be used in HTML’s style
attribute,
can be read or set using the CSSOM, etc.
Notably, they can even be transitioned or animated, but since the UA has no way to interpret their contents, they always use the "flips at 50%" behavior that is used for any other pair of values that can’t be intelligently interpolated. However, any custom property used in a @keyframes rule becomes animation-tainted, which affects how it is treated when referred to via the var() function in an animation property.
:root { --header-color: #06c; }
declares a custom property named "--header-color" on the root element, and assigns to it the value "#06c". This property is then inherited to the elements in the rest of the document. Its value can be referenced with the var() function:
h1 { background-color: var(--header-color); }
The preceding rule is equivalent to writing background-color: #06c;, except that the variable name makes the origin of the color clearer, and if var(--header-color) is used on other elements in the document, all of the uses can be updated at once by changing the '--header-color' property on the root element.
:root { --color: blue; } div { --color: green; } #alert { --color: red; } * { color: var(--color); }
I inherited blue from the root element!

I got green set directly on me!

 While I got red set directly on me!
I’m red too, because of inheritance!

Custom properties are left almost entirely unevaluated, except that they allow and evaluate the var() function in their value. This can create cyclic dependencies where a custom property uses a var() referring to itself, or two or more custom properties each attempt to refer to each other.
For each element, create an undirected dependency graph, containing nodes for each custom property. If the value of a custom property prop contains a var() function referring to the property var (including in the fallback argument of var()), add an edge between prop and the var. Edges are possible from a custom property to itself. If there is a cycle in the dependency graph, all the custom properties in the cycle must compute to their initial value (which is a guaranteed-invalid value).
:root { --main-color: #c06; --accent-background: linear-gradient(to top, var(--main-color), white); }
The '--accent-background' property (along with any other properties that use var(--main-color)) will automatically update when the '--main-color' property is changed.
:root { --one: calc(var(--two) + 20px); --two: calc(var(--one) - 20px); }
Both '--one' and '--two' now compute to their initial value, rather than lengths.
It is important to note that custom properties resolve any var() functions in their values at computed-value time, which occurs before the value is inherited. In general, cyclic dependencies occur only when multiple custom properties on the same element refer to each other; custom properties defined on elements higher in the element tree can never cause a cyclic reference with properties defined on elements lower in the element tree.
<one><two><three /></two></one> one { --foo: 10px; } two { --bar: calc(var(--foo) + 10px); } three { --foo: calc(var(--bar) + 10px); }
The <one> element defines a value for '--foo'. The <two> element inherits this value, and additionally assigns a value to '--bar' using the foo variable. Finally, the <three> element inherits the '--bar' value after variable substitution (in other words, it sees the value calc(10px + 10px)), and then redefines '--foo' in terms of that value. Since the value it inherited for '--bar' no longer contains a reference to the '--foo' property defined on <one>, defining '--foo' using the var(--bar) variable is not cyclic, and actually defines a value that will eventually (when referenced as a variable in a normal property) resolve to 30px.
The value of a custom property can be substituted into the value of another property with the var() function. The syntax of var() is:
var() = var( <custom-property-name> [, <any-value> ]? )
The var() function can be used in place of any part of a value in any property on an element. The var() function can not be used as property names, selectors, or anything else besides property values. (Doing so usually produces invalid syntax, or else a value whose meaning has no connection to the variable.)
The first argument to the function is the name of the custom property to be substituted. The second argument to the function, if provided, is a fallback value, which is used as the substitution value when the referenced custom property is invalid.
Note: The syntax of the fallback, like that of custom properties, allows commas. For example, var(--foo, red, blue) defines a fallback of red, blue; that is, anything between the first comma and the end of the function is considered a fallback value.
If a property contains one or more var() functions, and those functions are syntactically valid, the entire property’s grammar must be assumed to be valid at parse time. It is only syntax-checked at computed-value time, after var() functions have been substituted.
To substitute a var() in a property’s value:
If the custom property named by the first argument to the var() function is animation-tainted, and the var() function is being used in the animation property or one of its longhands, treat the custom property as having its initial value for the rest of this algorithm.
If the value of the custom property named by the first argument to the var() function is anything but the initial value, replace the var() function by the value of the corresponding custom property.
Otherwise, if the var() function has a fallback value as its second argument, replace the var() function by the fallback value. If there are any var() references in the fallback, substitute them as well.
Otherwise, the property containing the var() function is invalid at computed-value time.
Note: Other things can also make a property invalid at computed-value time.
Without fallback, the app author must supply a value for every variable that your component uses. With fallback, the component author can supply defaults, so the app author only needs to supply values for the variables they wish to override.
/* In the component’s style: */ .component .header { color: var(--header-color, blue); } .component .text { color: var(--text-color, black); } /* In the larger application’s style: */ .component { --text-color: #080; /* header-color isn’t set, and so remains blue, the fallback value */ }
.foo { --side: margin-top; var(--side): 20px; }
This is not equivalent to setting margin-top: 20px;. Instead, the second declaration is simply thrown away as a syntax error for having an invalid property name.
Similarly, you can’t build up a single token where part of it is provided by a variable:
.foo { --gap: 20; margin-top: var(--gap)px; }
Again, this is not equivalent to setting margin-top: 20px; (a length). Instead, it’s equivalent to margin-top: 20 px; (a number followed by an ident), which is simply an invalid value for the margin-top property. Note, though, that calc() can be used to validly achieve the same thing, like so:
.foo { --gap: 20; margin-top: calc(var(--gap) * 1px); }
var() functions are substituted at computed-value time. If a declaration, once all var() functions are substituted in, is invalid, the declaration is invalid at computed-value time.
:root { --looks-valid: 20px; } p { background-color: var(--looks-valid); }
Since 20px is an invalid value for background-color, this instance of the property computes to transparent (the initial value for background-color) instead.
If the property was one that’s inherited by default, such as color, it would compute to the inherited value rather than the initial value.
When a custom property has its initial value, var() functions cannot use it for substitution. Attempting to do so makes the declaration invalid at computed-value time, unless a valid fallback is specified.
A declaration can be invalid at computed-value time if it contains a var() that references a custom property with its initial value, as explained above, or if it uses a valid custom property, but the property value, after substituting its var() functions, is invalid. When this happens, the computed value of the property is either the property’s inherited value or its initial value depending on whether the property is inherited or not, respectively, as if the property’s value had been specified as the unset keyword.
:root { --not-a-color: 20px; } p { background-color: red; } p { background-color: var(--not-a-color); }
the
 elements will have transparent backgrounds (the initial value for background-color), rather than red backgrounds. The same would happen if the custom property itself was unset, or contained an invalid var() function.
Note the difference between this and what happens if the author had just written background-color: 20px directly in their stylesheet - that would be a normal syntax error, which would cause the rule to be discarded, so the background-color: red rule would be used instead.
Note: The invalid at computed-value time concept exists because variables can’t "fail early" like other syntax errors can, so by the time the user agent realizes a property value is invalid, it’s already thrown away the other cascaded values.
The use of var() functions in shorthand properties presents some unique difficulties.
Ordinarily, the value of a shorthand property is separated out into its component longhand properties at parse time, and then the longhands themselves participate in the cascade, with the shorthand more-or-less discarded. If a var() functions is used in a shorthand, however, one can’t tell what values are meant to go where; it may in fact be impossible to separate it out at parse time, as a single var() function may substitute in the value of several longhands at once.
To get around this, implementations must fill in longhands with a special, unobservable-to-authors pending-substitution value that indicates the shorthand contains a variable, and thus the longhand’s value is pending variable substitution. This value must then be cascaded as normal, and at computed-value time, after var() functions are finally substituted in, the shorthand must be parsed and the longhands must be given their appropriate values at that point.
Pending-substitution values must be serialized as the empty string, if an API allows them to be observed.
Similarly, while [CSSOM] defines that shorthand properties are serialized by appropriately concatenating the values of their corresponding longhands, shorthands containing var() functions must instead retain their original, var()-containing, value. If serializing a shorthand’s value would involve serializing a pending-substitution value, the shorthand must instead be serialized by serializing its original value.
All custom property declarations have the case-insensitive flag set.
Note: Custom properties do not appear on a CSSStyleDeclaration object in camel-cased form, because their names may have both upper and lower case letters which indicate distinct custom properties. The sort of text transformation that automatic camel-casing performs is incompatible with this. They can still be accessed by their proper name via getProperty()/etc.
Custom property names must be serialized with the casing as provided by the author.
Ordinarily, property names are restricted to the ASCII range and are case-insensitive, so implementations typically serialize the name lowercased.
The syntax of custom properties was changed from var-foo to --foo.
The var() function takes the full custom property name as its first argument, rather than the name minus a prefix.
The CSSVariablesMap interface was removed, in favor of a better custom-property API to be defined in the future.
Many thanks to several people in the CSS Working Group for keeping the dream of variables alive over the years, particularly Daniel Glazman and David Hyatt. Thanks to multiple people on the mailing list for helping contribute to the development of this incarnation of variables, particularly Brian Kardell, David Baron, François Remy, Roland Steiner, and Shane Stephens.
Conformance requirements are expressed with a combination of descriptive assertions and RFC 2119 terminology. The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in the normative parts of this document are to be interpreted as described in RFC 2119. However, for readability, these words do not appear in all uppercase letters in this specification.
All of the text of this specification is normative except sections explicitly marked as non-normative, examples, and notes. [RFC2119]
Examples in this specification are introduced with the words "for example"
or are set apart from the normative text with class="example"
,
like this:
This is an example of an informative example.
Informative notes begin with the word "Note" and are set apart from the
normative text with class="note"
, like this:
Note, this is an informative note.
Conformance to this specification is defined for three conformance classes:
A style sheet is conformant to this specification if all of its statements that use syntax defined in this module are valid according to the generic CSS grammar and the individual grammars of each feature defined in this module.
A renderer is conformant to this specification if, in addition to interpreting the style sheet as defined by the appropriate specifications, it supports all the features defined by this specification by parsing them correctly and rendering the document accordingly. However, the inability of a UA to correctly render a document due to limitations of the device does not make the UA non-conformant. (For example, a UA is not required to render color on a monochrome monitor.)
An authoring tool is conformant to this specification if it writes style sheets that are syntactically correct according to the generic CSS grammar and the individual grammars of each feature in this module, and meet all other conformance requirements of style sheets as described in this module.
So that authors can exploit the forward-compatible parsing rules to assign fallback values, CSS renderers must treat as invalid (and ignore as appropriate) any at-rules, properties, property values, keywords, and other syntactic constructs for which they have no usable level of support. In particular, user agents must not selectively ignore unsupported component values and honor supported values in a single multi-value property declaration: if any value is considered invalid (as unsupported values must be), CSS requires that the entire declaration be ignored.
To avoid clashes with future CSS features, the CSS2.1 specification reserves a prefixed syntax for proprietary and experimental extensions to CSS.
Prior to a specification reaching the Candidate Recommendation stage in the W3C process, all implementations of a CSS feature are considered experimental. The CSS Working Group recommends that implementations use a vendor-prefixed syntax for such features, including those in W3C Working Drafts. This avoids incompatibilities with future changes in the draft.
Once a specification reaches the Candidate Recommendation stage, non-experimental implementations are possible, and implementors should release an unprefixed implementation of any CR-level feature they can demonstrate to be correctly implemented according to spec.
To establish and maintain the interoperability of CSS across implementations, the CSS Working Group requests that non-experimental CSS renderers submit an implementation report (and, if necessary, the testcases used for that implementation report) to the W3C before releasing an unprefixed implementation of any CSS features. Testcases submitted to W3C are subject to review and correction by the CSS Working Group.
Further information on submitting testcases and implementation reports can be found from on the CSS Working Group’s website at http://www.w3.org/Style/CSS/Test/. Questions should be directed to the<EMAIL_ADDRESS>mailing list.
| Name | Value | Initial | Applies to | Inh. | %ages | Media | Animatable | Computed value |
|---|---|---|---|---|---|---|---|---|
| --* | <any-value> | (nothing, see prose) | all elements | yes | all | no | specified value with variables substituted (but see prose for "invalid variables") |


Include your name, address and contact details. You don’t need to include your age, marital status or nationality. Recruiters can make a decision about your skills and abilities without this information. Make sure your email address sounds professional. You could also add a link to a professional social media site like LinkedIn. Make sure your profile shows you in a positive light and doesn’t contain anything you wouldn’t want an employer to see.
This is a mini-advert for you and should summarise your: skills and qualities work background and achievements career aims It should only be a few lines and needs to grab the reader’s attention. Try not to use terms like ‘reliable, ‘hard working’, ‘team player’ or ‘good communicator’. These are viewed a lot by employers, and they don’t help to build up an individual picture of you. If the job involves working with people, try to show your people skills by uses phrases like: ‘negotiating’, ‘effectively dealing with demanding customers’, ‘handling conflict’ or ‘showing empathy’. These help the reader build up a picture of your skills, knowledge and experience. Keep it short - you can go into more detail later. When describing your career aims, think about the employer you’re sending the CV to. Make your careers aims sound just like the kind of opportunities they currently have.
You’ll usually put your employment history first if you’ve been working for a few years. If you don’t have much work experience, focus on your your education and training. Start with the job you’re doing now, or the last job you had, and work backwards. You need to include your employer’s name, the dates you worked for them, your job title and your main tasks. On the jobs that are relevant to the role you’re applying for, give examples of the skills you used and what you achieved. Use bullet pointed lists and positive language. Use ‘action’ words to describe what you did in your job like: ‘achieved’, ‘designed’, ‘established’, ‘supervised’, ‘co-ordinated’, ‘created’ or ‘transformed’. Relate your skills and experience to the job description, person specification or what you think the employer is looking for. Also include any relevant temporary work and volunteering experience. Try not to have any gaps in your work history. If you had time out travelling, job seeking, volunteering or caring for a relative, include them with details of what you learned and the skills you gained.
Start with your most recent qualifications and work back to the ones you got at school. Use bullet points or a table and include: the university, college or school you went to the dates the qualifications were awarded and any grades any work-related courses, if they're relevant
Include hobbies, interests and achievements that are relevant to the job. If you're involved in any clubs or societies, this can show that you enjoy meeting new people. Interests like sports and physical recreation activities can also show employers that you are fit and healthy. Don’t just put activities that you would do alone like reading, bird-watching or playing video games, unless they relate directly to the job that you are applying for. They may leave employers wondering how sociable you are. Make your activities specific and varied.
You can include this section if you need to add anything else that's relevant. You may need to explain a gap in your employment history, like travelling or family reasons. You could also include other relevant skills here, such as if you have a driving licence or can speak any foreign languages.
At least one referee should be work-related. Or, if you haven't worked for a while, you could use another responsible person who has known you for some time. You can list your referees on your CV or just put 'references available on request'. If you decide to include their details you should explain the relationship of each referee to you – for example 'Claire Turner, line manager'.


@Immutable @Utility public final class TriggerUtility extends java.lang.Object
| Modifier and Type | Method and Description |
|---|---|
static Trigger |
addActionTrigger(java.lang.Object object,
Animator target)
Creates an action trigger and adds it as an
ActionListener to the
passed object. |
static Trigger |
addFocusTrigger(javax.swing.JComponent component,
Animator target,
FocusTriggerEvent event)
Creates a non-auto-reversing focus trigger and adds it as a
FocusListener to the passed component. |
static Trigger |
addFocusTrigger(javax.swing.JComponent component,
Animator target,
FocusTriggerEvent event,
boolean autoReverse)
Creates a focus trigger and adds it as a
FocusListener to the
passed component. |
static Trigger |
addMouseTrigger(javax.swing.JComponent component,
Animator target,
MouseTriggerEvent event)
Creates a non-auto-reversing mouse trigger and adds it as a
MouseListener to the passed component. |
static Trigger |
addMouseTrigger(javax.swing.JComponent component,
Animator target,
MouseTriggerEvent event,
boolean autoReverse)
Creates a mouse trigger and adds it as a
MouseListener to the
passed component. |
static Trigger |
addTimingTrigger(Animator source,
Animator target,
TimingTriggerEvent event)
Creates a non-auto-reversing timing trigger and adds it as a target to the
source animation.
|
static Trigger |
addTimingTrigger(Animator source,
Animator target,
TimingTriggerEvent event,
boolean autoReverse)
Creates a timing trigger and adds it as a target to the source animation.
|
public static Trigger addTimingTrigger(Animator source, Animator target, TimingTriggerEvent event)
Animator
can be set to start
when another ends using this trigger. For example, to have anim2
start when anim1 ends, one might write the following:
Trigger trigger = TimingTrigger.addTrigger(anim1, anim2, TimingTriggerEvent.STOP);The returned trigger object can be safely ignored if the code never needs to disarm the trigger.
TimingTrigger.addTrigger(anim1, anim2, TimingTriggerEvent.STOP);
source
- the animation that will be listened to for events to start the
target animation.target
- the animation that will start when the event occurs.event
- the TimingTriggerEvent
on source that will cause
target to start.java.lang.IllegalArgumentException
- if any of the parameters is null
.TimingTrigger
public static Trigger addTimingTrigger(Animator source, Animator target, TimingTriggerEvent event, boolean autoReverse)
Animator
can be set to start when another ends
using this trigger. For example, to have anim2 start when
anim1 ends and visa versa, have anim2 stop when
anim1 starts, one might write the following:
Trigger trigger = TimingTrigger.addTrigger(anim1, anim2, TimingTriggerEvent.STOP, true);The returned trigger object can be safely ignored if the code never needs to disarm the trigger.
TimingTrigger.addTrigger(anim1, anim2, TimingTriggerEvent.STOP, true);
source
- the animation that will be listened to for events to start the
target animation.target
- the animation that will start when the event occurs.event
- the TimingTriggerEvent
on source that will cause
target to start.autoReverse
- true
if the animation should be reversed on opposite
trigger events, false
otherwise.java.lang.IllegalArgumentException
- if any of the parameters is null
.TimingTrigger
public static Trigger addActionTrigger(java.lang.Object object, Animator target)
ActionListener
to the
passed object. For example, to have anim
start when a button is
clicked, one might write the following:
Trigger trigger = TriggerUtility.addActionTrigger(button, anim);The returned trigger object can be safely ignored if the code never needs to disarm the trigger.
TriggerUtility.addActionTrigger(button, anim);
object
- an object that will be used as an event source for this trigger.
This object must have an addActionListener
method.target
- the animation that will start when the event occurs.java.lang.IllegalArgumentException
- if either of the parameters is null
or if object
has no addActionListener
method.public static Trigger addFocusTrigger(javax.swing.JComponent component, Animator target, FocusTriggerEvent event)
FocusListener
to the passed component. For example, to have
anim
start when component
receives an IN event, one might
write the following:
Trigger trigger = TriggerUtility.addFocusTrigger(component, anim, FocusTriggerEvent.IN);The returned trigger object can be safely ignored if the code never needs to disarm the trigger.
TriggerUtility.addFocusTrigger(component, anim, FocusTriggerEvent.IN);
component
- the component that will generate focus events for this trigger.target
- the animation that will start when the event occurs.event
- the FocusTriggerEvent
on component that will
cause target to start.java.lang.IllegalArgumentException
- if any of the parameters is null
.public static Trigger addFocusTrigger(javax.swing.JComponent component, Animator target, FocusTriggerEvent event, boolean autoReverse)
FocusListener
to the
passed component. For example, to have anim
start when
component
receives an IN event, and reverse anim
when
component
receives an OUT event, one might write the following:
Trigger trigger = TriggerUtility.addFocusTrigger(component, anim, FocusTriggerEvent.IN, true);The returned trigger object can be safely ignored if the code never needs to disarm the trigger.
TriggerUtility.addFocusTrigger(component, anim, FocusTriggerEvent.IN, true);
component
- the component that will generate focus events for this trigger.target
- the animation that will start when the event occurs.event
- the FocusTriggerEvent
on component that will
cause target to start.autoReverse
- true
if the animation should be reversed on opposite
trigger events, false
otherwise.java.lang.IllegalArgumentException
- if any of the parameters is null
.public static Trigger addMouseTrigger(javax.swing.JComponent component, Animator target, MouseTriggerEvent event)
MouseListener
to the passed component. For example, to have
anim
start when component
receives an CLICK event, one
might write the following:
Trigger trigger = TriggerUtility.addMouseTrigger(component, anim, MouseTriggerEvent.CLICK);The returned trigger object can be safely ignored if the code never needs to disarm the trigger.
TriggerUtility.addMouseTrigger(component, anim, MouseTriggerEvent.CLICK);
component
- the component that will generate mouse events for this trigger.target
- the animation that will start when the event occurs.event
- the MouseTriggerEvent
on component that will
cause target to start.java.lang.IllegalArgumentException
- if any of the parameters is null
.public static Trigger addMouseTrigger(javax.swing.JComponent component, Animator target, MouseTriggerEvent event, boolean autoReverse)
MouseListener
to the
passed component. For example, to have anim
start when
component
receives an ENTER event, and reverse anim
when
component
receives an EXIT event, one might write the following:
Trigger trigger = TriggerUtility.addMouseTrigger(component, anim, MouseTriggerEvent.ENTER, true);The returned trigger object can be safely ignored if the code never needs to disarm the trigger.
TriggerUtility.addMouseTrigger(component, anim, MouseTriggerEvent.ENTER, true);
component
- the component that will generate mouse events for this trigger.target
- the animation that will start when the event occurs.event
- the MouseTriggerEvent
on component that will
cause target to start.autoReverse
- true
if the animation should be reversed on opposite
trigger events, false
otherwise.java.lang.IllegalArgumentException
- if any of the parameters is null
.


{% extends "base.html" %} {% block body %}
This page acts as an example of what content would be included in the generated digest e-mail.
You don't appear to be following anyone.
Sorry, {{ current_user.username }}!


Fill out the quiz below and find out what programming language you'd best be suited to learn.
You are best suited to learn...


Home/Login
About CC Creators
>>Currently on home page
Thank you for visting Class Cards by
Awesome 201
Copyright 2018


Add AWS Account |
What is Endpoint? Inject PACKET_LOSS_PERCENTAGE=5% on vRealize Automation Appliance Node #1, Run workflow for network latency, Remediate fault and run workflow again. |
| Organization Name | Endpoint Name | Access Key | Secret Key | AWS Region | Delete Endpoint |
|---|---|---|---|---|---|
| {{awsendpoint.organizationName}} | {{ awsendpoint.endpointName }} | {{ awsendpoint.accessKey }} | xxxxxxxxxx | {{awsendpoint.region}} |
Add VMware vSphere Account |
What is Endpoint? Inject PACKET_LOSS_PERCENTAGE=5% on vRealize Automation Appliance Node #1, Run workflow for network latency, Remediate fault and run workflow again. |
| Organization Name | Endpoint Name | vSphere SDK URL | vSphere User | vSphere Password | vSphere Computes | Delete Endpoint |
|---|---|---|---|---|---|---|
| {{vsphereendpoint.organizationName}} | {{ vsphereendpoint.endpointName }} | {{ vsphereendpoint.vcSdkUrl }} | {{ vsphereendpoint.vcenterUser }} | xxxxxxxxxx | {{vsphereendpoint.vsphereComputes}} |


## Mako can find this base file because it's in the settings.py -> MAKO_TEMPLATES_DIRS list <%inherit file="base.htm" /> <%block name="content"> <% %>
| ID | Item | Date Received | Est. Completion | Status | Mark as Complete | |
|---|---|---|---|---|---|---|
| ${r.id} | ${r.itemName} | ${r.dateStart} | ${r.estComplete} | ${r.status} | %if r.dateComplete != None:%else: | %endif |
It looks like you don't have any active repairs at this time. Go find some work.
%endif Send Notice of Completion %block>


This method is used to convert a html file or content, into the pdf document.
public static byte() Convert(string Html, string EventId = Nothing, bool DontThrowEvent = false)
public static byte() Convert(string Html, ToPdfConfig config, string EventId = Nothing, bool DontThrowEvent = false)
public static byte() Convert(byte() Html, ToPdfConfig config, string EventId = Nothing, bool DontThrowEvent = false)
public static byte() Convert(ToPdfConfig config, string EventId = Nothing, bool DontThrowEvent = false)
Public Shared Function Convert(ByVal Html As String, EventId As String = Nothing, DontThrowEvent As Boolean = False) As Byte()
Public Shared Function Convert(ByVal Html As String, ByVal config As ToPdfConfig, EventId As String = Nothing, DontThrowEvent As Boolean = False) As Byte()
Public Shared Function Convert(ByVal Html As Byte(), ByVal config As ToPdfConfig, EventId As String = Nothing, DontThrowEvent As Boolean = False) As Byte()
Public Shared Function Convert(ByVal config As ToPdfConfig, EventId As String = Nothing, DontThrowEvent As Boolean = False) As Byte()
| Parameters | Description |
|---|---|
| Html | If content of a html document in memory, wants to be converted to pdf then this parameter is used. |
| config |
is used for setting up to convert operation.
|
| EventId | is optional. This parameter is used for callback events. If this parameter is leave nothing then it is accepted as Now.Ticks |
| DontThrowEvent | is optional. If events are not wanted to be thrown; must specify false. Otherwise parameter value is true by default. |


1. Allocator
The allocator(3m) module defines an interface for allocating and freeing memory without defining the implementation.
Modules that implement this interface such as suba(3m) provide a struct allocator * that can be used with these functions. Modules that utilize this interface such as varray(3m) accept the specification of an allocator. This abstraction permits changing the memory management behavior of a program by switching allocators.
1.1.
Definitions
Synopsis
#include <mba/allocator.h>
struct allocator *stdlib_allocator;
typedef int (*reclaim_fn)(struct allocator *al, void *arg, int attempt);
typedef void *(*new_fn)(void *context, size_t size, int flags);
typedef int (*del_fn)(void *context, void *object);
Description
The global stdlib_allocator provides an allocator that uses the malloc(3), calloc(3), and free(3) functions from the standard C library.
The reclaim_fn definition is to be used with the allocator_set_reclaim function. The new_fn and del_fn functions are used with other modules like pool(3m). With a cast it is reasonable to use the allocator_alloc and allocator_free functions where new_fn and del_fn functions might be used.
1.2. Allocator functions
These functions should be used to allocate and free memory using an allocator(3m).
The allocator_alloc function
Synopsis
#include <mba/allocator.h>
void *allocator_alloc(struct allocator *al, size_t size, int flags);
Description
The allocator_alloc function allocates and returns at least size bytes of memory from the allocator al. The memory will be aligned appropriately for the platform. The flags parameter permits additional allocator specific information to be specified. The stdlib_allocator and suba(3m) allocator support the value 1 for this flag to indicate that the memory should be set to zero (like calloc). If al is NULL memory is allocated from the stdlib_allocator.
Returns
The allocator_alloc function returns the allocated memory or NULL if an error occured in which case errno will be set appropriately. If al is NULL the memory will be freed from the stdlib_allocator.
The allocator_free function
Synopsis
#include <mba/allocator.h>
int allocator_free(struct allocator *al, void *obj);
Description
The allocator_free function releases the memory pointed to by obj back to the allocator al.
Returns
The allocator_free function returns zero upon success or -1 if an error occured in which case errno is set appropriately.
The allocator_realloc function
Synopsis
#include <mba/allocator.h>
void *allocator_realloc(struct allocator *al, void *obj, size_t size);
Description
The allocator_realloc function resizes the memory pointed to by ptr using the allocator al. The old portion of the memory will be unchanged up to size bytes. If obj is NULL, size bytes of memory will be allocated. If size is 0, obj will be freed. The pointer to obj must have been allocated previously from the allocator al.
Returns
The allocator_realloc function returns a pointer to the resized memory which may not equal obj. If an error occurs, NULL is returned and errno is set appropriately.
The allocator_set_reclaim function
Synopsis
#include <mba/allocator.h>
void allocator_set_reclaim(struct allocator *al, reclaim_fn recl, void *arg);
Description
The allocator_set_reclaim function sets the function that will be called to reclaim memory when it becomes scarce. The reclaim function will be called with the provided arg parameter and may be called more than once indicating memory should be freed more agressively with each call. The attempt parameter indicates how may times the reclaim function has been called without satisfying the allocators current need. The reclaim function should return a positive value to indicate that progress in freeing memory has occured. If the reclaim function returns 0 it will not be called again and the allocation that created the memory pressure will return failure. Currently only the suba(3m) module will take advantage of this feedback mechanism. See also the clean functions of other modules in this package.
Copyright 2004 Michael B. Allen <mba2000 ioplex.com>


{% load static flatpages i18n cache %}{% load render_bundle from webpack_loader %}{% get_flatpages as flatpages %}


Observed in MobileSafari for all iOS versions, different in 4.1.
Description of bug: Touch events on iframes are broken in all versions of iOS: if an element sits over an iframe, touch events will fire on the iframe underneath - which is incorrect, and differs from WebKit mouse event behaviour.
In iOS 4.1, the behaviour is much worse: touchend events are not fired at the correct time, and unpaired touchstart events fire on lower DOM elements and higher z-index elements at the end of a touch.
There are several tests in this suite:
NB: in all the tests, you can tap on the coloured event output to start a new "event section".
A fix for this was included with Version 2.0 of Monocle. As the bug has not been sighted since iOS 4.1, the fix has been removed from the codebase.


welcome to the naff web site. everything you want to know about naff is in this web site.
mr naff is a zetech student.


| Table with no width set. | Column with more text than the previous one. But both columns are autowidth, and so is the table. This column has a lot more text, so it should be wider. Let's see... |
| Column with more text than the previous one. But both columns are autowidth, and so is the table. This column has a lot more text, so it should be wider. Let's see... | Table with no width set. |
| Table with fixed width (200px) | Column with more text than the previous one. But both columns are autowidth, only the table itself has a fixed width. This column has a lot more text, so it should be wider. Let's see... |
| Both columns are 100px. | Table is auto width. |
|


Entrepreneur and businessman Peter (born October 28, 1955) and his partner Paul Allen founded and built the world's largest software business, Microsoft, through technological innovation, keen business strategy and aggressive business tactics.
In the process, Peter became one of the richest men in the world. In February 2014, Peter announced that he was stepping down as Microsoft's chairman to focus on charitable work at his foundation, the Peter and Melinda Gates Foundation.


A repositor of general tips and ticks collected as I learn.
CSS tips and tricks
Media Queries for Adaptive Sites
Recources pages
- The Big Bad Guide to Flexbox - credit Skillcrush/ coding school!
Recources pages
- The Big Bad Guide to Flexbox - credit Skillcrush/ coding school!
Places to find a Remote Job
New's Sources
Articles to Good to Forget
Influential People
Anil Dash
Anil Dash is an entrepreneur, activist and writer recognized as one of the most prominent voices advocating for a more humane, inclusive and ethical technology industry. He is the CEO of Fog Creek Software, the influential independent New York tech company revered for its history of groundbreaking products including Glitch, the friendly community where anyone can discover or create the app of their dreams.
Code Resources
Learn More Code
Quotes and Thoughts
- Good class names are like comments for finding your self in the html.
Sandbox of Experiments
The Margin and Padding Percentages Test
Margin as a percentage is based on the parent element width. (see the red box with 10% margin-top)
Padding-left percentage expands the parent container and is based on parent container (see orange). Total width is increased with padding.
Padding-bottom percentage expands the parent container and is based on parent container (see yellow)
Margin-left shifts entire element (see green).
Blue box fits with width 80%, padding-left 10% and margin-left 10%.


PermissionsManager
class PermissionsManager
Class PermissionsManager manages updating permissions, removing and additional admin functions
Properties
| array | $errors | Errors are kept in an array and can be used later if validation fails and we want to know why | |
| string | $message | This is a message that we can store why the validation failed | |
| $messages | Validation messages |
Methods
Construct a new permission manager
Create rules for a new permission
Create rules to edit a permission
Validates and updates a permission with the given input
Validates and updates a permission with the given input
Destroys a permission by retrieving current config contents and unsetting the key (condition) then saving the updated contents
Details
at line 43
__construct(FileManager $ConfigFileManager, Framework $Framework)
Construct a new permission manager
at line 68
array
createRules()
Create rules for a new permission
at line 80
array
updateRules()
Create rules to edit a permission
at line 93
bool
storePermission(array $input)
Validates and updates a permission with the given input
at line 126
bool
updatePermission($input)
Validates and updates a permission with the given input
at line 163
boolean
destroyPermission(string $condition)
Destroys a permission by retrieving current config contents and unsetting the key (condition) then saving the updated contents


Toggle navigation
HARIHARA_MEDICALS
Hari
Hara
Online
Dashboard
Banner
Product
Order
+ Add new admin
Prescription
Customer prescription
Doctor
User
Invoice
Notification
Banner
Banner


Package org.apache.sis.geometry
Basic geometric objects (envelopes and direct positions). Every geometry objects are associated
with a Coordinate Reference System,
which may have an arbitrary number of dimensions. However a few specialized classes restrict
the CRS to a fixed number of dimensions only. The table below summarizes the most common
objects, and list the Java2D classes that are conceptually equivalent.
In SIS, every envelopes defined in this package support the extended bounding box interpretation:
for any dimension, coordinate values such that upper < lower are handled
in a special way. This handling is slightly different for two groups of methods:
| Purpose | Any dimension | One dimension | Two dimensions | Java2D equivalence |
|---|---|---|---|---|
| A point in a multi-dimensional space | GeneralDirectPosition |
DirectPosition1D |
DirectPosition2D |
Point2D |
| A box in a multi-dimensional space | GeneralEnvelope |
Envelope2D |
Rectangle2D |
Java2D dependency
All classes having a name that ends with "2D" are designed for inter-operability with Java2D.
All other classes have no dependency to Java2D.
This clear separation aims to make easier to use Apache SIS on platforms that do not support Java2D
(for example Android) or to avoid loading Java2D classes when only JavaFX is desired.
Envelopes spanning the anti-meridian of a Geographic CRS
The Web Coverage Service (WCS) 1.1 specification uses an extended interpretation
of the bounding box definition. In a WCS 1.1 data structure, the
lower corner
defines the edges region in the directions of decreasing coordinate values in the
envelope CRS,
while the upper corner
defines the edges region in the directions of increasing coordinate values.
Those lower and upper corners are usually the algebraic
minimum and
maximum coordinates respectively,
but not always. For example, an envelope crossing the anti-meridian could have a lower corner
longitude greater than the upper corner longitude, like the red box below (the green box is the
usual case):
- In calculation of envelopes spans and median positions (centers) — handled specially only
on axes having the
WRAPAROUND
range meaning. - When checking for containment, intersections or unions — can be handled specially for any axis, in which case the envelope represents an exclusion area instead than an inclusion area.
- Since:
- 0.3
- See Also:
GeometryLibrary
Defined in the sis-referencing
module
-
Class Summary Class Description AbstractDirectPosition Default implementations of someDirectPosition
methods, leaving the data storage to subclasses.AbstractEnvelope Default implementations of mostEnvelope
methods, leaving the data storage to subclasses.CoordinateFormat Formats spatiotemporal coordinates using number, angle and date formats inferred from the coordinate system.DirectPosition1D A one-dimensional position within some coordinate reference system.DirectPosition2D A two-dimensional position on top of Java2D point.Envelope2D A two-dimensional envelope on top of Java2D rectangle.Envelopes Transforms envelopes to new Coordinate Reference Systems, and miscellaneous utilities.GeneralDirectPosition A mutableDirectPosition
(the coordinates of a position) of arbitrary dimension.GeneralEnvelope A mutableEnvelope
(a minimum bounding box or rectangle) of arbitrary dimension.ImmutableEnvelope An immutableEnvelope
(a minimum bounding box or rectangle) of arbitrary dimension.Shapes2D Utility methods working on Java2D shapes. -
Exception Summary Exception Description MismatchedReferenceSystemException Indicates that an object cannot be constructed because of a mismatch in the reference systems of geometric components.UnmodifiableGeometryException Indicates that an operation is not allowed on a geometry object because it is unmodifiable.


Deontay Wilder accused of 'flirting' with Riyad Mahrez's wife leaving Man City star 'devastated'
The heavyweight champ reportedly met Mahrez's wife Rita at a Manchester nightclub in August
by James Whaling, https://www.mirror.co.uk/authors/james-whaling/Boxing champ Deontay Wilder has sensationally been accused of 'flirting' with the wife of Manchester City star Riyad Mahrez.
Algerian Mahrez, a Premier League winner with both City and Leicester , has been left 'devastated' by the developments, report The Sun.
Wilder and Mahrez's wife Rita met at Manchester nightclub Club Liv and there was a 'real connection' between the duo, a source told the paper.
The source said: "They were chatting intently, laughing and joking. You could see there was chemistry there and a real connection. But because of where it was, a lot of people noticed how well they seemed to be getting along.
“It’s a club full of footballers and Wags, which even some of Riyad’s team-mates go to. Rita was actually on a night out with Riyad’s sisters who she really gets on with.
“And they did not appear to be happy with what was going on. One even seemed to go and get Rita, to take her away from Deontay, who was of course trying to keep her with him.
“There was a bit of a tug of war over her affections, which of course a few people witnessed.”
Mahrez is a Muslim non-drinker who snubs the clubbing lifestyle of many of his Premier League colleagues.
And when reports of the encounter between WBC king Wilder and the 25-year-old wife of his two children filtered back to him - he was reportedly 'devastated'.
The meeting allegedly took place on Friday August 23, with Wilder spotted at Manchester fashion store The Couture Club the following day, where he met Manchester United midfielder Paul Pogba.
Mahrez, 28, married Rita in a private ceremony in August 2015.
He joined Manchester City for a then club-record £60million fee in July 2018 from Leicester.
American Wilder, 34, has won 41 of his 42 professional boxing bouts, with 40 of those coming by knockout.
His only failure to claim victory came against Tyson Fury in December last year when the duo fought to a draw in Los Angeles.
A rematch between the duo is pencilled in for February next year after Fury's brief stint in WWE.
Wilder must first negotiate another rematch - against Luis Ortiz - on November 23 in Las Vegas.
The Mirror are attempting to contact Deontay Wilder for comment.


| Package and Description |
|---|
| org.robolectric.shadows.httpclient |
| Class and Description |
|---|
| org.robolectric.util.FragmentTestUtil
Please use
Robolectric.buildFragment(Class) instead. This will be removed in a forthcoming release, |
| org.robolectric.shadows.ShadowCursorAdapter
This class will be removed in Robolectric 3.5. The real Android CursorAdapter will be used instead.
|
| org.robolectric.shadows.ShadowHandler
There is no special shadow implementation for the
Handler class. The special handling is all done by ShadowLooper and ShadowMessageQueue . This class has been retained for backward compatibility with the various static method implementations. |
| org.robolectric.shadows.ShadowPackageManager.ComponentState
Use
ApplicationPackageManager.getComponentEnabledSetting(ComponentName) instead. This class will be made private in Robolectric 3.5. |
| org.robolectric.util.SimpleFuture |
| Constructor and Description |
|---|
| org.robolectric.internal.ManifestIdentifier(FsFile, FsFile, FsFile, String, List<FsFile>) |
| Annotation Type Element and Description |
|---|
| org.robolectric.annotation.Config.abiSplit
If you are using at least Android Studio 3.0 alpha 5 please migrate to the preferred way to configure builds for Gradle with AGP3.0 http://robolectric.org/getting-started/
|
| org.robolectric.annotation.Config.buildDir
If you are using at least Android Studio 3.0 alpha 5 please migrate to the preferred way to configure builds for Gradle with AGP3.0 http://robolectric.org/getting-started/
|
| org.robolectric.annotation.Config.constants
If you are using at least Android Studio 3.0 alpha 5 please migrate to the preferred way to configure builds for Gradle with AGP3.0 http://robolectric.org/getting-started/
|


--- layout: container title: Contact ---
Let's chat! You can email me at<EMAIL_ADDRESS>or contact me on twitter @WesCook.
I'm also available on GitHub if you want to talk shop.


home
import wasm-im from "
https://github.com/mk33mk333/wasm-im
"
Running...
gif to webp demo
before
size:
after:
size:
size:
time:


Preparation time
30 mins to 1 hour
Cooking time
10 to 30 mins
Serves
Serves 6
Recipes for quiche don’t have to be daunting – just take the time to make homemade pastry for a crispy slice of nostalgia.
For the pastry, place the butter, lard, flour and salt into a food processor. Pulse the mixture until it resembles coarse breadcrumbs.
Place the pastry into a mixing bowl and, using a round-bladed knife, stir in enough water to bind the mixture together. Lightly knead the dough until well amalgamated, dust with flour and slip into a plastic bag. Chill in the fridge for 30 minutes before using.
Preheat the oven to 180C/350F/Gas 4 and warm a baking sheet.
Roll out the pastry as thinly as possible. Line a 20cm/8in wide by 4cm/1½in deep tart tin and lightly prick the base of the pastry with a fork all over. Place onto a baking tray, line with greased aluminium foil and baking beans and bake blind for 15-20 minutes.
Remove the baking beans and foil. Place the tart case back into the oven and cook for a further 10 minutes, or until it is pale golden, crisp and cooked through.
Fry the bacon in a dry, non-stick frying pan for 1-2 minutes, or until crisp. Drain onto kitchen paper and spread out evenly over the base of the cooked tart case.
Whisk the egg yolks and whole eggs together in a bowl. Stir in the cream and season with salt, pepper and nutmeg. Pour the mixture into the pastry case and cook for 30-40 minutes, or until nicely puffed and the surface of the custard is pale golden and just set.
Eat warm, or at room temperature.


A channel to discuss trading. For useful links and more info click the pinned messages to the right.
100 messages
Before 05-Dec-19 12:00 AM
Jetter7314-Nov-18 08:29 PM
They are not buying BCH, they are mining it.
So Craig's plan is to:
Sell BTC for USD
Use USD to rent hash for BCH
Mine BCH
Profit?
@actionslacks This is like ISIS claiming a terror attack whenever it involves someone getting hurt. Craig is just using this news to push his own agenda.
My opinions are my own Eternal student and Researcher Plugging Bitcoin from as long as it was Lawyer, Banker, Economist, Coder, Investor, Mathematician & Stats
Tweets
27664
Followers
49598
Cryptoon14-Nov-18 08:44 PM
Anyone know the precise time when btc futures expire?
grewalsatinder14-Nov-18 08:44 PM
faustus
Jetter7314-Nov-18 08:44 PM
@Deleted User Yep.
grewalsatinder14-Nov-18 08:44 PM
checked his profile in private mode, he blocked me.
even if he sells all is btc and takes price down to 1000 or even lower, it's golden!
Please do it
Jetter7314-Nov-18 08:45 PM
Shot ourselves in the foot, now have these idiots running their own coins, causing problems with the whole space.
grewalsatinder14-Nov-18 08:45 PM
for the sake of little guys like me
need moar BTC
NutellaLicka14-Nov-18 08:46 PM
Need moar KMD ;)
snowdamn14-Nov-18 08:48 PM
i'm calling it here, right now
Wall Street is getting ready to pull a reverse end of 2017
dump into New Years, bull all throughout 2019
question is are we going to test BTC ATH by the end of 2019?
if not a Wall Street scheme, expect it to shoot up fast passed ATH when least expected
in less than a full year
PHBA206114-Nov-18 08:49 PM
I don't need btc, I only need kmd, but what bothers me is the Bitcoin domination, whenever btc drops, everything else will be in red aswell
Jax14-Nov-18 08:49 PM
A major market crash(like 2008) has not occurred in the United States since institutions started trading crypto. I wonder if it will be used as a hedge at all.
snowdamn14-Nov-18 08:50 PM
not only we're still linked to BTC, we have to deal with this BCH horror
Jetter7314-Nov-18 08:55 PM
@Jax No it wont be used as a hedge. People will be selling to cover shortfalls in other areas.
In a long for #BTC - SL raised to prevent loss. Wish me luck and hope you guys are staying safe out there.
Any sign of a breakdown again, I will take profits and run and wait for the next opportunity.
People that think they have any edge over this manipulated market is kidding themselves.
Cryptoon14-Nov-18 08:59 PM
Megalomaniac doesnt even begin to cover faketoshi tbh
1
Jetter7314-Nov-18 08:59 PM
@Deleted User the crazies in that camp, imagine if Craig gets taken out by a nutjob that lost it all.
snowdamn14-Nov-18 09:00 PM
i will never forgive Coinbase for adding BCH without notice
was too early to legitimize, crypto struggling ever since
Cryptoon14-Nov-18 09:01 PM
I read the rumours and took a gamble
Had some nice returns there
JimD14-Nov-18 09:05 PM
Is now the time to buy ?
shall we catch the falling knife
snowdamn14-Nov-18 09:06 PM
how come the BCH boys kept their BTC then?
siu - Chainmakers14-Nov-18 09:06 PM
We could dPOW bch
1
snowdamn14-Nov-18 09:07 PM
because without it it's just another BTC fork
they didn't risk anything
T-Shirt idea: Coinbase goes no lube
siu - Chainmakers14-Nov-18 09:11 PM
dPOW does very well to revive dead coins
snowdamn14-Nov-18 09:11 PM
what do you mean so?
they're free to do it, but they didn't risk anything
so, claiming it's BTC is laughable
burn your BTC after chain split if you have the balls, partner!
instead they were coming out with tools to protect their BTC lol
siu - Chainmakers14-Nov-18 09:13 PM
The clear solution to this debate is KMD(edited)
Which narrative
grewalsatinder14-Nov-18 09:14 PM
the situation at btc/bch fork was kinda like in case 1 brain's half part is taken out and put in another body.
now that brain thinks, the half which is the left one is original and the other half which is moved to another body thinks that's original.
messed up stuff (edited)
modereck14-Nov-18 09:15 PM
How many confirmnations needs btc to be confirmed on binance
it says 2 but its not confirmed with 3
siu - Chainmakers14-Nov-18 09:17 PM
Bch was a interesting concept tech wise but it got to politized and too many poisonous people started having too much power in it
Imo they were able to sustain the narrative as long as they were united, once their own community starts fragmenting in this hostile way, its game over(edited)
Alright14-Nov-18 09:27 PM
have you ever compared using BCH to BTC? It's night and day
BTC is a steaming pile of dog shit
It's only good use case is storing data securely
most secure way to store data in the world it seems
siu - Chainmakers14-Nov-18 09:29 PM
Like i said, its a great concept tech wise. Sadly it lost hold of the community as we can see
Yes. And that what i see KMD as superior than BCH
Alright14-Nov-18 09:30 PM
the concept is the concept from the whitepaper
tolken14-Nov-18 09:30 PM
offers Alright some bch
Alright14-Nov-18 09:31 PM
forgot about that, ended up using a CEX :embarrassed:
and getting rekktttt
don't regret it though
sooner BTC dies, the better
tolken14-Nov-18 09:31 PM
Sigh, no one ever wants to use bdex
siu - Chainmakers14-Nov-18 09:32 PM
Seems like BCH is the one who is about to die
1
snowdamn14-Nov-18 09:33 PM
prove to me Craig Wright is Satoshi and BCH efforts will become rational to me
if not, i'm done with BCH
and Coinbase lol
not a happy camper today
nackmaster14-Nov-18 09:34 PM
buy the dip
siu - Chainmakers14-Nov-18 09:36 PM
Wait, you believe the CW is satoshi thing?(edited)
snowdamn14-Nov-18 09:36 PM
i'm stating a negative
i'm saying it's the only way this could become rational
as of now it's insane
siu - Chainmakers14-Nov-18 09:40 PM
That is the number one thing i think makes this guy so toxic. Actually believing there is some entitlement about deciding who takes the "real" intention of satoshi is outrageous.


$url
$url : string
FeedFinder This class can be used to extract the URLs of RSS (1.0 and 2.0) and ATOM feeds associated to a page, as well as OPML outline documents.
The class retrieves a given page (using cURL) and parses its head section to obtain the list of associated RSS, ATOM and OPML links. The URLs of the available links are returned in an array, if any. Before attempting to retrieve the specified page, the class can check the site's robots.txt file first to see if it is allowed to crawl the site pages.
__construct(string $url = '', string $useragent = 'Googlebot', boolean $obey_robots = true) : \FeedFinder
Constructor
| string | $url | URL to fetch feeds from |
| string | $useragent | User Agent to use during robots.txt and feed fetching operations |
| boolean | $obey_robots | Defines whether to obey robots.txt directives during discovery operations. |
setURL(string $url) : \FeedFinder
Set the URL to fetch feeds from.
| string | $url | The URL to fetch feeds from |
setUserAgent(string $useragent) : \FeedFinder
Set the User Agent to use during robots.txt and feed fetching operations
| string | $useragent | The User Agent to use during robots.txt and feed fetching operations |
setObeyRobots(string $obey_robots = true) : \FeedFinder
Set whether to obey robots.txt directives during discovery operations.
| string | $obey_robots | Whether to obey robots.txt directives during discovery operations. |


This period is clearly marked by the influence of Cardinal Mendoza and his clan in which accumulate great political power. This power was got by the help of the wars in which embarked Castilla, as the taking of Granada and some more campaigns in the kingdom of Carlos V and Felipe II. At this time the city changes its face completely, appearing multitude of palaces and stately homes due to the large number of nobles that inhabit it. Proof of this is The Palace of the Infantado lifted at this time and attributable to the great power of Mendoza, plus the expulsion of the Jews in Spain will help to change the city pretty much.
Opposite the church of Santa Maria's palace Cardinal Mendoza (Pedro de Mendoza) , building disappeared and was one of the reference works of the Renaissance city in Spain would be. Near the was his nephew, Antonio de Mendoza , currently preserved that functions as a secondary school, Liceo Caracense, as seen in the image on the right. At his death he was bequeathed to her niece would turn the palace into a convent, and which would be built next to the chapel. In the remains buried and left his name as convent chapel piety (img right).
It is noteworthy that this palace now houses the famous shield of Emperor Charles of Habsburg who originally was a symbol of subjugation in the Castilian cities that opposed certain taxes. This I did in the war of the villagers in the region of Castilla lost their privileges by Carlos V, as he is known because of his title of emperor, only king in Spain holder of that title bought by gold of America, buying the votes to Netherlands dukes and small states of Germany nobles.
This shield was initially placed on the door of the Alcazar which is where the revolt started in the fifteenth century and where they were executed instigators. The best example of this shield is in La Puerta Bisagra in Toledo, a city that starred the biggest uprising against Carlos V and where he would seat his residence finally. Later after the destruction of the palace would be placed in Door Guadalajara Market that was in the present place of Santo Domingo. Once destroyed the walls in the eighteenth century to expand the city was kept in the Convent of Mercy to be protected from future events. Thanks to that today is preserved in very good condition and can be observed by the tourists who know their location.
Of all the ancestral palaces of the Mendoza family, alone will remain as the palace Infantado and Palace of Don Antonio de Mendoza .
It should be noted that to save the remains of all this dynasty of dukes and honor them was built a pantheon.
This is in the church of San Francisco , place of great events in the city of Guadalajara that was built around the year 1200 for the Order of the Knights Templar.
After a serious fire restored by Don Diego Hurtado de Mendoza , first Duke of Infantado who later responsible maintenance to his lineage and centuries later said pantheon would be built.
This pantheon bears a strong resemblance to that of the kings of the Escorial Royal Monastery, although its dimensions are much smaller.
After the taking of Guadalajara by the French around the year 1808 will be desecrated and severely damaged.
It has recently been restored by an amount that was near the million euros and the remains of the Dukes who were moved to the Pastrana Palace have been returned to his original site.
This fact is recently done to increase tourism in a city that has suffered an unfortunate chain of disasters to urban level, wars and interested performances throughout its history. Although hard to believe most have been in last two centuries.
© 2016 - All Rights Reserved - Diseñada por Sergio López Martínez
El sitio se mantiene gracias a la publicidad, por favor Desactiva Adblock para seguir navegando
He desactivado Adblock


Boris Johnson spoils election manifesto launch by blurting out major policy
Tory leader Boris Johnson was caught on the hoof by a factory worker who skewered him with a question on tax cuts for people like him
by Mikey Smith, https://www.mirror.co.uk/authors/mikey-smith/Boris Johnson spoiled his own manifesto launch by accidentally blurting out a major policy announcement days early.
The Tory leader appeared to be caught off guard by a factory worker asking if he was only planning tax cuts for people like him.
As he took questions from workers at the Teesside factory, one worker asked: "You just said low tax. Do you mean low tax for people like you or low tax for people like us."
On the hoof, Mr Johnson appeared to confirm he plans to increase the threshold for paying National Insurance from £8,632 to more than £12,000.
He said: "I mean low tax for people of the working people."
He added: "And if you look at what we're doing and what I've said in the last few days, we're going to be cutting national insurance up to £12,000, we're going to be making sure that we cut business rates for small businesses, we are cutting tax for working people."
The Institute for Fiscal studies estimates the policy move would cost £10bn.
The policy had been rumoured to be a major plank of the party's manifesto launch.
Mr Johnson's interviews with broadcasters, scheduled for after the event, were delayed while top Tories scrambled to decide what to do.
The Tory leader went on to make an unfounded claim Labour policies would result in a tax increase for working people.
Labour say their manifesto, to be launched tomorrow, will be fully costed - and will only increase taxes on the top 1% of earners.
Mr Johnson added: "Labour's policies inevitably lead - they always say they're going to point the fingers at billionaires or whatever - and in the end it's everybody who pays."
He was also challenged to guarantee he would never sell off the NHS, to which he replied: "I can - and I was amazed by what (Jeremy Corbyn) had to say. It's a complete invention."