{include file="public:head" /}
{include file="public:nav" /}
{include file="public:footer"/} {include file="public:scripts"/}


This Website is created as part of an assignment for the course IS601: Web System Development. Each student had to read/watch a list of documents/videos and learn about the topics related to the internet. Some of the topics are given below


Short ribs pancetta pig, ball tip meatball ham hock strip steak shankle.
Short ribs pancetta pig, ball tip meatball ham hock strip steak shankle.
Short ribs pancetta pig, ball tip meatball ham hock strip steak shankle.
Short ribs pancetta pig, ball tip meatball ham hock strip steak shankle.


Recently acquired some new things to wear? Enter the information below, and we'll find some outfits for you to show 'em off!
Select a colour:


Welcome to .xyz Technologies
Our vision is to exert unparalleled influence on creators and help advance the development of Web3.0
We are on a mission to build to build distributed networks that connect the future of internet services and allow individuals to own their digital assets.
Defining Web3.0
From A to .XYZ we are the development experts for Web3.0 & Blockchain
protocols.
The x-y-z of advancing distributed projects starts with a process and
ends with execution.
Our process is simple, hire experienced designers, product managers and engineers. We
specialize in building "full stack" peer-to-peer networks and help to unbundle web services in
order to
create community-operated protocols.
With a multi-cultural and distributed workforce, our project teams touch all areas of the modern
web stack, and employ elements of Agile, CI and Test-Driven Development.
We enjoy working with visionary founders and hackers to build and execute on productive growth.


We once again meet at Info.nl to continue work on the ideas explored in the previous meetup.
We look at this infographic: ‘Hoe ongelijk is het geld in Nederland eigenlijk verdeeld?’. It shows the facts about wealth inequality in the Netherlands, but in a somewhat convoluted way. It also doesn’t tell a story so it is to be expected people viewing this will not be persuaded of a particular point of view.
We talk about a few resources some of us have collected.
Next we discuss an idea that emerged in conversations on our chat system: a tool that informs people about inequality by making it personal. In the tool you would input some personal figures and then it shows where you are on the wealth/income spectrum.
The origin of this idea is the observation that most people think they’re somewhere in the middle of society’s wealth distribution when in fact they are somewhere in the bottom. From reading and conversations we’ve had the hypothesis has emerged that if we could give people insight into their actual position this might change their attitude and inspire action. E.g. ‘Ongelijk en onwetend’.
Let’s say we manage to build a thing that will enable people to accurately determine where they are on the ladder. Then what? We should use the energy produced by offering such insights towards a certain end.
We brainstorm some ideas. These include:
We talk some more about how things could work. We could play on the fact that most people overestimate where they are on the ladder. So they could be asked to guess where they are first, then enter some data, then see where they really are.
To make it more meaningful we could also show how their position has likely changed over time. And maybe do some projections into the future.
For people to really care though, we also need to talk about the social impact of inequality. We shouldn’t frame it as a personal, individual problem.
To be inspiring we should tell a story of what a society with less inequality would look like. This would play into the idea of self-interest properly understood. Even if you yourself are doing okay, reducing inequality will improve the lives of the community you are part of, which in turn should benefit you.
If we were to build this we should start by doing it as a ‘lean’ experiment.
Finally, we muse on the question of how to make the thing itself more democratic. It should be of use to everyone who enters data. So we should make the software open source and open up the data we collect. There should be a chat group or mailing list for anyone who uses it. And we should have community editable documentation.
We wrap up with brainstorming what we should be doing next.
And with that, we end the meetup and leave, energised as always.


First Name
Last Name
Email
Mobile phone
Street
Unit
City
Zip
Skills
C
Clojure
Data Science
Data Visualization
HTML/CSS
Mapping
Javascript
Node.js
Product Management
Python
R
Ruby
User Experience
Visual Design
Other Skill
Issues
Economic Development
Education
Environmental Sustainability
Housing
Poverty & Inequality
Public Health
Public Safety
Transportation
Other Issue


