Snookes1516.github.io
First Writing Service! We Do All Types of High-Quality. Buy essay online at professional essay writing service. Order custom research academic papers from the best trusted company. Just find a great help for students Freelance Editing and Proofreading Services. Find and hire a freelance copy editor and proofreader to make sure your copy doesn't include grammar, spelling.
Writers in the Sky Creative Writing Services. Do you love creative writing? Do you yearn to be a writer and create quality fiction? If yes, you have come to the right place. Here at the Creative Competitor PapersHelm Best Custom Academic Essay Writing Services. Writing, self-publishing, book marketing, making a living with your writing. Writers in the Sky Creative Writing Services We will match your project with an expert who can assist you with writing, editing and proofreading for books. Creative Writing 101 - Writers' Treasure.
Professional Essay writing help from Speedy Paper is 24/7 here for you. Get a free quote Creative Writing Editing Services - detectemplois.com. PapersHelm provides excellent academic services at affordable rates. Our custom writing services ensure you get premium academic writings on whichever subject.
Looking for the best way to get top best essay writing services USA ! Try our professional custom essay writing services, Best Dissertation Writing Services. Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide. Creative Writing vs. Technical Writing - Writers' Treasure. 20 Creative Writing Careers Writing Forward.
Resumesplanet.com - Professional Resume Writing Services. Creative Writing Editing Services.
Writing paragraphs that sing, editing your words and thoughts so they speak for themselves. This summer I am retiring from Academic editing. I will continue to edit Creative Writing (Fiction and Literary Non-Fiction only). I want to thank all of my clients. Affordable-Papers: Your Personal Essay Writer Exceeds. Writing And Editing: Five Problems to Avoid in Your First.
Online custom essays, term papers, research papers, reports, reviews and homework assignments. Professional custom writing service offers high quality and absolutely. What is the difference between creative writing and technical writing? Today, after learning what creative writing is and how to get started in it, we’re going. Proofreading - Essay writing service. I offer private editing services for selected manuscripts. Creative work one-on-one with writers who are committed to their writing services — editorial, short. Creative writing editing services. Creative writing is any form of writing which is written with the creativity of mind: fiction writing, poetry writing, creative nonfiction writing
Resumesplanet.com - first-rate professional custom resume writing service, providing helpful career tips and more to help get your career on track. Creative writing editing services to write about help with personal statement cv. Long, by taking their differences aand services writing creative editing aare given. Writing Editing Services. I offer private editing services for selected manuscripts. I work one-on-one with writers who are committed to their writing projects. ServiceScape Find Your Freelancer. Swift Creative Writing and Editing. Rated and reviewed editors, translators, graphic designers, and writers. Precise, fast, affordable, open 24/7, and 100% guaranteed. World's largest website for Creative Writing Jobs. Find $$$ Creative Writing Jobs or hire a Creative Writer to bid on your Creative Writing Job at Freelancer. Welcome to the First Writing Service. Essay writing, Homework help, Editing services.
6. Creative Writing Now – Endless Story Ideas. Creative Writing Now offers Endless Story Ideas, a free online writing course. The entire Essay Writing help online at your service SpeedyPaper.com. 25 Creative Writing Prompts Writing Forward. Proofreading and editing services. Editing (redactus - Lat. ) of any essay is a set of actions that prepare the essay for publication or defense. Studybay is an academic writing service for students: essays, term papers, dissertations and much more! We're trusted and chosen by many students all over the world.
Amazon.com: Writing Clearly: Grammar for Editing, 3rd Edition<PHONE_NUMBER>977): Janet Lane, Ellen Lange: Books. What do you do best: selling, marketing, coordinating, overseeing your business? In that case, let me handle your editing and proofing. Ever feel stumped? Uninspired? Blank? These creative writing prompts will kick your muse into high gear so you can start writing again. Be creative. Alpha Creative Writing Services provides you the best in class, plagiarism free and value for money Creative Writing at your convenient time from experts. Our Creative Writing program, one of the first of its kind in Canada, immerses you in every aspect of the writing life, from the development of ideas Editing and Custom Writing Service - Studybay.com. Creative Writing (BA) - Concordia University.
Writing Clearly: Grammar for Editing, 3rd Edition - amazon.com. Writing Editing Services. I offer private editing services for selected manuscripts. I work one-on-one with writers who are committed to writing writing projects. Creative Writing Jobs for November 2018 Freelancer.
Revision Free: Creative writing editing services. EssayWritersWorld.com - Best Essay Writing Service. Creative Editing Services, Mobile, Alabama. 386 likes. Creative Editing Services offers editing and ghostwriting services to authors and aspiring authors. Have you ever bothered to look at the creative writing careers that are available? Browse these job possibilities, and then go out there and make it happen. See For Yourself.With 295 park-like acres, proximity to downtown Indianapolis, and two new state-of-the-art housing facilities, our campus has it all.The 16 Best Online Creative Writing Courses - Bookfox. Creative Writing Services - Alpha Custom Writers. Creative Editing Services - Home Facebook. Freelance Editing Proofreading Services for Hire Online. Creative Writing Editing Services – Free Editing Services. Creative Writing Editing Services - Book Nanny: passionate.


