connect()
The connect()
function connects a React component to a Redux
store.
It provides its connected component with the pieces of the data it needs from the store, and the functions it can use to dispatch actions to the store.
It does not modify the component class passed to it; instead, it returns a new, connected component class that wraps the component you passed in.
The mapStateToProps
and mapDispatchToProps
deals
with your Redux store’s state
and dispatch
,
respectively. state
and dispatch
will be
supplied to your mapStateToProps
or
mapDispatchToProps
functions as the first argument.
The returns of mapStateToProps
and
mapDispatchToProps
are referred to internally as
stateProps
and dispatchProps
, respectively. They
will be supplied to mergeProps
, if defined, as the first and
the second argument, where the third argument will be
ownProps
. The combined result, commonly referred to as
mergedProps
, will then be supplied to your connected
component.
connect()
Parameters
connect
accepts four different parameters, all optional. By
convention, they are called:
mapStateToProps?: Function
mapDispatchToProps?: Function | Object
mergeProps?: Function
options?: Object
mapStateToProps?: (state, ownProps?) => Object
If a mapStateToProps
function is specified, the new wrapper
component will subscribe to Redux store updates. This means that any time
the store is updated, mapStateToProps
will be called. The
results of mapStateToProps
must be a plain object, which will
be merged into the wrapped component’s props. If you don’t want to
subscribe to store updates, pass null
or
undefined
in place of mapStateToProps
.
state: Object
ownProps?: Object
A mapStateToProps
function takes a maximum of two parameters.
The number of declared function parameters (a.k.a. arity) affects when it
will be called. This also determines whether the function will receive
ownProps. See notes here.
state
If your mapStateToProps
function is declared as taking one
parameter, it will be called whenever the store state changes, and given
the store state as the only parameter.
ownProps
If your mapStateToProps
function is declared as taking two
parameters, it will be called whenever the store state changes
or when the wrapper component receives new props (based on
shallow equality comparisons). It will be given the store state as the
first parameter, and the wrapper component’s props as the second
parameter.
The second parameter is normally referred to as ownProps
by
convention.
Your mapStateToProps
functions are expected to return an
object. This object, normally referred to as stateProps
, will
be merged as props to your connected component. If you define
mergeProps
, it will be supplied as the first parameter to
mergeProps
.
The return of the mapStateToProps
determine whether the
connected component will re-render (details
here).
For more details on recommended usage of mapStateToProps
,
please refer to
our guide on using mapStateToProps
.
You may define
mapStateToProps
andmapDispatchToProps
as a factory function, i.e., you return a function instead of an object. In this case your returned function will be treated as the realmapStateToProps
ormapDispatchToProps
, and be called in subsequent calls. You may see notes on Factory Functions or our guide on performance optimizations.
mapDispatchToProps?: Object | (dispatch, ownProps?) => Object
Conventionally called mapDispatchToProps
, this second
parameter to connect()
may either be an object, a function,
or not supplied.
Your component will receive dispatch
by default, i.e., when
you do not supply a second parameter to connect()
:
// do not pass `mapDispatchToProps`
connect()(MyComponent)
connect(mapState)(MyComponent)
connect(mapState, null, mergeProps, options)(MyComponent)
If you define a mapDispatchToProps
as a function, it will be
called with a maximum of two parameters.
dispatch: Function
ownProps?: Object
dispatch
If your mapDispatchToProps
is declared as a function taking
one parameter, it will be given the dispatch
of your
store
.
const mapDispatchToProps = (dispatch) => {
return {
// dispatching plain actions
increment: () => dispatch({ type: 'INCREMENT' }),
decrement: () => dispatch({ type: 'DECREMENT' }),
reset: () => dispatch({ type: 'RESET' }),
}
}
ownProps
If your mapDispatchToProps
function is declared as taking two
parameters, it will be called with dispatch
as the first
parameter and the props passed to the wrapper component as the second
parameter, and will be re-invoked whenever the connected component
receives new props.
The second parameter is normally referred to as ownProps
by
convention.
// binds on component re-rendering
;<button onClick={() => this.props.toggleTodo(this.props.todoId)} />
// binds on `props` change
const mapDispatchToProps = (dispatch, ownProps) => ({
toggleTodo: () => dispatch(toggleTodo(ownProps.todoId)),
})
The number of declared function parameters of
mapDispatchToProps
determines whether they receive ownProps.
See notes here.
Your mapDispatchToProps
functions are expected to return an
object. Each fields of the object should be a function, calling which is
expected to dispatch an action to the store.
The return of your mapDispatchToProps
functions are regarded
as dispatchProps
. It will be merged as props to your
connected component. If you define mergeProps
, it will be
supplied as the second parameter to mergeProps
.
const createMyAction = () => ({ type: 'MY_ACTION' })
const mapDispatchToProps = (dispatch, ownProps) => {
const boundActions = bindActionCreators({ createMyAction }, dispatch)
return {
dispatchPlainObject: () => dispatch({ type: 'MY_ACTION' }),
dispatchActionCreatedByActionCreator: () => dispatch(createMyAction()),
...boundActions,
// you may return dispatch here
dispatch,
}
}
For more details on recommended usage, please refer to
our guide on using mapDispatchToProps
.
You may define
mapStateToProps
andmapDispatchToProps
as a factory function, i.e., you return a function instead of an object. In this case your returned function will be treated as the realmapStateToProps
ormapDispatchToProps
, and be called in subsequent calls. You may see notes on Factory Functions or our guide on performance optimizations.
mapDispatchToProps
may be an object where each field is an
action creator.
import { addTodo, deleteTodo, toggleTodo } from './actionCreators'
const mapDispatchToProps = {
addTodo,
deleteTodo,
toggleTodo,
}
export default connect(null, mapDispatchToProps)(TodoApp)
In this case, React-Redux binds the dispatch
of your store to
each of the action creators using bindActionCreators
. The
result will be regarded as dispatchProps
, which will be
either directly merged to your connected components, or supplied to
mergeProps
as the second argument.
// internally, React-Redux calls bindActionCreators
// to bind the action creators to the dispatch of your store
bindActionCreators(mapDispatchToProps, dispatch)
We also have a section in our mapDispatchToProps
guide on the
usage of object shorthand form
here.
mergeProps?: (stateProps, dispatchProps, ownProps) => Object
If specified, defines how the final props for your own wrapped component
are determined. If you do not provide mergeProps
, your
wrapped component receives
{ ...ownProps, ...stateProps, ...dispatchProps }
by default.
mergeProps
should be specified with maximum of three
parameters. They are the result of mapStateToProps()
,
mapDispatchToProps()
, and the wrapper component’s
props
, respectively:
stateProps
dispatchProps
ownProps
The fields in the plain object you return from it will be used as the props for the wrapped component. You may specify this function to select a slice of the state based on props, or to bind action creators to a particular variable from props.
The return value of mergeProps
is referred to as
mergedProps
and the fields will be used as the props for the
wrapped component.
options?: Object
{
context?: Object,
pure?: boolean,
areStatesEqual?: Function,
areOwnPropsEqual?: Function,
areStatePropsEqual?: Function,
areMergedPropsEqual?: Function,
forwardRef?: boolean,
}
context: Object
Note: This parameter is supported in >= v6.0 only
React-Redux v6 allows you to supply a custom context instance to be used
by React-Redux. You need to pass the instance of your context to both
<Provider />
and your connected component. You may pass
the context to your connected component either by passing it here as a
field of option, or as a prop to your connected component in rendering.
// const MyContext = React.createContext();
connect(mapStateToProps, mapDispatchToProps, null, { context: MyContext })(
MyComponent
)
pure: boolean
true
Assumes that the wrapped component is a “pure” component and does not rely on any input or state other than its props and the selected Redux store’s state.
When options.pure
is true, connect
performs
several equality checks that are used to avoid unnecessary calls to
mapStateToProps
, mapDispatchToProps
,
mergeProps
, and ultimately to render
. These
include areStatesEqual
, areOwnPropsEqual
,
areStatePropsEqual
, and areMergedPropsEqual
.
While the defaults are probably appropriate 99% of the time, you may wish
to override them with custom implementations for performance or other
reasons.
We provide a few examples in the following sections.
areStatesEqual: (next: Object, prev: Object) => boolean
strictEqual: (next, prev) => prev === next
When pure, compares incoming store state to its previous value.
Example 1
You may wish to override areStatesEqual
if your
mapStateToProps
function is computationally expensive and is
also only concerned with a small slice of your state. The example above
will effectively ignore state changes for everything but that slice of
state.
Example 2
If you have impure reducers that mutate your store state, you may wish to
override areStatesEqual
to always return false:
This would likely impact the other equality checks as well, depending on
your mapStateToProps
function.
areOwnPropsEqual: (next: Object, prev: Object) => boolean
shallowEqual: (objA, objB) => boolean
(
returns true
when each field of the objects is equal )
When pure, compares incoming props to its previous value.
You may wish to override areOwnPropsEqual
as a way to
whitelist incoming props. You’d also have to implement
mapStateToProps
, mapDispatchToProps
and
mergeProps
to also whitelist props. (It may be simpler to
achieve this other ways, for example by using
recompose’s mapProps.)
areStatePropsEqual: (next: Object, prev: Object) => boolean
function
shallowEqual
When pure, compares the result of mapStateToProps
to its
previous value.
areMergedPropsEqual: (next: Object, prev: Object) => boolean
shallowEqual
When pure, compares the result of mergeProps
to its previous
value.
You may wish to override areStatePropsEqual
to use
strictEqual
if your mapStateToProps
uses a
memoized selector that will only return a new object if a relevant prop
has changed. This would be a very slight performance improvement, since
would avoid extra equality checks on individual props each time
mapStateToProps
is called.
You may wish to override areMergedPropsEqual
to implement a
deepEqual
if your selectors produce complex props. ex: nested
objects, new arrays, etc. (The deep equal check may be faster than just
re-rendering.)
forwardRef: boolean
Note: This parameter is supported in >= v6.0 only
If {forwardRef : true}
has been passed to
connect
, adding a ref to the connected wrapper component will
actually return the instance of the wrapped component.
connect()
Returns
The return of connect()
is a wrapper function that takes your
component and returns a wrapper component with the additional props it
injects.
import { login, logout } from './actionCreators'
const mapState = (state) => state.user
const mapDispatch = { login, logout }
// first call: returns a hoc that you can use to wrap any component
const connectUser = connect(mapState, mapDispatch)
// second call: returns the wrapper component with mergedProps
// you may use the hoc to enable different components to get the same behavior
const ConnectedUserLogin = connectUser(Login)
const ConnectedUserProfile = connectUser(Profile)
In most cases, the wrapper function will be called right away, without being saved in a temporary variable:
import { login, logout } from './actionCreators'
const mapState = (state) => state.user
const mapDispatch = { login, logout }
// call connect to generate the wrapper function, and immediately call
// the wrapper function to generate the final wrapper component.
export default connect(mapState, mapDispatch)(Login)
Because connect
is so flexible, it may help to see some
additional examples of how it can be called:
dispatch
and don’t listen to storeaddTodo
,
completeTodo
, …) without subscribing to the store
import * as actionCreators from './actionCreators'
export default connect(null, actionCreators)(TodoApp)
dispatch
and every field in the global stateDon’t do this! It kills any performance optimizations because
TodoApp
will rerender after every state change. It’s better to have more granularconnect()
on several components in your view hierarchy that each only listen to a relevant slice of the state.
dispatch
and todos
function mapStateToProps(state) {
return { todos: state.todos }
}
export default connect(mapStateToProps)(TodoApp)
todos
and all action creatorsimport * as actionCreators from './actionCreators'
function mapStateToProps(state) {
return { todos: state.todos }
}
export default connect(mapStateToProps, actionCreators)(TodoApp)
todos
and all action creators (addTodo
,
completeTodo
, …) as actions
import * as actionCreators from './actionCreators'
import { bindActionCreators } from 'redux'
function mapStateToProps(state) {
return { todos: state.todos }
}
function mapDispatchToProps(dispatch) {
return { actions: bindActionCreators(actionCreators, dispatch) }
}
export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
todos
and a specific action creator
(addTodo
)
import { addTodo } from './actionCreators'
import { bindActionCreators } from 'redux'
function mapStateToProps(state) {
return { todos: state.todos }
}
function mapDispatchToProps(dispatch) {
return bindActionCreators({ addTodo }, dispatch)
}
export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
todos
and specific action creators (addTodo
and deleteTodo
) with shorthand syntax
import { addTodo, deleteTodo } from './actionCreators'
function mapStateToProps(state) {
return { todos: state.todos }
}
const mapDispatchToProps = {
addTodo,
deleteTodo,
}
export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
todos
, todoActionCreators
as
todoActions
, and counterActionCreators
as
counterActions
import * as todoActionCreators from './todoActionCreators'
import * as counterActionCreators from './counterActionCreators'
import { bindActionCreators } from 'redux'
function mapStateToProps(state) {
return { todos: state.todos }
}
function mapDispatchToProps(dispatch) {
return {
todoActions: bindActionCreators(todoActionCreators, dispatch),
counterActions: bindActionCreators(counterActionCreators, dispatch),
}
}
export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
todos
, and todoActionCreators and
counterActionCreators together as actions
import * as todoActionCreators from './todoActionCreators'
import * as counterActionCreators from './counterActionCreators'
import { bindActionCreators } from 'redux'
function mapStateToProps(state) {
return { todos: state.todos }
}
function mapDispatchToProps(dispatch) {
return {
actions: bindActionCreators(
{ ...todoActionCreators, ...counterActionCreators },
dispatch
),
}
}
export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
todos
, and all todoActionCreators
and
counterActionCreators
directly as props
import * as todoActionCreators from './todoActionCreators'
import * as counterActionCreators from './counterActionCreators'
import { bindActionCreators } from 'redux'
function mapStateToProps(state) {
return { todos: state.todos }
}
function mapDispatchToProps(dispatch) {
return bindActionCreators(
{ ...todoActionCreators, ...counterActionCreators },
dispatch
)
}
export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
todos
of a specific user depending on propsimport * as actionCreators from './actionCreators'
function mapStateToProps(state, ownProps) {
return { todos: state.todos[ownProps.userId] }
}
export default connect(mapStateToProps)(TodoApp)
todos
of a specific user depending on props, and
inject props.userId
into the action
import * as actionCreators from './actionCreators'
function mapStateToProps(state) {
return { todos: state.todos }
}
function mergeProps(stateProps, dispatchProps, ownProps) {
return Object.assign({}, ownProps, {
todos: stateProps.todos[ownProps.userId],
addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text),
})
}
export default connect(mapStateToProps, actionCreators, mergeProps)(TodoApp)
mapToProps
Functions
The number of declared function parameters of
mapStateToProps
and
mapDispatchToProps
determines whether they receive
ownProps
Note:
ownProps
is not passed tomapStateToProps
andmapDispatchToProps
if the formal definition of the function contains one mandatory parameter (function has length 1). For example, functions defined like below won’t receiveownProps
as the second argument. If the incoming value ofownProps
isundefined
, the default argument value will be used.
function mapStateToProps(state) {
console.log(state) // state
console.log(arguments[1]) // undefined
}
const mapStateToProps = (state, ownProps = {}) => {
console.log(state) // state
console.log(ownProps) // {}
}
Functions with no mandatory parameters or two parameters*will receive
ownProps
.
const mapStateToProps = (state, ownProps) => {
console.log(state) // state
console.log(ownProps) // ownProps
}
function mapStateToProps() {
console.log(arguments[0]) // state
console.log(arguments[1]) // ownProps
}
const mapStateToProps = (...args) => {
console.log(args[0]) // state
console.log(args[1]) // ownProps
}
If your mapStateToProps
or
mapDispatchToProps
functions return a function, they will be
called once when the component instantiates, and their returns will be
used as the actual mapStateToProps
,
mapDispatchToProps
, functions respectively, in their
subsequent calls.
The factory functions are commonly used with memoized selectors. This gives you the ability to create component-instance-specific selectors inside the closure:
const makeUniqueSelectorInstance = () =>
createSelector([selectItems, selectItemId], (items, itemId) => items[itemId])
const makeMapState = (state) => {
const selectItemForThisComponent = makeUniqueSelectorInstance()
return function realMapState(state, ownProps) {
const item = selectItemForThisComponent(state, ownProps.itemId)
return { item }
}
}
export default connect(makeMapState)(SomeComponent)
While the connect
API has stayed almost entirely
API-compatible between all of our major versions, there have been some
small changes in options and behavior from version to version.
For details on the legacy 5.x and 6.x versions, please see these archived files in the React Redux repo:


