Pair of assertions to testing elements in the HTML output of the response.
Identical to assert_tag, but asserts that a matching tag does not exist. (See assert_tag for a full discussion of the syntax.)
Examples
# Assert that there is not a "div" containing a "p" assert_no_tag :tag => "div", :descendant => { :tag => "p" } # Assert that an unordered list is empty assert_no_tag :tag => "ul", :descendant => { :tag => "li" } # Assert that there is not a "p" tag with between 1 to 3 "img" tags # as immediate children assert_no_tag :tag => "p", :children => { :count => 1..3, :only => { :tag => "img" } }
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/assertions/tag_assertions.rb, line 118 118: def assert_no_tag(*opts) 119: clean_backtrace do 120: opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first 121: tag = find_tag(opts) 122: assert !tag, "expected no tag, but found tag matching #{opts.inspect}<EMAIL_ADDRESS>123: end 124: end
Asserts that there is a tag/node/element in the body of the response that meets all of the given conditions. The conditions parameter must be a hash of any of the following keys (all are optional):
- :tag: the node type must match the corresponding value
- :attributes: a hash. The node‘s attributes must match the corresponding values in the hash.
- :parent: a hash. The node‘s parent must match the corresponding hash.
- :child: a hash. At least one of the node‘s immediate children must meet the criteria described by the hash.
- :ancestor: a hash. At least one of the node‘s ancestors must meet the criteria described by the hash.
- :descendant: a hash. At least one of the node‘s descendants must meet the criteria described by the hash.
- :sibling: a hash. At least one of the node‘s siblings must meet the criteria described by the hash.
- :after: a hash. The node must be after any sibling meeting the criteria described by the hash, and at least one sibling must match.
- :before: a hash. The node must be before any sibling meeting the criteria described by the hash, and at least one sibling must match.
- :children: a hash, for counting children of a node. Accepts the
keys:
- :count: either a number or a range which must equal (or include) the number of children that match.
- :less_than: the number of matching children must be less than this number.
- :greater_than: the number of matching children must be greater than this number.
- :only: another hash consisting of the keys to use to match on the children, and only matching children will be counted.
- :content: the textual content of the node must match the given value. This will not match HTML tags in the body of a tag—only text.
Conditions are matched using the following algorithm:
- if the condition is a string, it must be a substring of the value.
- if the condition is a regexp, it must match the value.
- if the condition is a number, the value must match number.to_s.
- if the condition is true, the value must not be nil.
- if the condition is false or nil, the value must be nil.
Examples
# Assert that there is a "span" tag assert_tag :tag => "span" # Assert that there is a "span" tag with id="x" assert_tag :tag => "span", :attributes => { :id => "x" } # Assert that there is a "span" tag using the short-hand assert_tag :span # Assert that there is a "span" tag with id="x" using the short-hand assert_tag :span, :attributes => { :id => "x" } # Assert that there is a "span" inside of a "div" assert_tag :tag => "span", :parent => { :tag => "div" } # Assert that there is a "span" somewhere inside a table assert_tag :tag => "span", :ancestor => { :tag => "table" } # Assert that there is a "span" with at least one "em" child assert_tag :tag => "span", :child => { :tag => "em" } # Assert that there is a "span" containing a (possibly nested) # "strong" tag. assert_tag :tag => "span", :descendant => { :tag => "strong" } # Assert that there is a "span" containing between 2 and 4 "em" tags # as immediate children assert_tag :tag => "span", :children => { :count => 2..4, :only => { :tag => "em" } } # Get funky: assert that there is a "div", with an "ul" ancestor # and an "li" parent (with "class" = "enum"), and containing a # "span" descendant that contains text matching /hello world/ assert_tag :tag => "div", :ancestor => { :tag => "ul" }, :parent => { :tag => "li", :attributes => { :class => "enum" } }, :descendant => { :tag => "span", :child => /hello world/ }
Please note: assert_tag and assert_no_tag only work with well-formed XHTML. They recognize a few tags as implicitly self-closing (like br and hr and such) but will not work correctly with tags that allow optional closing tags (p, li, td). You must explicitly close all of your tags to use these assertions.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/assertions/tag_assertions.rb, line 96 96: def assert_tag(*opts) 97: clean_backtrace do 98: opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first 99: tag = find_tag(opts) 100: assert tag, "expected tag, but no tag found matching #{opts.inspect}<EMAIL_ADDRESS>101: end 102: end


SheetJS Data Preview Live Demo x-spreadsheet component library Source Code Repo Issues? Something look weird? Click here and report an issue Drop a spreadsheet file here to see sheet data ... or click here to select a file ... or paste a base64-encoding here


Santa Clara County ARES/RACES PackItForms
PIF: 2.1
User Call Sign:
User Name:
Message ID Prefix:
(3 characters max)
Use Tactical Call Sign
Tactical Call Sign:
Tactical Name:
Message ID Prefix:
(3 characters max)
Next Message Number:
Cancel


ILNativeType
Namespace: Microsoft.FSharp.Compiler.AbstractIL
Parent Module: IL
Native Types, for marshalling to the native C interface. These are taken directly from the ILASM syntax, see ECMA Spec (Partition II, 7.4).
Namespace: Microsoft.FSharp.Compiler.AbstractIL
Parent Module: IL
Native Types, for marshalling to the native C interface. These are taken directly from the ILASM syntax, see ECMA Spec (Partition II, 7.4).


The body mass index (BMI) is an international measure used to calculate whether a person is at the ideal weight. Developed by the polymath Lambert Quételet at the end of the 19th century, it is an easy and quick method for assessing the level of fat in each person, and is therefore an international predictor of obesity adopted by the World Health Organization (WHO).
What to do to improve BMI? To improve BMI it is important to check whether it is above or below what is considered normal. When the BMI is in the thin range, it is important to consult the nutritionist so that, in addition to making a complete assessment, an eating plan that focuses on weight gain in a healthy way is indicated.
On the other hand, when the BMI is in the range of overweight or obesity, it can be indicated by the nutritionist to perform a diet with more caloric restriction, in addition to the practice of regular physical activity, as it is possible to speed up the metabolism and favor weight loss, which directly influences BMI.
Fonts: tuasaude.com, wikipedia.org