A glimpse over capacity control in neural networks
By this point in time, there’s no need to emphasize how important deep learning has become. Yet, despite paving the way for some of the boldest and most complicated projects of this decade, much of deep learning’s theoretical guarantees remain unexplained.
According to classical statistical learning theory, the structure displayed by deep networks entails poor predictions over unseen instances. However, this is not often the case and, this mismatch between theory and practice is what gives deep learning a sort of magical appearance. Meanwhile, this aura is besieged by researchers that will try to tap into what really allows these models to perform so well.
To discuss this issue more closely, we need to formulate its setting. In classification problems, we typically have:
- A candidate model (or hypothesis) $h$ that maps the domain $x$ to the output $y$;
- A set of $n$ coupled observations $\mathcal{S_n} = \{ (x_1;y_1), …, (x_n; y_n) \}$, sampled from an unknown probability distribution $\mathcal{D}$;
- A target function $f$ that determines the output $y \in \{-1;1\}$ depending on the input $x$;
- A loss function $\ell$ that measures the prediction error of $h$ with respect to $f$.
In this setting, we would like to find a model that most closely approximates the target function $f$. According to our sampling distribution, this entails minimizing our expected risk: the the expected value of the error with respect to our $\mathcal{D}$:
$$R(h) := \mathbb{E}_{\mathcal{D}}[\ell(h, f)] \equiv \int_{\mathcal{X}} \ell(h(x), f(x))\,p(x)dx$$
We generate these candidates through a learning algorithm $\mathcal{A}$, that given a set of observations outputs a hypothesis. Knowing that we cannot access the sampling probability, our compass in this search is our training set. In other words, our proxy for the expected risk is the empirical risk: $$R_n(h) := \sum_{i=1}^n \ell(h(x_i), y_i).$$
Using the principle of Empirical Risk Minimization (ERM), we are assuming that the solution that minimizes the empirical risk also minimizes the expected risk. We say that a learning algorithm generalizes if the empirical risk approaches the expected risk as data grows to infinity. In other words, the generalization error, $\Delta R = R(h)-R_n(h)$ goes to zero. On the other hand, when this difference remains significantly large, we say the model overfits.
But consider the following, if we could access every conceivable hypothesis, what guarantee could ERM provide of finding a candidate that does not overfit? Think of the hypothesis that memorizes all training points and output their correct classification. Under ERM, we’d be finding a good candidate, since it perfectly fits our training data. However, when predicting an unseen observation, this model would be no better them random guessing, thus generalizing poorly.
To circumvent this, we limit our search space to a certain class of hypotheses, by only considering models with a certain structure (e.g. linear predictors). Here we essentially apply a set of assumptions of our model based on some prior knowledge of the problem, what we call inductive bias.
Under these circumstances, ERM is guaranteed to generalize as the number of data points grows to infinity. But more importantly, if our training data is sampled iid, we can devise bounds that indicate, with a small probability of error $\delta$, how close we are from the true risk.
$$\underset{S\sim\mathcal{D}^N}{\mathbb{P}}\left(R(h) - R_n(h) \le O\left (\frac{C(\mathcal{H})}{\sqrt{n}} \right)\right) > 1- \delta$$
These bounds are naturally governed by the number of data points, but also by the complexity $C$ of our hypothesis class. When considering finite sets of hypotheses, the complexity measure can simply be represented by the cardinality of the set. However, under infinte hypothesis classes, more elaborated techniques are needed.
Many competing complexity measures, and consequently generalization bounds, have been developed over the last 30 years: VC-dimension, Rademacher complexity, covering numbers, and so on. If we think about the effect of complexity on the generalization gap, the more complex a class is, the bigger the generalization gap can be. Even with a large amount of data, if the complexity measure of the model is too high, we have fewer guarantees of avoiding overfitting.
For the sake of illustration, let’s take the number of parameters of a neural network as a measure of its complexity. The MNIST dataset consists of images of handwritten digits in a 28x28 grid and contains more than 55 thousand data points. A fairly simple model, as an off-the-shelf LeNet contains more than 470 thousand parameters only in its first layer, let alone in the rest of the network. Due to its complexity, for this model to generalize with an acceptable error and probability, we would need trillions and trillions of data points. If we took this model and train it over MNIST, our natural inclination would be to think that a great performance in a training set would be the result of an interpolation of the data points, due to the large overparametrization of the model when compared to the dataset.
Still, we have tons of evidence that support generalization of under these settings. So… what gives?
Structured Risk Minimization and Regularization
By observing the bounds generated over the complexity of neural networks, we may think that without tremendous amounts of data, we cannot achieve generalization. However, imagine we had a class of hypothesis with a hierarchical structure, i.e. $\mathcal{H} \supseteq \mathcal{H}_1 … \supseteq \mathcal{H}_n$. In this class, each subset $\mathcal{H_i}$ has a smaller complexity than its supersets $C(\mathcal{H}) \ge C(\mathcal{H}_1) … \ge C(\mathcal{H}_n)$. If we could exploit the hierarchical structure, we can devise a way to learn a function while also minimizing its complexity, thus generating reasonable bounds. Akin to the ERM, this principle is called Structured Risk Minimization (SRM). However, if we even encounter such hierarchical classes, how to make these a controllable variable?
Regularization is a way to supplement the inductive bias present in our set of hypotheses by restraining the candidates to a particular condition. One typical example is known as weight-decay, or L2-Regularization, where we introduce a norm restriction on our model’s parameters $W$, generating the following optimization problem in the Ivanov form.
$$\textrm{minimize} \underset{\textrm{s.t. } \left\Vert W\right\Vert_2^2 \le r}{R_n(h)}$$
Typically, for means of analysis, we resort to the Tikhonov form despite them not being entirely interchangeable as we switch from a hard to a soft penalization term.
$$\textrm{minimize } R_n(h) + \lambda\left\Vert W\right\Vert_2^2$$
Regularization can come in different shapes and sizes. Besides, sometimes, regularization may come implicitly. This roughly refers to the learner’s preference to implicitly choosing certain structured solutions as if some explicit regularization term appeared in its objective function. For instance, it is known that introducing noise to the observations may induce the same effect as weight decay (Bishop (1994)). Another equivalent example is early stopping, i.e. stopping training once the validation loss starts to increase (Goodfellow (2016)).
However, despite all these techniques, even “bare-boned” deep networks seem to achieve fairly good generalization. Our intuition tells us that there must be an implicit control factor on the hypothesis space when training neural nets.
Complexity control via gradient descent
There are many competing intuitions on how deep neural nets are implicitly regularized. Generally, most of them point to the same factor: the training procedure, or more specifically, the gradient-based training. I don’t intend to make this a comprehensive review, so instead, I’ll provide an analysis on one of these, which is the work of Poggio et al. 2020 called Complexity Control by gradient descent in deep networks.
Gradient descent (GD) and its variations are widely used when training neural networks. In short, this technique update all parameters in the direction of the largest decrease on the loss function at each iteration, hence the name.
$$W_{t+1} = -\gamma(t)\nabla_{W_t} R_n$$
In the analysis of Poggio (2020), we use deep networks with ReLU (Rectified Linear Unit) activation functions: $\sigma(z) = \max(0, z)$. Also, instead of adding biases to each layer, we’ll only add them in the input layer as just another feature. Finally, we’ll be studying classification tasks using the exponential loss function that takes values $\{-1;1\}$:
$$\ell(x, y) := e^{-yf(x)}$$
We use this loss function to simplify our analysis of the gradient dynamics. Nevertheless, these results may be also extended to other exponential loss functions, such as the cross-entropy, most typically employed in classification tasks.
One of the advantages of this setting is to make use of the homogeneity property granted by ReLUs, that is $\sigma(z) = \frac{\partial\sigma}{\partial z}z$. This property enables us to detach the effects of scale and direction of the parameters. With that in mind, state our problem as follows: let $f(W,x)$ be a neural network composed by N layers $W_k$ In a given iteration, we can represent this network by the normalized version of the weights at layer $k$, that is: $$W_k = \rho_k V_k,$$ where $\rho_k$ is the norm of the weights at layer $k$ and $\left\Vert V_k \right\Vert$ is the unitary version of $W_k$. Using the homogeneity property, we can rewrite $f$ as being: $$f = \tilde{f}(V,x)\prod_{i=1}^N\rho_i,$$ where $\tilde{f}$ is the normalized version of the network.
Our goal here is to study how the gradient behaves throughout iterations, and we’ll do so through the lens of a dynamical system in the continuous space. That is, instead of study discrete evolutions, we’ll focus on the rate $\dot{W}$.
$$\dot{W} = \frac{dW}{dt} = -\gamma(t)\nabla_W(R_n(f)).$$
For the rest of the work, we neglect the effect of the learning rate $\gamma(t)$, thus obtaining the following rate for each layer:
$$\begin{aligned} \dot{W}_k &= -\frac{\partial R_n}{\partial W_k} \\ &= \sum_{i=1}^{N}\left [\frac{\partial f(x_i)}{\partial W_k}\right]y_ie^{-y_if(x_i)} \\ \end{aligned}$$
Next, we’ll break down the dynamics of $\dot{W}$ in its scalar $\dot{\rho}$ and normalized component $\dot{V}$.
$$\dot{\rho}_k = \frac{\partial \left\Vert W_k\right\Vert_2}{\partial t} = \frac{\partial \left\Vert W_k\right\Vert_2}{\partial W_k}\frac{\partial W_k}{\partial t}= V_k^\top\dot{W}_k.$$ and $$\dot{V}_k = \frac{\partial V_k}{dt} = \frac{\partial V_k}{\partial W_k}\frac{\partial W_k}{\partial t} = -\frac{S}{\rho_k} \dot{W}_k,$$
where
$$S_k = I - V_kV_k^\top.$$
In the following sections, we impose and relax some constraints and observe the effect on $\dot{V}$ and $\dot{\rho}$ under three different scenarios.
Case 1: constraining $\rho$ and $V$
In the first scenario, we consider $\rho$ to remain fixed throughout iterations and consistent with the definition, we’ll impose a restriction on $V_k$, such that $\left\Vert V_k \right\Vert_2^2 = 1$. There are several ways to impose this restriction, but for consistency, we’ll use Lagrangian multipliers. Our objective function then becomes:
$$\mathcal{L} = R_n(\rho \tilde{f}) + \sum_k\lambda_j \left(\left\Vert V_j \right\Vert_2^2-1\right).$$
Since $R_n = \sum_i e^{-y_i \rho\tilde{f}(x_i)}$ and $\dot{W}_k = \frac{\partial \mathcal{L}}{\partial W_k}$, we get:
$$ \dot{W}_k = \sum_i e^{-y_i \rho\tilde{f}(x_i)}y_i\rho\frac{\partial \tilde{f}}{\partial W_k} + 2\lambda_k\frac{\partial \left\Vert V_k \right\Vert_2^2}{\partial W_k} $$
Since by design, $\frac{\partial \mathcal{L}}{\partial \rho} = 0$, we focus on $\dot{V}$:
$$ \begin{align} \dot{V}_k &= \sum_i e^{-y_i \rho\tilde{f}(x_i)}y_i\rho\frac{\partial \tilde{f}}{\partial V_k} - 2 \lambda_kV_k &\left(\cdot\, V^\top_k\right)\\ \cancelto{0}{\dot{V}_kV_k^\top} &= \sum_i e^{-y_i \rho\tilde{f}(x_i)}y_i\rho\overbrace{\frac{\partial \tilde{f}}{\partial V_k}V^\top_k}^{\tilde{f}(x_i)} - 2 \lambda_k\cancelto{1}{V_kV^\top_k} &\\ \end{align} $$
Proof: $V_kV^\top_k = 1$ since $\left\Vert V_k \right\Vert_2^2 = 1$ and $\dot{V}_kV_k = 0$ due to $\frac{\partial \left\Vert V_k \right\Vert_2^2}{\partial t} = 0$.
As so happens with overparametrized models, we expect to reach total class separability, where $sgn(f(x_i)) = sgn(y_i) ,\forall (x_i, y_i) \in \mathcal{D}$. And this is the moment we want to study. For a large enough $\rho$, since we have perfect separation in the training set, the greatest values will yield the smallest loss contributions (due to the negative exponential), thus, they will vanish first. Hence, it is reasonable to assume that we reach a point where all but a few data points $x_*$ will vanish, converging to a stationary point in $V_k$ where:
$$\frac{\partial\tilde{f}(x_{*})}{\partial V_k} = \tilde{f}(x_{*})V_k$$
What is the meaning of this stationary point? We will discuss this after the second and third case.
Case 2: constraining $V_k$
In this case, everything remains the same, except that we let $\rho$ vary. Consequently, we have the following rate $\dot{\rho}=\frac{\partial \mathcal{L}}{\partial \rho_k}$: $$ \begin{align} \dot{\rho}_k &= \sum_{i=1}^{N}\left [V_k^\top\frac{\partial f(W, x_i)}{\partial W_k}\right]y_ie^{-y_if(x_i)}\\ &= \sum_{i=1}^{N}\left [\frac{\rho}{\rho_k}V_k^\top\frac{\partial \tilde{f}(V, x_i)}{\partial V_k}\right]y_ie^{-y_if(x_i)}\\ &= \frac{\rho}{\rho_k}\sum_{i=1}^{N}f(V, x_i)y_ie^{-y_i\rho\tilde{f}(x_i)} \end{align} $$
Here we notice an interesting evolution. Again, under total separability, the rate $\dot{\rho}$ will be always non-negative. Since it will march towards infinity where $R_n(\rho\tilde{f})\rightarrow 0$ we expect to have the same behavior we saw in the first scenario.
Case 3: unconstrained gradient descent
Finally, we come to the typical training setting where we have no explicit restrictions over any parameter. Further expanding the gradient dynamics we saw in the definition, we have:
$$ \begin{align} \dot{\rho}_k &= V_k^\top\dot{W}_k\\ &= \sum_{i=1}^{N}V_k^\top\left [\frac{\partial f(W, x_i)}{\partial V_k}\right]y_ie^{-y_if(x_i)}\\ &= \frac{\rho}{\rho_k}\sum_{i=1}^{N}\tilde{f}(x_i)y_ie^{-y_i\rho\tilde{f}(x_i)}\\ \end{align} $$
and, $$ \begin{align} \dot{V}_k &= \frac{S_k}{\rho_k}\dot{W}_k\\ &= \sum_{i=1}^{N}\frac{S_k}{\rho_k}\left [\frac{\partial f(W, x_i)}{\partial V_k}\right]y_ie^{-y_if(x_i)}\\ &= \frac{\rho}{\rho_k^2}\sum_{i=1}^{N}y_ie^{-y_i\rho\tilde{f}(x_i)}S_k\frac{\partial \tilde{f}(x_i)}{\partial V_k}\\ \end{align} $$
Here we see that the gradients $\dot{\rho}_k$ and $\dot{V}_k$ have identical and near-identical rates to the other scenarios, respectively, differing only by a factor of $\frac{1}{\rho_k^2}$.
For the scalar factor $\rho$ it is quite common to see methods that have the same march to infinity once separability has been reached. Also, under the same conditions of full separability, we can see that $V_k$ has the same stationary point in the unconstrained case, thus presenting a very plausible explanation on how gradient-based methods perform complexity control, by imposing an implicit restriction on $\left\Vert V\right\Vert$.
So, in the end, gradient descent doesn’t really care so much about the size or norm of the weights, rather its direction. But what is the meaning of this direction?
Interpretation
Under the mentioned assumptions, these dynamics all converge to the same stationary point, one that maximizes the margin. The margin is the minimum distance between a training example of a class and the decision boundary of the classifier. Along this boundary the classifier impartial to the competing classes, so by maximizing the minimal distance from this region, we are essentially promoting a greater dichotomy of classes.
As some intuition on why this happens in our case, think of the dynamics of $\dot{V}_k$ mentioned in Case 1. As $\rho$ increases, all the points where there’s more agreement between $y_i$ and $f(x_i)$ start to vanish. What we are left are the points $x^*$ where the classifier is most uncertain, i.e. closest to the decision boundary, much like the support vectors of an SVM. A guideline to a formal proof (as in Banburski et al. 2019) is to show that given two candidate solutions that fully separate our data, the one that minimizes the empirical risk has a bigger margin.
Experiments
To validate the dynamics here presented, we propose the following experiment. We use a noiseless dataset for binary classification to train models with similar architectures but different parametrizations. All of these are fully-connected networks with ReLU functions and no biases, all initialized with the same parameters. We only introduce a bias term in the first layer, as an additional input, following the theoretical setting presented. As a result of the layout, we can exploit the homogeneity property in the parametrization procedure.
In this step, we break down the weights into two parameters: scalars $\rho$ and normalized weights $V$. To enforce normalization throughout training, we either introduce a penalization term on the $\left\Vert V\right\Vert_2$, as with Lagrangian multipliers, or we forcibly normalize $V$ after each gradient update 2. And so we arrive at the following results.
2 More details on the experiment can be found in this repository.
Despite having different magnitudes, the dynamics of the scalars all display similar characteristics. For one, although in different rates, all $\rho$ increase once full separability is reached. What’s more, in the Lagrangian setting, there’s a strong relationship between the regularization factor $\lambda$ and the growth of $\rho$. The difference in magnitude between two and five layers can be explained by the additional number of parameters in the latter. However, in this case, soon after full separability is achieved, the rate of growth rapidly decreases nearly to a plateau.
As for the normalized weights $V$, these all become closer as training progresses. Particularly all the parametrized settings seem to converge to the same solution. Again, in deeper setting, the solutions are further separated, most likely a result of increasing overparametrization.
Finally, considering the margin $\min f(x_i)y_i ,\forall (x_i,y_i)\in\mathcal{D}$, its dynamics seem to agree with theory, as all margins increase after separability. The oscilations of margin during training are most likely a result of non-smooth decision boundaries which are corrected during training, when we see a change in the support vector, here represented by dots along the lines.
What about generalization?
We’ve seen a lot of technical details regarding the dynamics of the parameters during training. But, how does this relates to the initial topic of generalization bounds? The general understanding is expecting that this preference for a particular solution poses a limitation on the class complexity thus explaining the generalization phenomena of deep neural networks. In fact, there is some empirical evidence that may favor the view generalization under normalized networks.
Furthermore, the concept of margin is already widely explored in the context of complexity measures (Antos et al. 2002, Bartlett et al. 2017) . Particularly, one of its main instruments is the estimate named Rademacher complexity. One example of such classical generalization bounds is:
$$R(h) \le R_n(h) + c_1\mathbb{R}_n(\mathcal{H}) + c_2\sqrt{\frac{ln(\frac{1}{\delta})}{2n}},$$
where $\mathbb{R}_n$ is the empirical estimate of the Rademacher complexity over the hypothesis class $\mathcal{H}$. However, making use of the homogeneity property $h = \rho\tilde{h}$ we arrive at:
$$R(\rho\tilde{h}) \le R_n(\rho\tilde{h}) + \rho\mathbb{R}_n(\widetilde{\mathcal{H}}) + c_2\sqrt{\frac{ln(\frac{1}{\delta})}{2n}},$$
the expectation is to decrease the class complexity while also controlling the generalization bound via $\rho$. However, as we already know, $\rho$ naturally increases throughout training, so even with techniques that promise to bound $\rho$ may not be enough to explain generalization in the current settings.
As of now, even though there’s no unified or undisputed explanation on the generalization of deep networks. Still, this is one of the most popular and prolific topics in theoretical machine learning. With this standing challenge come many competing explanations but also new directions and ingenious analyses, all of which could be used in demystifying deep networks as well as the new endeavors about to come.
References
- Shalev-Shwartz, S., & Ben-David, S. (2014). Understanding machine learning: From theory to algorithms. Cambridge university press.
- Neyshabur, B., Li, Z., Bhojanapalli, S., LeCun, Y., & Srebro, N. (2018). Towards understanding the role of over-parametrization in generalization of neural networks. arXiv preprint.
- Bishop, C. M. (1995). Training with noise is equivalent to Tikhonov regularization. Neural computation
- Goodfellow, I., Bengio, Y., Courville, A., & Bengio, Y. (2016). Deep learning. Cambridge: MIT press.
- Poggio, T., Liao, Q., & Banburski, A. (2020). Complexity control by gradient descent in deep networks. Nature communications.
- Banburski, A., Liao, Q., Miranda, B., Rosasco, L., Hidary, J., & Poggio, T. (2019). Theory III: Dynamics and Generalization in Deep Networks - a simple solution. arXiv preprint.
- Antos, A., Kégl, B., Linder, T., & Lugosi, G. (2002). Data-dependent margin-based generalization bounds for classification. Journal of Machine Learning Research.
- Bartlett, P. L., Foster, D. J., & Telgarsky, M. J. (2017). Spectrally-normalized margin bounds for neural networks. In Advances in neural information processing systems.