Another example of technological choice was the power system. We knew right away that this one was going to cause no end of controversy. Modern civilization runs on electricity. That simple declarative sentence was a novel truth for most of North America and Europe by 1930, and the rest of the world by 1960, but by 1997 it hardly even merited a yawn. Which made the fragility of existing centralized power production and distribution networks all the more puzzling. We figured it must have had something to do with either economics, politics, or ignorance.
Our solution was to decentralize the power grid. We wouldn't have bothered to tweak the tiger by the tail, but in the U.S. the tiger -- that is to say, electric utility companies -- started to horn in on our territory, so we figured we'd hit them below the belt with some daring futurism.
Electric power consumption is something everyone can understand at the local level. Turn the switch, the appliances work, and at the end of the month one gets a bill from the power company for the number of kilowatts consumed. Strangely, it never seems to work in the opposite direction. Suppose that one decided to place a generator in one's backyard. One links it up to one's house, and one can run all one's appliances, no fuss, no muss. Let's say, in fact, that this generator generates more electricity than one can use personally. Why not sell the surplus kilowatts to the power company?
Why not? Because they don't want to buy it, that's why not. And why is that? Well, partially because dealing with hundreds of thousands of electricity sellers is a bit of pain in the posterior, admittedly. But the fundamental reason is that power corporations don't want to encourage competition. If everyone starts generating electricity, then the overall price per kilowatt goes down, and how then are they going to pay off the loans they borrowed to build power plants and networks?
In the real world, if one starts trying to sell electricity to one's neighbors, a nice friendly local law enforcement officer will likely drop by for a visit, followed in rapid succession by various legal representatives. Actually, sometimes it works. As long as people agree to incorporate, be regulated and supervised by the government, and pay corporate taxes, there's nothing illegal about becoming a power company. It depends on the laws of the state. Some towns in the U.S. and elsewhere do it. And the big power companies do, in fact, buy kilowatts from them.
Anyway, we decided that in the vCity, and thus in the world of the future, every citizen and every corporation would have the "legal" right to produce electricity at the local level of domicile, building, or facility. There would be no single power company per se, but rather hundreds of thousands of them, some very small, and some very large. Electricity would be purchased from, or sold to, the "open market". The price of a kilowatt would fluctuate and depend upon instant market conditions of supply and demand at the instant of purchase or sale. All of this would be monitored presumably by some pretty sophisticated telecomm and financial network software operated by the vCity Electrical Power Information Center.
One of the interesting side effects of decentralizing power generation, we figured, is that it would give individuals an additional monetary incentive to conserve when demand is high. With the correct freeware they would know exactly when to produce electricity for sale and/or cut back what they are buying to make the highest profit.
We figured that the major political/economic difference between the vCity power distribution network and those currently in the real world is that in the future, private corporations would operate pieces of the network for profit, but wouldn't own any of it. The people would retain title to every meter of cable/line right up to private property. Local government would rent a local area power network for a high monthly fixed fee, but would deduct the cost of replacements and improvements from either rent or annual taxes. We guessed that this would encourage private power distribution companies to operate efficiently and spend lots on refurbishment in order to really boost their real and paper profits. The local citizens would retain the right to kick out a bad "power distribution" tenant. So good customer service would be a must. What a concept.


This site is designed for instructional use. No products are actually sold. It is a fictitious site.
This is an example page for Chapter 47: Content Monitoring
The page will send three events triggered by the page loading. The event command should be attached to the <body> command using onLoad.
This site is designed for instructional use. No products are actually sold. It is a fictitious site.


