Simple Keyboard Teleop Example
Run the following commands in the terminal then refresh this page. Check the JavaScript
console for the output.
- roslaunch pr2_gazebo pr2_empty_world.launch
- roslaunch rosbridge_server rosbridge_websocket.launch
- Use your arrow keys on your keyboard to move the robot (must have this browser window
focused).


Setup
Error:
You sign up as a Patient
Supply your medical expert information below
Your id is:
Select Profile Pix (Optional):


 You can also get an RSS feed here.
Also, there w{{ bad|pluralize:"as,ere" }} {{ bad }} post{{ bad|pluralize }} we couldn't get. Sorry!
{% endif %} {% endblock content %}


As an open and approachable person who loves to engage with others both in person and virtually, I find myself always drawn to anything to do with technology and computers. As a self starter who loves being part of a team as well, I bring discpline and rigour from my years serving the US Army. This, in addition to my numerous diplomas in digital art, technology, animation, and now coding, have helped me reach my present postion where I hope to develop websites, both large and small. Ease of transition, smooth and appealing visuals that help deliver a client's vision in a concise and timely manner are my goals. Thank you for visiting my portfolio.
Thank you for viewing my webpage, this website showcases my current skills a a website developer. Please click on the links below to view my most recently projects.
Social Contact Information


Query is a newsletter for entrepreneurs who build stuff on the web. Every week @jrdnbwmn poses three questions to a founder of a successful business. Subjects range from pricing to working remotely to sustainable growth.
William Candillon is a 31-year-old software engineer from France. He built React Native Starter Kits during a sabbatical and now has repos, writing, and videos...
Keep Reading →Hi there 👋. I'm Jordan Bowman, the creator and host of Query. I make stuff for the web just like you and love talking to founders.
Follow on Twitter →


When you are learning complex stuff like a programming language, it is great to have a cheat sheet or quick reference guide to basic or commonly used items. This will speed up your efficiency in writing and useful because we don't have eidetic memory.