4.5. SIMP Administration¶
This chapter provides guidance on general administration practices applicable to SIMP environments.
Important
It is important to remember that SIMP approaches system configuration from a least privilege, defense in depth, mindset where possible.


Contact Infro
Our contact information
If you want to get in contact with us for catering, or to see what we have in stock, contat us by:
Phone:123-456-7890
Email:cupcakes@email.com


The ImViA Doctoral Day 2019 will offer a unique experience to BSc, MSc and PhD candidates to present and share there experience.
The symposium follows the 3C rule:
Community, Collaboration, Continuity
Feb. 18st, 2019: Paper submission and Online Registration
Feb. 25th, 2019: Review deadlines
Mar. 14th, 2016: Symposium date
Learn MoreMarch 14th, 2019 at Le Creusot
| 9:00 - 9:30 | Welcoming |
|---|---|
| 9:30 - 10:00 | Introduction Talk: David Fofi - ImViA Presentation |
| 10:00 - 11:00 | Presentation Session: Chair: Marc Blanchon Khawla Enim - "A deep learning approach for the segmentation of myocardial diseases" Yu Liu - "A Starting Point for Efficient Human Action Detection" Nathan Piasco - "Learning Scene Geometry for Visual Localization in Challenging Conditions" |
| 11:00 - 12:00 | Poster Session 1 |
| 12:00 - 13:30 | Lunch |
| 13:30 - 14:00 | Talk or Keynote: Fan Yang, Cyrille Migniot and Yannick Benezeth - Relationship between PhD student and supervisor |
| 14:00 - 15:30 | Presentation Session: Chair: Nathan Piasco Peixi Li - "Comparison of region of interest segmentation methods for video-based heart rate measurements" Rita Meziati - "Pulse Rate Variability for Emotional State Assessment" Alexandre Krebs - "Detection of H. pylori induced gastric inflammation by diffuse reflectance analysis" Marc Blanchon - "Outdoor Scenes Pixel-Wise Semantic Segmentation using Polarimetry and Fully Convolutional Network" |
| 15:30 - 15:40 | Break |
| 15:40 - 16:40 | Poster Session 2 |
| 16:40 | Closing |
Poster: 13:30 - 14:30 session
Latex vertical - Download tar.gz
Important ! Every Ph.D student at ImVia must submit a paper at least once during his thesis (in 2nd or 3rd year).
Papers in PDF format must be submitted here.
Each participant at the Doctoral Day will be assigned at least one paper to review.
The members of the Committee will assign the reviewer for each paper. They will as well review supplementary materials.
The Committee strives for a double blind review.
A best paper will be chosen by the committee after final submission.
Registration deadline is the 19 th February 2019.
Participants need to register here before this date.


Week 2
> In week 2 of Digital Engineering we learned how to use Fusion 360 to model
an object to then 3D print. I decided to make a case for my phone. One of the struggles with making
this model was making the case fit my phone. Theoretically, the measurements I had should have been
a perfect fit, but since the 3D printer shrinks the model slightly from its actual size it does not
fit on my phone. If I were to attempt this again I would make sure to take this into consideration.
FILES
Back to index


Before you begin
This is a Xamarin.Forms class which includes projects for iOS, Android, and Windows. When working on the exercises, you can select the easiest supported platform to run your application on. Refer to the Setup Requirements on the Xamarin University website if you need help with your development environment.
Overview
This session introduces the data binding infrastructure that is built into Xamarin.Forms. You will learn how to take advantage of this feature in your Xamarin.Forms applications to reduce the amount of code necessary to present data in your screens.
Objectives
- Use data binding to decouple code-behind from UI
- Use value converters to bind incompatible types
Lecture
XAM310 - Data Binding in Xamarin.Forms.
Exercises
-
Using Data Binding in a Xamarin.Forms ApplicationExercise
This group exercise will introduce creating and using bindings in code-behind and XAML. -
Keeping the UI and data in sync using BindingsExercise
This exercise will implement two-way binding for our UI; this will ensure UI data changes are sent to the code-behind. It will then implementINotifyPropertyChanged
to ensure that the UI is updated when the underlying data is changed. -
Using Value ConvertersExercise
There isn't always a 1:1 mapping between our available data and the user interface that presents that data. Value Converters are the bridge which spans this difference. In this exercise, we will use a Value Converter to data bind images to our resources. -
Homework: abstracting out the shared codeHomework
In this homework assignment, you will pull all the sharable code out of the code behind now that it no longer depends on the UI controls and place it into a separate class which can be unit tested.