Bradlee Speice, Mon 28 March 2016, Blog
An experiment in creating a robot that will imitate me on Twitter.
So, I'm taking a Machine Learning course this semester in school, and one of the topics we keep coming back to is natural language processing and the 'bag of words' data structure. That is, given a sentence:
How much wood would a woodchuck chuck if a woodchuck could chuck wood?
We can represent that sentence as the following list:
{
How: 1
much: 1
wood: 2
would: 2
a: 2
woodchuck: 2
chuck: 2
if: 1
}
Ignoring where the words happened, we're just interested in how often the words occurred. That got me thinking: I wonder what would happen if I built a robot that just imitated how often I said things? It's dangerous territory when computer scientists ask "what if," but I got curious enough I wanted to follow through.
Given an input list of Tweets, build up the following things:
woodchuck
in the example sentence, there is a 50% chance it is followed by chuck
and a 50% chance it is followed by could
. I need this distribution for all words.I'm using as input my tweet history. I don't really use Twitter anymore, but it seems like a fun use of the dataset. I'd like to eventually build this to a point where I can imitate anyone on Twitter using their last 100 tweets or so, but I'll start with this as example code.
I'll be using the NLTK library for doing a lot of the heavy lifting. First, let's import the data:
import pandas as pd
tweets = pd.read_csv('tweets.csv')
text = tweets.text
# Don't include tweets in reply to or mentioning people
replies = text.str.contains('@')
text_norep = text.loc[~replies]
And now that we've got data, let's start crunching. First, tokenize and build out the distribution of first word:
from nltk.tokenize import TweetTokenizer
tknzr = TweetTokenizer()
tokens = text_norep.map(tknzr.tokenize)
first_words = tokens.map(lambda x: x[0])
first_words_alpha = first_words[first_words.str.isalpha()]
first_word_dist = first_words_alpha.value_counts() / len(first_words_alpha)
Next, we need to build out the conditional distributions. That is, what is the probability of the next word given the current word is $X$? This one is a bit more involved. First, find all unique words, and then find what words proceed them. This can probably be done in a more efficient manner than I'm currently doing here, but we'll ignore that for the moment.
from functools import reduce
# Get all possible words
all_words = reduce(lambda x, y: x+y, tokens, [])
unique_words = set(all_words)
actual_words = set([x if x[0] != '.' else None for x in unique_words])
word_dist = {}
for word in iter(actual_words):
indices = [i for i, j in enumerate(all_words) if j == word]
proceeding = [all_words[i+1] for i in indices]
word_dist[word] = proceeding
Now that we've got the tweet analysis done, it's time for the fun part: hashtags! Let's count how many hashtags are in each tweet, I want to get a sense of the distribution.
import matplotlib.pyplot as plt
%matplotlib inline
hashtags = text_norep.str.count('#')
bins = hashtags.unique().max()
hashtags.plot(kind='hist', bins=bins)
That looks like a Poisson distribution, kind of as I expected. I'm guessing my number of hashtags per tweet is $\sim Poi(1)$, but let's actually find the most likely estimator which in this case is just $\bar{\lambda}$:
mle = hashtags.mean()
mle
Pretty close! So we can now simulate how many hashtags are in a tweet. Let's also find what hashtags are actually used:
hashtags = [x for x in all_words if x[0] == '#']
n_hashtags = len(hashtags)
unique_hashtags = list(set([x for x in unique_words if x[0] == '#']))
hashtag_dist = pd.DataFrame({'hashtags': unique_hashtags,
'prob': [all_words.count(h) / n_hashtags
for h in unique_hashtags]})
len(hashtag_dist)
Turns out I have used 603 different hashtags during my time on Twitter. That means I was using a unique hashtag for about every third tweet.
In better news though, we now have all the data we need to go about actually constructing tweets! The process will happen in a few steps:
And hopefully, we won't have anything too crazy come out the other end. The way we do the selection follows a Multinomial Distribution: given a lot of different values with specific probability, pick one. Let's give a quick example:
x: .33
y: .5
z: .17
That is, I pick x
with probability 33%, y
with probability 50%, and so on. In context of our sentence construction, I've built out the probabilities of specific words already - now I just need to simulate that distribution. Time for the engine to actually be developed!
import numpy as np
def multinom_sim(n, vals, probs):
occurrences = np.random.multinomial(n, probs)
results = occurrences * vals
return ' '.join(results[results != ''])
def sim_n_hashtags(hashtag_freq):
return np.random.poisson(hashtag_freq)
def sim_hashtags(n, hashtag_dist):
return multinom_sim(n, hashtag_dist.hashtags, hashtag_dist.prob)
def sim_first_word(first_word_dist):
probs = np.float64(first_word_dist.values)
return multinom_sim(1, first_word_dist.reset_index()['index'], probs)
def sim_next_word(current, word_dist):
dist = pd.Series(word_dist[current])
probs = np.ones(len(dist)) / len(dist)
return multinom_sim(1, dist, probs)
I've now built out all the code I need to actually simulate a sentence written by me. Let's try doing an example with five words and a single hashtag:
first = sim_first_word(first_word_dist)
second = sim_next_word(first, word_dist)
third = sim_next_word(second, word_dist)
fourth = sim_next_word(third, word_dist)
fifth = sim_next_word(fourth, word_dist)
hashtag = sim_hashtags(1, hashtag_dist)
' '.join((first, second, third, fourth, fifth, hashtag))
Let's go ahead and put everything together! We're going to simulate a first word, simulate the hashtags, and then simulate to fill the gap until we've either taken up all the space or reached a period.
def simulate_tweet():
chars_remaining = 140
first = sim_first_word(first_word_dist)
n_hash = sim_n_hashtags(mle)
hashtags = sim_hashtags(n_hash, hashtag_dist)
chars_remaining -= len(first) + len(hashtags)
tweet = first
current = first
while chars_remaining > len(tweet) + len(hashtags) and current[0] != '.' and current[0] != '!':
current = sim_next_word(current, word_dist)
tweet += ' ' + current
tweet = tweet[:-2] + tweet[-1]
return ' '.join((tweet, hashtags)).strip()
And now for something completely different: twenty random tweets dreamed up by my computer and my Twitter data. Here you go:
for i in range(0, 20):
print(simulate_tweet())
print()
...Which all ended up being a whole lot more nonsensical than I had hoped for. There are some good ones, so I'll call that an accomplishment! I was banking on grammar not being an issue: since my tweets use impeccable grammar, the program modeled off them should have pretty good grammar as well. There are going to be some hilarious edge cases (I'm looking at you, Ethics paper first, music in close to everyone
) that make no sense, and some hilarious edge cases (Waking up, OJ, I feel like Nick Jonas today
) that make me feel like I should have a Twitter rap career. On the whole though, the structure came out alright.
During class we also talked about an interesting idea: trying to analyze corporate documents and corporate speech. I'd be interested to know what this analysis applied to something like a couple of bank press releases could do. By any means, the code needs some work to clean it up before I get that far.
I'm pretty confident I re-invented a couple wheels along the way - what I'm doing feels a lot like what Markov Chain Monte Carlo is intended to do. But I've never worked explicitly with that before, so more research is needed.