We sell content!
- whiteboard dot-com e-commerce
- harness B2C networks
- e-enable sticky communities
- harness holistic e-services
- innovate out-of-the-box schemas
- repurpose innovative networks
- morph dot-com infrastructures
- redefine next-generation e-markets
- drive 24/365 technologies
- aggregate turn-key relationships
- expedite e-business channels
- extend cutting-edge interfaces
- streamline impactful bandwidth
- generate robust infomediaries


---
title: Tooltip
subtitle: Subtitle
layout: layout-docs
category: General
breadcrumb: General
icon: circle-question
---
A tooltip is a brief, informative message that appears when a user interacts
with an element.
Position your tooltip using the
sgds-tooltip is-tooltip-*position* class.
{%- highlight html -%}
{%- endhighlight -%}
Assign colours to your tooltip using the
sgds-tooltip is-tooltip-*stateColor* class.
{%- highlight html -%}
{%- endhighlight -%}
Guidelines
Tooltips can be attached to any active element (icons, text links,
buttons, etc.) on a page to provide descriptions or explanations. Thus,
tooltips are highly contextual and specific and don’t explain the bigger
picture or entire task flow.
Tooltips should not be used to display vital information for task
completion.
Tips that pop up on pages to inform users about new features or how to
use a specific functionality are not tooltips.
Because tooltips are initiated by a hover gesture, they can be used only
on devices with a mouse or keyboard. They are not normally available on
touchscreens.
Source:
NNG Group
{%- include sgds-feedback.html -%}


- NAME
- namespace - create and manipulate contexts for commands and variables
- SYNOPSIS
- namespace ?option? ?arg ...?
- DESCRIPTION
- namespace children ?namespace? ?pattern?
- namespace code script
- namespace current
- namespace delete ?namespace namespace ...?
- namespace eval namespace arg ?arg ...?
- namespace exists namespace
- namespace export ?-clear? ?pattern pattern ...?
- namespace forget ?pattern pattern ...?
- namespace import ?-force? ?pattern pattern ...?
- namespace inscope namespace script ?arg ...?
- namespace origin command
- namespace parent ?namespace?
- namespace qualifiers string
- namespace tail string
- namespace which ?-command? ?-variable? name
- WHAT IS A NAMESPACE?
- QUALIFIED NAMES
- NAME RESOLUTION
- IMPORTING COMMANDS
- EXPORTING COMMANDS
- SCOPED SCRIPTS
- EXAMPLES
- SEE ALSO
- KEYWORDS
namespace - create and manipulate contexts for commands and variables
namespace ?option? ?arg ...?
The namespace command lets you create, access, and destroy
separate contexts for commands and variables.
See the section WHAT IS A NAMESPACE? below
for a brief overview of namespaces.
The legal values of option are listed below.
Note that you can abbreviate the options.
- namespace children ?namespace? ?pattern?
-
Returns a list of all child namespaces that belong to the
namespace namespace.
If namespace is not specified,
then the children are returned for the current namespace.
This command returns fully-qualified names,
which start with a double colon (::).
If the optional pattern is given,
then this command returns only the names that match the glob-style pattern.
The actual pattern used is determined as follows:
a pattern that starts with double colon (::) is used directly,
otherwise the namespace namespace
(or the fully-qualified name of the current namespace)
is prepended onto the pattern.
- namespace code script
-
Captures the current namespace context for later execution
of the script script.
It returns a new script in which script has been wrapped
in a namespace inscope command.
The new script has two important properties.
First, it can be evaluated in any namespace and will cause
script to be evaluated in the current namespace
(the one where the namespace code command was invoked).
Second, additional arguments can be appended to the resulting script
and they will be passed to script as additional arguments.
For example, suppose the command
set script [namespace code {foo bar}]
is invoked in namespace ::a::b.
Then eval "$script x y"
can be executed in any namespace (assuming the value of
script has been passed in properly)
and will have the same effect as the command
::namespace eval ::a::b {foo bar x y}.
This command is needed because
extensions like Tk normally execute callback scripts
in the global namespace.
A scoped command captures a command together with its namespace context
in a way that allows it to be executed properly later.
See the section SCOPED SCRIPTS for some examples
of how this is used to create callback scripts.
- namespace current
-
Returns the fully-qualified name for the current namespace.
The actual name of the global namespace is ``''
(i.e., an empty string),
but this command returns :: for the global namespace
as a convenience to programmers.
- namespace delete ?namespace namespace ...?
-
Each namespace namespace is deleted
and all variables, procedures, and child namespaces
contained in the namespace are deleted.
If a procedure is currently executing inside the namespace,
the namespace will be kept alive until the procedure returns;
however, the namespace is marked to prevent other code from
looking it up by name.
If a namespace doesn't exist, this command returns an error.
If no namespace names are given, this command does nothing.
- namespace eval namespace arg ?arg ...?
-
Activates a namespace called namespace and evaluates some code
in that context.
If the namespace does not already exist, it is created.
If more than one arg argument is specified,
the arguments are concatenated together with a space between each one
in the same fashion as the eval command,
and the result is evaluated.
If namespace has leading namespace qualifiers
and any leading namespaces do not exist,
they are automatically created.
- namespace exists namespace
-
Returns 1 if namespace is a valid namespace in the current
context, returns 0 otherwise.
- namespace export ?-clear? ?pattern pattern ...?
-
Specifies which commands are exported from a namespace.
The exported commands are those that can be later imported
into another namespace using a namespace import command.
Both commands defined in a namespace and
commands the namespace has previously imported
can be exported by a namespace.
The commands do not have to be defined
at the time the namespace export command is executed.
Each pattern may contain glob-style special characters,
but it may not include any namespace qualifiers.
That is, the pattern can only specify commands
in the current (exporting) namespace.
Each pattern is appended onto the namespace's list of export patterns.
If the -clear flag is given,
the namespace's export pattern list is reset to empty before any
pattern arguments are appended.
If no patterns are given and the -clear flag isn't given,
this command returns the namespace's current export list.
- namespace forget ?pattern pattern ...?
-
Removes previously imported commands from a namespace.
Each pattern is a simple or qualified name such as
x, foo::x or a::b::p*.
Qualified names contain double colons (::) and qualify a name
with the name of one or more namespaces.
Each qualified pattern is qualified with the name of an
exporting namespace
and may have glob-style special characters in the command name
at the end of the qualified name.
Glob characters may not appear in a namespace name.
For each simple pattern this command deletes the matching
commands of the
current namespace that were imported from a different namespace.
For qualified patterns, this command first finds the matching
exported commands.
It then checks whether any of those commands
were previously imported by the current namespace.