On Tue, Aug 18, 2009 at 1:31 PM, Michael Neale<EMAIL_ADDRESS>> > Proably would use a set of case classes I guess, but would end up > looking like a pretty version of that (someone like Viktor will > probably show us !). As Peter Becker suggested previously in this thread, you could use the Either-type in Scala, or if you are adventurous: use the Box-type in Lift scala> def foo[T](fun : => T) : Either[T,Exception] = try { Left(fun) } catch { case e : Exception => Right(e) } foo: [T](=> T)Either[T,Exception] scala> def fooResult[T](fun : => T) : String = foo(fun) match { case Left(x) => "Yielded: " + x; case Right(x) => "Exception: " + x; } fooResult: [T](=> T)String scala> fooResult(10/0) res0: String = Exception: java.lang.ArithmeticException: / by zero scala> fooResult(System.currentTimeMillis) res1: String = Yielded:<PHONE_NUMBER>666 Box from Lift has a sligtly different semantics, it has 3 distinct states: Full Empty Failure while Either only has 2: Left Right > > > On Aug 18, 9:11 pm, Peter Becker<EMAIL_ADDRESS>wrote: > > Reinier Zwitserloot wrote: > > > Yes, an utopia with checked exceptions is probably pretty decent, but > > > as a practical matter they've been horribly abused. Not just by third > > > party libraries; the java core library is inconsistent in places and > > > has a lot of missing throws clauses in interfaces that can't be fixed > > > because it would break backwards compatibility. Trying to fix these > > > things is going to be even more painful than having to deal with > > > checked exceptions in the current circumstance, which is one of the > > > reasons why I advocate solving the problem directly. Such as offering > > > an opt out mechanism where a programmer can explicitly 'correct' the > > > compiler to say: Yah, I know, I know, this method call here DECLARES > > > that it'll throw SomeCheckedException, and I neither catch it nor > > > declare to throw it onwards, but, shaddap. I know what I'm doing, just > > > compile this code, and let me get on with my day. > > > > > It'll be abused, but the notion that exceptions will be abused in some > > > fashion is what we have to deal with. The question is: How can we make > > > sure the abuse is kept to a minimum? I'd assert that try {} catch > > > ( Throwable t ) { Log.log(t); } is a much worse abuse than > > > sneakythrowing. > > > > Agreed. > > > You get the benefit of being explicitly told about the checked > > > exceptions that you ought to be checking, but when the theory fails > > > due to a practical matter (the declared exception can't possibly > > > happen, or you want to throw the exception onward but due to a badly > > > designed interface you're not allowed to, etc, etc), you won't have to > > > jump through a bunch of hoops, obscuring the exception as you go. > > > > > Being able to return a disjoint type so you can cover extraordinary > > > exit conditions that way instead of throwing exceptions for them could > > > work, but I don't really know of any language that handles them all > > > that well. The only way I can see how it could possibly work is > > > pattern matching. Which scala can mostly do, can't it? > > > > As far as I understand you can't just do something like this (in > > Java-like syntax, but ignoring a few other things Java such as the > > .class for types): > > > > public Result|Error1|Error2 someMethod() {...} > > > > public void someOtherMethod() { > > var result = someMethod(); > > switch(typeof result) { > > case Result: > > processResult(result); > > default: > > handleError(result); > > } > > > > } > > > > public void processResult(Result result) {...} > > > > public void handleError(Error1|Error2 error) { > > ...code using anything on common supertypes of Error1/2... > > > > } > > > > Part of what I'd like to see is that there is no need to name the types > > used. The signature of the last method should also be allowed to be > > handleError(Error) assuming that both Error1 nad Error2 are subtypes of > > Error (which is really just normal polymorphism since it implies that > > the union is a subtype, too). > > > > My Scala is not good enough to judge what is truly possible, but most > > code I've seen seems to end up using Either in this case, which seems a > > bit of a kludge -- particularly if you create a union of more than two > > types. I'd be happy to hear about alternatives. > > > > Peter > > > > > > > > > On Aug 18, 12:13 pm, Peter Becker<EMAIL_ADDRESS>wrote: > > > > >> I still believe that the main reason people hate checked exceptions is > > >> that they have been used badly. > > > > >> But I don't really like them either, I just dislike runtime exceptions > > >> more ;-) The reason for that is that they hide things I might want to > > >> know about when using an API. No one reads documentation well enough, > > >> the enforcement checked exceptions give you is quite useful -- at > least > > >> given the context of Java. And I don't buy into the "just unit test" > > >> argument, things like SQLException and IOException rarely happen in > test > > >> environments unless the test was designed to test just that -- it is > the > > >> exceptional case you don't expect that scares me. > > > > >> What I would really like to see is a meet/or/disjunction/union > operator > > >> in the type system, with a case-like construct to resolve the > resulting > > >> types. Scala has two things that are halfway there (Either, case > > >> classes), but neither is the full monty. > > > > >> Peter > > > > >> phil swenson wrote: > > > > >>> there is a reason no other language ever written has checked > > >>> exceptions - checked exceptions are a bad idea. > > > > >>> On my first java project back in 1999 I remember adding in a checked > > >>> exception to a utility class. It has effects on hundreds of classes > > >>> and 1000s of method calls. I then decided it was more trouble than > it > > >>> was worth and switched everything to runtime exceptions. Worked > > >>> brilliantly. > > > > >>> Checked exceptions almost always degenerate into "throws exception" > on > > >>> 100s to 1000s of methods in your project. They simply don't scale, > > >>> one small change can ripple through an entire project. They also > lead > > >>> to try{blahblah}catch(Exception e}{} (exception hiding). They lead > to > > >>> logging the exception multiple times (catch, log, rethrow), giant > > >>> method signatures, exception wrapping, and other harmful practices. > > > > >>> The correct (IMO) way to handle it is to let the exception bubble up > > >>> to the top level thread and handle it there, whether it's present to > > >>> the user, log, and/or cancel a transaction. Exceptions almost never > > >>> can be recovered from and people are almost always fooling themselves > > >>> if they think they can. I think 95+% of the time exceptions are from > > >>> bugs, not from recoverable situations. People try to build hugely > > >>> fault tolerant systems and they end up hiding bugs. > > > > >>> In the rare case that you want to handle an exception at a lower > > >>> level, do it. But you certainly don't want this to be the default > > >>> behavior, it's the EXCEPTIONAL case. :) > > > > >>> On Aug 17, 9:10 pm, Michael Neale<EMAIL_ADDRESS>wrote: > > > > >>>> What do people think of the scala approach of no checked exceptions > - > > >>>> even checked exceptions are not treated specially by the constructor > > >>>> (personally, I like it). > > > > >>>> On Aug 18, 12:55 pm, Christian Catchpole<EMAIL_ADDRESS>> > >>>> wrote: > > > > >>>>> No, i just let that go up. I really try to avoid the declare as > null > > >>>>> then set thingy. > > > > >>>>> On Aug 18, 12:03 pm, Casper Bang<EMAIL_ADDRESS>wrote: > > > > >>>>>> You neglect to handle the checked exception declared by > > >>>>>> prepareStatement no? > > > > >>>>>> PreparedStatement stmt = null; > > >>>>>> try{ > > >>>>>> stmt = connection.prepareStatement(sql); > > >>>>>> final ResultSet rs = stmt.executeQuery(); > > >>>>>> try{ > > >>>>>> while (rs.next()){ > > >>>>>> // Stuff... > > >>>>>> { > > >>>>>> } > > >>>>>> finally{ > > >>>>>> rs.close(); > > >>>>>> }} > > > > >>>>>> catch(SQLException e){ > > >>>>>> // Logging...} > > > > >>>>>> finally{ > > >>>>>> try{ > > >>>>>> stmt.close(); > > >>>>>> } > > >>>>>> catch(SQLException whoTheFuckCares){ > > >>>>>> }; > > > > >>>>>> } > > > > >>>>>> Really, how many other ways are there to do it I wonder now? > (Apart > > >>>>>> from wrapping certain things, like the last try-catch clause in > some > > >>>>>> general purpose "closer util"?). > > > > >>>>>> /Casper > > > -- Viktor Klang Rogue Scala-head Blog: klangism.blogspot.com Twttr: viktorklang --~--~---------~--~----~------------~-------~--~----~ You received this message because you are subscribed to the Google Groups "The Java Posse" group. To post to this group, send email to<EMAIL_ADDRESS>To unsubscribe from this group, send email to<EMAIL_ADDRESS>For more options, visit this group at http://groups.google.com/group/javaposse?hl=en -~----------~----~----~----~------~----~------~--~---


This is a weather widget using Darksky API and using Javascript photo carousel to rotate through the days of the week, it also get uses an IP API to get your location which is used to get your rough location within 20-30 kms
This project graphs weather data using Darksky API and Charts Laravel Package. The main purpose of this project was to learn how to do charts whilst learning Laravel PHP framework
Weather forecast data from a free API provided by Darksky.net. The android app then parses the data (in JSON format) and display it in a single-page app. it also can handle errors and situations when the network is unavailable. Features used in this project are: Networking OkHttp DarkSky API Parsing JSON feed DialogFragment
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Fugit aliquam aperiam nulla perferendis dolor nobis numquam, rem expedita, aliquid optio, alias illum eaque. Non magni, voluptates quae, necessitatibus unde temporibus.


RE-IMAGINING THE WAY
WE GROW MONEY, GUARANTEED
STUNNING VISUALS
Here, I focus on a range of items and features that we use in life without giving them a second thought such as Coca Cola,
body
CLEAN CODE
Over 92% of computers are infected with Adware and spyware. Such software is rarely accompanied by uninstall utility
PUNCTUALITY
If you own an Iphone, you’ve probably already worked out how much fun it is to use it to watch movies-it has that nice big
screen


submit your app credentials
Before using the Databox IDE you have to register it as a new github application. Just follow the instructions below to get a client ID and secret, then add them to the form below and click update
registering your app
Register your new github app at https://github.com/settings/developers
When presented with the following screen, click on Register a new application
When prompted to fill in details, you can give the application any name, and provide any legitimate url for the homepage. The callback url must be:
http://localhost:8086/auth/github/callback
You will then be provided with a Client ID and Client Secret. These are what you need to finish the install:
Now open [your databox directory]/sdk/settings.json and put in your Client ID and Client Secret and then restart the sdk.
To restart the sdk, in the databox directory, run:
docker-compose -f docker-databox-sdk.yaml restart databox-sdk
And wait until you see:
Restarting databox-sdk ... done
Once done and restarted, if you go to http://localhost:8086/ you should be prompted to login to the sdk.


ROMAN NUMERALS
Please enter a number between 1 and 3,999 to display as a roman numeral
SUBMIT
CRYPTOSQUARE
Please enter a string to encode via square code
SUBMIT


| read.spss {foreign} | R Documentation |
read.spss
reads a file stored by the SPSS save
or
export
commands.
This was orignally written in 2000 and has limited support for changes in SPSS formats since (which have not been many).
read.spss(file, use.value.labels = TRUE, to.data.frame = FALSE, max.value.labels = Inf, trim.factor.names = FALSE, trim_values = TRUE, reencode = NA, use.missings = to.data.frame, sub = ".", add.undeclared.levels = c("sort", "append", "no"), duplicated.value.labels = c("append", "condense"), duplicated.value.labels.infix = "_duplicated_", ...)
file |
character string: the name of the file or URL to read. |
use.value.labels |
logical: convert variables with value labels
into R factors with those levels? This is only done if there are
at least as many labels as values of the variable (when values
without a matching label are returned as |
to.data.frame |
logical: return a data frame? |
max.value.labels |
logical: only variables with value labels and
at most this many unique values will be converted to factors if
|
trim.factor.names |
logical: trim trailing spaces from factor levels? |
trim_values |
logical: should values and value labels have
trailing spaces ignored when matching for |
reencode |
logical: should character strings be re-encoded to the
current locale. The default, |
use.missings |
logical: should information on user-defined
missing values be used to set the corresponding values to |
sub |
character string: If not |
add.undeclared.levels |
character:
specify how to handle variables with at least one value label and further
non-missing values that have no value label (like a factor levels in R).
For |
duplicated.value.labels |
character: what to do with duplicated value
labels for different levels.
For |
duplicated.value.labels.infix |
character: the infix used for labels of
factor levels with duplicated value labels in SPSS (default |
... |
passed to |
This uses modified code from the PSPP project (http://www.gnu.org/software/pspp/ for reading the SPSS formats.
If the filename appears to be a URL (of schemes http:,
ftp: or https:) the URL is first downloaded to a
temporary file and then read. (https: is supported where
supported by download.file
with its current default
method
.)
Occasionally in SPSS, value labels will be added to some values of a
continuous variable (e.g. to distinguish different types of missing
data), and you will not want these variables converted to factors. By
setting max.value.labels
you can specify that variables with a
large number of distinct values are not converted to factors even if
they have value labels.
If SPSS variable labels are present, they are returned as the
"variable.labels"
attribute of the answer.
Fixed length strings (including value labels) are padded on the right
with spaces by SPSS, and so are read that way by R. The default
argument trim_values=TRUE
causes trailing spaces to be ignored
when matching to value labels, as examples have been seen where the
strings and the value labels had different amounts of padding. See
the examples for sub
for ways to remove trailing spaces
in character data.
URL http://msdn.microsoft.com/en-us/library/ms776446(VS.85).aspx
provides a list of translations from Windows codepage numbers to
encoding names that iconv
is likely to know about and so
suitable values for reencode
. Automatic re-encoding is
attempted for apparent codepages of 200 or more in a UTF-8 or latin-1 locale:
some other high-numbered codepages can be re-encoded on most systems,
but the encoding names are platform-dependent (see
iconvlist
).
A list (or optionally a data frame) with one component for each variable in the saved data set.
If what looks like a Windows codepage was recorded in the SPSS file,
it is attached (as a number) as attribute "codepage"
to the
result.
There may be attributes "label.table"
and
"variable.labels"
. Attribute "label.table"
is a named
list of value labels with one element per variable, either NULL
or a named character vector. Attribute "variable.labels"
is a
named character vector with names the short variable names and
elements the long names.
If there are user-defined missing values, there will be a attribute
"Missings"
. This is a named list with one list element per
variable. Each element has an element type
, a length-one
character vector giving the type of missingness, and may also have an
element value
with the values corresponding to missingness.
This is a complex subject (where the R and C source code for
read.spss
is the main documentation), but the simplest cases
are types "one"
, "two"
and "three"
with a
corresponding number of (real or string) values whose labels can be
found from the "label.table"
attribute. Other possibilities are
a finite or semi-infinite range, possibly plus a single value.
See also http://www.gnu.org/software/pspp/manual/html_node/Missing-Observations.html#Missing-Observations.
If SPSS value labels are converted to factors the underlying numerical codes will not in general be the same as the SPSS numerical values, since the numerical codes in R are always 1,2,3,….
You may see warnings about the file encoding for SPSS save
files: it is possible such files contain non-ASCII character data
which need re-encoding. The most common occurrence is Windows codepage
1252, a superset of Latin-1. The encoding is recorded (as an integer)
in attribute "codepage"
of the result if it looks like a
Windows codepage. Automatic re-encoding is done only in UTF-8 and latin-1
locales: see argument reencode
.
Saikat DebRoy and the R-core team
A different interface also based on the PSPP codebase is available in
package memisc: see its help for spss.system.file
.
(sav <- system.file("files", "electric.sav", package = "foreign")) dat <- read.spss(file=sav) str(dat) # list structure with attributes dat <- read.spss(file=sav, to.data.frame=TRUE) str(dat) # now a data.frame ### Now we use an example file that is not very well structured and ### hence may need some special treatment with appropriate argument settings. ### Expect lots of warnings as value labels (corresponding to R factor labels) are uncomplete, ### and an unsupported long string variable is present in the data (sav <- system.file("files", "testdata.sav", package = "foreign")) ### Examples for add.undeclared.levels: ## add.undeclared.levels = "sort" (default): x.sort <- read.spss(file=sav, to.data.frame = TRUE) ## add.undeclared.levels = "append": x.append <- read.spss(file=sav, to.data.frame = TRUE, add.undeclared.levels = "append") ## add.undeclared.levels = "no": x.no <- read.spss(file=sav, to.data.frame = TRUE, add.undeclared.levels = "no") levels(x.sort$factor_n_undeclared) levels(x.append$factor_n_undeclared) str(x.no$factor_n_undeclared) ### Examples for duplicated.value.labels: ## duplicated.value.labels = "append" (default) x.append <- read.spss(file=sav, to.data.frame=TRUE) ## duplicated.value.labels = "condense" x.condense <- read.spss(file=sav, to.data.frame=TRUE, duplicated.value.labels = "condense") levels(x.append$factor_n_duplicated) levels(x.condense$factor_n_duplicated) as.numeric(x.append$factor_n_duplicated) as.numeric(x.condense$factor_n_duplicated) ## Long Strings (>255 chars) are imported in consecutive separate variables ## (see warning about subtype 14): x <- read.spss(file=sav, to.data.frame=TRUE, stringsAsFactors=FALSE) cat.long.string <- function(x, w=70) cat(paste(strwrap(x, width=w), "\n")) ## first part: x$string_500: cat.long.string(x$string_500) ## second part: x$STRIN0: cat.long.string(x$STRIN0) ## complete long string: long.string <- apply(x[,c("string_500", "STRIN0")], 1, paste, collapse="") cat.long.string(long.string)


The total number of editions of each art piece created by the artist are stored on the blockchain for transperancy and fairness by the artist. All editions sold by the artist to others are notraized on the blockchain for full transperancy, fairness and ensurance of ownership rights.
Blockchain address 0x1aDee3cE50a27BB680518cA9A99E2b1A65FebA12
pragma solidity >=0.5.0 <0.6.0; import "openzeppelin-solidity/contracts/ownership/Ownable.sol"; contract ShirleyShorArtRegistry is Ownable { struct ArtPiece { string name; // art piece name string projectName; // art piece project name uint8 totalEditions; // total number of editions that can be sold uint8 editionsSold; // total number of editions sold uint256 created; // record timestamp } struct PurchaseRecord { uint artPiece; // Art piece identifier uint8 edition; // purchased edition number address owner; // edition owner pub key uint price; // purchase price uint purchased; // time edition purchased } uint public artPieceIds; mapping (uint => ArtPiece) public artPiecesRegistry; uint public registrySize; mapping (uint => PurchaseRecord) public purchasedEditionsRegistry; // Register a new purchser of an art piece // Owner will be assigned a new edition number if an edition can be purchased function registerEdition(uint artPieceId, address owner, uint price) onlyOwner public { // ensure a new edition can be sold for the art piece ArtPiece memory artPiece = artPiecesRegistry[artPieceId]; require(artPiece.editionsSold < artPiece.totalEditions); // add the edition to the registry uint8 edition = artPiece.editionsSold + 1; uint id = registrySize++; purchasedEditionsRegistry[id] = PurchaseRecord(artPieceId, edition, owner, price, now); // update number of editions sold for this piece artPiece.editionsSold++; artPiecesRegistry[artPieceId] = artPiece; } function registerArtPiece(string memory name, string memory projectName, uint8 totalEditions) onlyOwner public { uint id = artPieceIds++; artPiecesRegistry[id] = ArtPiece(name, projectName, totalEditions, 0, now); } }
const Registry = artifacts.require("ShirleyShorArtRegistry"); const log = console.log; contract("ShirleyShorArtRegistry", async accounts => { it("Artist should be able to add artwork", async () => { const instance = await Registry.new(); const c = await instance.artPieceIds(); assert.equal(c, 0); const pieceName = "TeamHumanPrintA"; const project = "Team Human"; const totalEditions = 2; await instance.registerArtPiece(pieceName, project, totalEditions, {from: accounts[0]}); const c1 = await instance.artPieceIds(); assert.equal(c1, 1); const item = await instance.artPiecesRegistry(0); assert.equal(item.name, pieceName); assert.equal(item.projectName, project); assert.equal(item.totalEditions, totalEditions); assert.equal(item.editionsSold, 0); }); it("Artist should be able to register editions up to the total editions per piece", async () => { const instance = await Registry.new(); const pieceName = "TeamHumanPrintA"; const project = "Team Human"; const totalEditions = 2; await instance.registerArtPiece(pieceName, project, totalEditions, {from: accounts[0]}); // first edition const price = 200000; // wei await instance.registerEdition(0, accounts[1], price, {from: accounts[0]}); const item = await instance.purchasedEditionsRegistry(0); assert.equal(item.artPiece, 0); assert.equal(item.edition, 1); assert.equal(item.owner, accounts[1]); assert.equal(item.price, price); let artPiece = await instance.artPiecesRegistry(0); assert.equal(artPiece.editionsSold, 1); // second edition const price1 = 300000; // wei await instance.registerEdition(0, accounts[2], price1, {from: accounts[0]}); const item1 = await instance.purchasedEditionsRegistry(1); assert.equal(item1.artPiece, 0); assert.equal(item1.edition, 2); assert.equal(item1.owner, accounts[2]); assert.equal(item1.price, price1); artPiece = await instance.artPiecesRegistry(0); assert.equal(artPiece.editionsSold, 2); // attempting to sell 3rd edition should fail let res = false; try { res = await instance.registerEdition(0, accounts[3], price1, {from: accounts[0]}); } catch (err) { res = true; } assert.equal(res, true); }); });


I like designing experiences that inspire others. I'm passionate about technology & entrepreneurship for healthcare innovation and social good. See my work below, look at my resume or learn more about me here!
Nspire Innovation Network is Canada’s largest student-run non-profit organization in the business and technology space.
We connect innovative youth leaders with industry professionals and entrepreneurs to empower young innovators with skills and knowledge in the biz-tech arena.
As a Creative and Branding Associate on the 2016-2017 executive, I was in charge of marketing media and graphic design for all events held on the Western University campus.
Nspire Connects brings together incoming and first year university students with senior students and industry professionals to introduce them to the Canadian business and technology space and give them a taste of careers available in their field.
Ideas Exchange is about encouraging deep, interdisciplinary thinking to observe and analyze the challenging conditions in our digital age.
By running small group events dedicated to one facet of emerging technology, Nspire gives budding entrepreneurs an opportunity to understand an industry directly from its largest players.
Nspire Career Series organized several events designed to directly give students more information about internships at specific companies relating to technology.
I designed assets for web pages, Facebook promotion, and snapchat filters. One challenge I encountered is the difficulty of adhering to brand guidelines when designing for a wide range of events
throughout the year, but I consistently used the same fonts and similar textures to achieve unity while making exciting, varied graphics.
I also helped reboot our Instagram page and made several Snapchat filters for our national conference.
WVA
Western Venture Association provides members with education and opportunities in private equity and venture capital while bridging the gap between business acumen and entrepreneurship.
We organize educationals, group discussions, and conferences that connect university students with private equity and venture capital firms to understand the role funding plays in new businesses.
My role as a marketing director includes designing marketing plans, managing email marketing and social media outlets, connecting with sponsors, and writing blogs about recent VC and PE news.
The following graphics are from our educational with Google and represent a shift in branding towards geometric form for a more exciting, bold approach to the VC industry.
These graphics are from our 2016-2017 flagship conference, the WVA Open. Open had over 200 students registered and partnered with Shopify, Ivey Business School, and several VC firms.
In addition to our main conference, we host monthly educationals and socials to educate our members about VC and PE.
CAISA Fashion Show
CAISA Fashion Show is one of the largest student-run charity fashion shows in all of Canada 19 years in the making.
With a remarkable team of over a hundred executive members, performers, and models, we continuously dedicate countless hours to produce one of the most anticipated shows in the London community.
This year, we are proud to announce that our proceeds from the show will continue to support the Children’s Health Foundation — a charity that we have supported for over 16 years.
My role on the CAISA Fashion Show Graphics team was to create all graphics for web, print, and social media outlets and edit the photos for our show lookbook.
Our team (thank you to CAISA Graphics for teaching me) designed the show logo below and lookbook as well as cover photos and promotional media for over 25 individual events. The 2016-2017 show Espial was based around espionage and mystery.
We raised $35,000 for children's stem cell research - a new record for the fashion show.
Below are a selection of the promotional cards and cover photos I made throughout the year.
Our team also initiated a fundraiser to sell our homemade cards for Christmas and Valentines Day.
We sold a variety of cards made by each team member.
U.buk
U.buk aims to improve the efficiency of Toronto’s walk-in clinics by reducing patient wait times through an interactive, web-based platform.
It is a web application that allows patients to pre-book medical consultations based on published wait times and send their symptoms and contact data to a nearby walk-in clinic prior to arrival.
As the lead designer, my role included the presentation deck visuals, user research, and prototyping of our product screenshots to demonstrate U.buk's functionality.
U.buk received 3rd in the SpinMaster Business Plan competition and a Finalist award at the ship* startup festival.
U.buk aims to alleviate pain points in the patient walk-in clinic experience by:
-showing current wait times in nearby clinics within a 10km radius
-allowing patients to enter and submit medical information to facilities prior to visit
-notifying patients of the soonest estimated time a doctor will able to see them
A mobile-optimized experience allows patients to select an appropriate location and rapidly complete necessary paperwork prior to arrival at the appointment.
Our demonstration screenshots were based off of researching challenges millenials and families have in booking appointments.
Through a web application, clinics will be able to manage appointments, update wait times, analyze traffic flow, and submit billing information.
U.buk allows them to redirect resources into maximizing quality and efficiency in patient care; leveraging an online platform reduces receptionist calls, triaging, and paperwork.
Happi
Happiness is a skill that can be cultivated, provided you know how to practice and refine your abilities. Happi is designed to promote happiness by helping users understand the factors that contribute to their daily satisfaction. The app provides insight on when and why the individual is most satisfied by tracking happiness with a quick user input throughout the day. Happi will map these happiness measurements with data integrated from existing apps like MyFitness Pal. Happi’s goal is to create personalized recommendations between the users’ actions and happiness levels so that they can set and reach goals which improve their well-being.
Three screens were created for this design challenge - the main landing screen where a user could input their emotions throughout the day, insights into their happiness aligned with certain activities, and ability to integrate with other services.
Predominantly cool, calming colours were used.
The web page was designed with bright, sunny colours in mind to create a welcoming atmosphere when visitors enter the site.
Ceebos
Ceebos is a seamless personal chef app that knows what you want to eat.
With an integrated meal planner, healthy recipe platform, and interactive shopping lists to grocery stores and scheduled deliveries,
Ceebos understands your needs to make cooking simple and fun. Ceebos is currently a work in progress - we are in the user research stage, so contact me if you want to know more!
Here's a sample of our onboarding process designed to easily capture a user's culinary tastes and lifestyle habits.
With Ceebos’ smart API, you receive recipe suggestions based off of a machine learning algorithm that learns about you more from the recipes you like and dislike. Between our extensive recipes and your ability to submit or use community recipes, Ceebos has all the perfect recipes to ensure you have something delicious in front of you.
Our website - currently under construction -can be found here.


| dbListObjects {DBI} | R Documentation |
Returns the names of remote objects accessible through this connection
as a data frame.
This should include temporary objects, but not all database backends
(in particular RMariaDB and RMySQL) support this.
Compared to dbListTables()
, this method also enumerates tables and views
in schemas, and returns fully qualified identifiers to access these objects.
This allows exploration of all database objects available to the current
user, including those that can only be accessed by giving the full
namespace.
dbListObjects(conn, prefix = NULL, ...)
conn |
A DBIConnection object, as returned by
|
prefix |
A fully qualified path in the database's namespace, or |
... |
Other parameters passed on to methods. |
dbListObjects()
returns a data frame
with columns
table
and is_prefix
(in that order),
optionally with other columns with a dot (.
) prefix.
The table
column is of type list.
Each object in this list is suitable for use as argument in dbQuoteIdentifier()
.
The is_prefix
column is a logical.
This data frame contains one row for each object (schema, table
and view)
accessible from the prefix (if passed) or from the global namespace
(if prefix is omitted).
Tables added with dbWriteTable()
are part of the data frame.
As soon a table is removed from the database,
it is also removed from the data frame of database objects.
The same applies to temporary objects if supported by the database.
The returned names are suitable for quoting with dbQuoteIdentifier()
.
An error is raised when calling this method for a closed
or invalid connection.
The table
object can be quoted with dbQuoteIdentifier()
.
The result of quoting can be passed to dbUnquoteIdentifier()
.
The unquoted results are equal to the original table
object.
(For backends it may be convenient to use the Id class, but this is
not required.)
The prefix
column indicates if the table
value refers to a table
or a prefix.
For a call with the default prefix = NULL
, the table
values that have is_prefix == FALSE
correspond to the tables
returned from dbListTables()
,
Values in table
column that have is_prefix == TRUE
can be
passed as the prefix
argument to another call to dbListObjects()
.
For the data frame returned from a dbListObject()
call with the
prefix
argument set, all table
values where is_prefix
is
FALSE
can be used in a call to dbExistsTable()
which returns
TRUE
.
Other DBIConnection generics:
DBIConnection-class
,
dbAppendTable()
,
dbCreateTable()
,
dbDataType()
,
dbDisconnect()
,
dbExecute()
,
dbExistsTable()
,
dbGetException()
,
dbGetInfo()
,
dbGetQuery()
,
dbIsReadOnly()
,
dbIsValid()
,
dbListFields()
,
dbListResults()
,
dbListTables()
,
dbReadTable()
,
dbRemoveTable()
,
dbSendQuery()
,
dbSendStatement()
,
dbWriteTable()
con <- dbConnect(RSQLite::SQLite(), ":memory:") dbListObjects(con) dbWriteTable(con, "mtcars", mtcars) dbListObjects(con) dbDisconnect(con)


Yesterday I received an annoying email from a company—probably run by teenagers—called SOS.
Hi Frank!, it began, overfamiliarly. I don't know why I continued reading after such effrontery, but I did.
Here at SOS we're passionate about helping you maximise traffic to your website. SOS stands for Search Optimisation Solutions, and that's exactly what we do!
Like a fool, I carried on reading. I suppose I was won over by the thought that I could attract more than thirty-four readers. I became even more interested when SOS gave me one of their so-called “simple yet effective” tips without my having to pay them a penny.
Our research shows that web traffic increases a millionfold if you mention three names on your site. We call them The Three Ks—Kate, Kim, and Keith. That is, Kate Middleton, Kim Kardashian, and Keith Potger.
I am now racking my brains trying to work out how to concoct a story which includes the Duchess of Cambridge, the inexplicable celebrity, and a quarter of Antipodean 1960s pop sensations The Seekers, which is at once (a) credible, (b) morally uplifting, and (c) groovy. If any of the thirty-four of you have any ideas, please let me know in the Comments.
UPDATE : Gosh! Since I posted the above, an hour ago, traffic to Hooting Yard has increased to a whopping thirty-six! Thanks a million, SOS!


Time Series Analysis by State Space Methods statespace
¶
statsmodels.tsa.statespace
contains classes and functions that are
useful for time series analysis using state space methods.
A general state space model is of the form
where \(y_t\) refers to the observation vector at time \(t\), \(\alpha_t\) refers to the (unobserved) state vector at time \(t\), and where the irregular components are defined as
The remaining variables (\(Z_t, d_t, H_t, T_t, c_t, R_t, Q_t\)) in the equations are matrices describing the process. Their variable names and dimensions are as follows
Z : design \((k\_endog \times k\_states \times nobs)\)
d : obs_intercept \((k\_endog \times nobs)\)
H : obs_cov \((k\_endog \times k\_endog \times nobs)\)
T : transition \((k\_states \times k\_states \times nobs)\)
c : state_intercept \((k\_states \times nobs)\)
R : selection \((k\_states \times k\_posdef \times nobs)\)
Q : state_cov \((k\_posdef \times k\_posdef \times nobs)\)
In the case that one of the matrices is time-invariant (so that, for example, \(Z_t = Z_{t+1} ~ \forall ~ t\)), its last dimension may be of size \(1\) rather than size nobs.
This generic form encapsulates many of the most popular linear time series models (see below) and is very flexible, allowing estimation with missing observations, forecasting, impulse response functions, and much more.
Example: AR(2) model
An autoregressive model is a good introductory example to putting models in state space form. Recall that an AR(2) model is often written as:
This can be put into state space form in the following way:
Where
and
There are three unknown parameters in this model: \(\phi_1, \phi_2, \sigma^2\).
Models and Estimation¶
The following are the main estimation classes, which can be accessed through statsmodels.tsa.statespace.api and their result classes.
Seasonal Autoregressive Integrated Moving-Average with eXogenous regressors (SARIMAX)¶
The SARIMAX class is an example of a fully fledged model created using the statespace backend for estimation. SARIMAX can be used very similarly to tsa models, but works on a wider range of models by adding the estimation of additive and multiplicative seasonal effects, as well as arbitrary trend polynomials.
|
Seasonal AutoRegressive Integrated Moving Average with eXogenous regressors model |
|
Class to hold results from fitting an SARIMAX model. |
For an example of the use of this model, see the SARIMAX example notebook or the very brief code snippet below:
# Load the statsmodels api
import statsmodels.api as sm
# Load your dataset
endog = pd.read_csv('your/dataset/here.csv')
# We could fit an AR(2) model, described above
mod_ar2 = sm.tsa.SARIMAX(endog, order=(2,0,0))
# Note that mod_ar2 is an instance of the SARIMAX class
# Fit the model via maximum likelihood
res_ar2 = mod_ar2.fit()
# Note that res_ar2 is an instance of the SARIMAXResults class
# Show the summary of results
print(res_ar2.summary())
# We could also fit a more complicated model with seasonal components.
# As an example, here is an SARIMA(1,1,1) x (0,1,1,4):
mod_sarimax = sm.tsa.SARIMAX(endog, order=(1,1,1),
seasonal_order=(0,1,1,4))
res_sarimax = mod_sarimax.fit()
# Show the summary of results
print(res_sarimax.summary())
The results object has many of the attributes and methods you would expect from other statsmodels results objects, including standard errors, z-statistics, and prediction / forecasting.
Behind the scenes, the SARIMAX model creates the design and transition matrices (and sometimes some of the other matrices) based on the model specification.
Unobserved Components¶
The UnobservedComponents class is another example of a statespace model.
|
Univariate unobserved components time series model |
Class to hold results from fitting an unobserved components model. |
For examples of the use of this model, see the example notebook or a notebook on using the unobserved components model to decompose a time series into a trend and cycle or the very brief code snippet below:
# Load the statsmodels api
import statsmodels.api as sm
# Load your dataset
endog = pd.read_csv('your/dataset/here.csv')
# Fit a local level model
mod_ll = sm.tsa.UnobservedComponents(endog, 'local level')
# Note that mod_ll is an instance of the UnobservedComponents class
# Fit the model via maximum likelihood
res_ll = mod_ll.fit()
# Note that res_ll is an instance of the UnobservedComponentsResults class
# Show the summary of results
print(res_ll.summary())
# Show a plot of the estimated level and trend component series
fig_ll = res_ll.plot_components()
# We could further add a damped stochastic cycle as follows
mod_cycle = sm.tsa.UnobservedComponents(endog, 'local level', cycle=True,
damped_cycle=True,
stochastic_cycle=True)
res_cycle = mod_cycle.fit()
# Show the summary of results
print(res_cycle.summary())
# Show a plot of the estimated level, trend, and cycle component series
fig_cycle = res_cycle.plot_components()
Vector Autoregressive Moving-Average with eXogenous regressors (VARMAX)¶
The VARMAX class is an example of a multivariate statespace model.
|
Vector Autoregressive Moving Average with eXogenous regressors model |
|
Class to hold results from fitting an VARMAX model. |
For an example of the use of this model, see the VARMAX example notebook or the very brief code snippet below:
# Load the statsmodels api
import statsmodels.api as sm
# Load your (multivariate) dataset
endog = pd.read_csv('your/dataset/here.csv')
# Fit a local level model
mod_var1 = sm.tsa.VARMAX(endog, order=(1,0))
# Note that mod_var1 is an instance of the VARMAX class
# Fit the model via maximum likelihood
res_var1 = mod_var1.fit()
# Note that res_var1 is an instance of the VARMAXResults class
# Show the summary of results
print(res_var1.summary())
# Construct impulse responses
irfs = res_ll.impulse_responses(steps=10)
Dynamic Factor Models¶
Statsmodels has two classes that support dynamic factor models: DynamicFactorMQ and DynamicFactor. Each of these models has strengths, but in general the DynamicFactorMQ class is recommended. This is because it fits parameters using the Expectation-Maximization (EM) algorithm, which is more robust and can handle including hundreds of observed series. In addition, it allows customization of which variables load on which factors. However, it does not yet support including exogenous variables, while DynamicFactor does support that feature.
|
Dynamic factor model with EM algorithm; option for monthly/quarterly data. |
Results from fitting a dynamic factor model |
For an example of the DynamicFactorMQ class, see the very brief code snippet below:
# Load the statsmodels api
import statsmodels.api as sm
# Load your dataset
endog = pd.read_csv('your/dataset/here.csv')
# Create a dynamic factor model
mod_dfm = sm.tsa.DynamicFactorMQ(endog, k_factors=1, factor_order=2)
# Note that mod_dfm is an instance of the DynamicFactorMQ class
# Fit the model via maximum likelihood, using the EM algorithm
res_dfm = mod_dfm.fit()
# Note that res_dfm is an instance of the DynamicFactorMQResults class
# Show the summary of results
print(res_ll.summary())
# Show a plot of the r^2 values from regressions of
# individual estimated factors on endogenous variables.
fig_dfm = res_ll.plot_coefficients_of_determination()
The DynamicFactor class is suitable for models with a smaller number of observed variables
|
Dynamic factor model |
|
Class to hold results from fitting an DynamicFactor model. |
For an example of the use of the DynamicFactor model, see the Dynamic Factor example notebook
Linear Exponential Smoothing Models¶
The ExponentialSmoothing class is an implementation of linear exponential smoothing models using a state space approach.
Note: this model is available at sm.tsa.statespace.ExponentialSmoothing; it is not the same as the model available at sm.tsa.ExponentialSmoothing. See below for details of the differences between these classes.
Linear exponential smoothing models |
|
Results from fitting a linear exponential smoothing model |
A very brief code snippet follows:
# Load the statsmodels api
import statsmodels.api as sm
# Load your dataset
endog = pd.read_csv('your/dataset/here.csv')
# Simple exponential smoothing, denoted (A,N,N)
mod_ses = sm.tsa.statespace.ExponentialSmoothing(endog)
res_ses = mod_ses.fit()
# Holt's linear method, denoted (A,A,N)
mod_h = sm.tsa.statespace.ExponentialSmoothing(endog, trend=True)
res_h = mod_h.fit()
# Damped trend model, denoted (A,Ad,N)
mod_dt = sm.tsa.statespace.ExponentialSmoothing(endog, trend=True,
damped_trend=True)
res_dt = mod_dt.fit()
# Holt-Winters' trend and seasonality method, denoted (A,A,A)
# (assuming that `endog` has a seasonal periodicity of 4, for example if it
# is quarterly data).
mod_hw = sm.tsa.statespace.ExponentialSmoothing(endog, trend=True,
seasonal=4)
res_hw = mod_hw.fit()
Differences between Statsmodels’ exponential smoothing model classes
There are several differences between this model class, available at sm.tsa.statespace.ExponentialSmoothing, and the model class available at sm.tsa.ExponentialSmoothing.
This model class only supports linear exponential smoothing models, while sm.tsa.ExponentialSmoothing also supports multiplicative models.
This model class puts the exponential smoothing models into state space form and then applies the Kalman filter to estimate the states, while sm.tsa.ExponentialSmoothing is based on exponential smoothing recursions. In some cases, this can mean that estimating parameters with this model class will be somewhat slower than with sm.tsa.ExponentialSmoothing.
This model class can produce confidence intervals for forecasts, based on an assumption of Gaussian errors, while sm.tsa.ExponentialSmoothing does not support confidence intervals.
This model class supports concentrating initial values out of the objective function, which can improve performance when there are many initial states to estimate (for example when the seasonal periodicity is large).
This model class supports many advanced features available to state space models, such as diagnostics and fixed parameters.
Note: this class is based on a “multiple sources of error” (MSOE) state space formulation and not a “single source of error” (SSOE) formulation.
Custom state space models¶
The true power of the state space model is to allow the creation and estimation of custom models. Usually that is done by extending the following two classes, which bundle all of state space representation, Kalman filtering, and maximum likelihood fitting functionality for estimation and results output.
|
State space model for maximum likelihood estimation |
|
Class to hold results from fitting a state space model. |
For a basic example demonstrating creating and estimating a custom state space model, see the Local Linear Trend example notebook. For a more sophisticated example, see the source code for the SARIMAX and SARIMAXResults classes, which are built by extending MLEModel and MLEResults.
In simple cases, the model can be constructed entirely using the MLEModel class. For example, the AR(2) model from above could be constructed and estimated using only the following code:
import numpy as np
from scipy.signal import lfilter
import statsmodels.api as sm
# True model parameters
nobs = int(1e3)
true_phi = np.r_[0.5, -0.2]
true_sigma = 1**0.5
# Simulate a time series
np.random.seed(1234)
disturbances = np.random.normal(0, true_sigma, size=(nobs,))
endog = lfilter([1], np.r_[1, -true_phi], disturbances)
# Construct the model
class AR2(sm.tsa.statespace.MLEModel):
def __init__(self, endog):
# Initialize the state space model
super(AR2, self).__init__(endog, k_states=2, k_posdef=1,
initialization='stationary')
# Setup the fixed components of the state space representation
self['design'] = [1, 0]
self['transition'] = [[0, 0],
[1, 0]]
self['selection', 0, 0] = 1
# Describe how parameters enter the model
def update(self, params, transformed=True, **kwargs):
params = super(AR2, self).update(params, transformed, **kwargs)
self['transition', 0, :] = params[:2]
self['state_cov', 0, 0] = params[2]
# Specify start parameters and parameter names
@property
def start_params(self):
return [0,0,1] # these are very simple
# Create and fit the model
mod = AR2(endog)
res = mod.fit()
print(res.summary())
This results in the following summary table:
Statespace Model Results
==============================================================================
Dep. Variable: y No. Observations: 1000
Model: AR2 Log Likelihood -1389.437
Date: Wed, 26 Oct 2016 AIC 2784.874
Time: 00:42:03 BIC 2799.598
Sample: 0 HQIC 2790.470
- 1000
Covariance Type: opg
==============================================================================
coef std err z P>|z| [0.025 0.975]
------------------------------------------------------------------------------
param.0 0.4395 0.030 14.730 0.000 0.381 0.498
param.1 -0.2055 0.032 -6.523 0.000 -0.267 -0.144
param.2 0.9425 0.042 22.413 0.000 0.860 1.025
===================================================================================
Ljung-Box (Q): 24.25 Jarque-Bera (JB): 0.22
Prob(Q): 0.98 Prob(JB): 0.90
Heteroskedasticity (H): 1.05 Skew: -0.04
Prob(H) (two-sided): 0.66 Kurtosis: 3.02
===================================================================================
Warnings:
[1] Covariance matrix calculated using the outer product of gradients (complex-step).
The results object has many of the attributes and methods you would expect from other statsmodels results objects, including standard errors, z-statistics, and prediction / forecasting.
More advanced usage is possible, including specifying parameter transformations, and specifying names for parameters for a more informative output summary.
Overview of usage¶
All state space models follow the typical Statsmodels pattern:
Construct a model instance with an input dataset
Apply parameters to the model (for example, using fit) to construct a results instance
Interact with the results instance to examine the estimated parameters, explore residual diagnostics, and produce forecasts, simulations, or impulse responses.
An example of this pattern is as follows:
# Load in the example macroeconomic dataset
dta = sm.datasets.macrodata.load_pandas().data
# Make sure we have an index with an associated frequency, so that
# we can refer to time periods with date strings or timestamps
dta.index = pd.date_range('1959Q1', '2009Q3', freq='QS')
# Step 1: construct an SARIMAX model for US inflation data
model = sm.tsa.SARIMAX(dta.infl, order=(4, 0, 0), trend='c')
# Step 2: fit the model's parameters by maximum likelihood
results = model.fit()
# Step 3: explore / use results
# - Print a table summarizing estimation results
print(results.summary())
# - Print only the estimated parameters
print(results.params)
# - Create diagnostic figures based on standardized residuals:
# (1) time series graph
# (2) histogram
# (3) Q-Q plot
# (4) correlogram
results.plot_diagnostics()
# - Examine diagnostic hypothesis tests
# Jarque-Bera: [test_statistic, pvalue, skewness, kurtosis]
print(results.test_normality(method='jarquebera'))
# Goldfeld-Quandt type test: [test_statistic, pvalue]
print(results.test_heteroskedasticity(method='breakvar'))
# Ljung-Box test: [test_statistic, pvalue] for each lag
print(results.test_serial_correlation(method='ljungbox'))
# - Forecast the next 4 values
print(results.forecast(4))
# - Forecast until 2020Q4
print(results.forecast('2020Q4'))
# - Plot in-sample dynamic prediction starting in 2005Q1
# and out-of-sample forecasts until 2010Q4 along with
# 90% confidence intervals
predict_results = results.get_prediction(start='2005Q1', end='2010Q4', dynamic=True)
predict_df = predict_results.summary_frame(alpha=0.10)
fig, ax = plt.subplots()
predict_df['mean'].plot(ax=ax)
ax.fill_between(predict_df.index, predict_df['mean_ci_lower'],
predict_df['mean_ci_upper'], alpha=0.2)
# - Simulate two years of new data after the end of the sample
print(results.simulate(8, anchor='end'))
# - Impulse responses for two years
print(results.impulse_responses(8))
Basic methods and attributes for estimation / filtering / smoothing¶
The most-used methods for a state space model are:
fit
- estimate parameters via maximum likelihood and return a results object (this object will have also performed Kalman filtering and smoothing at the estimated parameters). This is the most commonly used method.smooth
- return a results object associated with a given vector of parameters after performing Kalman filtering and smoothingloglike
- compute the log-likelihood of the data using a given vector of parameters
Some useful attributes of a state space model are:
param_names
- names of the parameters used by the modelstate_names
- names of the elements of the (unobserved) state vectorstart_params
- initial parameter estimates used a starting values for numerical maximum likelihood optimization
Other methods that are used less often are:
filter
- return a results object associated with a given vector of parameters after only performing Kalman filtering (but not smoothing)simulation_smoother
- return an object that can perform simulation smoothing
Output and postestimation methods and attributes¶
Commonly used methods include:
summary
- construct a table that presents model fit statistics, estimated parameters, and other summary outputpredict
- compute in-sample predictions and out-of-sample forecasts (point estimates only)get_prediction
- compute in-sample predictions and out-of-sample forecasts, including confidence intervalsforecast
- compute out-of-sample forecasts (point estimates only) (this is a convenience wrapper around predict)get_forecast
- compute out-of-sample forecasts, including confidence intervals (this is a convenience wrapper around get_prediction)simulate
- simulate new data according to the state space modelimpulse_responses
- compute impulse responses from the state space model
Commonly used attributes include:
params
- estimated parametersbse
- standard errors of estimated parameterspvalues
- p-values associated with estimated parametersllf
- log-likelihood of the data at the estimated parameterssse
,mse
, andmae
- sum of squared errors, mean square error, and mean absolute errorfittedvalues
- fitted values from the model (note that these are one-step-ahead predictions)resid
- residuals from the model (note that these are one-step-ahead prediction errors)
Estimates and covariances of the unobserved state¶
It can be useful to compute estimates of the unobserved state vector
conditional on the observed data. These are available in the results object
states
, which contains the following
elements:
states.filtered - filtered (one-sided) estimates of the state vector. The estimate of the state vector at time t is based on the observed data up to and including time t.
states.smoothed - smoothed (two-sided) estimates of the state vector. The estimate of the state vector at time t is based on all observed data in the sample.
states.filtered_cov - filtered (one-sided) covariance of the state vector
states.smoothed_cov - smoothed (two-sided) covariance of the state vector
Each of these elements are Pandas DataFrame objects.
As an example, in a “local level + seasonal” model estimated via the UnobservedComponents components class we can get an estimates of the underlying level and seasonal movements of a series over time.
fig, axes = plt.subplots(3, 1, figsize=(8, 8))
# Retrieve monthly retail sales for clothing
from pandas_datareader.data import DataReader
clothing = DataReader('MRTSSM4481USN', 'fred', start='1992').asfreq('MS')['MRTSSM4481USN']
# Construct a local level + seasonal model
model = sm.tsa.UnobservedComponents(clothing, 'llevel', seasonal=12)
results = model.fit()
# Plot the data, the level, and seasonal
clothing.plot(ax=axes[0])
results.states.smoothed['level'].plot(ax=axes[1])
results.states.smoothed['seasonal'].plot(ax=axes[2])
Residual diagnostics¶
Three diagnostic tests are available after estimation of any statespace model, whether built in or custom, to help assess whether the model conforms to the underlying statistical assumptions. These tests are:
A number of standard plots of regression residuals are available for the same
purpose. These can be produced using the command
plot_diagnostics
.
Applying estimated parameters to an updated or different dataset¶
There are three methods that can be used to apply estimated parameters from a results object to an updated or different dataset:
append
- retrieve a new results object with additional observations that follow after the end of the current sample appended to it (so the new results object contains both the current sample and the additional observations)extend
- retrieve a new results object for additional observations that follow after end of the current sample (so the new results object contains only the new observations but NOT the current sample)apply
- retrieve a new results object for a completely different dataset
One cross-validation exercise on time-series data involves fitting a model’s parameters based on a training sample (observations through time t) and then evaluating the fit of the model using a test sample (observations t+1, t+2, …). This can be conveniently done using either apply or extend. In the example below, we use the extend method.
# Load in the example macroeconomic dataset
dta = sm.datasets.macrodata.load_pandas().data
# Make sure we have an index with an associated frequency, so that
# we can refer to time periods with date strings or timestamps
dta.index = pd.date_range('1959Q1', '2009Q3', freq='QS')
# Separate inflation data into a training and test dataset
training_endog = dta['infl'].iloc[:-1]
test_endog = dta['infl'].iloc[-1:]
# Fit an SARIMAX model for inflation
training_model = sm.tsa.SARIMAX(training_endog, order=(4, 0, 0))
training_results = training_model.fit()
# Extend the results to the test observations
test_results = training_results.extend(test_endog)
# Print the sum of squared errors in the test sample,
# based on parameters computed using only the training sample
print(test_results.sse)
Understanding the Impact of Data Revisions¶
Statespace model results expose a news
method that
can be used to understand the impact of data revisions – news – on model
parameters.
|
Impacts of data revisions and news on estimates of variables of interest |
Additional options and tools¶
All state space models have the following options and tools:
Holding some parameters fixed and estimating the rest¶
The fit_constrained
method
allows fixing some parameters to known values and then estimating the rest via
maximum likelihood. An example of this is:
# Construct a model
model = sm.tsa.SARIMAX(endog, order=(1, 0, 0))
# To find out the parameter names, use:
print(model.param_names)
# Fit the model with a fixed value for the AR(1) coefficient:
results = model.fit_constrained({'ar.L1': 0.5})
Alternatively, you can use the
fix_params
context manager:
# Construct a model
model = sm.tsa.SARIMAX(endog, order=(1, 0, 0))
# Fit the model with a fixed value for the AR(1) coefficient using the
# context manager
with model.fix_params({'ar.L1': 0.5}):
results = model.fit()
Low memory options¶
When the observed dataset is very large and / or the state vector of the model is high-dimensional (for example when considering long seasonal effects), the default memory requirements can be too large. For this reason, the fit, filter, and smooth methods accept an optional low_memory=True argument, which can considerably reduce memory requirements and speed up model fitting.
Note that when using low_memory=True, not all results objects will be available. However, residual diagnostics, in-sample (non-dynamic) prediction, and out-of-sample forecasting are all still available.
Low-level state space representation and Kalman filtering¶
While creation of custom models will almost always be done by extending MLEModel and MLEResults, it can be useful to understand the superstructure behind those classes.
Maximum likelihood estimation requires evaluating the likelihood function of the model, and for models in state space form the likelihood function is evaluated as a byproduct of running the Kalman filter.
There are two classes used by MLEModel that facilitate specification of the state space model and Kalman filtering: Representation and KalmanFilter.
The Representation class is the piece where the state space model representation is defined. In simple terms, it holds the state space matrices (design, obs_intercept, etc.; see the introduction to state space models, above) and allows their manipulation.
FrozenRepresentation is the most basic results-type class, in that it takes a “snapshot” of the state space representation at any given time. See the class documentation for the full list of available attributes.
|
State space representation of a time series process |
Frozen Statespace Model |
The KalmanFilter class is a subclass of Representation that provides
filtering capabilities. Once the state space representation matrices have been
constructed, the filter
method can be called, producing a FilterResults instance; FilterResults is
a subclass of FrozenRepresentation.
The FilterResults class not only holds a frozen representation of the state
space model (the design, transition, etc. matrices, as well as model
dimensions, etc.) but it also holds the filtering output, including the
filtered state
and
loglikelihood (see the class documentation for the full list of available
results). It also provides a
predict
method, which allows
in-sample prediction or out-of-sample forecasting. A similar method,
predict
, provides
additional prediction or forecasting results, including confidence intervals.
|
State space representation of a time series process, with Kalman filter |
|
Results from applying the Kalman filter to a state space model. |
|
Results of in-sample and out-of-sample prediction for state space models generally |
The KalmanSmoother class is a subclass of KalmanFilter that provides
smoothing capabilities. Once the state space representation matrices have been
constructed, the filter
method can be called, producing a SmootherResults instance; SmootherResults
is a subclass of FilterResults.
The SmootherResults class holds all the output from FilterResults, but
also includes smoothing output, including the
smoothed state
and
loglikelihood (see the class documentation for the full list of available
results). Whereas “filtered” output at time t refers to estimates conditional
on observations up through time t, “smoothed” output refers to estimates
conditional on the entire set of observations in the dataset.
|
State space representation of a time series process, with Kalman filter and smoother. |
Results from applying the Kalman smoother and/or filter to a state space model. |
The SimulationSmoother class is a subclass of KalmanSmoother that further
provides simulation and simulation smoothing capabilities. The
simulation_smoother
method can be called, producing a SimulationSmoothResults instance.
The SimulationSmoothResults class has a simulate method, that allows performing simulation smoothing to draw from the joint posterior of the state vector. This is useful for Bayesian estimation of state space models via Gibbs sampling.
State space representation of a time series process, with Kalman filter and smoother, and with simulation smoother. |
|
Results from applying the Kalman smoother and/or filter to a state space model. |
|
"Cholesky Factor Algorithm" (CFA) simulation smoother |
Statespace Tools¶
There are a variety of tools used for state space modeling or by the SARIMAX class:
|
Create a companion matrix |
|
Difference a series simply and/or seasonally along the zero-th axis. |
|
Determine if a polynomial is invertible. |
Transform unconstrained parameters used by the optimizer to constrained parameters used in likelihood evaluation |
|
Transform constrained parameters used in likelihood evaluation to unconstrained parameters used by the optimizer |
|
Transform unconstrained parameters used by the optimizer to constrained parameters used in likelihood evaluation for a vector autoregression. |
|
Transform constrained parameters used in likelihood evaluation to unconstrained parameters used by the optimizer |
|
|
Validate the shape of a possibly time-varying matrix, or raise an exception |
|
Validate the shape of a possibly time-varying vector, or raise an exception |


Interface to the 'Google Maps' APIs: (1) routing directions based on the 'Directions' API, returned as 'sf' objects, either as single feature per alternative route, or a single feature per segment per alternative route; (2) travel distance or time matrices based on the 'Distance Matrix' API; (3) geocoded locations based on the 'Geocode' API, returned as 'sf' objects, either points or bounds.
| Version: | 0.3.7 |
| Imports: | magrittr (≥ 1.5), xml2 (≥ 1.1.1), sf (≥ 0.5-3), bitops (≥ 1.0-6), plyr (≥ 1.8.4) |
| Suggests: | knitr, rmarkdown, leaflet |
| Published: | 2018-07-23 |
| Author: | Michael Dorman [aut, cre], Tom Buckley [ctb] |
| Maintainer: | Michael Dorman <dorman at post.bgu.ac.il> |
| BugReports: | https://github.com/michaeldorman/mapsapi/issues |
| License: | MIT + file LICENSE |
| NeedsCompilation: | no |
| Materials: | NEWS |
| In views: | WebTechnologies |
| CRAN checks: | mapsapi results |
| Reference manual: | mapsapi.pdf |
| Vignettes: |
Introduction to package 'mapsapi' |
| Package source: | mapsapi_0.3.7.tar.gz |
| Windows binaries: | r-devel: mapsapi_0.3.7.zip, r-release: mapsapi_0.3.7.zip, r-oldrel: mapsapi_0.3.7.zip |
| OS X binaries: | r-release: mapsapi_0.3.7.tgz, r-oldrel: mapsapi_0.3.7.tgz |
| Old sources: | mapsapi archive |
Please use the canonical form https://CRAN.R-project.org/package=mapsapi to link to this page.


The knowledge required to run a small network is similar to the one for a larger network. It is the number of devices involved that changes.
Small network typically involve a single router, a single WAN connection, one or more switches and APs (often integrated in one device).
The management can be done by an employee or a contractor.
Redundancy provides networks with reliability. It is achieved by duplicating: devices, links, power supplies, services.
Redundancy can be introduced progressively, starting with a second connection between multiple intermediary devices.
Small networks have typically one gateway to the Internet. A backup connection to a second ISP can be considered.
Software that makes use of the network can be divided in:
Real-time applications are the ones that stress the most a network design, because they rely on priority delivery.
Typical examples are Voice Over IP (VoIP) and IP Telephony. The difference being whether the voice-to-IP conversion is performed by the phone. However, VoIP is the go-to term.
Real-Time applications need protocols that supports delay-sensitive delivery and QoS, like RTP (Real-Time Transport Protocol) or RTCP (Real-Time Transport Control Protocol).
Often QoS is implemented in-hardware.
Networks can grow either reactively (responding to needs) or proactively (anticipating needs). It is clearly better to grow the network alongside its needs.
To carefully plan the scaling of a network you need: documentation, inventory, budget, traffic analysis.
Traffic/Protocol analysis allows an administrator to collect statistics about the traffic flowing in the network. With the right data, optimizations can be made. Some suggestions:
Analysis could reveal optimization paths that are trivial, or others requiring major overhaul of the network design.
Device physical protection is as important as protecting the software stack. The Attacker can be an outsider, but we can also play our (negative) part in these categories of threats:
Vulnerabilities can be found in:
There are programs (collectively known as malware) created for the purpose of causing harm:
In order to be executed, malicious code attacks need:
Reconnaissance involves the search, discovery and mapping of vulnerabilities in victim's systems.
nslookup
or whois
can be used to determine the address space belonging to the victim.nmap
an attacker can discover the transport layer ports that are opened on a system.stefanauss@barney:~$ nslookup hlcs.it
Server: <IP_ADDRESS>
Address: <IP_ADDRESS>#53
Non-authoritative answer:
Name: hlcs.it
Address: <IP_ADDRESS>
stefanauss@barney:~$ nslookup <IP_ADDRESS>
Server: <IP_ADDRESS>
Address: <IP_ADDRESS>#53
Non-authoritative answer:
<IP_ADDRESS>.in-addr.arpa name = ks381122.kimsufi.com.
Authoritative answers can be found from:
stefanauss@barney:~$ whois hlcs.it
*********************************************************************
* Please note that the following result could be a subgroup of *
* the data contained in the database. *
* *
* Additional information can be visualized at: *
* http://www.nic.it/cgi-bin/Whois/whois.cgi *
*********************************************************************
Domain: hlcs.it
Status: ok
Created: 2012-10-02 22:07:03
Last Update: 2014-10-18 00:43:12
Expire Date: 2015-10-02
Registrant
Organization: SOCIETA' COOPERATIVA COOPYLEFT A R.L.
Admin Contact
Name: Vincenzo Bruno
Organization: SOCIETA' COOPERATIVA COOPYLEFT A R.L.
Technical Contacts
Name: Unità Tecnica Tophost
Organization: Tophost srl
Address: Piazza della Libertà 10
Roma
00192
RM
IT
Created: 2009-09-28 11:25:11
Last Update: 2011-08-18 13:47:40
Registrar
Organization: Seeweb S.r.l.
Name: TOPHOST-REG
Web: http://www.tophost.it
Nameservers
ns1.th.seeweb.it
ns2.th.seeweb.it
stefanauss@barney:~$ nmap scanme.nmap.org
Starting Nmap 6.40 ( http://nmap.org ) at 2014-12-05 01:10 CET
Nmap scan report for scanme.nmap.org (<IP_ADDRESS>)
Host is up (0.23s latency).
Not shown: 997 closed ports
PORT STATE SERVICE
22/tcp open ssh
80/tcp open http
9929/tcp open nping-echo
Nmap done: 1 IP address (1 host up) scanned in 20.66 seconds
When unauthorized (attempted or successful) access to systems and exploitation of user privileges takes place.
There are many types of DoS attacks. They all target the exhaustion of system and network resources to the point where it's hard or impossible to legitimately use them.
Some kinds of Denial of Service attacks are:
If an attack is successful, administrators have to perform these steps in order to regain control:
A central patch server, automatic updates, and a standard software image can be good strategies to keep systems secure.
The Triple A governs access control by providing:
Firewalls are systems placed between networks, controlling the traffic flow between them using several techniques:
Firewall can take differents forms, such as:
Router(config)# service password-encryption
Router(config)# security password min-length 8
Router(config)# login block-for 240 attempts 3 within 60
Router(config)# line console 0
Router(config-line)# exec-timeout 10
Router(config-line)# end
exec timeout
tells the device to automatically disconnect logged-in users after the specified number of minutes of inactivy (idle).
Router(config)# ip domain-name hlcs.it
Router(config)# crypto key generate rsa
The name for the keys will be: Router.hlcs.it
Choose the size of the key modulus in the range of 360 to 2048 for your
General Purpose Keys. Choosing a key modulus greater than 512 may take
a few minutes.
How many bits in the modulus [512]: 2048
% Generating 2048 bit RSA keys, keys will be non-exportable...[OK]
*Dec 5 03:12:52.628: %SSH-5-ENABLED: SSH 1.99 has been enabled
Router(config)# username HLCS secret cisco
Router(config)# line vty 0 15
Router(config-line)# login local
Router(config-line)# transport input ssh
crypto key generate rsa
uses the RSA algorhythm to generate encryption keys.login local
enables password checking against a user database on the device.transport input [protocol]
specifies which protocol are enabled to access a specific configuration line with.Establishing a network baseline means detailing network performances over time to create a reference point.
Basic performance tests like ping
or traceroute
should be executed at different times of the day, days of the week, and stored as documentation for future comparisons.
There are integrated softwares that manage the creation and storage of large and detailed baselines.
On Cisco IOS, by typing ping
in privileg EXEC mode, without an address, an extended ping mode is accessed.
R2# ping
Protocol [ip]:
Target IP address: <IP_ADDRESS>
Repeat count [5]:
Datagram size [100]:
Timeout in seconds [2]:
Extended commands [n]: y
Source address or interface: <IP_ADDRESS>
Type of service [0]:
Set DF bit in IP header? [no]:
Validate reply data? [no]:
Data pattern [0xABCD]:
Loose, Strict, Record, Timestamp, Verbose[none]:
Sweep range of sizes [n]:
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to <IP_ADDRESS>, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 36/97/132 ms
Cisco IOS traceroute
implementation uses a different approach (as Linux does) than pure ICMP Echo Request/Reply. It sends UDP datagrams, always with incrementing TTL values.
R2#traceroute
Protocol [ip]:
Target IP address: <IP_ADDRESS>
Source address: <IP_ADDRESS>
Numeric display [n]:
Timeout in seconds [3]:
Probe count [3]:
Minimum Time to Live [1]:
Maximum Time to Live [30]:
Port Number [33434]:
Loose, Strict, Record, Timestamp, Verbose[none]:
Type escape sequence to abort.
Tracing the route to <IP_ADDRESS>
1 <IP_ADDRESS> 16 msec 16 msec 16 msec
2 <IP_ADDRESS> 28 msec 28 msec 32 msec
3 <IP_ADDRESS> 32 msec 28 msec *
CDP is a proprietary protocol by Cisco that allows a device to learn hardware and software information about other devices directly connected to it.
CDP runs at L2, so it can operate even if there is no network layer connectivity or different L3 protocols are running.
It provides details like Device identifiers, address list, port identifiers, capabilities, platform.
CDP is enabled by default on Cisco IOS, but it can represent a security risk. It can be disabled globally with the command no cdp run
, or per-interface with the command no cdp enable
.
Router1# show cdp neighbors
Capability Codes: R - Router, T - Trans Bridge, B - Source Route Bridge
S - Switch, H - Host, I - IGMP, r - Repeater
Device ID Local Intrfce Holdtme Capability Platform Port ID
Router2 Ser 0/0 179 R I 2621 Ser 0/1
Switch1 Fas 1/0 152 S I WS-C2924 Gig 2/2
Router1#show cdp neighbors detail
-------------------------
Device ID: Router2
Entry address(es):
IP address: <IP_ADDRESS>
Platform: cisco 2621, Capabilities: Router
Interface: Serial0/0, Port ID (outgoing port): Serial0/1
Holdtime : 136 sec
Version :
Cisco Internetwork Operating System Software
IOS (tm) C2600 Software (C2600-IK9O3S-M), Version 12.2(13), RELEASE SOFTWARE (fc1)
Copyright (c) 1986-2002 by cisco Systems, Inc.
Compiled Tue 19-Nov-02 22:27 by pwade
advertisement version: 2
Device ID: Switch1
Entry address(es):
IP address: <IP_ADDRESS>
Platform: WS-C2924, Capabilities: Trans-Bridge Switch
Interface: FastEthernet1/0, Port ID (outgoing port): FastEthernet0/12
Holdtime : 116 sec
Version :
Cisco Internetwork Operating System Software
IOS (tm) C2900XL Software (C2900XL-C3H2S-M), Version 12.0(5)WC3b, RELEASE SOFTWARE (fc1)
Copyright (c) 1986-2002 by cisco Systems, Inc.
Compiled Fri 15-Feb-02 10:14 by antonino
advertisement version: 2
Duplex: full
Processes and protocols running on Cisco IOS generate messages during their operation the can be helpful during troubleshooting.
The (#) debug
command allows these messages to appear in real-time on the console. They can be quite a lot, so debug can be activated for each single feature or area of interest.
! Enable ICMP message logging
Router# debug ip icmp
! Disable it
Router# no debug ip icmp
! Disable all debug messages of all types
Router# undebug all
By default, Cisco IOS prints debug messages only on the console connection. To have them available over virtual terminals (SSH and Telnet connections), use (#) terminal monitor
.


Welcome to Project21 UK! We are a charity dedicated to helping children and adults with Downs Syndrome across East Anglia. Based in Suffolk, we provide fun activities, days out, music sessions, trips to the theatre, and much more!


time - time a simple command or give resource usage
time [options] command
[arguments...]
The time command runs the specified program command with the given
arguments. When command finishes, time writes a message to
standard error giving timing statistics about this program run. These
statistics consist of (i) the elapsed real time between invocation and
termination, (ii) the user CPU time (the sum of the tms_utime and
tms_cutime values in a struct tms as returned by
times(2)), and (iii) the system CPU time (the sum of the
tms_stime and tms_cstime values in a struct tms as
returned by times(2)).
Note: some shells (e.g., bash(1)) have a built-in
time command that provides similar information on the usage of time
and possibly other resources. To access the real command, you may need to
specify its pathname (something like /usr/bin/time).
- -p
- When in the POSIX locale, use the precise traditional format
-
"real %f\nuser %f\nsys %f\n"
- (with numbers in seconds) where the number of decimals in the output for
%f is unspecified but is sufficient to express the clock tick accuracy,
and at least one.
If command was invoked, the exit status is that of command.
Otherwise, it is 127 if command could not be found, 126 if it could be
found but could not be invoked, and some other nonzero value (1–125) if
something else went wrong.
The variables LANG, LC_ALL, LC_CTYPE, LC_MESSAGES,
LC_NUMERIC, and NLSPATH are used for the text and formatting of
the output. PATH is used to search for command. The remaining
ones for the text and formatting of the output.
Below a description of the GNU 1.7 version of time. Disregarding the name
of the utility, GNU makes it output lots of useful information, not only about
time used, but also on other resources like memory, I/O and IPC calls (where
available). The output is formatted using a format string that can be
specified using the -f option or the TIME environment variable.
The default format string is:
%Uuser %Ssystem %Eelapsed %PCPU (%Xtext+%Ddata %Mmax)k
%Iinputs+%Ooutputs (%Fmajor+%Rminor)pagefaults %Wswaps
When the -p option is given, the (portable) output format
is used:
real %e
user %U
sys %S
The format is interpreted in the usual printf-like way. Ordinary characters are
directly copied, tab, newline and backslash are escaped using \t, \n and \\, a
percent sign is represented by %%, and otherwise % indicates a conversion. The
program time will always add a trailing newline itself. The conversions
follow. All of those used by tcsh(1) are supported.
Time
- %E
- Elapsed real time (in [hours:]minutes:seconds).
- %e
- (Not in tcsh(1).) Elapsed real time (in seconds).
- %S
- Total number of CPU-seconds that the process spent in kernel mode.
- %U
- Total number of CPU-seconds that the process spent in user mode.
- %P
- Percentage of the CPU that this job got, computed as (%U + %S) / %E.
Memory
- %M
- Maximum resident set size of the process during its lifetime, in
Kbytes.
- %t
- (Not in tcsh(1).) Average resident set size of the process, in
Kbytes.
- %K
- Average total (data+stack+text) memory use of the process, in Kbytes.
- %D
- Average size of the process's unshared data area, in Kbytes.
- %p
- (Not in tcsh(1).) Average size of the process's unshared stack
space, in Kbytes.
- %X
- Average size of the process's shared text space, in Kbytes.
- %Z
- (Not in tcsh(1).) System's page size, in bytes. This is a
per-system constant, but varies between systems.
- %F
- Number of major page faults that occurred while the process was running.
These are faults where the page has to be read in from disk.
- %R
- Number of minor, or recoverable, page faults. These are faults for pages
that are not valid but which have not yet been claimed by other virtual
pages. Thus the data in the page is still valid but the system tables must
be updated.
- %W
- Number of times the process was swapped out of main memory.
- %c
- Number of times the process was context-switched involuntarily (because
the time slice expired).
- %w
- Number of waits: times that the program was context-switched voluntarily,
for instance while waiting for an I/O operation to complete.
I/O
- %I
- Number of filesystem inputs by the process.
- %O
- Number of filesystem outputs by the process.
- %r
- Number of socket messages received by the process.
- %s
- Number of socket messages sent by the process.
- %k
- Number of signals delivered to the process.
- %C
- (Not in tcsh(1).) Name and command-line arguments of the command
being timed.
- %x
- (Not in tcsh(1).) Exit status of the command.
- -f format, --format=format
- Specify output format, possibly overriding the format specified in the
environment variable TIME.
- -p, --portability
- Use the portable output format.
- -o file, --output=file
- Do not send the results to stderr, but overwrite the specified
file.
- -a, --append
- (Used together with -o.) Do not overwrite but append.
- -v, --verbose
- Give very verbose output about all the program knows about.
- -q, --quiet
- Don't report abnormal program termination (where command is
terminated by a signal) or nonzero exit status.
- --help
- Print a usage message on standard output and exit successfully.
- -V, --version
- Print version information on standard output, then exit successfully.
- --
- Terminate option list.
Not all resources are measured by all versions of UNIX, so some of the values
might be reported as zero. The present selection was mostly inspired by the
data provided by 4.2 or 4.3BSD.
GNU time version 1.7 is not yet localized. Thus, it does not
implement the POSIX requirements.
The environment variable TIME was badly chosen. It is not
unusual for systems like autoconf(1) or make(1) to use
environment variables with the name of a utility to override the utility to
be used. Uses like MORE or TIME for options to programs (instead of program
pathnames) tend to lead to difficulties.
It seems unfortunate that -o overwrites instead of appends.
(That is, the -a option should be the default.)
Mail suggestions and bug reports for GNU time to
<EMAIL_ADDRESS>Please include the version of time, which
you can get by running
time --version
and the operating system and C compiler you used.
bash(1), tcsh(1), times(2), wait3(2)
This page is part of release 5.05 of the Linux man-pages project. A
description of the project, information about reporting bugs, and the latest
version of this page, can be found at https://www.kernel.org/doc/man-pages/.


Sign Up
Please fill in this form to create an account!
* Required
User successfuly registered.
Alert!
Please check in on some of the fields below.
Register
Already have an account?
Login here.


Hyper Island Application Task 2020
This work is created as my application task for Hyper Island 2020. It is a work of fiction based on true events that are occuring daily all over the world. I've written this with the intent of raising awareness of the UN Sustainable Development Goals. The main focus is gender equality, but it highlights other goals as well. The statistics have gone up, and the world is a better place, but that doesn't mean that we're done and can give up. There are still countries that don't have the basic human rights, the UN pledged to Leave No One Behind.
The Sustainable Development Goals (SDGs), also known as the Global Goals, were adopted by all United States Nations Member States in 2015 as a universal call to action to end poverty, protect the planet and ensure that all people enjoy peace and prosperity by 2030.
If you want to read more about the UN Sustainable Development Goals, click here. You can read why the goals are important, and what you can do to help. Now you're thinking what can I do alone? I can't change anything, that's up for governments and world leaders. You're wrong, every contribution helps, small or large. Therefore, the UN has published a Lazy Person's Guide to Saving the World. You don't have to do everything on that list, but if you can do a few things. All those few things add up, and in the end, we've made a change.
This isn't my story, I wrote it, but it's not about me. Why should you read it and why should you care? Because, it is someone's story. It is someone's life, someone's future. And it isn't someone, it's millions. Millions of girls and boys.
"Tell me and I'll forget. Show me, and I may not remember. Involve me, and I'll understand"Start readingNative American Proverb


by searching the movie title or paste the imdb link of the movie into the search
invite your friends by pressing the share button
the creator of this room can randomly select a movie or starting a vote. All room users can vote!


12/3/17
The Meditation Process
How did the 'process over product' concept affect the way you tackled the site redesign and rebuild?
I found this week rather challenging, doing the whole rebuild. Partially due to the amount of time it took me to familiarise myself with the skeleton framework. I'm still not sure I've got a handle on it! Being able to focus on what I was doing rather than whether I was going to achieve it was rather useful. It meant I actually spent less time trying to perfect my code (as much of my perfectionist side protested) and instead enjoyed what I was doing.
What did you think about meditation before reading chapter 2 of Search Inside Yourself?
It seems useful to some people. I don't know that meditation for extended periods could ever work for me, but I certainly enjoy and use some of the smaller processes.
What new things have you learnt about meditation?
I like the idea of meditaion being cultivating your mind. I also loved the gym analogy. One thing I do like to do is to go to the gym (especially with others, but by myself too. So forgive some brief enthusiasm). When you try new exercises you're inevitably terrible, but being able to push past that bit of resistance or to keep trying while still being terrible is very rewarding. I like how easily attention training and focusing is compared to this, where even if you don't think you're very good, the fact that you're doing it means you're getting better (It's just like being at the gym!).
Did any of the suggested meditation techniques stand out to you?
“If you have to react (for example, you really have to scratch), try to take five breaths before reacting.” I liked this concept and am definitely going to be adding it to my repertoire.
Any other musings?
“The act of creating good intentions is itself a form of meditation.”
Meditation is forming mental habits and “an attitude of self-directed kindness”
The four main meditation postures: sitting, standing, walking (my favourite), and lying down.
Sitting like a mountain.


--- layout: post esbma_id: 1403 date: 2002-04-11 12:00:00 keywords: cornsharp title: Blog entry on 11 Apr 2002 ---
Joel's latest piece is another good one, on the topic of how to choose a ship date: "For Systems With Millions of Customers and Millions of Integration Points, Prefer Rare Releases. You can do it like Apache: one release at the beginning of the Internet Bubble, and one release at the end. Perfect."
My favorite tidbit from the Tech-Ed show this week: I was talking with a Microsoftie on Tuesday and I noticed he was wearing one of those bracelets. Many Christians wear one that says "WWJD", which stands for "What Would Jesus Do?". It took a moment or two of glancing to realize that this guy's bracelet actually says "WWBD".