Listings and mortgages weak
by Houses and HolesVia CoreLogic, the leading index for weekly mortgages is up modestly year on year:
But the real story is the serious weakness in listings:
There are 780 words left in this subscriber-only article.
Via CoreLogic, the leading index for weekly mortgages is up modestly year on year:
But the real story is the serious weakness in listings:
There are 780 words left in this subscriber-only article.


2 Kings 4:21
And she went up, and laid him on the bed of the man of God, and shut the door upon him, and went out.


Netslide
Slide the grid squares around so that they all join up into a single connected network with no loops.
Click on the arrows at the edges of the grid to move a row or column left, right, up or down. The square that falls off the end of the row comes back on the other end.
Squares connected to the middle square are lit up. Aim to light up every square in the grid (not just the endpoint blobs).
Connecting across a red barrier line is forbidden. On harder levels, there are fewer barriers, which makes it harder rather than easier!


The Story of Us (1999) 1 1/2 stars out of 4. Starring Bruce Willis, Michelle Pfeiffer, Rob Reiner and Rita Wilson. Directed by Reiner.
I wish I could say I liked "The Story of Us." I found it enjoyable and entertaining, but at the same time, simplistic and shallow.
"The Story of Us" is a look at a marriage at a crossroads.
After 15 years and two kids together, Ben and Katie Jordan (Bruce Willis and Michelle Pfeiffer) have nothing left to say to each other.
As one of them narrates, the silences between the pair were louder than any arguments.
Yet the script by Alan Zweibel and Jessie Nelson fails to really show how Ben and Katie grew apart.
There is a lot of talk of neither one listening to the other, of the demands of parenthood and career creating wedges between them. And sequences highlighting these events are shown.
But the entire thing feels superficial and slight. Ben and Katie are presented as two highly educated and articulate individuals, so it is difficult to buy into the proposition that they cannot communicate.
Directed by Rob Reiner, "The Story of Us" is sunny and perky. And that is another of the film's problems It is bathed in a cheery glow that sabotages the supposed dark tone of its main plot.
For in essence, "The Story of Us" is a comedy. Thus it is difficult to seriously accept or be concerned with the disintegration of the Jordans' marriage.
You instinctively know from the outset what the outcome will be.
This is not to imply that "The Story of Us" is a bad movie. It is bubbly and warm, almost at odds with its storyline.
Willis and Pfeiffer are most likable. The only quibble is with Willis' various hair pieces, which become distracting as the film bounces back and forth through various flashbacks into the Jordans' relationship.
As usual, when he is not playing macho he-men, Willis gives a well-rounded performance. He allows Ben's vulnerability to show, as well as his character's rage and frustration with his situation.
Pfeiffer is luminous and golden. Her big, expressive eyes shine with joy or mist with sorrow.
Where the movie falls short is in explaining the estrangement between Ben and Katie. There problems seem so ordinary, so minor - and their love for each other seems so strong - that you wonder what their problems actually are.
An attempt to show their differences by bringing in their parents fails, as does the glimpses of the pair with various counselors. You just cannot take their estrangement on face value.
A talented supporting cast, featuring Reiner and Rita Wilson, work hard to help out Willis and Pfeiffer, but all are undone by a weak script that makes light of the main premise.
"The Story of Us" will satisfy fans of Willis and Pfeiffer, but that's about it. It contains several laughs, but very little insight.
Bob Bloom is the film critic at the Journal and Courier in Lafayette,IN. He can be reached by e-mail at<EMAIL_ADDRESS>or<EMAIL_ADDRESS>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


Tate & Lyle plc 2019 Q2 - Results - Earnings Call Presentation
by SA Transcripts, https://seekingalpha.com/author/sa-transcriptsThe following slide deck was published by Tate & Lyle plc in conjunction with their 2019 Q2 earnings call.
The following slide deck was published by Tate & Lyle plc in conjunction with their 2019 Q2 earnings call.