In effect, this un-does the action of a namespace import command.
- namespace import ?-force? ?pattern pattern ...?
-
Imports commands into a namespace.
Each pattern is a qualified name like
foo::x or a::p*.
That is, it includes the name of an exporting namespace
and may have glob-style special characters in the command name
at the end of the qualified name.
Glob characters may not appear in a namespace name.
All the commands that match a pattern string
and which are currently exported from their namespace
are added to the current namespace.
This is done by creating a new command in the current namespace
that points to the exported command in its original namespace;
when the new imported command is called, it invokes the exported command.
This command normally returns an error
if an imported command conflicts with an existing command.
However, if the -force option is given,
imported commands will silently replace existing commands.
The namespace import command has snapshot semantics:
that is, only requested commands that are currently defined
in the exporting namespace are imported.
In other words, you can import only the commands that are in a namespace
at the time when the namespace import command is executed.
If another command is defined and exported in this namespace later on,
it will not be imported.
- namespace inscope namespace script ?arg ...?
-
Executes a script in the context of the specified namespace.
This command is not expected to be used directly by programmers;
calls to it are generated implicitly when applications
use namespace code commands to create callback scripts
that the applications then register with, e.g., Tk widgets.
The namespace inscope command is much like the namespace eval
command except that the namespace must already exist,
and namespace inscope appends additional args
as proper list elements.
namespace inscope ::foo $script $x $y $z
is equivalent to
namespace eval ::foo [concat $script [list $x $y $z]]
thus additional arguments will not undergo a second round of substitution,
as is the case with namespace eval.
- namespace origin command
-
Returns the fully-qualified name of the original command
to which the imported command command refers.
When a command is imported into a namespace,
a new command is created in that namespace
that points to the actual command in the exporting namespace.
If a command is imported into a sequence of namespaces
a, b,...,n where each successive namespace
just imports the command from the previous namespace,
this command returns the fully-qualified name of the original command
in the first namespace, a.
If command does not refer to an imported command,
the command's own fully-qualified name is returned.
- namespace parent ?namespace?
-
Returns the fully-qualified name of the parent namespace
for namespace namespace.
If namespace is not specified,
the fully-qualified name of the current namespace's parent is returned.
- namespace qualifiers string
-
Returns any leading namespace qualifiers for string.
Qualifiers are namespace names separated by double colons (::).
For the string ::foo::bar::x,
this command returns ::foo::bar,
and for :: it returns an empty string.
This command is the complement of the namespace tail command.
Note that it does not check whether the
namespace names are, in fact,
the names of currently defined namespaces.
- namespace tail string
-
Returns the simple name at the end of a qualified string.
Qualifiers are namespace names separated by double colons (::).
For the string ::foo::bar::x,
this command returns x,
and for :: it returns an empty string.
This command is the complement of the namespace qualifiers command.
It does not check whether the namespace names are, in fact,
the names of currently defined namespaces.
- namespace which ?-command? ?-variable? name
-
Looks up name as either a command or variable
and returns its fully-qualified name.
For example, if name does not exist in the current namespace
but does exist in the global namespace,
this command returns a fully-qualified name in the global namespace.
If the command or variable does not exist,
this command returns an empty string. If the variable has been
created but not defined, such as with the variable command
or through a trace on the variable, this command will return the
fully-qualified name of the variable.
If no flag is given, name is treated as a command name.
See the section NAME RESOLUTION below for an explanation of
the rules regarding name resolution.
A namespace is a collection of commands and variables.
It encapsulates the commands and variables to ensure that they
won't interfere with the commands and variables of other namespaces.
Tcl has always had one such collection,
which we refer to as the global namespace.
The global namespace holds all global variables and commands.
The namespace eval command lets you create new namespaces.
For example,
namespace eval Counter {
namespace export bump
variable num 0
proc bump {} {
variable num
incr num
}
}
creates a new namespace containing the variable num and
the procedure bump.
The commands and variables in this namespace are separate from
other commands and variables in the same program.
If there is a command named bump in the global namespace,
for example, it will be different from the command bump
in the Counter namespace.
Namespace variables resemble global variables in Tcl.
They exist outside of the procedures in a namespace
but can be accessed in a procedure via the variable command,
as shown in the example above.
Namespaces are dynamic.
You can add and delete commands and variables at any time,
so you can build up the contents of a
namespace over time using a series of namespace eval commands.
For example, the following series of commands has the same effect
as the namespace definition shown above:
namespace eval Counter {
variable num 0
proc bump {} {
variable num
return [incr num]
}
}
namespace eval Counter {
proc test {args} {
return $args
}
}
namespace eval Counter {
rename test ""
}
Note that the test procedure is added to the Counter namespace,
and later removed via the rename command.
Namespaces can have other namespaces within them,
so they nest hierarchically.
A nested namespace is encapsulated inside its parent namespace
and can not interfere with other namespaces.
Each namespace has a textual name such as
history or ::safe::interp.
Since namespaces may nest,
qualified names are used to refer to
commands, variables, and child namespaces contained inside namespaces.
Qualified names are similar to the hierarchical path names for
Unix files or Tk widgets,
except that :: is used as the separator
instead of / or ..
The topmost or global namespace has the name ``'' (i.e., an empty string),
although :: is a synonym.
As an example, the name ::safe::interp::create
refers to the command create in the namespace interp
that is a child of namespace ::safe,
which in turn is a child of the global namespace, ::.
If you want to access commands and variables from another namespace,
you must use some extra syntax.
Names must be qualified by the namespace that contains them.
From the global namespace,
we might access the Counter procedures like this:
Counter::bump 5
Counter::Reset
We could access the current count like this:
puts "count = $Counter::num"
When one namespace contains another, you may need more than one
qualifier to reach its elements.
If we had a namespace Foo that contained the namespace Counter,
you could invoke its bump procedure
from the global namespace like this:
Foo::Counter::bump 3
You can also use qualified names when you create and rename commands.
For example, you could add a procedure to the Foo
namespace like this:
proc Foo::Test {args} {return $args}
And you could move the same procedure to another namespace like this:
rename Foo::Test Bar::Test
There are a few remaining points about qualified names
that we should cover.
Namespaces have nonempty names except for the global namespace.
:: is disallowed in simple command, variable, and namespace names
except as a namespace separator.
Extra colons in any separator part of a qualified name are ignored;
i.e. two or more colons are treated as a namespace separator.
A trailing :: in a qualified variable or command name
refers to the variable or command named {}.
However, a trailing :: in a qualified namespace name is ignored.
In general, all Tcl commands that take variable and command names
support qualified names.
This means you can give qualified names to such commands as
set, proc, rename, and interp alias.
If you provide a fully-qualified name that starts with a ::,
there is no question about what command, variable, or namespace
you mean.
However, if the name does not start with a ::
(i.e., is relative),
Tcl follows a fixed rule for looking it up:
Command and variable names are always resolved
by looking first in the current namespace,
and then in the global namespace.
Namespace names, on the other hand, are always resolved
by looking in only the current namespace.
In the following example,
set traceLevel 0
namespace eval Debug {
printTrace $traceLevel
}
Tcl looks for traceLevel in the namespace Debug
and then in the global namespace.
It looks up the command printTrace in the same way.
If a variable or command name is not found in either context,
the name is undefined.
To make this point absolutely clear, consider the following example:
set traceLevel 0
namespace eval Foo {
variable traceLevel 3
namespace eval Debug {
printTrace $traceLevel
}
}
Here Tcl looks for traceLevel first in the namespace Foo::Debug.
Since it is not found there, Tcl then looks for it
in the global namespace.
The variable Foo::traceLevel is completely ignored
during the name resolution process.
You can use the namespace which command to clear up any question
about name resolution.
For example, the command:
namespace eval Foo::Debug {namespace which -variable traceLevel}
returns ::traceLevel.
On the other hand, the command,
namespace eval Foo {namespace which -variable traceLevel}
returns ::Foo::traceLevel.
As mentioned above,
namespace names are looked up differently
than the names of variables and commands.
Namespace names are always resolved in the current namespace.
This means, for example,
that a namespace eval command that creates a new namespace
always creates a child of the current namespace
unless the new namespace name begins with ::.
Tcl has no access control to limit what variables, commands,
or namespaces you can reference.
If you provide a qualified name that resolves to an element
by the name resolution rule above,
you can access the element.
You can access a namespace variable
from a procedure in the same namespace
by using the variable command.
Much like the global command,
this creates a local link to the namespace variable.
If necessary, it also creates the variable in the current namespace
and initializes it.
Note that the global command only creates links
to variables in the global namespace.
It is not necessary to use a variable command
if you always refer to the namespace variable using an
appropriate qualified name.
Namespaces are often used to represent libraries.
Some library commands are used so frequently
that it is a nuisance to type their qualified names.
For example, suppose that all of the commands in a package
like BLT are contained in a namespace called Blt.
Then you might access these commands like this:
Blt::graph .g -background red
Blt::table . .g 0,0
If you use the graph and table commands frequently,
you may want to access them without the Blt:: prefix.
You can do this by importing the commands into the current namespace,
like this:
namespace import Blt::*
This adds all exported commands from the Blt namespace
into the current namespace context, so you can write code like this:
graph .g -background red
table . .g 0,0
The namespace import command only imports commands
from a namespace that that namespace exported
with a namespace export command.
Importing every command from a namespace is generally
a bad idea since you don't know what you will get.
It is better to import just the specific commands you need.
For example, the command
namespace import Blt::graph Blt::table
imports only the graph and table commands into the
current context.
If you try to import a command that already exists, you will get an
error. This prevents you from importing the same command from two
different packages. But from time to time (perhaps when debugging),
you may want to get around this restriction. You may want to
reissue the namespace import command to pick up new commands
that have appeared in a namespace. In that case, you can use the
-force option, and existing commands will be silently overwritten:
namespace import -force Blt::graph Blt::table
If for some reason, you want to stop using the imported commands,
you can remove them with a namespace forget command, like this:
namespace forget Blt::*
This searches the current namespace for any commands imported from Blt.
If it finds any, it removes them. Otherwise, it does nothing.
After this, the Blt commands must be accessed with the Blt::
prefix.
When you delete a command from the exporting namespace like this:
rename Blt::graph ""
the command is automatically removed from all namespaces that import it.
You can export commands from a namespace like this:
namespace eval Counter {
namespace export bump reset
variable Num 0
variable Max 100
proc bump {{by 1}} {
variable Num
incr Num $by
Check
return $Num
}
proc reset {} {
variable Num
set Num 0
}
proc Check {} {
variable Num
variable Max
if {$Num > $Max} {
error "too high!"
}
}
}
The procedures bump and reset are exported,
so they are included when you import from the Counter namespace,
like this:
namespace import Counter::*
However, the Check procedure is not exported,
so it is ignored by the import operation.
The namespace import command only imports commands
that were declared as exported by their namespace.
The namespace export command specifies what commands
may be imported by other namespaces.
If a namespace import command specifies a command
that is not exported, the command is not imported.
The namespace code command is the means by which a script may be
packaged for evaluation in a namespace other than the one in which it
was created. It is used most often to create event handlers, Tk bindings,
and traces for evaluation in the global context. For instance, the following
code indicates how to direct a variable trace callback into the current
namespace:
namespace eval a {
variable b
proc theTraceCallback { n1 n2 op } {
upvar 1 $n1 var
puts "the value of $n1 has changed to $var"
return
}
trace variable b w [namespace code theTraceCallback]
}
set a::b c
When executed, it prints the message:
the value of a::b has changed to c
Create a namespace containing a variable and an exported command:
namespace eval foo {
variable bar 0
proc grill {} {
variable bar
puts "called [incr bar] times"
}
namespace export grill
}
Call the command defined in the previous example in various ways.
# Direct call
foo::grill
# Import into current namespace, then call local alias
namespace import foo::grill
grill
Look up where the command imported in the previous example came from:
puts "grill came from [namespace origin grill]"
variable
exported, internal, variable
Copyright © 1993-1997 Bell Labs Innovations for Lucent Technologies
Copyright © 1997 Sun Microsystems, Inc.
Copyright © 2000 Scriptics Corporation.
Copyright © 1995-1997 Roger E. Critchlow Jr.