McLaren F1 and Node.js
Pete X. Graham
Technical Lead - Pirata
<EMAIL_ADDRESS>mclaren.com/formula1
High traffic/profile
Big build CMS
Realtime system. Telemetry about race cars
Speed
Throttle
G-force
Position on track
Laptimes
Commentary
Evolution of Site
2010 site
http://vimeo.com/11238103
2011 site
http://vimeo.com/30428042
2012 site?
Long Term Project
On going Updates
New functionality
Redesign approx every year
Careful with technology choices
Strive to improve coding/testing/architecture
Current Technologies
LAMP stack
PHP and Zend Framework backend with Doctrine
Custom Daemon
Nginx message module
Architecture Diagram
Why Node.js?
Node.js Is Bad Ass Rock Star Tech
Made for realtime event based systems
Scales well?
Websockets
Node and LAMP
Can they complement each other?
If we use node to what extend do we use it?
Initially could keep Nginx server
Code Needs to...
listen to feed
connect to mysql database. read/write.
publish to client/nginx
save images and push to CDN?
RISK!
If it's not broke...
Simulate multiple users?
How to load test/benchmark current solution?
What next?
Write node backend
Beta.mclaren.com (domain may differ)
Release as open source?
Replay functionality? Not possible with current system.
NASA/TFL style open APIs (Mongo DB)
Thank You
Pete X. Graham
<EMAIL_ADDRESS>https://github.com/pxg


| Package | Description |
|---|---|
| org.powertac.samplebroker | |
| org.powertac.samplebroker.core |
Implementation of the core of a Power TAC broker, including time-keeping,
server login and communication, message routing, and session management.
|
| org.powertac.samplebroker.interfaces |
Interfaces that can be implemented by broker behavioral modules,
connecting them to the core and the server.
|
| Class and Description |
|---|
| Activatable
Interface for services that need to be called when the final
TimeslotComplete message has been received from the server
in each timeslot.
|
| BrokerContext
Provides message handler registration, along with
access to competition context information, including
The message router for outgoing messages
The underlying org.powertac.common.Broker instance
The name of this broker
The base time for the current simulation
The length of common data arrays
|
| Initializable
Implementations of this interface have their initialize() methods called
at the appropriate point in the broker startup sequence.
|
| MarketManager
Encapsulates broker market interactions.
|
| PortfolioManager
Interface for portfolio manager, makes usage statistics available.
|
| Class and Description |
|---|
| BrokerContext
Provides message handler registration, along with
access to competition context information, including
The message router for outgoing messages
The underlying org.powertac.common.Broker instance
The name of this broker
The base time for the current simulation
The length of common data arrays
|
| Class and Description |
|---|
| BrokerContext
Provides message handler registration, along with
access to competition context information, including
The message router for outgoing messages
The underlying org.powertac.common.Broker instance
The name of this broker
The base time for the current simulation
The length of common data arrays
|
Copyright © 2019 Power TAC. All rights reserved.


Smarty offers you a large variety of elements and predefined modern layouts.
Flexible pricing
Infinite possibilities
Monthly free updates


Press ctrl-space, or type a '<' character to activate autocompletion. This demo defines a simple schema that guides completion. The schema can be customized—see the manual.
Development of the xml-hint
addon was kindly
sponsored
by www.xperiment.mobi.


This software is released under the MIT License, and provided without any warranty. Data source: Edmonton Open Data Website.