--- layout: post title: "To log or not to log" description: "There's no reason to make logging any harder than it has to be. Here's a compositional approach in F#." date: 2015-11-30 8:45 UTC tags: [F#] --- {% include JB/setup %}
{{ page.description }}
Logging seems to be one of those cross-cutting concerns on which people tend to spend a lot of effort. For programmers coming from an object-oriented language like C#, finding a sane approach to logging seems to be particularly difficult.
In my book about Dependency Injection, I made an effort to explain that logging and other cross-cutting concerns are best addressed by Decorators (or dynamic interception). You can use the same design with F# functions.
Consider, as an example, an HTTP API for a restaurant booking system. This example is taken from my Test-Driven Development with F# Pluralsight course, but you can see an almost identical example for free in this recording of a BuildStuff talk.
The application is composed of small, mostly pure functions:
let imp = Validate.reservationValid >> Rop.bind (Capacity.check 10 SqlGateway.getReservedSeats) >> Rop.map SqlGateway.saveReservation
Exactly what each function does isn't important in this context, but here are the types involved:
| Function | Type |
|---|---|
| imp | ReservationRendition -> Rop.Result<unit, Error> |
| Validate.reservationValid | ReservationRendition -> Rop.Result<Reservation, Error> |
| Capacity.check | int -> (DateTimeOffset -> int) -> Reservation -> Rop.Result<Reservation, Error> |
| SqlGateway.saveReservation | Reservation -> unit |
In short, the imp
function validates the input, applies some business rules if the input was valid, and saves the reservation to a database if the business rules allow it.
I strongly believe that in any well-designed code base, the core implementation should be independent of cross-cutting concerns such as logging. If the above reservation system is well-designed, it should be possible to retrofit logging onto it without changing the existing functions. Indeed, that turns out to be possible.
You should use an existing logging library such as Serilog, log4net, NLog, etc. instead of rolling your own. In this example, imagine that you're using the well-known SomeExternalLoggingLibrary. In order to protect yourself against changes etc. in the external library, you first define your own, application-specific logging module:
module BookingLog = let logError = SomeExternalLoggingLibrary.logError let logInformation = SomeExternalLoggingLibrary.logInformation
Both functions have the type fileName:string -> msg:string -> unit
.
As a beginning, you can start by logging the final result of executing the imp
function. Since it has the type ReservationRendition -> Rop.Result<unit, Error>
, if you implement a log function that both accepts and returns Rop.Result<unit, Error>
, you can append that to the composition of imp
. Start with the logging function itself:
module BookingLog = // ... let logReservationsPost logFile result = match result with | Failure(ValidationError msg) -> logError logFile msg | Failure CapacityExceeded -> logError logFile "Capacity exceeded." | Success () -> logInformation logFile "Reservation saved." result
This function has the type string -> Rop.Result<unit, Error> -> Rop.Result<unit, Error>
. It matches on the cases of result
and logs something relevant for each case; then it returns result
without modifying it.
Since the logReservationsPost function both accepts and returns the same type, you can easily append it to the other functions while composing imp
:
let imp = Validate.reservationValid >> Rop.bind (Capacity.check 10 SqlGateway.getReservedSeats) >> Rop.map SqlGateway.saveReservation >> BookingLog.logReservationsPost logFile
Notice how BookingLog.logReservationsPost is simply added as the last line of composition. This compiles because that function returns its input.
Running the application with various input demonstrates that logging works as intended:
Information: Reservation saved. Error: Invalid date. Information: Reservation saved. Error: Capacity exceeded.
You've seen that you can append high-level logging of the final value, but can you also add logging deeper in the guts of the implementation?
Imagine that you need to also log what happens before and after Capacity.check is called. One option is to add a logging function with the same type as Capacity.check, that also Decorates Capacity.check, but I think it's simpler to add two functions that log the values before and after Capacity.check.
The type of Capacity.check is int -> (DateTimeOffset -> int) -> Reservation -> Rop.Result<Reservation, Error>
, but after partial application, it's only Reservation -> Rop.Result<Reservation, Error>
. In order to log what happens before Capacity.check is called, you can add a function that both accepts and returns a Reservation:
let logBeforeCapacityCheck logFile reservation = logInformation logFile (sprintf "Checking capacity for %s..." (reservation.Date.ToString "d")) reservation
This function has the type string -> Reservation -> Reservation
, and is placed within the BookingLog module. The logInformation function is used to log the input, which is then returned.
Likewise, you can also log what happens after Capacity.check is invoked. Since Capacity.check returns Rop.Result<Reservation, Error>, your log file must take that type as both input and output:
let logAfterCapacityCheck logFile result = match result with | Failure(ValidationError msg) -> logError logFile msg | Failure CapacityExceeded -> logError logFile (sprintf "Capacity exceeded.") | Success r -> logInformation logFile (sprintf "All is good for %s." (r.Date.ToString "d")) result
The logAfterCapacityCheck function has the type string -> Rop.Result<Reservation, Error> -> Rop.Result<Reservation, Error>
, and is also placed within the BookingLog module. Like the logReservationsPost function, it matches on result
and logs accordingly; then it returns result
. Do you see a pattern?
Because of these types, you can compose them into imp
:
let imp = Validate.reservationValid >> Rop.map (BookingLog.logBeforeCapacityCheck logFile) >> Rop.bind (Capacity.check 10 SqlGateway.getReservedSeats) >> BookingLog.logAfterCapacityCheck logFile >> Rop.map SqlGateway.saveReservation >> BookingLog.logReservationsPost logFile
Notice that BookingLog.logBeforeCapacityCheck and BookingLog.logAfterCapacityCheck are composed around Capacity.check. The final BookingLog.logReservationsPost is also still in effect. Running the application shows that logging still works:
Information: Checking capacity for 27.11.2015... Information: All is good for 27.11.2015. Information: Reservation saved.
The first two log entries are created by the logs around Capacity.check, whereas the last line is written by BookingLog.logReservationsPost.
Some programmers are concerned about the performance implications of logging. You may wish to be able to control whether or not to log.
The easiest way to do that is to make logging itself conditional:
let logError fileName msg = if log then SomeExternalLoggingLibrary.logError fileName msg else () let logInformation fileName msg = if log then SomeExternalLoggingLibrary.logInformation fileName msg else ()
where log
is a boolean value. If log
is false, the above two functions simply return ()
(unit) without doing anything. This prevents costly IO from happening, so may already be enough of a performance optimisation. As always when performance is the topic: don't assume anything; measure.
In reality, you probably want to use more granular flags than a single log
flag, so that you can control informational logging independently from error logging, but I'm sure you get the overall idea.
Even with boolean flags, you may be concerned that logging adds overhead even when the log
flag is false. After all, you still have a function like logBeforeCapacityCheck above: it uses sprintf to format a string, and that may still be too much if it happens too often (again: measure).
For the sake of argument, imagine that you've measured the cost of leaving the logging functions logReservationsPost, logBeforeCapacityCheck, and logAfterCapacityCheck in place when log
is false, and that you find that you'll need to turn them off in production. That's not a problem. Recall that before you added these functions, the application worked fine without logging. You compose these functions into imp
in order to add logging, but you don't have to. You can even make this decision at compile time:
let imp = Validate.reservationValid #if LOG >> Rop.map (BookingLog.logBeforeCapacityCheck logFile) #endif >> Rop.bind (Capacity.check 10 SqlGateway.getReservedSeats) #if LOG >> BookingLog.logAfterCapacityCheck logFile #endif >> Rop.map SqlGateway.saveReservation #if LOG >> BookingLog.logReservationsPost logFile #endif
Notice the presence of the conditional compilation flag LOG
. Only if the application is compiled with the LOG
flag will the logging code be compiled into the application; otherwise, it runs without any logging overhead at all.
Personally, I've never needed to control logging at this level, so this isn't a recommendation; it's only a demonstration that it's possible. What's much more important to me is that everything you've seen here has required zero changes of the application code. The only code being modified is the Composition Root, and I regard the Composition Root as a configuration file.
In a well-designed application, you should be able to append logging without impacting the core implementation. You can do that by taking a Decorator-like approach to logging, even in a Functional application. Due to the compositional nature of a well-designed code base, you can simply slide log functions in where you need them.
Even if you're concerned about the performance implications of logging, there are various ways by which you can easily turn off logging overhead if you don't need it. Only do this if you've measured the performance of your application and found that you need to do so. The point is that if you design the application to be composed from small functions, you can always fine-tune logging performance if you need to. You don't have to do a lot of up-front design to cater specifically to logging, though.
In my examples, I deliberately kept things crude in order to make it clear how to approach the problem, but I'm sure Scott Wlaschin could teach us how to refactor such code to a sophisticated monadic design.
It should also be noted that the approach outlined here leverages F#'s support for impure functions. All the log functions shown here return unit, which is a strong indicator of side-effects. In Haskell, logging would have to happen in an IO context, but that wouldn't impact the overall approach. The boundary of a Haskell application is an IO context, and the Composition Root belongs there.
Comments
It's implicit in these strategies that "application-specific logging module" will be a singleton, right? Otherwise, it would be necessary to pass a logger instance into every method.
In a multi-threaded context, this will result in all logs going to the same destination, with potential for jumbles if multiple threads are executing simultaneously, relatively unpredictable results if execution flows through multiple threads, etc.
I've never been able to come up with a way around the "jumble" problem other than passing a logger in every function call (or, when using OOP, giving every class a Logger property). But having every function take a "logger" parameter is not ideal either, for obvious reasons.
Do you have any thoughts on how to allow logging to be specific to each flow of execution, other than generating a logger at the entry point and passing it as a parameter to everything?
Ben, thank you for writing. It's not at all implicit that Singletons are involved. This article discusses a semi-functional design where there's no objects, just functions. It seems, however, that some of your concerns relate to object-oriented design.
In object-oriented design, I recommend modelling logging and other cross-cutting concerns as applications of the Decorator or Chain of Responsibility design patterns. As mentioned in this article, I discuss this in my book, but this blog also contains an example of this, although it's about instrumentation instead of logging. These two cross-cutting concerns are closely related in structure, though, so I hope you still find it informative. Such an approach to design eliminates the need for passing
log
dependencies around in business logic and other places where it doesn't belong.The way I've seen people address the problem with multi-threaded logging is to have a logger object per thread (or, safer this day, per HTTP request, or similar). This object simply collects all log data in memory until flushed. Some designs require client developers to explicitly call a
Flush
method, but typically you can automate this so that it happens automatically when the thread or HTTP context is disposed of.When
Flush
is called, the infrastructure writes the entire log message to a queue. This can happen concurrently, but then you have a single-threaded subscriber on that queue that handles each message one at a time. This serialises the log messages, and you avoid interleaving of data.


A binding is an association between a name and that which the name denotes. Bindings are established in a lexical environment or a dynamic environment by particular special operators.
An environment is a set of bindings and other information used during evaluation (e.g., to associate meanings with names).
Bindings in an environment are partitioned into namespaces. A single name can simultaneously have more than one associated binding per environment, but can have only one associated binding per namespace.
<IP_ADDRESS> The Global Environment


1 reference to InternalState
System.Management.Automation (1)
engine\CommandBase.cs (1)
435
return this.
InternalState
;


%matplotlib inline
from __future__ import print_function
import pandas as pd
import matplotlib.pyplot as plt
import statsmodels.api as sm
dta = sm.datasets.macrodata.load_pandas().data
index = pd.Index(sm.tsa.datetools.dates_from_range('1959Q1', '2009Q3'))
print(index)
dta.index = index
del dta['year']
del dta['quarter']
print(sm.datasets.macrodata.NOTE)
print(dta.head(10))
fig = plt.figure(figsize=(12,8))
ax = fig.add_subplot(111)
dta.realgdp.plot(ax=ax);
legend = ax.legend(loc = 'upper left');
legend.prop.set_size(20);
The Hodrick-Prescott filter separates a time-series $y_t$ into a trend $\tau_t$ and a cyclical component $\zeta_t$
$$y_t = \tau_t + \zeta_t$$The components are determined by minimizing the following quadratic loss function
$$\min_{\\{ \tau_{t}\\} }\sum_{t}^{T}\zeta_{t}^{2}+\lambda\sum_{t=1}^{T}\left[\left(\tau_{t}-\tau_{t-1}\right)-\left(\tau_{t-1}-\tau_{t-2}\right)\right]^{2}$$gdp_cycle, gdp_trend = sm.tsa.filters.hpfilter(dta.realgdp)
gdp_decomp = dta[['realgdp']].copy()
gdp_decomp["cycle"] = gdp_cycle
gdp_decomp["trend"] = gdp_trend
fig = plt.figure(figsize=(12,8))
ax = fig.add_subplot(111)
gdp_decomp[["realgdp", "trend"]]["2000-03-31":].plot(ax=ax, fontsize=16);
legend = ax.get_legend()
legend.prop.set_size(20);
The Baxter-King filter is intended to explictly deal with the periodicty of the business cycle. By applying their band-pass filter to a series, they produce a new series that does not contain fluctuations at higher or lower than those of the business cycle. Specifically, the BK filter takes the form of a symmetric moving average
$$y_{t}^{*}=\sum_{k=-K}^{k=K}a_ky_{t-k}$$where $a_{-k}=a_k$ and $\sum_{k=-k}^{K}a_k=0$ to eliminate any trend in the series and render it stationary if the series is I(1) or I(2).
For completeness, the filter weights are determined as follows
$$a_{j} = B_{j}+\theta\text{ for }j=0,\pm1,\pm2,\dots,\pm K$$$$B_{0} = \frac{\left(\omega_{2}-\omega_{1}\right)}{\pi}$$$$B_{j} = \frac{1}{\pi j}\left(\sin\left(\omega_{2}j\right)-\sin\left(\omega_{1}j\right)\right)\text{ for }j=0,\pm1,\pm2,\dots,\pm K$$where $\theta$ is a normalizing constant such that the weights sum to zero.
$$\theta=\frac{-\sum_{j=-K^{K}b_{j}}}{2K+1}$$$$\omega_{1}=\frac{2\pi}{P_{H}}$$$$\omega_{2}=\frac{2\pi}{P_{L}}$$$P_L$ and $P_H$ are the periodicity of the low and high cut-off frequencies. Following Burns and Mitchell's work on US business cycles which suggests cycles last from 1.5 to 8 years, we use $P_L=6$ and $P_H=32$ by default.
bk_cycles = sm.tsa.filters.bkfilter(dta[["infl","unemp"]])
fig = plt.figure(figsize=(12,10))
ax = fig.add_subplot(111)
bk_cycles.plot(ax=ax, style=['r--', 'b-']);
The Christiano-Fitzgerald filter is a generalization of BK and can thus also be seen as weighted moving average. However, the CF filter is asymmetric about $t$ as well as using the entire series. The implementation of their filter involves the calculations of the weights in
$$y_{t}^{*}=B_{0}y_{t}+B_{1}y_{t+1}+\dots+B_{T-1-t}y_{T-1}+\tilde B_{T-t}y_{T}+B_{1}y_{t-1}+\dots+B_{t-2}y_{2}+\tilde B_{t-1}y_{1}$$for $t=3,4,...,T-2$, where
$$B_{j} = \frac{\sin(jb)-\sin(ja)}{\pi j},j\geq1$$$$B_{0} = \frac{b-a}{\pi},a=\frac{2\pi}{P_{u}},b=\frac{2\pi}{P_{L}}$$$\tilde B_{T-t}$ and $\tilde B_{t-1}$ are linear functions of the $B_{j}$'s, and the values for $t=1,2,T-1,$ and $T$ are also calculated in much the same way. $P_{U}$ and $P_{L}$ are as described above with the same interpretation.
The CF filter is appropriate for series that may follow a random walk.
print(sm.tsa.stattools.adfuller(dta['unemp'])[:3])
print(sm.tsa.stattools.adfuller(dta['infl'])[:3])
cf_cycles, cf_trend = sm.tsa.filters.cffilter(dta[["infl","unemp"]])
print(cf_cycles.head(10))
fig = plt.figure(figsize=(14,10))
ax = fig.add_subplot(111)
cf_cycles.plot(ax=ax, style=['r--','b-']);
Filtering assumes a priori that business cycles exist. Due to this assumption, many macroeconomic models seek to create models that match the shape of impulse response functions rather than replicating properties of filtered series. See VAR notebook.


 PLEASE MODIFY THE ORIGINAL SOURCE IN THE 'https://github.com/istio/istio' REPO source_repo: https://github.com/istio/istio title: operator description: The Istio operator. generator: pkg-collateral-docs number_of_entries: 4 max_toc_level: 2 remove_toc_prefix: 'operator ' ---
The Istio operator.
| Flags | Description |
|---|---|
--kubeconfig <string> |
Paths to a kubeconfig. Only required if out-of-cluster. (default ``) |
--master <--kubeconfig> |
(Deprecated: switch to --kubeconfig) The address of the Kubernetes API server. Overrides any value in kubeconfig. Only required if out-of-cluster. (default ``) |
Starts the Istio operator server
operator server [flags]
| Flags | Description |
|---|---|
--base-chart-path <string> |
The absolute path to a directory containing nested charts, e.g. /etc/istio-operator/helm. This will be used as the base path for any IstioControlPlane instances specifying a relative ChartPath. (default ``) |
--ctrlz_address <string> |
The IP Address to listen on for the ControlZ introspection facility. Use '*' to indicate all addresses. (default `localhost`) |
--ctrlz_port <uint16> |
The IP port to use for the ControlZ introspection facility (default `9876`) |
--default-chart-path <string> |
A path relative to base-chart-path containing charts to be used when no ChartPath is specified by an IstioControlPlane resource, e.g. 1.1.0/istio (default ``) |
--kubeconfig <string> |
Paths to a kubeconfig. Only required if out-of-cluster. (default ``) |
--log_as_json |
Whether to format output as JSON or in plain console-friendly format |
--log_caller <string> |
Comma-separated list of scopes for which to include caller information, scopes can be any of [all, default, patch, tpath, translator, util, validation] (default ``) |
--log_output_level <string> |
Comma-separated minimum per-scope logging level of messages to output, in the form of <scope>:<level>,<scope>:<level>,... where scope can be one of [all, default, patch, tpath, translator, util, validation] and level can be one of [debug, info, warn, error, fatal, none] (default `default:info`) |
--log_rotate <string> |
The path for the optional rotating log file (default ``) |
--log_rotate_max_age <int> |
The maximum age in days of a log file beyond which the file is rotated (0 indicates no limit) (default `30`) |
--log_rotate_max_backups <int> |
The maximum number of log file backups to keep before older files are deleted (0 indicates no limit) (default `1000`) |
--log_rotate_max_size <int> |
The maximum size in megabytes of a log file beyond which the file is rotated (default `104857600`) |
--log_stacktrace_level <string> |
Comma-separated minimum per-scope logging level at which stack traces are captured, in the form of <scope>:<level>,<scope:level>,... where scope can be one of [all, default, patch, tpath, translator, util, validation] and level can be one of [debug, info, warn, error, fatal, none] (default `default:none`) |
--log_target <stringArray> |
The set of paths where to output the log. This can be any path as well as the special values stdout and stderr (default `[stdout]`) |
--master <--kubeconfig> |
(Deprecated: switch to --kubeconfig) The address of the Kubernetes API server. Overrides any value in kubeconfig. Only required if out-of-cluster. (default ``) |
Prints out build version information
operator version [flags]
| Flags | Shorthand | Description |
|---|---|---|
--kubeconfig <string> |
Paths to a kubeconfig. Only required if out-of-cluster. (default ``) | |
--master <--kubeconfig> |
(Deprecated: switch to --kubeconfig) The address of the Kubernetes API server. Overrides any value in kubeconfig. Only required if out-of-cluster. (default ``) | |
--output <string> |
-o |
One of 'yaml' or 'json'. (default ``) |
--short |
-s |
Use --short=false to generate full version information |
| Metric Name | Type | Description |
|---|---|---|
istio_build | LastValue | Istio component build info |


Healthify
Download App
Healthify for Doctors
Login/Sign Up
Profile
Medical Details
Work
My Health Cart
Address
{{Address}}
Age
{{Age}}
Email
{{Email}}
Gender
{{Gender}}
Date Of Birth
{{DOB}}
Blood Group
Occupation
{{Occupation}}
Height
{{Height}}
weight
{{weight}}
Body Mass Index
{{BMI}}
Known Allergies
{{Allergies}}
Mediclaim
Mediclaim ID
{{Mediclaim_ID}}
Menu 2
Some content in menu 2.


most path/to/file- Open several files:
most path/to/file1 path/to/file2- Open a file at the first occurrence of "string":
most path/to/file +/string- Move through opened files:
:O n- Jump to the 100th line:
100j- Edit current file:
e- Split the current window in half:
- Exit:o
Q


APRILE A film review by Steve Rhodes Copyright 2000 Steve Rhodes RATING (0 TO ****): **
Set against the backdrop of a change in the Italian government and of the birth of his son, Nanni Moretti's APRILE stars himself as a neurotic filmmaker. Moretti can best be thought of as an Italian Woody Allen.
Where the two directors differ is that Moretti seems so constantly and incurably happy that it is hard to take his complaints seriously. (I once found myself teaching an overcrowded course at Berkeley, so I warned my students on the first day how tough I would be and suggested that they take the less crowded section that followed mine. I was astonished to find the class just as full on the second day. As the students told me later, they didn't believe me because I was too nice. So it is with Moretti, which takes much of the sting out of his caustic comedy.)
Some of the film's most endearing images are those of Moretti with his infant son. As the baby wails, Moretti doesn't know what to do. A mother can supply milk to quiet the child, but a father has no such weapon in his arsenal. What he can do, Moretti figures, is promise material goods. "Don't cry like that," he tells his son. "I'll buy you a scooter the moment you turn 14."
Among the many scenes that don't work is one involving a bowl of pasta that doesn't appear hot. One of Moretti's assistants on the documentary tries to blow cigarette smoke over the pasta, but it looks fake. Much of the movie's humor comes across as cold as the pasta.
Part of the film's humor surrounds Moretti's insecurity. He worries that his documentaries will not let him say what he wants to say. He is even more concerned that he doesn't have anything to say in the first place.
Another theme is his procrastination. An obsessive letter writer about the political situation in Italy, he never gets around to sending these missives. He decides instead to take them to Hyde Park in London. There, among a group of noisy preachers, he reads his letters in Italian to a quizzical crowd.
As the frustrated Moretti films his documentary, his mind strays to the film he really wants to be making instead -- a colorful musical set in the 1950s about a Trotskyite chef. At the end of APRILE, we get to watch a little bit of this fun little farce being filmed. This is the movie that I wish he had made rather than APRILE.
Although APRILE may find resonance among Italians, much of its humor went past this American. It may be that understanding the nuances of the Italian political parties would have helped. Or perhaps Moretti is simply an acquired taste.
APRILE runs 1:18. The movie is in Italian with English subtitles. It is not rated but might be PG-13 for some language and one brief scene of pot smoking and would be acceptable for kids around 11 and up.
The film will be playing as part of the San Francisco International Film Festival (http://www.sfiff.org), which runs April 20 to May 4, 2000. It does not have a United States distributor.
Email<EMAIL_ADDRESS>Web: http://www.InternetReviews.com
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


In the following section, we will create one job per each file to transform the data from csv, tsv, xls (typical input formats) to parquet.
We will place this data under the folder named “curated” in the data lake.
This step needs to be done per each file you have.
import sys
import datetime
import re
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
glueContext = GlueContext(SparkContext.getOrCreate())
job = Job(glueContext)
## DONT FORGET TO PUT IN YOUR INPUT AND OUTPUT LOCATIONS BELOW.
your_database_name = "YOUR-DATABASE-NAME"
your_table_name = "YOUR-TABLE-NAME"
output_location = "s3://YOUR-BUCKET-NAME/curated/YOUR-TABLE-NAME"
job.init("byod-workshop" + str(datetime.datetime.now().timestamp()))
#load our data from the catalog that we created with a crawler
dynamicF = glueContext.create_dynamic_frame.from_catalog(
database = your_database_name,
table_name = your_table_name,
transformation_ctx = "dynamicF")
# invalid characters in column names are replaced by _
df = dynamicF.toDF()
def canonical(x): return re.sub("[ ,;{}()\n\t=]+", '_', x.lower())
renamed_cols = [canonical(c) for c in df.columns]
df = df.toDF(*renamed_cols)
# write our dataframe in parquet format to an output s3 bucket
df.write.mode("overwrite").format("parquet").save(output_location)
job.commit()
Notice that we have a section in this script where we are replacing invalid characters that you may have in your column headers. Spark doesn’t accept certain characters in field names including spaces.
Click * Save, then Run Job
Check the status of the job by selecting the job and go to history tab in the lower panel. In order to continue we need to wait until this job is done, this can take around 5 minutes (and up to 10 minutes to start), depending on the size of your dataset.
To make sure the job transformed the data:
You will need to create a similar job for each table you have.


Each year Apple organizes a conference for their third party platform developers. The conference is called WWDC (world wide developers conference) and takes place in California, USA. Although the tickets are extremly expensive (1,599$ each) it is almost impossible to get the chance to buy one due to the mass of people who try their luck.
The conference is all about the software; Apple uses the opening keynote to introduce the new major versions of their platform operating systems, iOS and macOS. The rest of the week there are a ton of talks given by Apple employees plus labs where you can talk one to one to the developers who build the SDKs and tools you use every day.
Attending WWDC is propably every iOS/macOS developer’s dream and so it is mine. Fortunately, Apple has a special treatment for pupils, students and members of STEM organizations. Last year I send an application for a scholarship which would have allowed me to visit the conference for free. Unfortunately, I did not win the scholarship but my friend Kilian did which made me happy as well.
Instead of visiting WWDC I had the great opportunity to attend AltConf which was taking place in San Francisco during the time of WWDC last year. I am incredible happy about the chance I got. Being in San Francisco during a time where thousands of people around you who love the same things as you do is awesome. I collected a ton of invaluable experiences and met a lot of very interesting people. Some of them I am very proud to call my friends.
Although AltConf was really interesting and definitely worth the visit it was kind of sad to see all the people with badges go into the toward building each morning.
Later in October last year I started my master studies which means I am still a student and able to apply for a scholarship again. Having my experiences from last year in mind it was clear that I needed to try my luck. The only problems I had were the financial load of buying a plane ticket to the most expensive place in the world and staying there for the week. This is still a problem but it is one which I try to figure out if I get the chance to.
And that brings me to the original intend of this blog post: I am extremely proud to present you the project I built as an application for this year’s WWDC scholarship. The task was to build some visually interactive scene using Swift Playgrounds, a part of Xcode and seperate app on iPad. There are literally infinite possibilities which makes it really hard to get the right idea. When Swift was firstly announced Chris Lattner (the inventor of Swift) built a SpriteKit scene in Playgrounds. That was very impressive and so my first thought was to build a graphical scene as well. But it turns out that graphical three dimensional scenes are not my biggest strength.
If you started reading this blog from the beginning you may know that I like to overthink complex problems and learn new things. You may also have read that I wanted to build my own compiler for a new programming language, lbd. Having this in mind I came to the conclusion that the Playground itself is the best interactive scene I know. So I started implementing my own.
Due to security reasons it is not possible to write, compile and run binaries inside iOS apps. But it is possible to evaluate Javascript using a framework called JavaScriptCore! That is it!
I built a lexer, parser, abstract syntax tree and a Javascript generator plus some user interface and a small wrapper around JavaScriptCore. The result is pretty impressive (especially for 2-3 days of work) and I am very proud about it. Today I would like to open source the repository to be open for contributions and the possibility for others to learn.
I do not think that this project will stay as a weekend hackathon project but will grow in the future. The potential is literally endless because it is not possible for me to implement all features that a team of professionals at Apple creates. And that it is totally okay! The app is not meant to replace something; it is just an addition to try out the language on the go.
If you would like to pre-alpha test the app send me a direct message on Twitter. Feel also free to check out the repository on Github! Thanks for reading this blog post, I am really thrilled about the future! Wish me luck for the scholarship lottery, announcement is on April 21.
PS: The name is inspired by this great episode of Rick and Morty:


The problem was I had to capitalize each letter of each word in an array. I felt quite confused as to go about the issue. I broke the problem down into steps writing out psuedocode. Then I could ask the right questions for each step that I was facing. Then I looked around the web for additional info. and eventually managed to solve the the problem.
The problem was where I had to look through an array and if the person hiding was Scooby then say what door he was behind. Almost immediatley in my head I could work out what to do. But I still wrote out the steps to sort through the problem just so I was clear with myself. I had to loop through the array check each object in that array's hiding property and if that property was equal to the string of Scooby then it should return that same objects door number. Then the function had to break, but if it wasn't scooby then it would keep on looping till it found the hiding property with the value of scooby.
-
Pseudocode:
I feel very confident using this method. It seems to help me the most, in terms of breaking down a problem into it's individual steps. -
Trying something:
I always almost do this first to see if I really grasp the problem. If not I use another probem solving technique. -
Rubber ducky method:
I usually talk to myself rather than an object but I feel a little confident doing this. -
Reading error messages:
I find these somewhat usefull, and usually I feel confident reading them. Depends on the diffuclty of the problem. -
Console.logging:
I actually quite like using concole.log to give me an idea of what some variable or object might look like after a certain step. -
Googling:
Propably the top of my list with this, there is so much stuff that other people have already faced that you can google. -
Asking your peers for help:
Not so confident in this one yet, although it is only now that I have really considered doing this as the challeges go on and get harder. -
Asking coaches for help:
This falls under the same as asking my peers, basically just asking the slack cahnnel. Not super confident about but also will actually consider asking there if I'm really stuck. -
Improving your process with reflection:
This is something I have not really done before/ couldn't be bothered doing before, but I think it has had great impact. It's really helped me vocalise the thoughts in my head, and also made me really think back on the challenges I've faced.


Last updated: December 4, 2019
When you sign up for Userbase, we ask for your full legal name, email address, and password. That's just so you can login to your account, use the features of Userbase, and for us to send you invoices, updates, or other essential information. We will never sell your information to third parties, and we won’t use your name in marketing statements without your permission.
You always have the right to access the personal information we store about you. And, if you wish to further limit our use of your personal information, please contact Daniel Vassallo at<EMAIL_ADDRESS>Users of Userbase can store any type of information in Userbase, but we do not access or share that data, and do not know what type of data you or other users are storing.
When you pay for Userbase, we ask for your credit card and billing address. That's so we can charge you for the service, calculate taxes due, and send you invoices. Your credit card is passed directly to our payment processor (Stripe) and doesn't ever go through our servers. We store a record of the payment transaction for account history, invoicing, and billing support. We store your billing address to calculate any sales tax due in the United States, to detect fraudulent credit card transactions, and to print on your invoices.
When you contact Userbase with a question or to ask for help, we will keep that correspondence and the email address for future reference. When you browse our website and marketing pages, we may track that for statistical purposes (like conversion rates and to test new designs). We also store any information you volunteer, like surveys, for as long as it makes sense.
The only times we’ll ever share your info:
You may have heard about the General Data Protection Regulation ("GDPR") in Europe. GDPR gives people under its protection certain rights with respect to their personal information collected by us from this website. Accordingly, Userbase recognizes and will comply with GDPR. Your rights under GDPR include:
Many of these rights can be exercised by signing in and directly updating your account information. If you have questions about exercising these rights or need assistance, please contact us at<EMAIL_ADDRESS>As part of the services we provide, and only to the extent necessary, we may use certain third party processors to process some or all of your personal information. For identification of these processors, and where they are located, please see our subprocessor listing. We have signed appropriate data processing contracts that comply with GDPR with each processor.
Userbase won’t hand your data over to law enforcement unless a court order says we have to. We flat-out reject requests from local and federal law enforcement when they seek data without a court order. And unless we're legally prevented from it, we will always inform you when such requests are made.
All data is encrypted via SSL/TLS every time it travels on a network, including when transmitted from our servers to your browser. All data is also encrypted at rest, both when it is live in the database, as well as during backups.
In order to improve our services and the website, and provide more convenient, relevant experiences to you, we and our vendors may use "cookies", "web beacons", and similar devices to track your activities.
You understand that Userbase uses third party vendors and hosting partners to provide the necessary hardware, software, networking, storage, and related technology required to provide you with our services. A current list of vendors is available upon request.
In cases of onward transfer to these third parties for data of EU, United Kingdom, or Swiss individuals received pursuant to the Privacy Shield Frameworks, Userbase is potentially liable should any issues or concerns arise.
When you cancel your account, we will ensure that nothing is stored on our servers past 30 days. Anything you delete on your account while it's active will also be purged within 30 days.
Userbase complies with the EU-U.S. Privacy Shield Framework and the Swiss-U.S. Privacy Shield Framework as set forth by the U.S. Department of Commerce regarding the collection, use, and retention of personal information transferred from the European Union, the United Kingdom, and Switzerland to the United States, respectively. Userbase has certified to the Department of Commerce that it adheres to the Privacy Shield Principles. If there is any conflict between the terms in this privacy policy and the Privacy Shield Principles, the Privacy Shield Principles shall govern. To learn more about the Privacy Shield program, and to view our certification, please visit https://www.privacyshield.gov/.
Userbase is subject to the investigatory and enforcement powers of the Federal Trade Commission (FTC) with regard to the Privacy Shield Frameworks.
In compliance with the US-EU and Swiss-US Privacy Shield Principles, Userbase commits to resolve complaints about your privacy and our collection or use of your personal information. European Union, United Kingdom, or Swiss individuals with inquiries or complaints regarding this privacy policy should first contact Daniel Vassallo at<EMAIL_ADDRESS>or by mail at Encrypted Development LLC, 24 Roy St. #465, Seattle, WA 98109, USA.
Userbase has further committed to refer unresolved privacy complaints under the EU-US and Swiss-US Privacy Shield Principles to an independent dispute resolution mechanism, the BBB EU PRIVACY SHIELD, operated by the Council of Better Business Bureaus. If you do not receive timely acknowledgment of your complaint, or if your complaint is not satisfactorily addressed, please visit https://www.bbb.org/EU-privacy-shield/for-eu-consumers for more information and to file a complaint.
Please note that if your complaint is not resolved through these channels, under limited circumstances, a binding arbitration option may be available before a Privacy Shield Panel.
Userbase is operated in the United States, from the Amazon Web Services us-east-1 region. If you are located in the European Union or elsewhere outside of the United States, please be aware that any information you provide to us will be transferred to the United States. By using our services or providing us with your information, you consent to this transfer.
Userbase may update this policy occassionally. We will notify you about significant changes by emailing the account owner or by placing a prominent notice on the website. You can access, change or delete your personal information at any time by contacting Daniel Vassallo at<EMAIL_ADDRESS>or by mail at Encrypted Development LLC, 24 Roy St. #465, Seattle, WA 98109, USA.
Questions about this privacy policy? Please contact Daniel Vassallo at<EMAIL_ADDRESS>or by mail at Encrypted Development LLC, 24 Roy St. #465, Seattle, WA 98109, USA, and we’ll be happy to answer them!


Today, I'm happy to introduce to you another Aurelia community group that's built at least a dozen amazing plugins for our community. Read on to learn more...
SpoonX is a company that has its focus mainly on architecture and infrastructure in a consulting fashion, open source work and supplying commercial support.
Community
SpoonX has a lot of open source projects, and has chosen Aurelia as their framework of choice when it comes to front-end application development. With this in mind, they set out to supply some essential plugins to the community. They're a company with dedicated focus on the community, including a full-time community manager who helps actively maintain the projects.
They've spent almost a year on developing, perfecting, testing and documenting their plugins, which are now stable and available to use.
Essential Plugins
The following plugins are considered the most matured, and essential plugins. They have been used in production for at least 6 months now, are fully documented and have support for all bundling techniques.
aurelia-api
Talking to your API shouldn't be difficult. You shouldn't have to repeat yourself. You shouldn't need nuclear power plants to make it easier. You should just be able to say "give me that thing!" and be done with it.
aurelia-api
comes with a set of cool features that makes talking to APIs easy and fun. aurelia-api
is a module wrapped around aurelia-fetch-client that allows you to:
- Perform the usual CRUD
- Supply criteria for your API
- Manage more than one endpoint
- Add defaults
- Add interceptors
- More!
aurelia-orm
Working with endpoints and client-side entities is unavoidable when doing API driven development. You end up writing a small wrapper for your XHRs / websocket events and putting your request methods in one place. Even though your endpoints are important, you still end up neglecting them. Enter aurelia-orm
. This module provides you with some useful and cool features, such as:
- Entity definitions
- Repositories
- Associations
- Simple decorators
- Validation
- Type casting
- Self-populating (multi/single) select element
- Uses aurelia-api, so those benefits apply here as well
- More!
This makes it easier to focus on your application and organize your code.
aurelia-authentication
aurelia-authentication
makes local and third-party authentication easy. If your server is setup right, it can be as simple selecting your server endpoint from your
aurelia-api
setup and adding your third-party client id. Then you are ready to go. Basically, aurelia-authentication
does not use any cookies but relies on a JWT (json web token; other token formats have basic support) stored in the local storage of the browser.
Do you have multiple endpoints? No problem! In the recommended setting, aurelia-authentication
makes use of aurelia-api which sets up multiple endpoints easily. Just specify in your aurelia-authentication configuration which endpoints you want to use and your access token will be sent along with your requests automatically.
aurelia-notification
aurelia-notification
is a very simple plugin which allows you to display notifications in your application. It translates messages using aurelia-i18n
and setting it up is as simple as configuring notification types and setting the style to use.
Shiny Plugins
These modules are newer, but also already being used in production. Most of them also come with a fair amount of documentation. The community members responsible for the plugins have written a small introduction for each.
swan-example
By @doktordirk and @RWOverdijk .
We needed a place to demo our plugins, and so we created swan-example.
SWAN is a nifty little stack, which stands for Sails Waterline Aurelia and Node. It comes with a cli tool , which isn't much yet, but does help you define a project structure and get started quickly using our opinionated aurelia-skeleton and auth-ready node server. We've used this tool to build the swan-example, which you can see by clicking here .
- Username: example
- Password: example
aurelia-view-manager
By @bas080 .
Components often require some HTML. We at SpoonX
tend to use bootstrap for styling and templating. But we also want to make it easy for people that might use other CSS frameworks. aurelia-view-manager
allows you to easily overwrite the HTML template of components that use aurelia-view-manager's @resolvedView
decorator. If you want to make your component CSS framework independent, head over to the
usage
section.
aurelia-form
By @bas080 .
aurelia-form
makes your life easier by letting you define and generate forms based on data. It does so by using something named a schema.
A schema is a collection of objects that describes the form you want. The schema consists out of basic javascript data types which every programmer understands and knows how to manipulate. A simple example:
this.loginSchema = [{
type: 'email',
key : 'email'
}, {
type: 'password',
key : 'password'
}];
this.credentials = {};
You can then use this schema and the object that holds the data like this:
<schema-form schema.bind="schema" model.bind="credentials"></schema-form>
This plugin is especially useful when combined with
aurelia-orm
, as it generates the form based on your entity schema using the custom component <entity-form>
.
aurelia-pager
By @VMBindraban .
aurelia-pager
is a component that handles pagination for your application.
Besides the basic functionality of a paginator like setting the amount of items for each page, it also supports:
- Data from an array
- Data from a resource (using aurelia-orm )
- Criteria (using a resource with sailsjs/waterline or express)
- Page range, for example
3 4 [5] 6 7
- Your own custom template (defaults to bootstrap)
aurelia-filter
By @VMBindraban .
aurelia-filter
is a basic GUI criteria selector, it generates a search/filter criteria object. You can easily generate criteria based on AND
or OR
conditional blocks. Based on the field you have selected, it can transform the input field into the proper type, for example a number or date. It supports all the
sailsJS/waterline
operators. There is also support for entities (using
aurelia-orm
).
aurelia-datatable
By @jeremyvergnas .
aurelia-datatable
is probably one the most common components you can find within interactive applications. It allows you to have an overview of your data and manipulate them, in a user-friendly manner.
aurelia-datatable
has been made to provide you an easy and powerful way to implement datatables in your Aurelia application(s). In combination with aurelia-orm, aurelia-view-manager and aurelia-pager, you will get, out of the box, a datatable component ready to use, with the following features:
- Custom columns (with aliases and value converter)
- Sorting
- Searching
- Pagination
- Custom criteria
- Optional edit/remove actions on your rows
- Custom actions on your rows
- Custom footer on your datatable
aurelia-config
By @doktordirk .
With the increasing number of plugins, plugin initialization and configuration has become somewhat tedious. Currently, one might have something like this, a long list of plugins and their configs:
aurelia.use
.plugin('aurelia-api', aureliaApiConfig)
.plugin('aurelia-authentication', aureliaAuthenticationConfig)
.plugin('aurelia-notification', aureliaNotificationConfig)
// ...
Using aurelia-config, that becomes easier and more organized. We have just a single namespaced config object with all the configuration options and aurelia-config does all those plugin calls for us with the appropriate namespace section. Here's a simple example:
// Example config
let appConfigOverwrites = {
'aurelia-api': {
endpoints: [
{name: 'api', url: 'http://<IP_ADDRESS>:1337/'}
]
},
'aurelia-authentication': {
endpoint: 'api'
}
'aurelia-notification': {
baseClass: 'custom-notifications'
}
};
// Configure function
export function configure(aurelia) {
aurelia.use
.standardConfiguration()
.plugin('aurelia-config', [
'aurelia-api',
'aurelia-authentication',
'aurelia-notification',
], appConfigOverwrites);
}
That's the main feature of aurelia-config, but there's more to it.
- Initialize and configure you plugins in one place with a single namespaced configuration object.
- Automatically load and merge defaults which can be directly loaded from plugins by aurelia-config itself.
- Access the merged config by using our resolver or injecting aurelia-config everywhere.
- Since the merged settings are an instance of homefront, all it's method are available, too.
Homefront
By @Rawphs .
Homefront is a module that allows you to merge, flatten, expand, search in, fetch from, remove from, put in and work with objects easily. It was started as an educational project but has made its way into wetland, aurelia-config and json-statham . It is fully tested, and makes working with objects a lot more fun.
aurelia-charts
By @bas080 .
aurelia-charts
is a plugin that allows you to use the chart library you like most. It has a simple API and standardizes the way charts are used in your projects. It does so by letting others define sane defaults.
It allows for you to write your own plugins, or use an existing one (for example aurelia-charts-c3 ).
This project is being used by us, but isn't labeled "stable" yet, as is visible by the lack of documentation.
Bonus: Wetland
By @RWOverdijk .
For the past two months we've been working on a brand new nodeJS orm. For now it lacks documentation, but has neat features. It's based on the JPA spec (which took some reading ) and took inspiration from the way doctrine implemented it. It obviously required some changes to fit the node.js world, but those were kept to a minimum.
A glossary of its features to date:
- Abstracted principles (repositories, entities, hydrators)
- Unit of work using proxies
- Nested joins
- Nested persist
- Mapping
- Transactions
- Migrations
- Great performance (smart hydrator and state management)
- Strict typing (written in typescript)
Feel free to browse the code , and if you're interested leave a star so you can track the progress.
Conclusion
We're very happy with the work we've done. The plugins are stable and the documentation has proven to be very helpful.
- If you have questions, suggestions, wish to contribute, add a plugin to the stack or if you have a need for banter, feel free to join us on gitter .
- If you like our work, help us out and star our repositories.


Layouts
Blog
Pages
Elements
With forms you can get almost any kind of information from your visitors, who will definitely appreciate this attractive element.
Sign up to our newsletter and be the first to know about our latest news, special offers, events, and discounts.
Country


|
From Text to Concepts
|
Go to the source code of this file.
Classes | |
| class | Concept::UnitTest::Test |
| class | Concept::UnitTest::TestFixture |
Macros | |
| #define | ASSERT_TRUE(condition) assertTrue(condition, #condition) |
| #define | GREEN "\033[1;32m" |
| #define | RED "\033[1;31m" |
| #define | ENDCOLOR "\033[0m" |
The MIT License
Copyright(c) 2019 Leonce Mekinda
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files(the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
| #define ASSERT_TRUE | ( | condition | ) | assertTrue(condition, #condition) |
Check a condition
| #define GREEN "\033[1;32m" |
Define ANSI colors for POSIX terminals TODO: Check terminal capability beforehand


cat blog lets you dig your claws into the latest news, information, tips, and products that are breaking in the world of felines. Holy Meow! Our cat blog lets you dig your claws into the latest news, information, tips and products that are breaking in the world of cats. always on the prowl for what cat lovers need to know to keep their cats healthy and happy.
We talk about topics that cat parents need to know about. Does your cat have hairballs? We have some tips to help your cat cutback on this nasty grooming concern. Or maybe your cat is trying to tell you something… well, we know how to decode all that secret kitty body language. Or perhaps you’re welcoming a new kitten or cat into your family – let us help you get your home ready for this new addition.  We’ve thought of all of that and much more, giving you the answers you need to make your cat’s life purr-fect. Plus, we’ll keep you posted on all the cool cat news, events, contests, studies, videos, and funny updates that make the Internet so cat friendly.
cat blog helps to inspire cat parents, offering our readers the best ideas and solutions for life with their cats. From feline-friendly home decor items, adorable pictures of kittens, and cat rescue organizations, to in-depth information about all the official recognized cat breeds to choose from and common feline health symptoms and treatments, we’ve got our paws on the pulse of what’s happening in the world of cats.
If you have a question, if there’s a product you’d like us to review or something you like to know more about, please let us know and we’ll cover it in our cat blog. The more crazy cat people, the better–there’s always room for one more feline lover in our cat community!


Hey my name is Joscelyn.
I enjoy writing code!
Phone:<PHONE_NUMBER> Email<EMAIL_ADDRESS>Here is my GitHub


| handle {httr} | R Documentation |
This handle preserves settings and cookies across multiple requests. It is the foundation of all requests performed through the httr package, although it will mostly be hidden from the user.
handle(url, cookies = TRUE)
url |
full url to site |
cookies |
DEPRECATED |
Because of the way argument dispatch works in R, using handle() in the
http methods (See GET()
) will cause problems when trying to
pass configuration arguments (See examples below). Directly specifying the
handle when using http methods is not recommended in general, since the
selection of the correct handle is taken care of when the user passes an url
(See handle_pool()
).
handle("http://google.com") handle("https://google.com") h <- handle("http://google.com") GET(handle = h) # Should see cookies sent back to server GET(handle = h, config = verbose()) h <- handle("http://google.com", cookies = FALSE) GET(handle = h)$cookies ## Not run: # Using the preferred way of configuring the http methods # will not work when using handle(): GET(handle = h, timeout(10)) # Passing named arguments will work properly: GET(handle = h, config = list(timeout(10), add_headers(Accept = ""))) ## End(Not run)


--- date: 2012-01-14T00:00:00Z published: true title: Canada's election laws changing to reflect Twitter reality url: /2012/01/14/canada-s-election-laws-changing-to-reflect-twitter-reality/ ---
The Harper government will repeal the ban on communicating election results while polls are still open, bringing the law into harmony with the realities of today's instant communications.
The election night blackout was adopted in 1938, to prevent western voters from knowing the results of the election in the east when they cast their ballots.
Minister of State for Democratic Reform Tim Uppal announced via Twitter Friday that the antiquated law will been repealed in time for the next election.


It is used for identification
The svg that is going to be added to the final logo
Create/Build the default shapes (logo, title, slogan) using the data/properties provided by the user interface
The svg that will serve as a parent for the shapes
The propierties provided by the store of the user interface
Use this function to extend a base for adding additional Svgs on the logo.
An object that containts the esentials Svgs, like: logo, title, slogan. Also suport derivate from it.
Generated using TypeDoc
Additional shapes used in the exteneded version of the base


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/donating.20olean.20files.html ---
I'm working on a branch of mathlib with a student. I just merged master into our branch, fixed up some conflicts, and compiled. I hence have a bunch of working olean files. Can I somehow pass these to the student with cache-olean
? Another approach which will probably work is to stop git ignoring olean files and then just push all the olean files onto the branch, but this seems like an inappropriate use of github.
You should be able to git commit (to your branch) and then run cache-olean
.  This is exactly what cache-olean
is meant to do.
After running cache-olean
you can check the _cache
folder to see the archive that was created, named after the commit hash.
I guess it should work for you to send the right archive to your student and have them put it in their _cache
folder. But I've never tried.
If I'm sending tarballs to a student I may as well just tar up the olean files directly.
If you have DropBox, you could make _cache
a symbolic link to a drop box directory and sync it that way
Last winter, I was working on an extension to sccache
that would have allowed sharing compilation caches. Maybe I should get back to it
The symbolic link idea is nice. I'm assuming that this sort of thing is possible in Win10? I don't know the equivalent of ln -s
. It's just a bore for a student to have to compile stuff after I've pushed to a branch and compiled myself. Thanks!
https://www.maketecheasier.com/create-symbolic-links-windows10/
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Please enter the following information in order to process your concerns.
Phone Number:
Email:
Please Select Product Group:
Books Movies Consumer Electronics Computer
Description of problem: (Limit 200 characters)


His medically installed titanium steel claws and his extremly quickly healing flesh allows him to be a fierce hand to hand combatant.
"Thor"
The norse god of Thunder and lightning wield a hammer of endless power.
"Dare Devil"
Because he is blind all of his other senses have been heightened to allow for mastery of martial arts and parcour.
"Hulk"
Proffessor Bruce Banner was subjected to a test chemical which no aloows him to turn into an enormous green monster when he is enraged.
"The Black Widow"
The Super Spy has been fighting crime from a young age, her prowess and hightend senses allow for her to vanquish evil.
"Iron Man"
Multi Billionair and playboy, Toni Stark engineered himself a revalutionary suit of armor aloowing him to fly and use a range of top tier military utilities.
"Captain America"
The All American super human faught against Red Skull and his nazi army, only to be frozen and brought back to life in the modern world to fight alongside the Avengers.


This Privacy Policy describes how your personal information is collected, used, and shared when you visit or make a purchase from goosechase.io (the “Site”).
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR SOFTWARE AUTHORS BE LIABLE FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OR OTHER LIABILITY ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
When you visit the Site, we automatically collect certain information about your device, including information about your web browser, IP address, time zone, and some of the cookies that are installed on your device. Additionally, as you browse the Site, we collect information about the individual web pages or products that you view, what websites or search terms referred you to the Site, and information about how you interact with the Site. We refer to this automatically-collected information as “Device Information.”
We collect Device Information using the following technologies:
Additionally when you make a purchase or attempt to make a purchase through the Site, we collect certain information from you, including your name, billing address, shipping address, payment information (including credit card numbers), email address, and phone number. We refer to this information as “Order Information.”
When we talk about “Personal Information” in this Privacy Policy, we are talking both about Device Information and Order Information.
We use the Order Information that we collect generally to fulfill any orders placed through the Site (including processing your payment information, and providing you with invoices and/or order confirmations). Additionally, we use this Order Information to:
We use the Device Information that we collect to help us screen for potential risk and fraud (in particular, your IP address), and more generally to improve and optimize our Site (for example, by generating analytics about how our customers browse and interact with the Site, and to assess the success of our marketing and advertising campaigns).
We do not share your Personal Information with any third parties, unless to comply with applicable laws and regulations, to respond to a subpoena, search warrant or other lawful request for information we receive, or to otherwise protect our rights.
Please note that we do not alter our Site’s data collection and use practices when we see a Do Not Track signal from your browser.
When you place an order through the Site, we will maintain your Order Information for our records unless and until you ask us to delete this information.
We may update this privacy policy from time to time in order to reflect, for example, changes to our practices or for other operational, legal or regulatory reasons.
For more information about our privacy practices, if you have questions, or if you would like to make a complaint, please contact us on Slack or by e-mail at chasdevs@gmail.com.


Home
Solutions
Education
Financial services
Community
Products
Support
Support home
Customer Service
Knowledge base
Forum
Events Log:
Note:
Dragging of "Community" is disabled.
Dropping of "Forum" is disabled.


More often than not, working in a IT project requires a lot of repetitive tasks. In particular, one area that can be very debilitating is the creation of test data. We know it is indispensable to the project, but it does not make that task less boring.
You are working in a Java project. One of the thing to test is the validation logic of some input XML files. One object, called the XmlInputSuperbEnterpriseValidator (notice the Java naming convention), takes a XML file path as input and return true if the file is valid.
Input file is just a simple XML file, which could look like this:
<root>
<value1>1</value1>
<value2>a</value2>
</root>
where value1 accepts number between 0 and 9 and value2 accepts letters (a-z).
To test this, one can create a test class like the following.
package com.core.validator;
import static org.junit.Assert.*;
public class XmlInputSuperEnterpriseValidatorTest {
@Test
public void 01_normalInput_returnsTrue() {
assertTrue(XmlInputSuperbEnterpriseValidator.validate("input/01.xml"));
}
}
Then, for each test case, create the XML file and add exactly the same test function.
What if you have 50 different permutations of XML file. You’ll need to create all of them and create the exact same test methods. And what if the specification change and you have to add new fields? Here again, a lot of manual operation will be required to update the test cases.
What could happen here is that the tests will just be thrown away as the maintenance is taking more effort that most people are willing to give.
As a good little software engineer, one of the question that should pop out of your mind is: “Isn’t there a better way to do that?”
It’s not rocket science, but using python (or any other language really) to automate the test creation will save you a bunch of time and also make everybody in the project happier.
The basic workflow is the following:
The test definition is the input of the generator. We need to specify what kind of test data we want to generate. In this example, we want to generate tests that will try all possible permutations for value1 and value2 of the input file.
The format of the test definition is up to you; here we will just use plain text.
1,2,3,4,5,6,7,8,9
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
First things first, let’s create a class that will represent the data for one test:
import os
class TestData:
def __init__(self, name, path, value1, value2):
self.value1 = value1
self.value2 = value2
self.path = path
self.name = name
We have our test data representation, great. Now we need a way to convert it to text. We could just use Python string interpolation but there is a much better way.
A very neat way to generate text file in python is to use a templating language. Web frameworks, such as Django or Flask, are heavy users of templating language to generate the HTML pages from data coming from the server.
Here, we will use jinja2 to generate our XML and java files. First, define the template using jinja templating language. Quick way is just to define it as a string in the python file but it can also be read from file, which is better practice when the templates are getting bigger and more numerous.
XML_TEMPLATE = """<root>
<value1></value1>
<value2></value2>>
</root>
"""
Notice the curly brackets? Jinja will replace what’s inside by whatever objects we pass. Object should have variables ‘value1’ and ‘value2’ to work.
The next snippet will print this template with a test case object.
from jinja2 import Template
if __name__ == "__name__":
template = Template(XML_TEMPLATE)
test_case = TestCase('name', 'path', 'value1', 'value2')
print(template.render(test_case=test_case)
We insert the test~case~ variable in the template by passing it as a keyword argument of the render method of jinja2.Template. This will print:
<root>
<value1>value1</value1>
<value2>value2</value2>>
</root>
Creating the template for the java test class can be done in a similar fashion. Here, we will leverage the for loop of jinja.
JAVA_TEMPLATE = """
package com.core.validator;
import static org.junit.Assert.*;
public class XmlInputSuperbEnterpriseValidatorTest {
}
"""
The variable to insert in the template is test~cases~. It should be an iterable as we use it in the for loop. Here how to generate 1000 test cases with the java class to test them.
from jinja2 import Template
if __name__ == "__name__":
java_template = Template(JAVA_TEMPLATE)
xml_template = Template(XML_TEMPLATE)
path_out = "/somewhere/you/want/"
test_cases = [TestCase("{}_test".format(i),
path_out,
i,
i+1) for i in range(0, 1000)]
# Create the java file
with open(path_out + 'XmlInputSuperbEnterpriseValidatorTest.java', 'w') as f:
f.write(java_template.render(test_cases=test_cases)
# Create the xml files
for test_case in test_cases:
with open(path_out + test_case.path + test_case.name, 'w') as f:
f.write(xml_template.render(test_case=test_case))
Instead of printing the rendered templates to the console, we will just write them to a file.
We have a way to represent our tests, we have a way to print our tests to file, we just need to have a way to read our test specification and convert it to a TestCase object.
Our input file first line is the value1, and the second line is the value2. To avoid cluttering the blog post, I will assume the file is always correct and has as many elements in the first line than in the second line.
with open('test_specification') as f:
test_input_values = [x.rstrip().split(',') for x in f.readlines()]
values1 = test_input_values[0]
values2 = test_input_values[1]
Then you can combine these value the way you want to create your test cases.
Using zip:
test_cases = [TestCase('{}_test'.format(nb),
path_out,
value1,
value2) for nb, (value1, value2) in enumerate(zip(values1, values2))]
zip will create a generator from many iterables. The ith element of a zip object is a tuple containing the ith elements of each of the input iterables. For example,
for a, b in zip([1, 2], [3, 4]):
print("{} - {}".format(a, b))
Will print “1 - 2” and “3 - 4”.
zip is combined with enumerate. Enumerate is also very simple. It takes an iterator. The ith element of enumerate is (i, ith element of input iterator).
for index, el in enumerate(['a','b']):
print("Index {}: {}".format(index, el))
Will print “Index 0: a” and “Index 1: b”. Notice that when combining zip with enumerate, you need to add brackets when unpacking the values. Not using brackets would throw a ValueError (not enough values to unpack (expected 3, got 2). The reason is that enumerate is sending a tuple of size two.
Another way to combine test cases is to use itertools.product. Product will yield all combinaisons possible of multiple iterables.
from itertools import product
for a, b in product([1, 2], ['a', 'b', 'c']):
print("{} - {}".format(a, b))
will print: 1 - a 1 - b 1 - c 2 - a 2 - b 2 - c
You can use product to test all the possible combinaisons of your input values.
from itertools import product
test_cases = [TestCase('{}_test'.format(nb),
path_out,
value1,
value2) for nb, (value1, value2) in enumerate(product(values1, values2))]
There is so much to say about generators, iterators.
In this post, we learned about how to use python and jinja2 to automate test creation.
This is a simple example, the concept of automation is very powerful and helps tremendously in every day life. Even if your activities do not imply coding, there must be some repetitive task that can be automize. For example, sending the same mail to each mail address in an excel spreadsheet. This can be automized (see pandas to read from excel file).
If you’re interested in the subject, have a look at automate the boring stuff with Python.


Strings are essentially slices of bytes, and are not required to be UTF-8 encoded. But the range loop assumes UTF-8
encoding. The iteration element is the rune (like a character), and the index is the byte number of the first byte of the rune (not the number of
the rune). Thus, when the multi-byte character é is encountered, the index 4 is skipped.
Reference:


FASTA is a program used to search in large Protein or DNA sequence data banks. It was developed at the University of Virginia by William R. Pearson, and D.J. Lippman.
FASTA is installed in /opt/Bio/fasta/. FASTA is run in a similar manner to NCBI Blast.
First create a test query file
[nostromo@rocks-168 ~]$ cat > test.txt >Test AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC TTCTGAACTGGTTACCTGCCGTGAGTAAATTAAAATTTTATTGACTTAGGTCACTAAATACTTTAACCAA TATAGGCATAGCGCACAGACAGATAAAAATTACAGAGTACACAACATCCATGAAACGCATTAGCACCACC ATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAG CCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGGTAACGAGGTAACAACCATGCGAGTGTTGAA GTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGTGTTGCCGATATTCTGGAAAGCAATGCC AGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTGGCGATGATTG AAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTT |
The next step is to search for this against a database sequence. For this, we can download a DNA or protein sequence database or use the ones that are provided by the program. For this example, we will use the ones present along with the fasta program in /opt/Bio/fasta/.
[nostromo@rocks-168 ~]$ fasta34 # fasta34 FASTA searches a protein or DNA sequence data bank version 3.4t25 Sept 2, 2005 Please cite: W.R. Pearson & D.J. Lipman PNAS (1988) 85:2444-2448 test sequence file name: test.txt library file name: /opt/Bio/fasta/gst.seq ktup? (1 to 6) [6] 1 Query library test.txt vs /opt/Bio/fasta/gst.seq library searching /opt/Bio/fasta/gst.seq library 1>>>Test - 560 nt vs /opt/Bio/fasta/gst.seq library 1287 residues in 1 sequences Altschul/Gish params: n0: 560 Lambda: 0.192 K: 0.177 H: 0.360 FASTA (3.47 Mar 2004) function [optimized, +5/-4 matrix (5:-4)] ktup: 1 join: 77, opt: 62, open/ext: -12/-4, width: 16 Scan time: 0.000 Enter filename for results []: res.txt How many scores would you like to see? [20] The best scores are: opt bits E(1) gi|193547|gb|J04632|MUSGLUTA Mouse glutathione (1287) [r] 68 21.5 0.22 gi|193547|gb|J04632|MUSGLUTA Mouse glutathione (1287) [f] 62 19.8 0.55 More scores? [0] Display alignments also? (y/n) [n] y number of alignments [20]? 560 residues in 1 query sequences 1287 residues in 1 library sequences Scomplib [34t25] start: Wed Mar 15 16:14:08 2006 done: Wed Mar 15 16:14:51 2006 Total Scan time: 0.000 Total Display time: 0.010 Function used was FASTA [version 3.4t25 Sept 2, 2005] |
Looking into res.txt we can see the results of our search.
Further information about the usage of fasta can be obtained from /opt/Bio/fasta/fasta3x.doc present on the frontend of your installation.
More information is also available at the FASTA home page.
For support, you are encouraged to join the FASTA mailing list at http://list.mail.virginia.edu/mailman/listinfo/fasta_list


Astute readers will note that posts currently appear undated and without a comment option. This is due to one of those laughably-named “upgrades”, which as far as I can see just make life more difficult. Fear not, equilibrium will be restored as soon as possible. I will be wittering about this in due course (i.e., in approximately fifty years time).
UPDATE : Dates and Comments restored, as you can see. The Yard's boffin is working on further tweaks to tidy up the spacing between posts and a few other horrors.
UPDATE UPDATE : Back to normal. I suppose I could delete this post, but I will leave it here for the historical record, to be pored over by future scholars. Also, leaving it here means I can continue to assert that there has been at least one posting every day since the sixteenth of December last year, which makes a change from the awful hiatuses (hiatae?) of yore.


Package com.jme.input.ios
Class TouchEventPool
- java.lang.Object
-
- com.jme.input.ios.TouchEventPool
-
public class TouchEventPool extends java.lang.Object
TouchEventPool provides a RingBuffer of jME TouchEvents to help with garbage collection on Android. Each TouchEvent is stored in the RingBuffer and is reused if the TouchEvent has been consumed. If a TouchEvent has not been consumed, it is placed back into the pool at the end for later use. If a TouchEvent has been consumed, it is reused to avoid creating lots of little objects. If the pool is full of unconsumed events, then a new event is created and provided.- Author:
- iwgeric
-
-
Constructor Summary
Constructors Constructor Description TouchEventPool(int maxEvents)
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description void
destroy()
com.jme.input.event.TouchEvent
getNextFreeEvent()
Fetches a touch event from the reuse poolvoid
initialize()
void
storeEvent(com.jme.input.event.TouchEvent event)
Stores the TouchEvent back in the pool for later reuse.
-
-
-
Method Detail
-
initialize
public void initialize()
-
destroy
public void destroy()
-
getNextFreeEvent
public com.jme.input.event.TouchEvent getNextFreeEvent()
Fetches a touch event from the reuse pool- Returns:
- a usable TouchEvent
-
storeEvent
public void storeEvent(com.jme.input.event.TouchEvent event)
Stores the TouchEvent back in the pool for later reuse. It is only reused if the TouchEvent has been consumed.- Parameters:
event
- TouchEvent to store for later use if consumed.
-
-


I am a highly motivated and aspiring web developer from Sarasota, FL. I am currently enrolled in Lambda School for Full Stack Web Development. I have been coding and programming as a hobby for about 3 years and enjoyed it so much I decided to make it a career. I have a passion for creating functional modern applications that look original.
When I'm not behind my computer I enjoy cycling and spending time with my family. I have a lovely wife and a young son who loves baseball and golf. I also enjoy golfing and helping my son with his baseball card collection.
Susheela B-H, aka SoosheBot in digital spaces, is a journalist turned early career full-stack developer with a background in digital content and optimization. As a writer who frequently served as a bridge between IT and marketing/creative departments, Susheela works with a wide range of communities to effectively to diagnose problems, identify needs, and collaborate to prioritize solutions.
I am currently a Web Development Student at Lambda School. I have a basic understanding of HTML5, CSS, JavaScript, and Python. I also have an Entry-Level Certification in Python from the Python Institute. I have a background in construction as well as restaurant management, and from these backgrounds have learned the skills needed to organize and communicate with teams and to think about things in a modular way, understanding the role of each tree in the proverbial forest.