- Q1:What is your service?
- Answer:We engage to provide you a satisfied wedding planning service, our duty including to wedding party planning, wedding equipment selling, and providing documental record of your wedding.
- Q2:How can I contact you?
- Answer:Pleace reach us out at<PHONE_NUMBER>.


Mitie's clients hold back on spending until after Brexit and the General Election
by Alex DanielOutsourcing giant Mitie has warned that its clients are holding back on committing to new projects, amid ongoing Brexit uncertainty and the upcoming general election.
The firm, which provides cleaning, security, facilities management, energy and healthcare services, said the uncertainty could affect revenue growth in the coming months.
Read more: Mitie to continue managing Lloyds Bank facilities until 2024
However, it reported rising turnover and profit as it moved onto the second part of a five-year turnaround plan.
Shares fell seven per cent today.
Revenue grew 11 per cent, operating profit was up five per cent, and the company’s order book grew one per cent.
It comes after Mitie said it was selling its catering business to royal warrant holder CH&Co for as much as £85m.
Chief executive Phil Bentley told City A.M.: “Clients are going, ‘oh that roof, maybe we’ll fix it next year not this year.’”
He added: “But … there's still some economic growth in our big clients. It’s not spectacular growth, but it’s not falling off a cliff either.”
The company, which is less dependent than its rivals on public sector work, said its order book grew one per cent to £4.1bn, helped by contract wins from the Bank of England, HM Revenue and Customs, and a major London airport.
Bentley added: “The Catering disposal to our strategic partner CH&CO has strengthened our balance sheet and sharpened our focus on those business lines where we can secure a leading market position, underpinned by technology.
“Although still early days, we can see the success of this approach in our security business where we continue to win market share.”
Read more: Mitie sells food unit to the Queen's caterers
Last month, it emerged Whitehall had come under pressure from some of its most prominent public service outsourcers for slow decision-making, as time and resources were increasingly directed towards no-deal Brexit planning.
Three sources with knowledge of the matter told City A.M. that de facto no-deal Brexit secretary Michael Gove had been urged to “get a move on” so more work can be handed out.


Thank you for visiting my Portfolio site!
I am a digital data designer who graduated in May 2019 with a Master of Science (M.S.) in
from the Parsons School of Design (at The New School) in NYC. During my coursework at Parsons, I took several studio classes which
blended together web development, data design, and storytelling. You may view a few of my projects on this site
and hopefully enjoy the content!
If you are interested to know more about my professional background, you can check my LinkedIn page or send me an email.


Student Owned Services WRUB Clinical Lab Health Education Pharmacy Student Medical Insurance Legal Assistance Off-Campus Housing Ticket Office


mockspresso-guava / com.episode6.hackit.mockspresso.guava / SupplierMaker / <init>
<init>
SupplierMaker()
Deprecated: This functionality is now exposed by the kotlin extension method `automaticSuppliers()` and its JavaSupport counterpart MockspressoGuavaPluginsJavaSupport#automaticSuppliers()
This class will be marked internal/protected in a future release
Special object handling for guava's Supplier


Beta This is a test version of the layout of this page. Take the survey to help us improve it
Collection
FE choices provides comparable information to help learners and employers make informed choices about education and training.
All FE choices data is available on GOV.UK and DATA.GOV.UK with performance indicators held on the National Careers Service website.
FE choices consists of:
Information is provided about:
further education colleges and other organisations that receive government funding and offer education and training to people over the age of 16
organisations that offer academic and vocational subjects, apprenticeships, and training on and off the job
Please see the transparency spreadsheet for technical information about the surveys. If you require further detail about the calculation method for the learner satisfaction survey please email<EMAIL_ADDRESS>to request further details.
Clear and comparable information to help you as a learner and employer to make informed choices about post-16 further education and training.
FE Choices also helps further education organisations to assess their own performance.
Learner destinations data is available under the final heading, FE Choices performance indicators.
If you have any questions please contact<EMAIL_ADDRESS>or 0370 2670001.
The learner satisfaction survey for 2016 to 2017 runs from 31 October 2016 to 7 April 2017. The survey is an opportunity for existing learners to rate their learning or training.
This year we have one survey for all learners, including community learners and have broadened the questions to capture the benefits learners’ experience.
The employer satisfaction survey 2016 to 2017 will start on Monday, 27 March 2017. The first link below gives you access to the survey results from last year’s survey. The other links provide information for colleges and training providers on how you can administer this year’s survey.


--- layout: page title: About header-img: "img/about-bg.png" ---
This is where I'll report my progress


|
Class Summary |
| Field |
Schema identity constraint field. |
| Field.XPath |
Field XPath. |
| IdentityConstraint |
Base class of Schema identity constraint. |
| IDValue |
Stores a value associated with a particular field of an identity constraint that
has successfully matched some string in an instance document. |
| Key |
Schema key identity constraint. |
| KeyRef |
Schema key reference identity constraint. |
| Selector |
Schema identity constraint selector. |
| Selector.XPath |
Schema identity constraint selector XPath expression. |
| Unique |
Schema unique identity constraint. |
| XPath |
Bare minimum XPath parser. |
| XPath.Axis |
Axis. |
| XPath.LocationPath |
A location path representation for an XPath expression. |
| XPath.NodeTest |
Node test. |
| XPath.Step |
A location path step comprised of an axis and node test. |
| XPathMatcher |
XPath matcher. |


This is my CSS Web page
Humming bird
Today is awesome day
Hello Humming Bird
You like balloons right!!


cdemi's
24 September 2019 |
.NET #dotNet |
Announcing .NET Core 3.0 (devblogs.microsoft.com) |
| We’re excited to announce the release of .NET Core 3.0. It includes many improvements, including adding Windows Forms and WPF, adding new JSON APIs, support for ARM64 and improving performance across the board. C# 8 is also part of this release,... Read more |
Front End |
Inside the Web Browser’s Performance API (blog.cloudflare.com) Birthday Week Product News Deep Dive API |
| Building a beautiful, feature-rich website is easier than ever before. Not long ago, you’d have to fire up a text editor and hand-craft a lot of HTML, CSS, and JavaScript. Today, you can use WYSIWYG tools and third-party libraries that make development much simpler.... Read more |
DevOps |
Evolving Regional Evacuation (medium.com) |
| At Netflix we prioritize innovation and velocity in pursuit of the best experience for our 150+ million global customers. This means that our microservices constantly evolve and change, but what doesn’t change is our responsibility to provide a highly available service that delivers 100+ million hours of daily streaming to our subscribers.... Read more |
Data |
The Rise of Managed Apache Kafka as a Service (confluent.io) Apache Kafka as a Service Event Streaming Applications Event Streaming Platform |
| Unlocking the benefits of event streaming can be painful due to infrastructure challenges. We’ll cover what to look for in a complete, fully managed Apache Kafka as a service for multi-cloud or serverless data processing.... Read more |
Infrastructure #sysadmin |
Introducing Browser Insights (blog.cloudflare.com) Birthday Week Product News Analytics |
| Speed matters. We know that when your website or app gets faster, users have a better experience and you get more conversions and more revenue. At Cloudflare, we spend our days obsessing about speed and building new features to squeeze out as much performance as possible.... Read more |
When TCP sockets refuse to die (blog.cloudflare.com) SYN TCP Spectrum Tech Talks |
| We noticed something weird - the TCP sockets which we thought should have been closed - were lingering around. We realized we don't really understand when TCP sockets are supposed to time out! We naively thought enabling TCP keepalives would be enough... but it isn't!... Read more |
Internet of Things #IoT |
Stuff The Internet Says On Scalability For September 20th, 2019 (highscalability.com) |
| Wake up! It's HighScalability time...... Read more |
Product #ProductOwnership #ProductManagement |
Raising Prices is Hard (backblaze.com) |
| Every company is faced with the decision to raise prices at some point. Here's an inside look at the process behind a recent price raise at Backblaze, including the why, how, and when.... Read more |
General Tech #Tech |
Reproducible work environments using Docker (thoughtworks.com) |
| This article covers the basics of using Docker to control dependencies ranging from operating system to packages. While we use Python as an example here, the concepts are equally applicable to any other programming language.... Read more |
Welcome to Birthday Week 2019 (blog.cloudflare.com) Birthday Week Product News |
| September has always been a special month for Cloudflare. Nine years ago — on September 27th — we launched Cloudflare. And, each year since, we’ve celebrated our birthday with a week full of new products and innovations that support our mission of helping to build a better Internet.... Read more |
|
This newsletter is made with 💖 by cdemi and sponsored by moo Research. You can find this MIT Licensed open-source project on GitHub cdemi/NewsletterCurator. You can also find an archive of all sent newsletters on GitHub at https://newsletters.cdemi.io/. If you want to unsubscribe from this newsletter, please click here. If you're new and you want to subscribe to this newsletter, please click here. |