The Apache HTTP Server is a widely deployed web server that can be used in combination with a WSGI module, such as mod_wsgi or a stand-alone WSGI server to run Python web applications.
Apache remains the most commonly deployed web server with a reign of 20+ years. Its wide usage contributes to the large number of tutorials and open source modules created by developers for anyone to use.
Apache's development began in mid-1994 as a fork of the NCSA HTTP Server project. By early 1996, Apache overtook the previously dominant but suddenly stagnant NCSA server as NCSA's progress stalled due to signficantly reduced development attention.
The official project documentation page contains a section with How-Tos and Tutorials to handle authentication, security and dynamic content.
Reverse proxies shows
how to set up Apache as a reverse proxy using mod_proxy
.
Apache Web Server on Ubuntu 14.04 LTS explains how to install Apache on Ubuntu 14.04, which is still a supported release. Note however, do not install mod_python because it is now insecure and made obsolete by mod_wsgi and WSGI servers.
Deploy Django on Apache with Virtualenv and mod_wsgi provides instructions for what packages to install to get Apache up and running with mod_wsgi on Ubuntu.
Apache and mod_wsgi on Ubuntu 10.04 is an older post that shows how to set up Apache on the now out-of-support Ubuntu 10.04 LTS release. This setup isn't recommended in 2016 and beyond but if you are already using 10.04 as your base operating system you might need to reference this material.
Caddy is a relatively new HTTP server created in 2015 and written in Go. The server's philosophy and design emphasize HTTPS-everywhere along with the HTTP/2 protocol.
Caddy can be used both for testing during local development or as part of a production deployment as an HTTP server and a reverse proxy with the proxy directive.
A look inside Caddy shows and explains some of the Go code written to build the server.
The official Caddy server docs are the spot to look for what directives can be placed into a Caddy configuration file
Caddy a modern web server supporting HTTP/2 is a quick synopsis on installing Caddy along with a short example configuration file.
HTTP 2.0 on localhost with Caddy shows how to use a self-signed certificate with Caddy to do local development with an HTTP/2 web server.
Is Caddy free? explains the donation and sponsorships model that Caddy uses to continue development on the server. The gist is that the server is free to clone, download and use. Sponsors and optional donations are currently used to fund ongoing development.
Green Unicorn, commonly shortened to "Gunicorn", is a Web Server Gateway Interface (WSGI) server implementation that is commonly used to run Python web applications.
Gunicorn is one of many WSGI server implementations, but it's particularly important because it is a stable, commonly-used part of web app deployments that's powered some of the largest Python-powered web applications in the world, such as Instagram.
Gunicorn implements the PEP3333 WSGI server standard specification so that it can run Python web applications that implement the application interface. For example, if you write a web application with a web framework such as Django, Flask or Bottle, then your application implements the WSGI specification.
Gunicorn knows how to run a web application based on the hook between the WSGI server and the WSGI-compliant web app.
Here is an example of a typical Django web application and how it is run by Gunicorn. We'll use the django_defaults as an example Django project. Within the django_defaults project subdirectory, there is a short wsgi.py file with the following contents:
"""
WSGI config for django_defaults project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_defaults.settings")
application = get_wsgi_application()
That wsgi.py
file was generated by the django-admin.py startproject
command
when the Django project was first created. Django exposes an application
variable via that wsgi.py
file so that a WSGI server can use application
as a hook for running the web app. Here's how the situation looks visually:
Gunicorn is based on a pre-fork worker model, compared to a worker model architecture. The pre-work worker model means that a master thread spins up workers to handle requests but otherwise does not control how those workers perform the request handling. Each worker is independent of the controller.
There are three framework-specific posts on the Full Stack Python blog for configuring Gunicorn for development on Ubuntu:
Deploying Django 1.7 on Ubuntu with DigitalOcean with PostgreSQL, Nginx, and Gunicorn is a detailed walkthrough that uses Green Unicorn as the WSGI server part of the deployment.
The Full Stack Python Guide to Deployments provides detailed step-by-step instructions for deploying Gunicorn as part of an entire Python web application deployment.
Flask on Nginx and Gunicorn combines the Nginx web server with Gunicorn in a deployment to serve up a Flask application.
The answers to the question "what's the best practice for running Django with Gunicorn?" provide some nuance for how Gunicorn should be invokin the callable application variable provided by Django within a deployment.
How to Install Django with Gunicorn and Nginx on FreeBSD 10.2 is a tutorial for FreeBSD, which is not often used in walkthroughs compared to the frequency that Ubuntu and CentOS tutorials appear.
How to make a Scalable Python Web App using Flask, Gunicorn, NGINX on Ubuntu 14.04 and Deploy a Flask App on Ubuntu both provide steps for setting up a Flask web app using Gunicorn. There isn't much explanation provided with each tutorial but they can still be good concise references in case you're having issues with Ubuntu.
The Django and Flask documentation each contain instructions for deploying the respective frameworks with Gunicorn.
Set up Django, Nginx and Gunicorn in a Virtualenv controled by Supervisor is a GitHub Gist with some great explanations for why we're setting up virtualenv and what to watch out for while you're doing the deployment.
Testing determines whether software runs correctly based on specific inputs and identifies defects that need to be fixed.
As software scales in codebase size, it's impossible for a person or even a large team to keep up with all of the changes and the interactions between the changes. Automated testing is the only proven method for building reliable software once they grow past the point of a simple prototype. Many major software program development failures can be traced back to inadequate or a complete lack of testing.
It's impossible to know whether software works properly unless it is tested. While testing can be done manually, by a user clicking buttons or typing in input, it should be performed automatically by writing software programs that test the application under test.
There are many forms of testing and they should all be used together. When a single function of a program is isolated for testing, that is called unit testing. Testing more than a single function in an application at the same time is known as integration testing. User interface testing ensures the correctness of how a user would interact with the software. There are even more forms of testing that large programs need, such as load testing, database testing, and browser testing (for web applications).
Python software development culture is heavy on software testing. Because Python is a dynamically-typed language as opposed to a statically-typed language, testing takes on even greater importance for ensuring program correctness.
The Minimum Viable Test Suite shows how to set unit tests and integration tests for a Flask example application.
Good test, bad test explains the difference between a "good" test case and one that is not as useful. Along the way the post breaks down some myths about common testing subjects such as code coverage, assertions and mocking.
Python Testing is a site devoted to testing in - you guessed it - the Python programming language.
The case for test-driven development by Michael DeHaan explains how automation is the only way to build software at a large scale.
Google has a testing blog where they write about various aspects of testing software at scale.
Still confused about the difference between unit, functional and integration tests? Check out this top answer on Stack Overflow to that very question.
Using pytest with Django shows how to get a basic pytest test running for a Django project and explains why the author prefers pytest over standard unittest testing.
Unit testing is a method of determining the correctness of a single function isolated from a larger codebase. The idea is that if all the atomic units of an application work as intended in isolation, then integrating them together as intended is much easier.
Unit testing is just one form of testing that works in combination with other testing approaches to wring out the bugs from a piece of software being developed. When several functions and classes are put together it's often difficult to determine the source of a problem if several bugs are occurring at the same time. Unit testing helps eliminate as many of the individual bugs as possible so when the application comes together as a whole the separate parts work as correct as possible. Then when issues arise they can often be tracked down as unintended consequences of the disparate pieces not fitting together properly.
There are many tools for creating tests in Python. Some of these tools, such as pytest, replace the built-in unittest framework. Other tools, such as nose, are extensions that ease test case creation. Note that many of these tools are also used for integration testing by writing the test cases to exercise multiple parts of code at once.
unittest is the built-in standard library tool for testing Python code.
pytest is a complete testing tool that emphasizes backwards-compatibility and minimizing boilerplate code.
nose is an extension to unittest that makes it easier to create and execute test cases.
testify was a testing framework meant to replace the common unittest+nose combination. However, the team behind testify is transitioning to pytest so it's recommended you do not use testify for new projects.
Dive into Python 3's chapter on unit testing has a complete example with code and a detailed explanation for creating unit testing with the unittest module.
Unit Testing Your Twilio App Using Python’s Flask and Nose is a detailed tutorial for using the nose test runner for ensuring a Flask application is working properly.
Understanding unit testing explains why testing is important and shows how to do it effectively in your applications.
Unit testing with Python provides a high-level overview of testing and has diagrams to demonstrate what's going on in the testing cycle.
The Python wiki has a page with a list of Python testing tools and extensions.
Working Effectively with Unit Tests is an interview with the author of a book by the title where he shares some of the insight he's learned on the topic.
Generate your tests
shows how to write a test generator that works with the unittest
framework.
An Extended Introduction to the nose Unit Testing Framework shows how this test runner can be used to write basic test suites. While the article is from 2006, it remains relevant today for learning how to use nose with your projects.
Integration testing exercises two or more parts of an application at once, including the interactions between the parts, to determine if they function as intended. This type of testing identifies defects in the interfaces between disparate parts of a codebase as they invoke each other and pass data between themselves.
While unit testing is used to find bugs in individual functions, integration testing tests the system as a whole. These two approaches should be used together, instead of doing just one approach over the other. When a system is comprehensively unit tested, it makes integration testing far easier because many of the bugs in the individual components will have already been found and fixed.
As a codebase scales up, both unit and integration testing allow developers to quickly identify breaking changes in their code. Many times these breaking changes are unintended and wouldn't be known about until later in the development cycle, potentially when an end user discovers the issue while using the software. Automated unit and integration tests greatly increase the likelihood that bugs will be found as soon as possible during development so they can be addressed immediately.
Integration testing with Context Managers gives an example of a system that needs integration tests and shows how context managers can be used to address the problem. There are a couple other useful posts in this series on testing including thoughts on integration testing and processes vs. threads for integration testing.
Pytest has a page on integration good practices that you'll likely want to follow when testing your application.
Integration testing, or how to sleep well at night explains what integration tests are and gives an example. The example is coded in Java but still relevant when you're learning about integration testing.
Code metrics can be produced by static code analysis tools to determine complexity and non-standard practices.
Code metrics allow developers to find problematic codebase areas that may need refactoring. In addition, some metrics such as technical debt assist developers in communicating to non-technical audiences why issues with a system are occurring.
Radon is a tool for obtaining raw metrics on line counts, Cyclomatic Complexity, Halstead metrics and maintainability metrics.
Pylint contains checkers for PEP8 code style compliance, design, exceptions and many other source code analysis tools.
PyFlakes parses source files for errors and reports on them.
Pyntch is a static code analyzer that attempts to detect runtime errors. It does not perform code style checking.
Static Code Analizers for Python is an older article but goes over the basics of what Python static code analyzers do.
This Stack Overflow question on Python static code analysis tools contains comparison discussions of PyLint, PyChecker and PyFlakes.
Getting Started with Pylint goes over setting up Pylint, generating the .pylintrc file and what's in the configuration.
This /r/Python poll on what linters the community uses provides some input on using PyCharm just for its linting features as well as some other approaches.
Developers often find themselves in situations where the code they've written is not working quite right. When that happens, a developer debugs their code by instrumenting, executing and inspecting the code to determine what state of the application does not match the assumptions of how the code should be correctly running.
There are bugs in every modest sized or larger application. Every developer has to learn how to debug code in order to write programs that work as correctly as time and budget allow.
Debugging your Python code walks through a scenario where pdb can be used to find a defect in a block of Python code.
pdb - Interactive Debugger is featured on the Python Module of the Week blog and has some great detail on using the program effectively.
Python debugging tools provides a list of tools such as pdb and its derivatives ipdb, pudb and pdb++ along with how they can be used in the hunt for defects.
Debugging in Python elaborates on what pdb does and how it can be used.
Bots are software programs that combine requests, which are typically provided as text, with contextual data, such as geolocation and payment information, to appropriately handle the request and respond. Bots are often also called "chatbots", "assistants" or "agents."
How to Buid an SMS Slack Bot is a tutorial on using SMS text messages to communicate with a Slack bot that can post and receive messages. The bot is a good base for a more complicated Slack bot that could use natural language processing or other more advanced parsing techniques. Either Python 2 or 3 can be used with the code which is also available on GitHub.
How to write a Slack bot in Python is a solid code tutorial for building your first bot on the Slack platform.
A Slack bot with Python’s 3.5 asyncio shows how to connect a bot to Slack via the web API using the Python 3 asyncio standard library.
Facebook-Message-Bot is an open source Facebook Messenger bot written in Python.
Slack bot token leakage exposing business critical information is a detailed look at a search on GitHub for Slack tokens that are used mostly for bots but must be kept secret. Otherwise those tokens expose the entire Slack team's messaging to outside parties.
The Economist wrote a general piece on why bots look like they'll gain adoption in various market segments. The piece doesn't have much technical depth but it's a good overview of how some businesses are looking at the opportunity.
Bots won't replace apps is a fantastic piece by WeChat's product manager on how text-based bots alone typically do not provide a good user experience. Instead, chat apps with automated responses, user data and basic web browser functionality are what has allowed bot concepts to bloom in Asian markets. There's a lot of good information in this post to unpack.
The terms "full stack" and "Full Stack Python" are ambiguous but I am using a specific definition here on this site. These term can be defined for a web stack either to mean
Every layer, from the machine code up to the browser, are written in Python
Python code interacts with code written in other languages such as C and JavaScript to provide a complete web stack
I named this site specifically for the second definition: Python is one programming language among many that are used to build your application stack.
Some folks took the title of the site to mean Python runs everything from the web browser on down. That's simply not practical or possible. While Python is an amazing programming language, there are many tasks it does not do well.
Python is just one language among many that allows our computers to execute software and communicate with each other.
For beginners, learning the syntax and libraries in Python necessary to build a web application or web API is a major undertaking. Even intermediate and advanced Python software developers need to constantly program and learn to keep up with our ever evolving ecosystem. I created Full Stack Python to be just one of many resources that help Python developers build and maintain their programming skills.
This is a running list of the major changes to Full Stack Python since its inception in December 2012. Another way to view the modifications is through the source repository's commit log on GitHub.
New logo! This one's way more Python software stack, way less boring folder-thingy. Here's how the old one looked in comparison:
Added a future direction section to explain current priorities for further developments on the site.
Full Stack Python has completely blown away my expectations for what I could accomplish with a side project. I really appreciate all the in-person feedback, emails and pull requests I've received from the community. Keep them coming!
For 2016 I'm building out the scope of the site beyond web development into core Python concepts, data analysis and visualization and (hopefully) some hardware hacking such as with the Raspberry Pi and Arduino Yun.
A huge update was released in the form of the The Full Stack Python Guide to Deployments, a step-by-step tutorial book for learning how to deploy Python web applications.
Note that these plans can change based on pull requests from the community. I work to integrate PRs within a day or two so please submit one when you see a fix or improvement that needs to be made!
This website was coded and written by Matt Makai (@mattmakai), currently a Developer Evangelist at Twilio in San Francisco, California.
Other projects by Matt include The Full Stack Python Guide to Deployments book, Coding Across America, Underwear and Choose Your Own Adventure Presentations. You can reach him by email at<EMAIL_ADDRESS>Twitter @mattmakai or on GitHub at makaimc.
Read my thoughts on the "full stack" trend in a post I wrote for O'Reilly Radar.
Typos, inaccurate statements or general areas for improvement can be handled through an issue ticket or pull request on GitHub.


Some of your workplaces' data does not meet the WDF {{ wdfStartDate | date: 'yyyy' }} to
{{ wdfEndDate | date: 'yyyy' }} requirements
Your workplaces met the WDF 2021 to 2022 requirements, but updating those currently shown as 'not meeting' will save
you time next year.
All your workplaces' data meets the WDF {{ wdfStartDate | date: 'yyyy' }} to
{{ wdfEndDate | date: 'yyyy' }} requirements


public static interface IWorkspaceConnection.IConfigurationOpFactory
#commit(IChangeSetHandle, Collection)
| Modifier and Type | Method and Description |
|---|---|
IWorkspaceConnection.IDeleteOp |
delete(IVersionableHandle itemHandle)
Returns a operation object for deleting a versionable item from the
workspace's configuration.
|
IWorkspaceConnection.IDeleteSubtreeOp |
deleteSubtree(IFolderHandle folderHandle)
Returns an operation object for deleting a subtree of versionable
items rooted at the specified folder from the workspace's
configuration.
|
IWorkspaceConnection.IMarkAsMergedOp |
markAsMerged(IVersionableHandle item,
IVersionableHandle selectedContributorState,
IVersionableHandle proposedContributorState)
Returns an operation object representing the desire to resolve a conflict
with the state which currently exists in the configuration.
|
IWorkspaceConnection.IMergeOp |
merge(IWorkspaceConnection.IMergeResultOp nestedOp,
IVersionableHandle selectedContributorState,
IVersionableHandle proposedContributorState)
Returns an operation object representing the desire to resolve a conflict
through the action as indicated by a supplied configuration operation object.
|
IWorkspaceConnection.IRevertOp |
revert(IVersionableHandle itemStateHandle)
Returns a operation object for placing a versionable item in the
workspace's configuration in a pre-existing state whose state id is
included with the handle.
|
IWorkspaceConnection.ISaveOp |
save(IVersionable item)
Returns an operation object for placing a versionable item in
the workspace's configuration in the given state.
|
IWorkspaceConnection.ISaveOp |
save(IVersionable item,
java.util.Collection<? extends com.ibm.team.scm.common.internal.dto.ExternalLinkEntry> externalLinks)
Returns an operation object for placing a versionable item in
the workspace's configuration in the given state.
|
IWorkspaceConnection.IUndoOp |
undo(IVersionableHandle itemHandle)
Returns a operation object for removing changes for the given item
from an active change set.
|
IWorkspaceConnection.IUndoMergeOp |
undoMerge(IVersionableHandle itemHandle)
Returns a operation object for undoing the merge for the given item
from an active change set.
|
IWorkspaceConnection.ISaveOp save(IVersionable item)
IItem.getWorkingCopy()
of an existing versionable; the versionable is a working copy of a
previously-retrieved state that the client has modified to suit.
In both case, a new versionable state is created in the repository.item
- the versionable item; must be a working copy, must not be null
commit
; never null
IWorkspaceConnection.ISaveOp save(IVersionable item, java.util.Collection<? extends com.ibm.team.scm.common.internal.dto.ExternalLinkEntry> externalLinks)
IItem.getWorkingCopy()
of an existing versionable; the versionable is a working copy of a
previously-retrieved state that the client has modified to suit.
In both case, a new versionable state is created in the repository.item
- the versionable item; must be a working copy, must not be null
externalLinks
- external links if any.commit
; never null
IWorkspaceConnection.IMergeOp merge(IWorkspaceConnection.IMergeResultOp nestedOp, IVersionableHandle selectedContributorState, IVersionableHandle proposedContributorState)
IWorkspaceConnection.commit(IChangeSetHandle, Collection, IProgressMonitor)
.
If the supplied contributors (selected & proposed) do not align with what is in the conflict
record for that item, the call to commit() will fail.nestedOp
- an operation which serves as the merge result for a conflict; cannot be null
.selectedContributorState
- an item-state handle which describes the selected contributor to the conflict, can
be null
to indicate a deletion.proposedContributorState
- an item-state handle which describes the proposed contributor to the conflict, can
be null
to indicate a deletion.commit
; never null
IWorkspaceConnection.conflictReport()
,
IItemConflictReport.getProposedContributorState()
,
IItemConflictReport.getSelectedContributorState()
IWorkspaceConnection.IMarkAsMergedOp markAsMerged(IVersionableHandle item, IVersionableHandle selectedContributorState, IVersionableHandle proposedContributorState)
It is also considered an error (at the time of commit()) to perform this operation on an item whose state selection refers to a state that is not a successor to the originally selected state for the conflict.
The intended use of this operation is as follows:#save(IVersionable,IVersionableHandle,IVersionableHandle)
into two distinct
(but equivalent) stepsitem
- the versionable item handle; the state id, if present, is
ignored; must not be null
selectedContributorState
- an item-state handle which describes the selected contributor to the conflict, can
be null
to indicate a deletion.proposedContributorState
- an item-state handle which describes the proposed contributor to the conflict, can
be null
to indicate a deletion.commit
; never null
IWorkspaceConnection.conflictReport()
IWorkspaceConnection.IRevertOp revert(IVersionableHandle itemStateHandle)
itemStateHandle
- the versionable item handle with state id; must not be
null
commit
; never null
IWorkspaceConnection.IDeleteOp delete(IVersionableHandle itemHandle)
Note that one of these operations cannot be commited alone. It is always necessary to simultaneously commit a modification to (or deletion of) the folder that contains the given item.
itemHandle
- the versionable item handle; the state id, if present, is
ignored; must not be null
commit
; never null
IWorkspaceConnection.IDeleteSubtreeOp deleteSubtree(IFolderHandle folderHandle)
If the folder has descendants in the configuration at commit time,
this operation "macro expands" to a set of individual
delete(IVersionableHandle)
operations for each of the items
in the subtree, including the folder itself. It is considered an
error (detected at commit time) if after macro expanding a single
call to commit has multiple operations that mention the same item.
folderHandle
- the versionable folder item handle; the state id, if
present, is ignored; must not be null
commit
; never null
IWorkspaceConnection.IUndoOp undo(IVersionableHandle itemHandle)
itemHandle
- the versionable item handle; the state id, if present, is
ignored; must not be null
commit
; never null
IWorkspaceConnection.IUndoMergeOp undoMerge(IVersionableHandle itemHandle)
itemHandle
- the versionable item handle; the state id, if present, is
ignored; must not be null
commit
; never null


Why do people keep saying this rebrand is going to overnight change things... it's a process...
3
Alecandro23-May-19 02:58 AM
Can you store ARRR in the Agama wallet?
Regnar23-May-19 02:58 AM
It's in Beta and is a new community project that is doing Automated escrow services. I'm not sure how much ARRR is available but you can put an order request up and see if someone fills it
Yes, ARRR runs only in Native mode though, so you have to sync the chain and can't run Native and Lite modes at the same time
Alecandro23-May-19 03:00 AM
ahhh okay so better off getting the wallet then
Regnar23-May-19 03:00 AM
?
Alecandro23-May-19 03:00 AM
Pirate Ocean?
Sorry haha
Regnar23-May-19 03:00 AM
ohh yea
PirateOcean is another wallet that can store ARRR
You can also run CLI (what I use) though that has no GUI
Not sure if this works still since new options have come out, but back when Pirate just started people used this to get some easily. https://dexstats.info/onboarding.php I think @CHMEX runs it
Contribute to artemii235/SuperNET development by creating an account on GitHub.
johnwhitestar23-May-19 08:51 AM
@KomodoWorld I'm a trader, trying to switch to a Dex, as I'm sick of losing money on CEXs. So what you are saying does it mean that there is no place to trade at the moment?
KomodoWorld23-May-19 08:52 AM
sorry, currently there's no practical way to trade via BarterDEX, you should check again in a few months. v2 is a vast improvement on v1 on all aspects
johnwhitestar23-May-19 08:53 AM
and the info I mentioned previously has to do with v1, which is still active, right?
KomodoWorld23-May-19 08:54 AM
yes, but not sure if there are nodes active now
johnwhitestar23-May-19 08:55 AM
what would be the best strategy for me to get notice soon after v2 is released?
KomodoWorld23-May-19 08:57 AM
follow Komodo on twitter, reddit or subscribe the newsletter. It will be announced. Tere will be an open beta before a full release
1
johnwhitestar23-May-19 08:57 AM
so I'll see the announcement here as well?
KomodoWorld23-May-19 08:57 AM
yes of course
johnwhitestar23-May-19 08:57 AM
(I mean in # official channel)
KomodoWorld23-May-19 08:58 AM
yes it will be an important announcement
johnwhitestar23-May-19 08:59 AM
Thank you very much!
CryptoNinjaa23-May-19 09:04 AM
It will be historic when MM2 platforms are released
FishyGuts23-May-19 09:28 AM
If you follow KMD you wont miss it @johnwhitestar - And all the free marketing hacked and compromised CEX's give BarterDEX will remind you too.
As @jl777c said, even with an unlimited budget, Komodo couldn't have purchased the kind of marketing BarterDEX has been getting lately in regards to CEXs being a problem.
johnwhitestar23-May-19 09:38 AM
That's true
Crabby Paddy23-May-19 09:42 AM
Zex looking juicy on dp
FishyGuts23-May-19 09:43 AM
Do I need to migrate my zex?
I mined a bunch while back
Crabby Paddy23-May-19 09:44 AM
Snapshot and airdrop happened already. As long as you have keys
FishyGuts23-May-19 09:44 AM
and when rfox airdrop?
Crabby Paddy23-May-19 09:44 AM
You’re fine
FishyGuts23-May-19 09:44 AM
yes I have them
Crabby Paddy23-May-19 09:44 AM
Rfox is dependant on Benny, so maybe ask him or wait for news on that one
FishyGuts23-May-19 09:44 AM
So if I migrate or w/e I will have zexo and rfox?
ok thanks
Zex discord hafve info for migrating or hasn't happened yet?
Crabby Paddy23-May-19 09:47 AM
Has happened just Linux wallet working (Zexo chain)


There are several MIDI messages which make up the MTC protocol. All but one are specially defined SysEx messages.
The most important message is the Quarter Frame message (which is not a SysEx message). It has a status of 0xF1, and one subsequent data byte. This message is sent periodically to keep track of the running SMPTE time. It's analogous to the MIDI Clock message. The Quarter Frame messages are sent at a rate of 4 per each SMPTE Frame. In other words, by the time that a slave has received 4 Quarter Frame messages, a SMPTE Frame has passed. So, the Quarter Frame messages provide a "sub-frame" clock reference. (With 30 fps SMPTE, this "clock tick" happens every 8.3 milliseconds).
But the Quarter Frame is more than just a quarter frame "clock tick". The Quarter Frame message's data byte contains the SMPTE time (ie, hours, minutes, seconds, and frames). SMPTE time is normally expressed in 80 bits. Obviously, this is too many bits to be contained in 1 8-bit data byte. So, each Quarter Frame message contains just one piece of the time (for example, one Quarter Frame may contain only the hours). In order to get the entire SMPTE time at any given point, a slave needs to receive several Quarter Frame messages, and piece the current SMPTE time together from those messages. It takes 8 Quarter Frame messages to convey the current SMPTE time. In other words, by the time that a slave can piece together the current SMPTE time, two SMPTE frames have passed (ie, since there are 4 Quarter Frame messages in each frame). So, MTC's version of SMPTE time actually counts in increments of 2 SMPTE Frames per each update of the current SMPTE time.
The first (of 8) Quarter Frame message contains the low nibble (ie, bits 0 to 3) of the Frame Time. The second Quarter Frame message contains the high nibble (ie, bits 4 to 7) of the Frame Time. The third and fourth messages contain the low and high nibbles of the Seconds Time. The fifth and sixth messages contain the low and high nibbles of the Minutes Time. The seventh and eighth messages contain the low and high nibbles of the Hours Time. The eighth message also contains the SMPTE frames-per-second Type (ie, 24, 25, 30 drop, or 30 fps). If you were to break up the Quarter Frame's data byte into its 7 bits, the format is:
0nnn dddd
where nnn is one of 7 possible values which tell you what dddd represents. Here are the 7 values, and what each causes dddd to represent.
Value dddd 0 Current Frames Low Nibble 1 Current Frames High Nibble 2 Current Seconds Low Nibble 3 Current Seconds High Nibble 4 Current Minutes Low Nibble 5 Current Minutes High Nibble 6 Current Hours Low Nibble 7 Current Hours High Nibble and SMPTE Type0xF1 0x25
means that the 5 is the low nibble of the Seconds Time (because nnn is 2). If the following Quarter Frame is subsequently received,
0xF1 0x32
then this means that 2 is the high nibble of the Seconds Time. Therefore, the current SMPTE Seconds is 0x25 (ie, 37 seconds).
In the data byte for the Hours High Nibble and SMPTE Type, the bits are interpreted as follows:
0nnn x yy d
where nnn is 7. x is unused and set to 0. d is bit 4 of the Hours Time. yy tells the SMPTE Type as follows:0 = 24 fps 1 = 25 fps 2 = 30 fps (Drop-Frame) 3 = 30 fps
When MTC is running in the forward direction (ie, time is advancing), the Quarter Frame messages are sent in the order of Frames Low Nibble to Hours High Nibble. In other words, the order looks something like this:
0xF1 0x0n where n is the current Frames Low Nibble 0xF1 0x1n where n is the current Frames High Nibble 0xF1 0x2n where n etc. 0xF1 0x3n 0xF1 0x4n 0xF1 0x5n 0xF1 0x6n 0xF1 0x7nWhen MTC is running in reverse (ie, time is going backwards), these are sent in the opposite order, ie, the Hours High Nibble is sent first and the Frames Low Nibble is last.
The arrival of the 0xF1 0x0n and 0xF1 0x4n messages always denote where SMPTE Frames actually occur in realtime.
Since 8 Quarter Frame messages are required to piece together the current SMPTE time, timing lock can't be achieved until the slave has received all 8 messages. This will take from 2 to 4 SMPTE Frames, depending upon when the slave comes online.
The Frame number (contained in the first 2 Quarter Frame messages) is the SMPTE Frames Time for when the first Quarter Frame message is sent. But, because it takes 7 more Quarter Frames to piece together the current SMPTE Time, when the slave does finally piece the time together, it is actually 2 SMPTE Frames behind the real current time. So, for display purposes, the slave should always add 2 frames to the current time.
For cueing the slave to a particular start point, Quarter Frame messages are not used. Instead, an MTC Full Frame message should be sent. The Full Frame is a SysEx message that encodes the entire SMPTE time in one message as so (in hex):
F0 7F cc 01 01 hr mn sc fr F7
cc is the SysEx channel (0 to 127). It is suggested that a device default to using its Manufacturer's SysEx ID number for this channel, giving the musician the option of changing it. Channel number 0x7F is used to indicate that all devices on the daisy-chain should recognize this Full Frame message.
The hr, mn, sc, and fr are the hours, minutes, seconds, and frames of the current SMPTE time. The hours byte also contains the SMPTE Type as per the Quarter Frame's Hours High Nibble message.
The Full Frame simply cues a slave to a particular SMPTE time. The slave doesn't actually start running until it starts receiving Quarter Frame messages. (Which implies that a slave is stopped whenever it is not receiving Quarter Frame messages). The master should pause after sending a Full Frame, and before sending a Quarter Frame, in order to give the slave time to cue to the desired SMPTE time.
During fast forward or rewind (ie, shuttle) modes, the master should not continuously send Quarter Frame messages, but rather, send Full Frame messages at regular intervals.
SMPTE also provides for 32 "user bits", information for special functions which vary with each product. (Usually, these bits can only be programmed from equipment that supports such). Upto 4 characters or 8 digits can be written. Examples of use are adding a date code or reel number to a tape. The user bits tend not to change throughout a run of time code, so rather than stuffing this information into a Quarter Frame, MTC provides a separate SysEx message to transmit this info.
F0 7F cc 01 02 u1 u2 u3 u4 u5 u6 u7 u8 u9 F7
cc is the SysEx channel (0 to 127). Only the low nibble of each of the first 8 data bytes is used. Only the 2 low bits of u9 is used.
u1 = 0000aaaa
u2 = 0000bbbb
u3 = 0000cccc
u4 = 0000dddd
u5 = 0000eeee
u6 = 0000ffff
u7 = 0000gggg
u8 = 0000hhhh
u9 = 000000ii
These nibbles decode into an 8-bit format of aaaabbbb ccccdddd eeeeffff gggghhhh ii. It forms 4 8-bit characters, and a 2 bit Format Code. u1 through u8 correspond to the SMPTE Binary Groups 1 through 8. u9 are the 2 Binary Group Flag Bits, defined by SMPTE.
The Users Bits messages can be sent at any time, whenever these values must be passed to some device on the daisy-chain.
There are two Notation Information messages which can be used to setup a device that needs to interact with the musician using musical bars and beats.
Time Signature
The Time Signature message can setup Time Signature or indicate a change of meter.
F0 7F cc 03 ts ln nn dd qq [nn dd...] F7
cc is the SysEx channel (0 to 127).
ts is 02 if the Time Signature is to be changed now, or 42 if the Time Signature is to be changed at the end of the currently playing measure.
ln is the number of data bytes following this field. Normally, this will be a 3 if there is not a compound time signature in the measure.
nn dd are the Numerator and Denominator of the Time Signature, respectively. Like with MIDI File Format's Time Signature MetaEvent, the Denominator is expressed as a power of 2.
qq is the number of notated 32nd notes in a MIDI quarter note. Again, this is similiar to the same field in MIDI File Format's Time Signature MetaEvent.
[nn dd ...] are optional, additional pairs of num/denom, to define a compound time signature within the same measure.
Bar Marker
The Bar Marker message indicates the start of a musical measure. It could also be used to setup and mark off bars of an introductory "count down".
F0 7F cc 03 01 lb mb F7
cc is the SysEx channel (0 to 127).
lb mb is the desired bar number, with the LSB first (ie, Intel order). This is a signed 14-bit value (low 7 bits are in lb, right-justified, and bits 8 to 14 are in mb, right-justified). Zero and negative numbers up to -8,190 indicate count off measures. For example, a value of -1 (ie, lb mb = 7F 7F) means that there is a one measure introduction. A value of zero would indicate no count off. Positive values indicate measures of the piece. The first measure is bar 1 (ie, lb mb = 01 00). A maximum neg number (lb mb = 00 40) indicates "stopped play" condition. A maximum positive value (lb mb = 7E 3F) indicates running condition, but no idea about measure number. This would be used by a device wishing to mark the passage of measures without keeping track of the actual measure number.
The Setup message can be used to implement one of 19 defined "events". A master device uses this message to tell slave units what "events" to perform, and when to perform those events. Here's the general template for the message.
F0 7F cc 04 id hr mn sc fr ff sl sm [more info] F7
cc is the SysEx channel (0 to 127).
hr mn sc fr ff is the SMPTE time when the event is to occur. This is just like the Full Frame message, except that there is also a fractional frame parameter, ff, which is 1/100 of a frame (ie, a value from 0 to 99).
sl sm is this event's 14-bit Event Number (0 to 16,383). sl is bits 0 to 6, and sm is bits 7 to 13.
id tells what this Event Type is. Depending upon the Type, the message may have
additional bytes placed where
Special (00)
Contains the setup information that affects a device globally, as opposed to individual tracks, sounds, programs, sequences, etc.). In this case, the Event Number is actually a word which further describes what the event is, as so:
Time Code Offset (00 00) refers to a relative Time Code offset for each unit. For example, a piece of video and a piece of music that are supposed to go together may be created at different times, and likely have different absolute time code positions. Therefore, one must be offset from the other so that they will match up. Each slave on the daisy-chain needs its own offset so that all can be matched up to the master's SMPTE start time.
Enable Event List (01 00) means for a slave to enable execution of events in its internal "list of events" when each one's respective SMPTE time occurs.
Disable Event List (02 00) means for a slave to disable execution of events in its internal "list of events", but not to erase the list.
Clear Event List (03 00) means for a slave to erase all events in its internal list.
System Stop (04 00) refers to a time when the slave may shut down. This serves as a protection against Event Starts without Event Stops, tape machines running past the end of a reel, etc.
Event List Request (05 00) is sent by the master, and requests the slave (whose channel matches the message) to send all events in its list as a series of Setup messages, starting from the SMPTE time in this message.
NOTE: For the first 5 Special messages, the SMPTE time isn't used and is ignored.
Punch In (01) and Punch Out (02)
These refer to the enabling and disabling of record mode on a slave. The Event Number refers to the track to be recorded. Multiple Punch In and Punch Out points (and any of the other Event Types below) may be specified by sending multiple Setup messages with different SMPTE times.
Delete Punch In (03) and Delete Punch Out (04)
Deletes the Punch In or Punch Out (with the matching Event Number and SMPTE Time) from the slave's event list. In other words, it deletes a previously sent Punch In or Punch Out Setup message.
Event Start (05) and Event Stop (06)
These refer to the start/stop (ie, playback) of some continuous action (ie, an action that begins when an Event Start is received, and continues until an Event Stop is received). The Event Number refers to which action on the slave is to be started/stopped. Such actions may include playback of a specific looped waveform, a fader moving on an automated mixer, etc.
Event Start (07) and Event Stop (08) with additional info
Almost the same as the above 2 Event Types, but these have additional bytes before the final 0xF7. Such additional bytes could be for an effect unit's changing parameters, the volume level of a sound effect being adjusted, etc. The additional info should be nibblized with the lowest bits first. For example, if the Note On message 0x91 0x46 0x7F was to be encoded in some additional info bytes, they would be 0x01 0x09 0x06 0x04 0x0F 0x07.
Delete Event Start (09) and Delete Event Stop (0A)
Deletes the Event Start or Event Stop (with the matching Event Number and SMPTE Time) from the slave's event list. In other words, it deletes a previously sent Event Start or Event Stop Setup message (either the Types without additional info, or with additional info).
Cue Point (0B)
Sets an action to be triggered (ie, an action that does something once and automatically stops afterward) or a marker at the specified SMPTE time. These include a "hit" point for a sound effect, a marker for an edit point, etc. The Event Number should represent the action or marker. For example, Event Number 3 could be to trigger a car crash sound effect. Then, several car crashes could be specified by sending several Cue Point Setup messages, each with Event Number 3, but different SMPTE times.
Cue Point (0C) with additional info
Like the above, but this message may have additional bytes before the final 0xF7. Such additional bytes could be for an effect unit's parameters, the volume level of a sound effect, etc. The additional info should be nibblized with the lowest bits first.
Delete Cue Point (0D)
Deletes one of the preceding 2 Setup messages (with the same Event Number and SMPTE time) from the slave's event list.
Event Name (0E) with additional info)
This assigns an ascii name to the event with the matching Event Number and SMPTE time. It for the musician's point of reference. The additional info bytes are the ascii name. For a newline character, include both a carriage return (0x0A) and line feed (0x0D). The ascii bytes are nibblized. For example, ascii 'A' (0x41) becomes the two bytes, 0x01 0x04.
To summarize the interaction between master and slave depending upon "play mode":
The master is in normal play at normal or vari-speed rates. The master is sending Quarter Frame messages to the slave. The messages are in ascending order, starting with 0xF1 0x0n and ending with 0xF1 0x7n. If the master is capable of reverse play, then the messages are sent in reverse, starting with 0xF1 0x7n and ending with 0xF1 0x0n.
The master is being "rocked" or "cued" by hand. For example, a tape machine may have the tape still in contact with the playback head so that the musician can cue the contents of the tape to a specific point. The master is sending Quarter Frame messages to the slave. The messages are in ascending order, starting with 0xF1 0x0n and ending with 0xF1 0x7n. If the master is playing in a reverse direction, then the messages are sent in reverse, starting with 0xF1 0x7n and ending with 0xF1 0x0n. Because the musician may be changing the tape direction rapidly, the order of the Quarter Frames must change along with the tape direction.
The master is rewinding or fast forwarding tape. No contact is made with the playback head. So, no cueing is happening. Therefore, the master only need send the slave periodic Full Frame messages at regular intervals as a rough indication of the master's position. The SMPTE time indicated by the last Full Frame message actually takes affect upon the reception of the next Quarter Frame message (ie, when Play Mode resumes).


Biti blasts ‘Mnangagwa nonsense’
by Staff ReporterMDC Vice President Tendai Biti has described Wednesday’s brutal disruption of party President Nelson Chamisa’s Harare address to his supporters as nonsensical and a typical President Emmerson Mnangagwa move to suppress opposition activities.
“We say no to fascism, we say no to madness. SADC must be watching this. Mrs. Tax must be watching, President (South African Cyril) Ramaphosa must be watching this,” said Biti Wednesday while speaking to journalists outside the MDC HQ.
“We do not want this nonsense. This is a typical Mnangagwa move.”
Biti’s comments followed chaotic events earlier in the day when truckloads of anti-riot police descended on Chamisa’s Hope of the Nation Address (HONA) Wednesday, beating up and injuring dozens of party supporters.
Ordinary citizens were also caught up in the skirmishes.
The police details were under supervision by the Officer Commanding Harare District Oscar Mugomeri.

Police had also descended on civilians in Harare’s teeming downtown area.
About 25 civilians were reported injured.
This included an elderly man who had blood gushing from his head after he was struck with a baton stick.
Some of those caught up in the violence were later admitted at a private hospital in Harare.
The brutal police reaction elicited strong condemnation from the MDC, civil society and further spotlighted on President Mnangagwa’s half-hearted commitment to restoring the country back to good leadership.
Source – newzimbabwe


Welcome to the Home Page
Home
Customer Info Sign Up
Today Sale
Billing
About Us
Contact Us
Reach me through my email:
manishkumar.bobbili3@gmail.com


Neuroplasticity and the Growth Mindset.
Discuss how understanding the principles of neuroplasticity benefits people.
When we learn, we create new pathways between neurons in our brains. We often get caught in a trap of saying "I'm good at X but I'm terrible at Y" and that becomes a fixed concept to us. Neuroplasticity means that "even though I'm currently terrible at Y, I can learn about it and get better at it, it isn't something that I have to live with forever. I am not the issue, I just haven't been exposed to it enough". The value of understanding Neuroplasticity is that anyone can learn anything.
Discuss how you might engage with the principals of neuroplasticity for your own benefit.
As I'm currently learning to code as a part of the Enspiral Dev Academy, understanding neuroplasticity allows me to get past self doubts and negativity in my learning process. Proficiency with a skill doesnt happen in 2 weeks.
What are some of the ways to increase your neuroplasticity?
- Get enough quality sleep.
- Keep active and excercise.
- Find purpose in what you're doing.
- Read books.
I found a lot of this here:
- https://thriveglobal.com/stories/how-to-improve-your-neuroplasticity/
I found this site quite helpful in that it provides real things that you can actively keep on top of to improve neuroplasticity.
Discuss what is a Growth Mindset and why it is relevant
I found this image at https://www.mindsetworks.com/science/Impact and so credit goes to them. I learn best visually and so this was an awesome, simple and clear way to explain the value and characteristics of a growth mindset.
How will you integrate growth mindset into your learning journey?
- Celebrate growth with others. This will mean giving honest and true praise to others in my cohort and being able to accept it when it's given to me.
- Emphasise growth over speed. recognise that I won't be the fastest to learn if I want to learn it well. I will and should make mistakes to grow from them.
- Be realistic in my expectations of myself. Its going to take a lot longer than this bootcamp for me to be a brilliant developer but it will give me a strong start and help me find a growth path.
Link to a resource that you found particularly useful or engaging.
Similar to the link I shared about neuroplasticity, this website (https://www.opencolleges.edu.au/informed/features/develop-a-growth-mindset/ ) provides a great list of ways to implement a growth mindset in a tangible way.


Code && Coffee
Casual meetup for those who program or are learning how. Demo your projects, discuss the latest tech, or just enjoy a cup of coffee while working. Everyone interested in coding is welcome.
Awesome, but when and where?
Friday November 2nd, 5:30 PM to 7:30 PM, CBY A04.


| Title | Company | Location | Type | Level | Years of Experience | Country | Skills |
|---|---|---|---|---|---|---|---|
| Title | Company | Location | Type | Level | Years of Experience | Country | Skills |
| Title | Company | Location | Type | Level | Years of Experience | Minimum Years of Experience | Country | Skills |
|---|---|---|---|---|---|---|---|---|
| Title | Company | Location | Type | Level | Years of Experience | Country | Skills | Minimum Years of Experience |


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
I know it is so simple to buy the already minced up chicken but the problem is you do not know what you are getting and it often has loads of fat and a bit of gristle in it. Buy your own and then mince it up yourself.
Each serving provides 237kcal, 31g protein, 3g carbohydrate (of which 3g sugars), 11g fat (of which 2g saturates), 2g fibre and 2.3g salt.
Drizzle the oil into a large frying pan over a high heat. Add the minced chicken with salt and pepper and cook for 4-5 minutes, stirring regularly and breaking it up as you do so, until it turns from pink to white. Cut a piece open to check it is cooked and then tip the chicken into a colander set over a bowl. Leave to cool for five minutes (so it doesn’t cause the herbs to wilt) while also allowing any excess liquid to drain off, if necessary.
Pour the fish sauce and lime juice into a large bowl and stir in the sugar until dissolved. Add the spring onions, cucumber, red chilli, ginger, coriander, all but a small handful of the mint leaves and the peanuts and stir together well. Tip the chicken in and toss it through. Taste it and check to see if it needs a little bit more of anything to get it just to your liking.
Arrange three lettuce leaves on each of four serving plates and place a couple of spoonfuls of the mixture into each one. Scatter the remaining mint leaves over to garnish and serve. The best way to eat these is to simply just pick a cup up with your hands and bite in.


Many of the problems found in real projects occur because of honest mistakes – temporary “test” changes and misclicks by a tired developer can silently add poorly-performing Assets, or change the import settings of existing Assets.
For any project of significant scale, it is best to have a first line of defense against human errors. It is relatively simple to write a small piece of code that ensures that no one can add a 4K uncompressed Texture to a project.
And yet, this is a surprisingly common problem. A 4K uncompressed Texture occupies 60 megabytes of memory. On a low-end mobile device, such as an iPhone 4S, it is dangerous to consume more than about 180–200 megabytes of memory. If added by mistake, this Texture inadvertently occupies between a third and a quarter of the application’s memory budget, and causes difficult-to-diagnose out-of-memory errors.
While it is now possible to track these issues down with the 5.3 Memory Profiler, it is arguably better to make sure such mistakes are impossible in the first place.
The AssetPostprocessor
class in the Unity Editor can be used to enforce certain minimum standards on a Unity project. This class receives callbacks when Assets are imported. To use it, inherit from AssetPostprocessor
and implement one or more OnPreprocess
methods. Significant ones include:
OnPreprocessTexture
OnPreprocessModel
OnPreprocessAnimation
OnPreprocessAudio
See the Scripting Reference on AssetPostprocessor for more possible OnPreprocess
methods.
public class ReadOnlyModelPostprocessor : AssetPostprocessor {
public void OnPreprocessModel() {
ModelImporter modelImporter =
(ModelImporter)assetImporter;
if(modelImporter.isReadable) {
modelImporter.isReadable = false;
modelImporter.SaveAndReimport();
}
}
}
This is a simple example of an AssetPostprocessor
enforcing rules on a project:
This class is called any time a model is imported into the project, or whenever a model has its import settings changed. The code simply checks to see if the Read/Write enabled
flag (represented by the isReadable
property) is set to true
. If it is, it forces the flag to be false
and then saves and reimports the Asset.
Note that calling SaveAndReimport
causes this snippet of code to be called again! However, because it is now assured that isReadable
is false, this code does not produce an infinite reimport loop.
The reason for this change is discussed in the “Models” section, below.
Disable the read/write enabled flag
The Read/Write enabled
flag causes a Texture to be kept twice in memory: once on the GPU and once in CPU-addressable memory(1) (NOTE:
This is because, on most platforms, readback from GPU memory is extremely slow. Reading a Texture from GPU memory into a temporary buffer for use by CPU code (e.g. Texture.GetPixel) would be very nonperformant.). In Unity, this setting is disabled by default, but it can be accidentally switched on.
Read/Write Enabled
is only necessary when manipulating Texture data outside of Shaders (such as with the Texture.GetPixel
and Texture.SetPixel
APIs) and should be avoided whenever possible.
Disable Mipmaps if possible
For objects that have a relatively invariant Z-depth relative to the Camera, it is possible to disable mipmaps to save about a third of the memory required to load the Texture. If an object changes Z-depth, disabling mipmaps can lead to worse Texture sampling performance on the GPU.
In general, this is useful for UI Textures and other Textures that are displayed at a constant size on screen.
Compress all Textures
Using a texture compression format suitable for the project’s target platform is crucial for saving memory.
If the selected texture compression format is unsuited to the target platform, Unity decompresses the Texture when the Texture is loaded, consuming both CPU time and an excessive amount of memory. This is most commonly a problem on Android devices, which often support vastly different texture compression formats depending on the chipset.
Enforce sensible Texture size limits
While this is simple, it is also very easy to forget to resize a Texture or to inadvertently alter the Texture size import setting. Determine a sensible maximum size for different types of Textures and enforce these via code.
For many mobile applications, 2048x2048 or 1024x1024 is sufficient for Texture atlases, and 512x512 is sufficient for Textures applied to 3D models.
Disable the Read/Write enabled flag
TheRead/Write enabled
flag for models operates identically to the one described for Textures. However, it is enabled by default for models.
Unity requires this flag to be enabled if a project is modifying a Mesh at runtime via script, or if the Mesh is used as the basis for a MeshCollider component. If the model is not used in a MeshCollider and is not manipulated by scripts, disable this flag to save half of the model’s memory.
Disable rigs on non-character models
By default, Unity imports a generic rig for non-character models. This causes an Animator
component be to added if the model is instantiated at runtime. If the model is not animated via the Animation system, this adds unnecessary overhead to the animation system, because all active Animators must be ticked once per frame.
Disable the rig on non-animated models to avoid this automatic addition of an Animator component and possible inadvertent addition of unwanted Animators to a Scene.
Enable the Optimize Game Objects option on animated models
The Optimize Game Objects option has a significant performance impact on animated models. When the option is disabled, Unity creates a large transform hierarchy mirroring the model’s bone structure whenever the model is instantiated. This transform hierarchy is expensive to update, especially if other components (such as Particle Systems or Colliders) are attached to it. It also limits Unity’s ability to multithread Mesh skinning and bone animation calculations.
If specific locations on a model’s bone structure need to be exposed (such as exposing a model’s hands in order to dynamically attach weapon models) then these locations can be specifically whitelisted in the Extra Transforms
list.
Some additional details can be found in the Unity Manual page on the Model Importer.
Use Mesh compression when possible
Enabling Mesh compression reduces the number of bits used to represent the floating-point numbers for different channels of a model’s data. This can lead to a minor loss of precision, and the effects of this imprecision should be checked by artists before use in a final project.
The specific numbers of bits that a given compression level uses are detailed in the ModelImporterMeshCompression Scripting Reference.
Note that it is possible to use different levels of compression for different channels, so a project may choose to compress only tangents and normals while leaving UVs and vertex positions uncompressed.
Note: Mesh Renderer Settings
When adding Mesh Renderers to Prefabs or GameObjects, take note of the settings on the component. By default, Unity enables Shadow casting and receiving, Light Probe sampling, Reflection Probe sampling, and Motion Vector calculation.
If a project does not require one or more of these features, ensure that they’re turned off by an automated script. Any runtime code that adds MeshRenderers needs to toggle these settings as well.
For 2D games, accidentally adding a MeshRenderer to the Scene with the shadow options turned on adds a full shadow pass to the rendering loop. This is generally a waste of performance.
Platform-appropriate compression settings
Enable a compression format for audio that matches the available hardware. All iOS devices include hardware MP3 decompressors, and many Android devices support Vorbis natively.
Further, import uncompressed audio files into Unity. Unity always recompresses audio when building a project. There is no need to import compressed audio and then recompress it; this only serves to degrade the quality of the final audio clips.
Force audio clips to mono
Few mobile devices actually have stereo speakers. On a mobile project, forcing the imported audio clips to be mono-channel halves their memory consumption. This setting is also applicable to any audio without stereo effects, such as most UI sound effects.
Reduce audio bitrate
While this requires consultation with an audio designer, attempt to minimize the bitrate of audio files in order to further save on memory consumption and built project size.


Govt. to go for reverse tendering for Happy Nest project
by Staff ReporterThe State government has decided to go for reverse tendering with regard to Amaravati Happy Nest project.
The government on Monday issued orders (GO.MS.No. 2965) approving the proposal of the AP Capital Region Development Authority (AP CRDA) to “adopt modalities to be implemented on tender-cum-reverse auctioning process or reverse tendering process.” The orders are subject to the approval of the CRDA.
“The above orders are for the specific purpose of the bids in respect of Amaravati Happy Nest Housing Project only and there shall not be any contractual and legal obligation. The Commissioner, APCRDA shall take necessary action accordingly,” said the government in the GO.
It has been reported in these columns recently that the State government is contemplating reverse tendering for Happy Nest, a modern gated community at Nelapadu village in Capital city Amaravati, shortly. The CRDA officials have “studied the proposal” following a suggestion from Chief Minister Y.S. Jagan Mohan Reddy at a review meeting a couple of months ago.


The Department of Education’s (ED) mission is “to promote student achievement and preparation for global competitiveness by fostering educational excellence and ensuring equal access.” ED’s congressional budget includes appropriations for various education programs. These programs are executed via grant awards to State Education Agencies (SEA) and Local Education Agencies (LEA – i.e. school district). These programs differ from Pell Grants and Student Loans which directly aid individuals. In FY16 the amount appropriated was $44 billion.
Every bubble on the right represents a sub-program composed of open grants. There are over 270 sub-programs that each support a different educational cause. The bubble size reflects the total amount awarded. The color of the bubble represents the funding available as a percentage of the award amount. Hovering over a bubble will provide detailed information on the sub-program. Use the buttons above to explore more about grant programs at ED.
To learn more about ED’s grants please visit: http://www.grants.gov
Grants come in two major categories, Formula and Discretionary. Formula grants are congressionally approved funds distributed based on a formula. Any qualified SEA or LEA can request their funding amount which is calculated off the relevant demographic numbers. Discretionary grants are awarded based on merit and eligibility. Grantees submit applications. Then a competitive review process occurs and a final funding decision is made by ED.
As of 1 January 2017, there was $7.1 billion in discretionary commitments and $32 billion in formula. These commitments will differ from the annual budget because some grants are awarded for multiple years. However, all grants are funded annually over their lifespan. Over the next year grantees will spend down funds and new grants will be awarded. The information visualized with the bubbles update daily.
Each sub-program is grouped under its respective Principal Offices. Programs, and their sub-programs, are administered by different offices at ED. Each Principal Office focuses on supporting specific national education efforts. Hover over the acronym to see the office’s full name. There are also 10 regional offices that provide points of contact and assistance for schools, parents, and citizens. If you are interested in learning more about federal education programs, please contact your regional office or visit https://www2.ed.gov
The size of the bubble reflects the funds available.


22nd Jul 2018:
Joachim's Lafosse's Latest Film
The selection of films is forerun by Keep Going, the latest film by Belgian director Joachim Lafosse, an intelligent and exceptionally emotionally charged drama about a crisis in a mother-son relationship on a trip together. Like in his previous films (Our Children and After Love), Lafosse again focuses on cracks in family relations, but in this film he sets them against a backdrop of a modern-day western.
I Am Not a Witch by Rungano Nyoni is the biggest discovery of last year’s Cannes selection Directors’ Fortnight and a BAFTA Winner for outstanding debut. A modern-day fairy tale about an eight-year-old girl accused of witchcraft is an occasionally hilarious satire of African traditionalism, and occasionally a sad story about the oppression of African women. Rungano Nyoni found her inspiration in African witch camps serving to segregate ‘problematic’ women, but also as a tourist attraction.
Another entry is the latest film by Swiss director Germinal Roaux Fortuna, the winner in the Generation 14plus section at the 68th Berlinale. A film about a girl migrant in a Swiss catholic convent is a combination of marvellous directing procedures and a gloomy tale that might just have a happy ending. Bruno Ganz, one of the greatest German-speaking actors, stars in the role of the priest.
I Am Júlia, a debut film by Spanish director Elena Martin, follows an architecture student on exchange in Berlin and her adaptation to the new environment. This outstanding portrayal of young people at a crossroads in their lives is stylistically impressive, thanks to cinematography, characters and vistas of East Berlin. Elena Martin, also appearing in the leading role, marvellously embodied the fears, tensions and confusion of the ‘Skype’ generation any young person can easily relate to.
The heroine of the German feelgood drama Rock My Heart is a 17-year-old Jana, born with a heart condition. Defying fate, Jana accepts every challenge and to the horror of her concerned parents embarks on every dangerous adventure. With heart-warming characters and a touching story, Rock My Heart conveys an ever young message of persistence and perseverance.


Ooty, the Queen of Hill stations, welcome you with mesmerising meadows, soothing environment, cool weather and a wide array of sightseeing places to visit and admire. Each tourist attraction in Ooty promises a unique and lively experience that will leave you in awe for many days to come. However, if you are wondering what to do in Ooty and what to see in Ooty then have a look at the various sightseeing places that we have mentioned below. With these interesting places to see, you can be sure of having a memorable Ooty tour.
One of the most important parts of every Ooty tour, Ooty lake is indeed a place to visit. nIt is an artificial lake that was built for fishing purposes. This lake is popular for boating. Tourists can be seen enjoying a refreshing ride on its serene waters. There is boating house located near the lake offering a wide array of boats on hire. Cycling by the side of lake is also worth experiencing. There are also a few shops located around the lake, selling various locally made items.view details...
Connecting Eastern Ghats and the Western Ghats, on the Ooty Mysore route, Mudumalai National Park is another place to visit by Nature lovers when on their tour to Ooty. This national park boasts of many wild animals and rich avian fauna along with equally rich flora. It has also been declared as a tiger reserve as it is home to approximately 50 tigers. If interested one can also find accommodation as many guest houses are offered by the Forest Department at different location of the park. view details...
Located at a distance of 2 km from Ooty Lake, Deer Park is easily accessible by road. With its rich fauna along with varieties of deer such as Sambhar and the Chithal, Deer park makes up for an interesting visit, especially for wildlife enthusiasts. Equally rich is the variety of flora in this park. Spread across an area of 22 acres, this park was established in the year of 1986. It is one of the known wildlife sanctuaries of not only Tamil Nadu but of India presenting amazing opportunity to observe the wildlife and various animals from closer. view details...
Rose Garden is another popular place to visit in Ooty. Maintained by Government of Tamil Nadu, this garden is spread across 4 hectares of land and proudly presents more than 20 thousand variety of roses. A well maintained garden, it also boasts of winning Garden of Excellence Award for South Asia from the World Federation of Rose Societies. The unparalleled beauty of roses promises a visual treat and an ideal backdrop for photography.view details...


| Catalina |
|
SSLEngine attribute added to the AprLifecycleListener(fhanik)
|
|
Add API for Comet IO handling (remm, fhanik)
|
|
Servlet 2.5 support (remm)
|
|
| Jasper |
|
JSP 2.1 support (jhook, remm)
|
|
Unifed EL 2.1 support (jhook)
|
|
| Coyote |
|
SSLEnabled attribute required for SSL to be turned on, on all HTTP connectors(fhanik)
|
|
| Cluster |
|
New cluster configuration and new documentation (fhanik)
|
|
|