SystemPropertiesPicoContainer is a special type of PicoContainer that is populated from the System Properties passed into the Java application when it started.
Here is an example of how to use SystemPropertiesPicoContainer to map system properties as configuration for a component, with parameter names as the bindings.
Consider this component:
public class BigFatComponent { URL spellWebService; int timeout; public BigFatComponent(String spellingWebServiceURL, int timeout) throws MalformedURLExeption { this.spellWebService = new URL(spellingWebServiceURL); this.timeout = timeout; } public String toString() { return "URL=" + spellWebService + ", timeout=" + timeout; } // other methods }
For automatic binding of system properties to parameter names of the component:
PicoContainer syspropsContainer = new SystemPropertiesPicoContainer(); MutablePicoContainer mpc = new DefaultPicoContainer(syspropsContainer); mpc.as(Characteristics.USE_NAMES).addComponent(BigFatComponent.class);
Here is another manual use forcing an association between a system properties, and the relative position of a parameter in the constructor. It is most useful when there is not a tie-up between the parameter names and the system properties. In this case the arg passed in to the ConfigParameter (varargs list) is the one that matches the syst property name:
mpc.addComponent(BigFatComponent.class, ConfigParameter("wsURL"), ConfigParameter("serviceTimeout"));
System properties can be set for the scope of the application only, as you start the application:
java -Dwebservice.url=http://servicehost/service -Dwebservice.timeout=50 -jar myAppJar.jar -cp picocontainer-2.0.jar
Type conversion is automatic in many cases. Properties in a properties file are clearly strings. Parameters can be any of:
SystemPropertiesPicoContainer can be part of a tree of containers. It makes sense, of course, being more near the root of that tree.


At the end of 2014 a first draft of a Heroku buildpack for crystal was createad. This was truly great. Being able to run crystal apps in the Heroku stack was charm idea.
While we continued to develop the language, the tools, and the standard library, the community around Crystal grew. Many were interested in trying their Crystal-powered web apps in Heroku.
However, due to some flaws in the approach, the buildpack failed to stay up to date with the latest versions of Crystal; but that is now solved! Yay!
While efforts to develop web frameworks continue nowadays, we wanted to share the very basic steps to use the Crystal buildpack to deploy a web application in Heroku without the need for any additional dependencies.
Create a Crystal project
This assumes you already have crystal installed.
Use crystal init app
to create the app.
$ crystal init app heroku101 create heroku101/.gitignore create heroku101/LICENSE create heroku101/README.md create heroku101/.travis.yml create heroku101/shard.yml create heroku101/src/heroku101.cr create heroku101/src/heroku101/version.cr create heroku101/spec/spec_helper.cr create heroku101/spec/heroku101_spec.cr Initialized empty Git repository in /Users/bcardiff/Work/Manas/crystal/heroku101/.git/ $ cd heroku101/
Note: During the rest of the post all the commands are executed from the heroku101/
directory.
The shard.yml
file declares the name of the project as heroku101
. This will be used by the buildpack to determine the main source file to compile: ./src/heroku101.cr
.
$ cat shard.yml name: heroku101 version: 0.1.0 ...
To create a simple http server edit the src/heroku101.cr
file and add the following content:
To build and run the program:
$ crystal src/heroku101.cr Listening on http://<IP_ADDRESS>:8080
Open your browser at http://<IP_ADDRESS>:8080.
To stop the server just terminate the process by pressing Ctrl+C
.
Herokufy it
Right now the project knows nothing about Heroku. To get started, a Heroku application needs first to be registered. The easiest way to do this is via the Heroku toolbelt:
$ heroku create --buildpack https://github.com/crystal-lang/heroku-buildpack-crystal.git Creating app... done, ⬢ sleepy-thicket-16179 Setting buildpack to https://github.com/crystal-lang/heroku-buildpack-crystal.git... done https://sleepy-thicket-16179.herokuapp.com/ | https://git.heroku.com/sleepy-thicket-16179.git
The above command will generate a random app name. Check the docs to give your app a name from the beginning.
Before deploying, we need to make a small change. Heroku randomly assigns a port number to be used by the app. Thanks to the buildpack, this will be informed in a --port
option when running the application.
So, add a require "option_parser"
at the beginning of src/heroku101.cr
and override the port
variable default with:
The full src/heroku101.cr
should be:
To build and run with --port
option:
$ crystal src/heroku101.cr -- --port 9090 Listening on http://<IP_ADDRESS>:9090
Or build an optimised release locally and execute it via:
$ crystal build src/heroku101.cr --release $ ./heroku101 Listening on http://<IP_ADDRESS>:8080 ^C $ ./heroku101 --port 9090 Listening on http://<IP_ADDRESS>:9090 ^C
Deploy!
When you are ready to go live with your app just deploy it the usual way with git push heroku master
.
$ git push heroku master Counting objects: 22, done. Delta compression using up to 8 threads. Compressing objects: 100% (17/17), done. Writing objects: 100% (22/22), 2.85 KiB | 0 bytes/s, done. Total 22 (delta 3), reused 0 (delta 0) remote: Compressing source files... done. remote: Building source: remote: remote: -----> Fetching set buildpack https://github.com/crystal-lang/heroku-buildpack-crystal.git... done remote: -----> Crystal app detected remote: -----> Installing Crystal (0.17.3 due to latest release at https://github.com/crystal-lang/crystal) remote: -----> Installing Dependencies remote: -----> Compiling src/heroku101.cr (auto-detected from shard.yml) remote: remote: -----> Discovering process types remote: Procfile declares types -> (none) remote: Default types for buildpack -> web remote: remote: -----> Compressing... remote: Done: 289.4K remote: -----> Launching... remote: Released v3 remote: https://sleepy-thicket-16179.herokuapp.com/ deployed to Heroku remote: remote: Verifying deploy.... done. To https://git.heroku.com/sleepy-thicket-16179.git * [new branch] master -> master
The buildpack will:
- Install the latest crystal release.
- Install project dependencies via shards.
- Compile the main source file in release mode.
- Run the web server process with
--port
option.
Specify the crystal version
If you want to use a different Crystal version, create a .crystal-version
file with the desired version, following crenv’s convention.
$ echo '0.17.1' > .crystal-version
Commit the changes in .crystal-version
and deploy.
$ git push heroku master Counting objects: 3, done. Delta compression using up to 8 threads. Compressing objects: 100% (2/2), done. Writing objects: 100% (3/3), 301 bytes | 0 bytes/s, done. Total 3 (delta 1), reused 0 (delta 0) remote: Compressing source files... done. remote: Building source: remote: remote: -----> Fetching set buildpack https://github.com/crystal-lang/heroku-buildpack-crystal.git... done remote: -----> Crystal app detected remote: -----> Installing Crystal (0.17.1 due to .crystal-version file) remote: -----> Installing Dependencies remote: -----> Compiling src/heroku101.cr (auto-detected from shard.yml) ...
You will now notice the (0.17.1 due to .crystal-version file)
legend.
Whenever you are ready to upgrade to the latest crystal version, update the content of the file or just remove it and deploy again.
Show me the code!
Find all the sample source code used at https://github.com/bcardiff/sample-crystal-heroku101.
To contribute to crystal buildpack, just fork it. Contributions are welcome!


Hi, The mistakes was easy to solve since I have simply forgotten to retrieve the return value of a me_failed call. Bye. -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://www.gecode.org/pipermail/users/attachments/20180417/6cac6322/attachment.html>


---
title: "Lecture Notes"
layout: archive
excerpt: "Slides and other material used in the lectures"
sitemap: true
permalink: /slides/
frontpageorder: 1
categories: [frontpage]
---
Lecture 1: Introduction, Aug 13, 2019
Lecture 2: What are (video) games? Aug 16, 2019
Lecture 3: Game Design, Aug 20, 2019
Lecture 4: Game Design Document, Aug 23, 2019
Lecture 5: Unity, Sep 3, 2019
Lecture 6: Game Engine Basics, Sep 6, 2019
Lecture 7: Players, Sep 10, 2019
Lecture 8: World Building, Sep 13, 2019
Lecture 9: Vectors, Sep 17, 2019
Lecture 10: 3D Graphics, Sep 20, 2019
Lecture 11: 2D Graphics, Sep 24, 2019
Lecture 12: Homogeneous Coordinates, Matrices, Quaternions, Oct 1, 2019
Lecture 13: Review, Oct 4, 2019
Vector math sample problems
Vector math sample problem solutions
Lecture 14: AI, Oct 15, 2019
Lecture 15: Pathfinding, Oct 29, 2019
Lecture 16: Advanced AI, Nov 1, 2019
Lecture 17: Physics Simulation, Nov 5, 2019
Lecture 18: Collision Detection, Nov 12, 2019
Lecture 19: Physics, Nov 15, 2019
Lecture 20: Networked Games, Nov 19, 2019
Lecture 21: Review, Nov 22, 2019
Lecture 22: Games, Nov 26, 2019


A novel solution to an old problem
Application overview
View team members and add collaborators
See competition brief
Details
Application details
Project summary
Public description
Scope
Application questions
1. Business opportunity
2. Potential market
3. Project exploitation
4. Economic benefit
5. Technical approach
6. Innovation
7. Risks
8. Project time
9. Funding
10. Adding value
Finances
Empire Ltd finances
Finances overview
Print your application
Review and submit


{{ .Params.lead | safeHTML }}
Join communitySuccessful data science projects are delivered by data scientists who can experiment quickly and deliver production systems independently. Metaflow supports the full lifecycle of projects from prototype to production.
Doing this successfully requires a whole stack of infrastructure: data, compute, orchestration, versioning, and more 😮 Metaflow helps you set up all of it, so data scientists can focus more on data science, less on engineering 🥳
Metaflow was started at Netflix where it powers tens of business-critical data science systems. Outerbounds was founded to continue the development of Metaflow outside Netflix, in collaboration with various companies from biotech to real estate.
We welcome you to look around, start using Metaflow, ask questions, and contribute. We are excited to have you!
{{ .Params.lead | safeHTML }}
{{ partial "main/blog-meta.html" . -}}


Log into InfoWeb (this might take a while...)
Open your timetable (click me!) and copy everything
Paste your timetable below and let the magic happen


Slurm Workload Manager is a popular HPC cluster job scheduler found in many of the top 500 super computers. The sluRm
R package provides an R wrapper to it that matches the parallel package’s syntax, this is, just like parallel
provides the parLapply
, parMap
, parSapply
, etc., sluRm
provides Slurm_lapply
, Slurm_Map
, , etc.Slurm_sapply
While there are other alternatives such as future.batchtools
and rslurm
, this R package has the following advantages over the other two:
It is dependency free, which means that it works out-of-the-box
Puts an emphasis on been similar to the workflow in the R package parallel
It provides a general framework for the user to create its own wrappers without using template files.
And the development version from GitHub with:
library(sluRm)
#> On load, `sluRm` sets default options for your jobs (`chdir`, which is the default directory where sluRm will use to create the auxiliar files, and `job-name`, which is the option of the same name in Slurm. You can view/set these at:
#> ?opts_sluRm
#> or you could just type
#> "opts_sluRm".
# Suppose that we have 100 vectors of length 50 ~ Unif(0,1)
set.seed(881)
x <- replicate(100, runif(50))
We can use the function Slurm_lapply
to distribute computations
ans <- Slurm_lapply(x, mean, submit = FALSE)
#> Warning: `X` is not a list. The function will coerce it into one using `as.list`
#> Warning: [submit = FALSE] The job hasn't been submitted yet. Use sbatch() to submit the job, or you can submit it via command line using the following:
#> sbatch --chdir=/home/vegayon/Documents/sluRm --job-name=sluRm-job-1503bd158c8 /home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/01-bash.sh
Notice the submit = FALSE
option. To get more info, we can actually set the verbose mode on
opts_sluRm$verbose_on()
ans <- Slurm_lapply(x, mean, submit = FALSE)
#> Warning: `X` is not a list. The function will coerce it into one using `as.list`
#> Warning: The path '/home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8' already
#> exists and will be overwritten.
#>
#> --------------------------------------------------------------------------------
#> [VERBOSE MODE ON] The R script that will be used is located at:
#> /home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/00-rscript.r
#> and has the following contents:
#> --------------------------------------------------------------------------------
#> Slurm_env <- function (x)
#> {
#> y <- Sys.getenv(x)
#> if ((x == "SLURM_ARRAY_TASK_ID") && y == "") {
#> return(1)
#> }
#> y
#> }
#> ARRAY_ID <- as.integer(Slurm_env("SLURM_ARRAY_TASK_ID"))
#> INDICES <- readRDS("/home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/INDICES.rds")
#> X <- readRDS("/home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/X.rds")[INDICES[[ARRAY_ID]]]
#> FUN <- readRDS("/home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/FUN.rds")
#> mc.cores <- readRDS("/home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/mc.cores.rds")
#> seeds <- readRDS("/home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/seeds.rds")
#> set.seed(seeds[ARRAY_ID], kind = NULL, normal.kind = NULL)
#> ans <- parallel::mclapply(
#> X = X,
#> FUN = FUN,
#> mc.cores = mc.cores
#> )
#> saveRDS(ans, sprintf("/home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/03-answer-%03i.rds", ARRAY_ID), compress = TRUE)
#>
#> --------------------------------------------------------------------------------
#> The bash file that will be used is located at:
#> /home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/01-bash.sh
#> and has the following contents:
#> --------------------------------------------------------------------------------
#> #!/bin/sh
#> #SBATCH --job-name=sluRm-job-1503bd158c8
#> #SBATCH --output=/home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/02-output-%A-%a.out
#> #SBATCH --array=1-2
#> #SBATCH --ntasks=1
#> #SBATCH --cpus-per-task=2
#> export OMP_NUM_THREADS=1
#> /usr/lib/R/bin/Rscript --vanilla /home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/00-rscript.r
#>
#> --------------------------------------------------------------------------------
#> EOF
#> --------------------------------------------------------------------------------
#> Warning: [submit = FALSE] The job hasn't been submitted yet. Use sbatch() to submit the job, or you can submit it via command line using the following:
#> sbatch --chdir=/home/vegayon/Documents/sluRm --job-name=sluRm-job-1503bd158c8 /home/vegayon/Documents/sluRm/sluRm-job-1503bd158c8/01-bash.sh
Take a look at the vignette here.
Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.


There are plenty of ways to help us out, from being an event ambassador to simply holding a coffee morning. Simply fill in the form below and we will be in touch.
There are many, many ways to help out. Have a look at our list of suggestions
If any of these look good then feel free to download our sponsor form and get going!


Strength {{passwordStrength}}% (minimum: 50%)
Annoyed by sheer nonsense like "One number, one letter, one special character"? So are we. We calculate password strength based on actual mathematical logic.
"I will always love blua.blue" (50%) and "blUa@8" (52%) will both fulfill the minimum requirement.


RiversideRocks is no longer partnered with us after a staff member
was threatened on the forum of a project of his - Scripting
to Save
Lives.
We won't IP ban them yet, but we will be monitoring any
suspicious activity from RiversideRocks
or Scripting to Save Lives
members.


Main ASSIGN functions for prediction.
assign.convergence
Check the convergence of the MCMC chain
assign.cv.output
Cross validation output
assign.mcmc
The Gibbs sampling algorithm to approximate the joint distribution of the model parameters
assign.output
Prediction/validation output for test data
assign.preprocess
Input data preprocessing
assign.summary
Summary of the model parameters estimated by the Gibbs sampling algorithm
assign.wrapper
ASSIGN All-in-one function
ComBat.step2
Perform the second step of ComBat
optimizeGFRN
Optimize GFRN gene lists lengths
runassignGFRN
Run optimized single pathway ASSIGN
excludegenes
Exclude Gene List
geneList1
Pathway signature gene sets
gfrn_geneList
Pathway Signature Gene Lists
testData1
Gene expression profiling from cancer patients (test dataset)
trainingData1
Gene expression profiling from cell line perturbation experiments (training dataset)
gather_assign_results
Gather the ASSIGN results in a specific directory
merge_drop
Combine two data frames
pcaplot
Display a PCA Plot of the Data


RT @avdi: After a lot of thought and consulting with friends, I've decided to say some things about John Sonmez, Charles Max Wood, gatekeep…
10/28/2019, 11:41:56 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @avdi: After a lot of thought and consulting with friends, I've decided to say some things about John Sonmez, Charles Max Wood, gatekeep…
10/28/2019, 11:41:56 AM
Favs: 0
Retweets: 0
link


T
- specifies the device dependent indicator pattern type.public abstract class TrcPriorityIndicator<T>
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
protected TrcDbgTrace |
dbgTrace |
protected static boolean |
debugEnabled |
| Constructor and Description |
|---|
TrcPriorityIndicator(java.lang.String instanceName)
Constructor: Create an instance of the object.
|
| Modifier and Type | Method and Description |
|---|---|
abstract T |
getPattern()
This method gets the current set pattern.
|
int |
getPatternPriority(T pattern)
This method searches the given pattern priorities array for the given pattern.
|
boolean |
getPatternState(T pattern)
This method returns the pattern state if it is in the priority list.
|
void |
resetAllPatternStates()
This method resets all pattern states in the pattern priority list and set the indicator device to non-active
state.
|
abstract void |
setPattern(T pattern)
This method sets the pattern to the physical indicator device in a device dependent way.
|
void |
setPatternPriorities(T[] priorities)
This method sets the pattern priority list for operations that need it.
|
void |
setPatternState(T pattern,
boolean enabled)
This method enables/disables the pattern in the priority list.
|
java.lang.String |
toString()
This method returns the instance name.
|
protected static final boolean debugEnabled
protected TrcDbgTrace dbgTrace
public TrcPriorityIndicator(java.lang.String instanceName)
instanceName
- specifies the instance name.public abstract T getPattern()
public abstract void setPattern(T pattern)
pattern
- specifies the indicator pattern. If null, turn off the indicator pattern.public java.lang.String toString()
toString
in class java.lang.Object
public void setPatternState(T pattern, boolean enabled)
pattern
- specifies the pattern in the priority list.enabled
- specifies true to turn the pattern ON, false to turn it OFF.public boolean getPatternState(T pattern)
pattern
- specifies the pattern in the priority list.public void resetAllPatternStates()
public int getPatternPriority(T pattern)
pattern
- specifies the indicator pattern to be searched in the pattern priorities array.public void setPatternPriorities(T[] priorities)
priorities
- specifies the pattern priority list or null to disregard the previously set list.


{{ $featured_image := index (.Params.images) 0 }}
{{/* Trimming the slash and adding relURL make sure the image works no matter where our site lives */}}
{{ $featured_image := (trim $featured_image "/") | relURL }}
{{- .Title | default .Site.Title -}}
{{ with .Params.description }}
{{ . }}
{{ end }}
read more