To import code from your code files to your Research Environment session, use Python.
One of the drawbacks of using the Research Environment you may encounter is the need to rewrite code you've already written in a file in the backtesting environment. Instead of rewriting the code, you can import the methods from the backtesting environment into the Research Environment to reduce development time. For example, say you have the following helpers.py file in your project:
def Add(a, b): return a+b
To import the preceding method into your research notebook, use the import
statement.
from helpers import Add # reuse method from helpers.py Add(3, 4)
If you adjust the file that you import, restart the Research Environment session to import the latest version of the file. To restart the Research Environment, stop the research node and then open the notebook again.


| HYTOOL Function Reference |
Filter a signal in order to reduce the noise.
yf = hyfilter( x, y, [typef, [p]] ) x,y = two vectors describing the input signal OPTIONAL ARGUMENTS: typef = allows to select the type of filter typef = 'moving' for the moving average = Default option typef = 'butter' for the Butterworth filter p = parameter that depends on the type of filter that has been chosen. Two methods are proposed: a moving average and a Butterworth digital filter. The Butterworth tool filters high frequency components in the signal. for the moving average p = size of the moving window in number of points by default it is equal to 10 for the Butterworth filter p = period of the cutoff frequency in number of measurements by default it is equal to 10
The hytool function hyfilter filters a data set x,y in order to reduce the noise. The Butterworth tool filters high frequency components in the signal. It is very sensitive of outliers.Therefore the Butterworth filter is more appropriate for noisy signals without outliers, the moving average is recommended to filter very irregular signals.The Butterworth filter requires the signal processing toolbox. The moving average is less sensitive of outliers but at the same time less smooth.
hf = hyfilter( t,s ) hf = hyfilter( t,s,'butter' ) hf = hyfilter( t,s,'moving',30 ) hf = hyfilter( t,s,'butter',3 ) qfi = hyfilter( tf,qf,'butter')
hyselect, hysampling, hyclean, hyplot Published output in the Help browser showdemo hyfilter
| Hytool |
© 1998-2017 Philppe Renard and Co. Terms of Use Acknowledgments


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
Dietary
Stir the essential flavours of an English summertime into this delicious, verdant risotto.
Fill a saucepan with water and bring to the boil. Add the broad beans and return to the boil. Cook for one minute then drain in a colander under running water until cold. Remove the beans from their skins and set aside. Mix the mint with two tablespoons of the olive oil and set aside.
Melt 25g/1oz of the butter with the remaining oil in a large non-stick saucepan and fry the onion and garlic for five minutes until softened, but not coloured. Stir in the thyme, lemon zest, bay leaf and risotto rice and cook for a few seconds more until the rice is glistening.
Pour the wine in to the pan and boil over a medium heat until the liquid has reduced by half. Slowly start adding the stock, a ladleful at a time, stirring well between each addition. Simmer for 2-3 minutes or until the liquid has almost all been absorbed before adding more. Cook for 15 minutes or until the rice is tender.
Meanwhile, fill a medium saucepan with water and bring to the boil. Cook the runner beans for three minutes, or until tender. Drain in a colander then return to the pan and toss with a small knob of the remaining butter and plenty of ground black pepper.
Remove the thyme and lemon zest from the rice and discard. Stir in the broad beans, peas and asparagus with the remaining stock and cook for three minutes until tender, stirring regularly. Remove from the heat and stir in the feta. Season with salt and freshly ground black pepper. Cover with a lid and set aside.
Add the remaining butter to the risotto and stir. Spoon into four deep plates and tap gently on the work surface to spread the risotto slightly. Spoon over the minted olive oil. Top with the runner beans and shavings of fresh parmesan and serve immediately.


PKCS12
Section: OpenSSL (1)Updated: 2006-12-21
Index Return to Main Contents
NAME
pkcs12 - PKCS#12 file utilitySYNOPSIS
openssl pkcs12 [-export] [-chain] [-inkey filename] [-certfile filename] [-name name] [-caname name] [-in filename] [-out filename] [-noout] [-nomacver] [-nocerts] [-clcerts] [-cacerts] [-nokeys] [-info] [-des | -des3 | -idea | -aes128 | -aes192 | -aes256 | -camellia128 | -camellia192 | -camellia256 | -nodes] [-noiter] [-maciter | -nomaciter | -nomac] [-twopass] [-descert] [-certpbe cipher] [-keypbe cipher] [-macalg digest] [-keyex] [-keysig] [-password arg] [-passin arg] [-passout arg] [-rand file(s)] [-CAfile file] [-CApath dir] [-CSP name]DESCRIPTION
The pkcs12 command allows PKCS#12 files (sometimes referred to as PFX files) to be created and parsed. PKCS#12 files are used by several programs including Netscape, MSIE and MS Outlook.COMMAND OPTIONS
There are a lot of options the meaning of some depends of whether a PKCS#12 file is being created or parsed. By default a PKCS#12 file is parsed. A PKCS#12 file can be created by using the -export option (see below).PARSING OPTIONS
- -in filename
- This specifies filename of the PKCS#12 file to be parsed. Standard input is used by default.
- -out filename
- The filename to write certificates and private keys to, standard output by default. They are all written in PEM format.
- -pass arg, -passin arg
- the PKCS#12 file (i.e. input file) password source. For more information about the format of arg see the PASS PHRASE ARGUMENTS section in openssl(1).
- -passout arg
- pass phrase source to encrypt any outputed private keys with. For more information about the format of arg see the PASS PHRASE ARGUMENTS section in openssl(1).
- -noout
- this option inhibits output of the keys and certificates to the output file version of the PKCS#12 file.
- -clcerts
- only output client certificates (not CA certificates).
- -cacerts
- only output CA certificates (not client certificates).
- -nocerts
- no certificates at all will be output.
- -nokeys
- no private keys will be output.
- -info
- output additional information about the PKCS#12 file structure, algorithms used and iteration counts.
- -des
- use DES to encrypt private keys before outputting.
- -des3
- use triple DES to encrypt private keys before outputting, this is the default.
- -idea
- use IDEA to encrypt private keys before outputting.
- -aes128, -aes192, -aes256
- use AES to encrypt private keys before outputting.
- -camellia128, -camellia192, -camellia256
- use Camellia to encrypt private keys before outputting.
- -nodes
- don't encrypt the private keys at all.
- -nomacver
- don't attempt to verify the integrity MAC before reading the file.
- -twopass
- prompt for separate integrity and encryption passwords: most software always assumes these are the same so this option will render such PKCS#12 files unreadable.
FILE CREATION OPTIONS
- -export
- This option specifies that a PKCS#12 file will be created rather than parsed.
- -out filename
- This specifies filename to write the PKCS#12 file to. Standard output is used by default.
- -in filename
- The filename to read certificates and private keys from, standard input by default. They must all be in PEM format. The order doesn't matter but one private key and its corresponding certificate should be present. If additional certificates are present they will also be included in the PKCS#12 file.
- -inkey filename
- file to read private key from. If not present then a private key must be present in the input file.
- -name friendlyname
- This specifies the ``friendly name'' for the certificate and private key. This name is typically displayed in list boxes by software importing the file.
- -certfile filename
- A filename to read additional certificates from.
- -caname friendlyname
- This specifies the ``friendly name'' for other certificates. This option may be used multiple times to specify names for all certificates in the order they appear. Netscape ignores friendly names on other certificates whereas MSIE displays them.
- -pass arg, -passout arg
- the PKCS#12 file (i.e. output file) password source. For more information about the format of arg see the PASS PHRASE ARGUMENTS section in openssl(1).
- -passin password
- pass phrase source to decrypt any input private keys with. For more information about the format of arg see the PASS PHRASE ARGUMENTS section in openssl(1).
- -chain
- if this option is present then an attempt is made to include the entire certificate chain of the user certificate. The standard CA store is used for this search. If the search fails it is considered a fatal error.
- -descert
- encrypt the certificate using triple DES, this may render the PKCS#12 file unreadable by some ``export grade'' software. By default the private key is encrypted using triple DES and the certificate using 40 bit RC2.
- -keypbe alg, -certpbe alg
- these options allow the algorithm used to encrypt the private key and certificates to be selected. Any PKCS#5 v1.5 or PKCS#12 PBE algorithm name can be used (see NOTES section for more information). If a a cipher name (as output by the list-cipher-algorithms command is specified then it is used with PKCS#5 v2.0. For interoperability reasons it is advisable to only use PKCS#12 algorithms.
- -keyex|-keysig
- specifies that the private key is to be used for key exchange or just signing. This option is only interpreted by MSIE and similar MS software. Normally ``export grade'' software will only allow 512 bit RSA keys to be used for encryption purposes but arbitrary length keys for signing. The -keysig option marks the key for signing only. Signing only keys can be used for S/MIME signing, authenticode (ActiveX control signing) and SSL client authentication, however due to a bug only MSIE 5.0 and later support the use of signing only keys for SSL client authentication.
- -macalg digest
- specify the MAC digest algorithm. If not included them SHA1 will be used.
- -nomaciter, -noiter
-
these options affect the iteration counts on the MAC and key algorithms.
Unless you wish to produce files compatible with MSIE 4.0 you should leave
these options alone.
To discourage attacks by using large dictionaries of common passwords the algorithm that derives keys from passwords can have an iteration count applied to it: this causes a certain part of the algorithm to be repeated and slows it down. The MAC is used to check the file integrity but since it will normally have the same password as the keys and certificates it could also be attacked. By default both MAC and encryption iteration counts are set to 2048, using these options the MAC and encryption iteration counts can be set to 1, since this reduces the file security you should not use these options unless you really have to. Most software supports both MAC and key iteration counts. MSIE 4.0 doesn't support MAC iteration counts so it needs the -nomaciter option.
- -maciter
- This option is included for compatibility with previous versions, it used to be needed to use MAC iterations counts but they are now used by default.
- -nomac
- don't attempt to provide the MAC integrity.
- -rand file(s)
- a file or files containing random data used to seed the random number generator, or an EGD socket (see RAND_egd(3)). Multiple files can be specified separated by a OS-dependent character. The separator is ; for MS-Windows, , for OpenVMS, and : for all others.
- -CAfile file
- CA storage as a file.
- -CApath dir
- CA storage as a directory. This directory must be a standard certificate directory: that is a hash of each subject name (using x509 -hash) should be linked to each certificate.
- -CSP name
- write name as a Microsoft CSP name.
NOTES
Although there are a large number of options most of them are very rarely used. For PKCS#12 file parsing only -in and -out need to be used for PKCS#12 file creation -export and -name are also used.If none of the -clcerts, -cacerts or -nocerts options are present then all certificates will be output in the order they appear in the input PKCS#12 files. There is no guarantee that the first certificate present is the one corresponding to the private key. Certain software which requires a private key and certificate and assumes the first certificate in the file is the one corresponding to the private key: this may not always be the case. Using the -clcerts option will solve this problem by only outputting the certificate corresponding to the private key. If the CA certificates are required then they can be output to a separate file using the -nokeys -cacerts options to just output CA certificates.
The -keypbe and -certpbe algorithms allow the precise encryption algorithms for private keys and certificates to be specified. Normally the defaults are fine but occasionally software can't handle triple DES encrypted private keys, then the option -keypbe PBE-SHA1-RC2-40 can be used to reduce the private key encryption to 40 bit RC2. A complete description of all algorithms is contained in the pkcs8 manual page.
EXAMPLES
Parse a PKCS#12 file and output it to a file:
openssl pkcs12 -in file.p12 -out file.pem
Output only client certificates to a file:
openssl pkcs12 -in file.p12 -clcerts -out file.pem
Don't encrypt the private key:
openssl pkcs12 -in file.p12 -out file.pem -nodes
Print some info about a PKCS#12 file:
openssl pkcs12 -in file.p12 -info -noout
Create a PKCS#12 file:
openssl pkcs12 -export -in file.pem -out file.p12 -name "My Certificate"
Include some extra certificates:
openssl pkcs12 -export -in file.pem -out file.p12 -name "My Certificate" \ -certfile othercerts.pem
BUGS
Some would argue that the PKCS#12 standard is one big bug :-)Versions of OpenSSL before 0.9.6a had a bug in the PKCS#12 key generation routines. Under rare circumstances this could produce a PKCS#12 file encrypted with an invalid key. As a result some PKCS#12 files which triggered this bug from other implementations (MSIE or Netscape) could not be decrypted by OpenSSL and similarly OpenSSL could produce PKCS#12 files which could not be decrypted by other implementations. The chances of producing such a file are relatively small: less than 1 in 256.
A side effect of fixing this bug is that any old invalidly encrypted PKCS#12 files cannot no longer be parsed by the fixed version. Under such circumstances the pkcs12 utility will report that the MAC is OK but fail with a decryption error when extracting private keys.
This problem can be resolved by extracting the private keys and certificates from the PKCS#12 file using an older version of OpenSSL and recreating the PKCS#12 file from the keys and certificates using a newer version of OpenSSL. For example:
old-openssl -in bad.p12 -out keycerts.pem openssl -in keycerts.pem -export -name "My PKCS#12 file" -out fixed.p12
SEE ALSO
pkcs8(1)
Index
- NAME
- SYNOPSIS
- DESCRIPTION
- COMMAND OPTIONS
- PARSING OPTIONS
- FILE CREATION OPTIONS
- NOTES
- EXAMPLES
- BUGS
- SEE ALSO
This document was created by man2html, using the manual pages.
Time: 05:29:09 GMT, December 24, 2015


If you have any questions about the Southern Property Hub or would like to find out more, please complete the form below.


Sweet Home
2 Guest
1 Room
1 Bathroom
Channel the pursuit of pause in this one-of-a-kind earth house. The cozy retreat was hand-sculpted using local and sustainable natural materials, and features a central living space with cantilevered slab stairs leading to the loft bedroom.


Geolocation Device Test
To test the Geolocation API. This page does not transmit any data except to request tiles from mapbox.com.
| Time | Age | Accuracy (P=95%) | Latitude | Longitude | Altitude (m) | Altitude Accuracy (P=95%) | Heading | Speed |
|---|
To test the Geolocation API. This page does not transmit any data except to request tiles from mapbox.com.
| Time | Age | Accuracy (P=95%) | Latitude | Longitude | Altitude (m) | Altitude Accuracy (P=95%) | Heading | Speed |
|---|


-
Auto evaluation
February 21 2007, 5:15 PM by Xavier Damman
-
Last week at Ngozi university
February 22 2007, 7:07 PM by Xavier Damman
-
Fuckin' security measures at Heathrow airport
February 24 2007, 11:57 AM by Xavier Damman
-
Report on the DB1 course
February 24 2007, 12:29 PM by Xavier Damman
-
Report on the DB2 course
February 24 2007, 1:02 PM by Xavier Damman
-
The trip back home to Madrid
February 24 2007, 5:04 PM by Xavier Damman
-
QEC2007: game over
March 6 2007, 3:48 PM by Xavier Damman
-
Please, help me choose my new glasses!
March 9 2007, 5:49 AM by Xavier Damman
-
Exposition gratuite du KotAstro sur le Soleil
March 18 2007, 7:18 PM by Xavier Damman
-
Pronostiques élections françaises
March 18 2007, 8:15 PM by Xavier Damman
-
2 semaines de répis avant l'exode français
April 23 2007, 2:01 PM by Xavier Damman
-
Sarko l'emporte
May 6 2007, 6:18 PM by Xavier Damman
-
Inconvenient truth: DVD gratuit avec le Télémoustique d'aujourd'hui!
May 9 2007, 2:50 PM by Xavier Damman
-
The Klaxon Revolution Project
May 24 2007, 11:24 AM by Xavier Damman
-
A new skin for tribal.be
May 24 2007, 11:35 AM by Xavier Damman
-
Latest news
July 17 2007, 1:01 PM by Xavier Damman
-
You are working on different projects and you can't concentrate on one at a time? This is for you...
July 23 2007, 9:21 PM by Xavier Damman
-
I'm starting learning Japanese!
August 19 2007, 4:31 PM by Xavier Damman
-
Next step: ObjectiveLessEmission.org
December 18 2007, 2:23 AM by Xavier Damman
-
Mercedes class R 306gr CO2
January 6 2008, 9:22 PM by Xavier Damman


"SHITTAH-TREE "(Isaiah 41:19; R.V., “acacia tree”). Shittah wood was employed in making the various parts of the tabernacle in the wilderness, and must therefore have been indigenous in the desert in which the Israelites wandered. It was the acacia or mimosa (Acacia Nilotica and A. seyal). “The wild acacia (Mimosa Nilotica), under the name of sunt, everywhere represents the seneh, or senna, of the burning bush. A slightly different form of the tree, equally common under the name of seyal, is the ancient ‘shittah,’ or, as more usually expressed in the plural form, the‘shittim,’ of which the tabernacle was made.” Stanley’s Sinai, etc. (Exodus 25:10, 13, 23, 28).
"SHITTAH-TREE "(Isaiah 41:19; R.V., “acacia tree”). Shittah wood was employed in making the various parts of the tabernacle in the wilderness, and must therefore have been indigenous in the desert in which the Israelites wandered. It was the acacia or mimosa (Acacia Nilotica and A.
seyal). “The wild acacia (Mimosa Nilotica), under the name of sunt, everywhere represents the seneh, or senna, of the burning bush. A slightly different form of the tree, equally common under the name of seyal, is the ancient ‘shittah,’ or, as more usually expressed in the plural form, the‘shittim,’ of which the tabernacle was made.” Stanley’s Sinai, etc. (Exodus 25:10, 13, 23, 28).


{% from "mtrh_dev/templates/includes/rfq/rfq_macros.html" import item_name_and_description %} {% for d in doc.items %}
{{_("UOM") + ":"+ d.uom}}
{{_("0:00 = No Quote") }}


Reads the Fluent Universal file format as written by Fluent v4.5 . This reader supports the ASCII output from Fluent. Binary files are not supported.
Parameters
ReadFluentParams
Name Type Description UI Control filename string Name of Fluent file to read. File Dialog load int Triggers loading of the Fluent file. Button Output Ports
Name Type Description out_mesh Mesh_Struct+Node_Data Structured mesh read from Fluent file. out_obj DefaultObject DataObject which can directly be rendered by the standard data viewers.
This code segment reads the Fluent Universal format, output by Fluent v4.5 This code is the structured code of Fluent. It only handles single block curvilinear grids. It is assumed here that the velocities are stored in curvi-linear mode. See Fluent's USE CYLINDRICAL VELOCITIES flag. No attempt is made here to convert from cartesian velocities.
This reader olny supports the ASCII output from Fluent. Binary is not supported.
Reading Fluent's document "Appendix A, pp 1-52, Description of the FLUENT Universal File" May 10, 1997, is recommended.
filename
String parameter that specifies which Fluent file should be read. The filename string should contain the full path name of the file and can contain any of the AVS/Express environment variables (e.g. $XP_PATH<1>)
load
Integer parameter that triggers the loading of the Fluent file.
out_mesh
Structured mesh + Node data output that contains the geometry and attached data values read from the Fluent file. The output consists of the nodal coordinates, connectivity information and the data values per node.
out_obj
The directly renderable output of the ReadFluent macro. This output contains the geometry data read from the Fluent file in a form that can directly be rendered by the standard data viewers.
The ReadFluentFunc functional macro uses the low-level read_fluent_core module. The macro takes as input the parameter blocks, ReadFluentParams. The macro outputs the data read from the Fluent file as structured mesh with node data.
The ReadFluentFunc functional macro and the ReadFluentUI user interface macro are both used by the ReadFluent user macro. All of these macros use the ReadFluentParams parameter block to communicate. Additional to the mesh the ReadFluent user macro has an output for a DefaultObjects which can directly be rendered by the standard data viewers.
The project includes an example application that demonstrates the use of the ReadFluent macro. The ReadFluentEg application uses the ReadFluent macro to read an Fluent file (ascii) as it is produced by FLUENT version 4.5. The Example contains an isosurface and a bounds module to show the inner structure of the mesh which is read by the ReadFluentMacro.
xp_comm_proj/rdfluent/rdflmods.v contains the V definitions of the read_fluent_core module and the ReadFluentParams parameter block.
xp_comm_proj/rdfluent/rdflmacs.v contains the V definitions of the ReadFluentUI UI macro, the ReadFluentFunc functional macro and the ReadFluent user macro.
xp_comm_proj/rdfluent/rdflapps.v contains the V definitions of the ReadFluentEg example application.
The low-level ReadFluentMods library containing the low-level module read_fluent_core does not specify a process. By default the express process will be used.
Dr. Jean M. Favre, CSCS, Swiss Center for Scientific Computing Via Cantonale, 6928 Manno, Switzerland
Tobias Schiebeck, International AVS Centre


I am a Californian with food influence from all over Asia, I grew up in Hong Kong, moved to Los Angeles, raised three beautiful kids, worked in the toy industry, now I make my own website, and share my favorite recipes with you.
Hope you can check them out for yourself!
Great to view on your device, responsive, and optimized!
Will have image, video, animation, to showcase the food!
Cook with your family and friends!
Eating brings us together!
Send me questions or comments you have, I love your feedback!


Mickey Blue Eyes (1999) Reviewed by Eugene Novikov http://www.ultimate-movie.com Member: Online Film Critics Society
*** out of four
"Here's a painting by one of our newest artists. It's entitled 'Die Piggy Piggy Die Die"
Starring Hugh Grant, James Caan, Jeanne Tripplehorn, Burt Young. Rated PG-13.
Hollywood actors with strong British accents and no desire to master an American one will have trouble getting roles that don't involve playing an Englishman in America. This has led to the constant typecasting of talents like Hugh Grant who always ends up playing the bumbling Brit in romantic comedies when he is likely capable of so much more. Thus his performances have become excruciatingly predictable. As many have pointed out, Hugh Grant is a great personality and an even better screen presence. A shame his personality and presence are precisely the same in nearly every film he does.
Mickey Blue Eyes is a romantic comedy but it is also a spoof of organized crime. It is not the outright parody that Mafia! was and it takes its story very seriously but the script certainly has a satirical edge. Grant plays Michael Felgate, a New York auctioneer who is madly in love with Gina Vitale (Jeanne Tripplehorn). He finds an elaborate way of proposing marriage to her. It backfires, but when he does get around to asking her to marry him she breaks into tears and runs away.
Why? Mike finds out that she is part of a mafioso family. Most of her relatives have spent time in jail at some point in their lives and are still very much mobsters. Gina insists that shoe can't marry him because it will get him involved in her family's dealings. They do you one favor, she says, and you're indebted to them forever.
Eventually Gina gives in and the couple weds, but only after Michael solemnly swears that he will not get involved with her family. He does, of course. The mob scratches his back and he is forced to scratch back. They (Gina's father, played by James Caan, her uncle the mob boss portrayed by Burt Young and others played by Joe Viterelli and John Ventimiglia) get Michael involved in a money laundering scheme by making Michael auction off various paintings of theirs, making people that owe them money buy those paintings and making Michael hand over the money. This gets Michael in some trouble with the FBI who are wise to the mobsters' schemes.
Scripted by Adam Scheinman (Little Big League) and Robert Kuhn (The Cure, an underrated 1995 gem) and directed by Kids in the Hall veteran Kelly Makin, Mickey Blue Eyes is a tremendously funny movie. The jabs at the mafia are not as in-your-face as they were in Mafia! but they are twice as witty and twice as entertaining. A few, indeed, garnered none other than belly laughs from me, which took me by surprise because what I had expected least from this movie is the do-anything-for-a-laugh attitude it employed.
The highlight of this energetic romp has to be the brilliant, knee- slapping turn by the often humorless James Caan (Eraser). Everything he tries with his deadpan performance works and the result is comedy bliss. Hugh Grant is equally effective; he manages to be funny even though he is playing the same role he's played in countless movies. The only weak link in the cast is Jeanne Tripplehorn who manages to make her character bitchy for 99% of her screen time. Why would Hugh Grant want to marry her again?
It's a shame that the romance disappears for most of the middle portion of the film to make room for Michael's mafia antics. Funny as those may be, if this is the romantic comedy that Warner is oh-so-feverishly trying to promote, why not make the romance a central part of the picture? That worked so well in Notting Hill.
The ending of the movie is far too convenient and too cloying, but everything leadiing up to it is a comic delight. Affectionate, hilarious and light as a feather, Mickey Blue Eyes may not be the movie of the year but it's an entertaining -- if instantly forgettable -- diversion. ©1999 Eugene Novikov
Sent via Deja.com http://www.deja.com/ Share what you know. Learn what you don't.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Expat Journal
Tell your story
About Journaling
Journaling is a well established, proven tool for optimizing all your positive daily actions - effectively a 'secret sauce' for successful transitions.
In a world that is overpoweringly focused on 'input' - your Facebook feeds, your email inbox, your day to day work and social interactions, journaling is a place where you can focus on your own creative or developmental 'output' - what happened, and how you reacted. Ever better, it does so quietly, privately and independently, so you can use it whenever, wherever you are. It helps you to take a step back and identify what's important to you, where you want to see change, and where you can acknowledge the negative in your environment, interactions and responses, and explore changes that you want to make.
We develop Guided Journals to support your wellbeing, growth and development throughout your global journey, whether this is your first, fifth or final move. We know that journaling is a critical skill for those of us living in transition, helping us to navigate continents, cultures, and challenges successfully. Whether you choose the original Finding Home Abroad book or our new interactive mobile version, the questions and insights will simplify and open up the journaling process for you, guiding you as you explore your experiences and helping you to find clarity and build confidence in the unfamiliar. For those who regularly journal, those who have never journaled before, or those who want to help others through their global transitions, we're looking forward to meeting with you and sharing the power of journaling.
How it works
Let’s be honest: expat life can be tough. Although exciting, exhilarating and enriching, it can also be one of the greatest challenges you face. In this guided journal, you'll get the tools you need not just to survive, but to thrive, whether it's your first, fourth or final transition. Created by Trisha Carter, a Cross Cultural Psychologist, and Rachel Yates, Expat Consultant, this carefully crafted series of guided exercises will help you in find your feet, your tribe and ultimately, home. You already know that journaling is a powerful tool for change, and an essential practice for your expat transition. The trouble is, where to start? We've all been there.
Starting with a beautiful custom journaling toolkit, we follow up with a tailored series of prompts delivered to your inbox at a rate to suit you. The questions and insights encourage you to observe, (internally and externally), reflect, and embrace new perspectives, cross cultural skills and your personal experiences. They help you through the well-documented passages of highs and lows, anticipation, frustration, disillusionment, excitement, sense of accomplishment and moments of self doubt. The process of international relocation and transition is often described as a rollercoaster, and we help you stay positive, adapt successfully and cross cultures with clarity and confidence.
Start it now!
Discover how Expat Journals can help you support international transitions, with our range of client support resources. Finding Home Abroad uses guided journaling to encourage clients to improve their observations of the new world around them and become more aware of their responses. To access your toolkit, login now.


{% extends "scls/list_base.html" %} {% load i18n %} {% block title %}{% trans "My Collections" %}{% endblock %} {% block empty %}
You have not imported any collection matching the filter yet. You may want to import one.


Methods
base64URLEncodedStringToArray(base64) → {Uint8Array}
Utility method to convert a base64 URL encoded string
with a trailing '=' to an Uint8Array.
Note: libsodium expects keys to be Uint8Array objects.
Parameters:
| Name | Type | Description |
|---|---|---|
base64 |
string | URL encoded string with trailing '=' |
Returns:
Array of Uint8 integers
- Type
- Uint8Array
exportKeys() → {string}
Export a key pair to two base64 URL encoded strings.
Returns:
base64 URL encoded string with trailing '='
- Type
- string
getPrivateKey() → {string}
Get the base64 encoded string of the private key of the key pair.
Add a trailing '=' sign to make it URL-safe.
Returns:
base64 URL encoded string with trailing '='
- Type
- string
getPublicKey() → {string}
Get the base64 URL encoded string of the public key of the key pair.
Add a trailing '=' sign to make it URL-safe.
Returns:
base64 URL encoded string with trailing '='
- Type
- string
importKeys(public, private)
Method to set the key values for a public-private key pair
with base64 URL encoded strings with trailing '='s.
Note: this method overwrites the original keys in this object!
Parameters:
| Name | Type | Description |
|---|---|---|
public |
string | key: base64 URL encoded string with trailing '=' |
private |
string | key: base64 URL encoded string with trailing '=' |


MiePy ======= Python module to calcuate scattering coefficients of a plane wave incident on a sphere or core-shell structure using Mie theory


Hi! Unfortunately, this site is not the place to enter niceties.
Please check
Zulip
or contact the
faculty
for a link to the most recent Google Form.


Now that I use grunt, the JavaScript Task Runner my life has changed! It makes task automation so cool that it is a must have in every web project (and even sometime in other projects!). There’s also a great alternative called Gulp.js. It is probably better if you are starting, but because I am used to Grunt, I did not move to that fancy new tool yet.
Pelican automation
I searched pelican gruntfile on duckduckgo and found nothing very interesting. There is this grunt-pelican repo but it doesn’t seem to work right at the time of writing this article and its ReadMe is missing some code.
Because pelican is easy to use, I decided to make my own gruntfile instead! After around half an hour, I managed to get something interesting.
How to
First, create a package.json file to save dependencies using this command:
Then, install the fun stuff
Everything will be saved in your package.json, so next time you want to install them, you only have to run npm install. The package file will contain something like this:
The Gruntfile
Here’s my awesome Gruntfile.coffee:
Note: make sure you have pelican installed with pip install pelican. Replace gableroux with your own theme name (where your magic files are stored) and enjoy the Grunt awesomeness by running grunt in a terminal.
Here’s the jshintrc file I used:
And my coffeelint.json file:
Why coffeescript? Visit coffeescript’s website, click on “try coffeescript”, copy/paste my Gruntfile.coffee and see how it is easier to read in coffee. Consider this as syntax sugar, but when it comes to extending javascript classes, I really prefer using coffeescript.
The fun part
Now, when I write new content in markdown files, or when I edit my theme, my browser automagically refresh my website using LiveReload Chrome Extension on my second screen. Having a workflow updating like this lets me write quality content (can you confirm this?), instead of running a bunch of scripts manually every time only to fix a typo on a blog post.
Grunt rocks.
Enjoy
September 2015 edit
You should use Browser Sync instead, it’s even more awesome!