| Package | Description |
|---|---|
| org.apache.olingo.odata2.api |
OData Library API
|
| org.apache.olingo.odata2.api.ep |
Entity Provider
|
| org.apache.olingo.odata2.api.ep.callback |
Entity Provider Callbacks
|
| org.apache.olingo.odata2.api.ep.entry |
Entity Provider Entries
|
| org.apache.olingo.odata2.api.processor |
Data Processor
|
| org.apache.olingo.odata2.api.rt |
Runtime Support
|
| org.apache.olingo.odata2.api.uri |
URI Parser Facade
|
| org.apache.olingo.odata2.api.uri.info |
URI Parser Result Views
|
| org.apache.olingo.odata2.jpa.processor.api.jpql |
OData JPA Processor API Library - Java Persistence Query Language
|
| Class and Description |
|---|
| UriInfo
Structured parts of the request URI - the result of URI parsing.
|
| Class and Description |
|---|
| ExpandSelectTreeNode
Expression tree node with information about selected properties and to be expanded links.
|
| PathInfo
Object to keep OData URI information.
|
| Class and Description |
|---|
| ExpandSelectTreeNode
Expression tree node with information about selected properties and to be expanded links.
|
| Class and Description |
|---|
| ExpandSelectTreeNode
Expression tree node with information about selected properties and to be expanded links.
|
| Class and Description |
|---|
| PathInfo
Object to keep OData URI information.
|
| Class and Description |
|---|
| ExpandSelectTreeNode.ExpandSelectTreeNodeBuilder
Builder interface
|
| UriParser
Wrapper for UriParser functionality.
|
| Class and Description |
|---|
| ExpandSelectTreeNode
Expression tree node with information about selected properties and to be expanded links.
|
| ExpandSelectTreeNode.ExpandSelectTreeNodeBuilder
Builder interface
|
| KeyPredicate
Key predicate, consisting of a simple-type property and its value as String literal
|
| NavigationPropertySegment
Navigation property segment, consisting of a navigation property and its
target entity set.
|
| NavigationSegment
Navigation segment, consisting of a navigation property, its target entity set,
and, optionally, a list of key predicates to determine a single entity out of
the target entity set.
|
| PathSegment
URI path segment consisting of an URI path element and URI matrix parameters.
|
| SelectItem
An item of a $select system query option.
|
| UriInfo
Structured parts of the request URI - the result of URI parsing.
|
| UriNotMatchingException
URI-parsing exception resulting in a 404 Not Found response.
|
| UriSyntaxException
Exception for violation of the OData URI construction rules,
resulting in a 400 Bad Request response.
|
| Class and Description |
|---|
| KeyPredicate
Key predicate, consisting of a simple-type property and its value as String literal
|
| NavigationPropertySegment
Navigation property segment, consisting of a navigation property and its
target entity set.
|
| NavigationSegment
Navigation segment, consisting of a navigation property, its target entity set,
and, optionally, a list of key predicates to determine a single entity out of
the target entity set.
|
| SelectItem
An item of a $select system query option.
|
| Class and Description |
|---|
| KeyPredicate
Key predicate, consisting of a simple-type property and its value as String literal
|
Copyright © 2013-2017 The Apache Software Foundation. All Rights Reserved.


+ XCTAssertEqual(str!, "{\"\(param.0)\":\(NSString(string:param.0).intValue)}", "expect that serialized value should not contain trailing zero or decimal as they are whole numbers ")
+ }
+ }
+
+ funcexcecute_testWholeNumbersWithIntInput() {
+ for i in-10..<10 {
+ let iStr ="\(i)"
+ let testDict = [iStr : i]
+ let str =try?trySerialize(testDict)
+ XCTAssertEqual(str!, "{\"\(iStr)\":\(i)}", "expect that serialized value should not contain trailing zero or decimal as they are whole numbers ")
+ }
+ }
+ excecute_testSetLessThanOne()
+ excecute_testSetGraterThanOne()
+ excecute_testWholeNumbersWithDoubleAsInput()
+ excecute_testWholeNumbersWithIntInput()
+ }
+
functest_serialize_null() {
functest_serialize_null() {
let arr = [NSNull()]
let arr = [NSNull()]
XCTAssertEqual(trytrySerialize(arr), "[null]")
XCTAssertEqual(trytrySerialize(arr), "[null]")
You can't perform that action at this time.
You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.


Number of channals:
Sample Rate:
Max / Min Frequency:
FFT size:
Frequency Bit Count:
Frequency Resolution:
Max / Min Decibels:
Threshold:
Render FPS:


meet new people.
play the game.
it's easy&fun.
We work to make more people get acquainted and communicate better. Our task - to make communication interesting and dynamic.
Millions of people from all over the world are meeting each other and building out their relationships on Flirchi right now!
Everyone gets at least one message per session
Active user makes 100 contacts per day
Every second contact leads to a new dialogue


ST-20 Standard
Deck
Team
Blog
Developers
Careers
Blog
Developers
Careers
Toggle navigation
The Polymath Team
Join our team
Trevor Koverko
Co-Founder & Chief Executive Officer
Chris Housser
Co-Founder & Chief Operations Officer
Pablo Ruiz
VP of Engineering
Thomas Borrel
Chief Product Officer
Graeme Moore
VP of Marketing
Igor Denisov
M&A and Strategic Partnerships
Kalman Gabriel
Strategic Partnerships
Adam Dossa
Head of Technology
Boris Shevchenko
Lead dApps Architect
Satyam Agrawal
Solidity Developer
Shannon Clarke
Developer
Thom Malone
Lead Designer
Ryan Keller
Sr. Project Manager
Lauren Hulvey
Executive Assistant Operations
Matthew Woo
Product Advisor
Heslin Kim
APAC Head of Business Development
Stan Timofeev
Designer
Trevor Longino
Chief Marketing Officer
Ka Yi (Emily) Sit
Business Development for APAC
Audrey Kirkwood
Executive Assistant
Andy Mak
Corporate Accountant
Stephane Gosselin
Solidity Developer
Charles St. Louis
Open Source Community Manager
Gopi Kotaru
Product Manager / Scrum Master
Josep Mateu Clemente
Quality Assurance Engineer
Victor Gabriel Vicente
Solidity Developer
Ananthan Vijayakumar
Senior Accountant
Troy Wong
Chief Finance Officer
Lukasz Wicher
Business Development Associate
Trillions of Dollars On The Blockchain Are Coming
Create Your Security Token


Training F1 Score:
Training F1 Score:
In the tradition of Tkinter SVM GUI, the purpose of this website is to demonstrate how machine learning model forms are affected by the shape of the underlying dataset. By selecting a dataset or by creating one of your own, you can fit a model to the data and see how the model would make decisions based on the data it has been trained on. The fitted contours display the highest likelihoods of the class the model would select.
Although this is a toy example, hopefully it helps give you the intuition that the machine learning process is a model selection search for the best combination of features, algorithm, and hyperparameter that generalize well in a bounded feature space.
This application is for demonstration purposes only.
Naive Bayesian models are a collection of supervised classification algorithms that apply Bayes rule of conditional probability with the "naive" assumption of conditional independence between all pairs of features given the value. Bayesian predictions are based on the conditional likelihood of the joint probability of all features and the target class. Becasue features are treated like likelihoods, the primary difference of each classifier is the assumptions they make about the distrubition of the features.
array-like shape (n_classes,)
float
float
bool
float or None
bool
Support vector machines are supervised, discriminitive classifiers that learn an optimal hyperplane that can separate and categorize data. This hyperplane (e.g. an defined space one dimension less than the ambient space) maximizes the distance between groups of classes by selecting support vectors from each group (potentially with some slack) then finding the parallel hyperplane between those vectors that is halfway between the orthogonal. To optimize support vector discovery, the kernel functions are used to find mappings that increase the space between points, increasing separability between classes.
float
{'linear', 'poly', 'rbf', 'sigmoid', 'precomputed', None}
(n_samples, n_samples)
.
int
float
float
boolean
float
{dict, 'balanced'}
n_samples / (n_classes * np.bincount(y))
int
{‘ovo’, ‘ovr’}
(n_samples, n_classes)
as all other classifiers, or the original one-vs-one (‘ovo’) decision function of libsvm which has shape
(n_samples, n_classes * (n_classes - 1) / 2)
. However, one-vs-one (‘ovo’) is always used
as multi-class strategy.
Logistic Regression is a supervised classification algorithm that models the probabilities describing the possible outcome (class) of a single trial using a logistic function. This method is also known as a logit regression, maximum-entropy classifier, or log-linear classifier.
{'l1', 'l2', 'elasticnet', 'none'}
bool
dual=False
when n_samples > n_features
.
float
float
bool
float
[x, self.intercept_scaling]
, i.e. a “synthetic” feature with constant value
equal to intercept_scaling is appended to the instance vector.
{dict, 'balanced'}
n_samples / (n_classes * np.bincount(y)).
{'newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'}
int
{'ovr', 'multinomial', 'auto'}
float
0 <= l1_ratio <=1
. Only used if penalty='elasticnet'
.
Setting l1_ratio=0
is equivalent to using penalty='l2'
, while setting l1_ratio=1
is equivalent to using penalty='l1'
. For 0 < l1_ratio < 1
, the penalty is a combination of L1 and L2.


jQuery Masonry
Docs
Introduction
Options
Methods
Animating
Help
Demos
Basic single-column
Basic multi-column
Images
Tumblelog example
Animating with jQuery
Animating with CSS Transitions
Animating with Modernizr
Adding items
Infinite Scroll
Gutters
Right-to-left
Centered
Fluid
Corner stamp
Tests
Lots of bricks
Dual instances
First child no width
Empty
Destroy
Centered few


Home
About
Location
Disclaimer
Sign Out
Facts
SCHOOLS
Instructions
Personality Test
Aptitude Test
Results
Home
Explore
Achievements
HOW TO
Sign in to FACTS
Login with Facebook
Login with Google
Login with Twitter


Hi, I'm John! I'm a recent 2020 graduate earning my B.E in Computer Engineering. Feel free to explore my projects! My resume can be found under the links section. NOTE: Site 90% complete.
Car Shopping
It's been a real pain..., but I finally bought my first car! :D


Javascript: Hangman
WINS:
0
LOSSES:
0
Moves Remaining:
Select Difficulty:
Easy
Normal
Hard
Keyboard Loading...


Adding changes to cause conflict
Practice makes perfect!
In a little repo in github.
stash example 1
now tagging


Purpose of Job
The Manager of Data Processing is responsible for leading a team of Data Processors in delivering exceptional quality and timely materials to Ipsos Researchers, enabling this group of people to meet their project objectives and to build and sustain lasting client relationships.
Essential Job Functions
- Manage a team of Senior Data Analysts, Data Analysts and/or Data Associates.
- Ensure the work of the entire staff is delivered with the highest level of quality at all times.
- Together with Senior Management, set clear standards, procedures and policies. Communicate these to your team members and ensure these criteria are followed.
- Ensure that direct reports recognize the costs associated with their work and to keep them in-line with the Business Unit’s goals.
- Manage relationships with outside vendors, including scheduling, budgeting project costs, communicating processes and managing client expectations.
- Assist direct reports in answering client questions and offer alternative solutions to specific project execution.
- Provide solutions and support to direct reports when conflicts in scheduling, costing or other project-related issues arise.
- Build a reputation with internal and external clients for excellent service and repeat business.
- Responsible for training new staff at all levels within Data Processing.
Required Skills and Abilities
- 5 – 7 years data processing experience.
- Proven ability to be quick and accurate when assessing situations and in determining next crucial steps and to take appropriate action.
- Active listener with demonstrated negotiation and problem solving skills.
- Demonstrate diplomacy and tact when handling difficult situations.
- Superior verbal and written communication skills.
- A self-starter; ready to champion initiatives beyond the scope of the job.
- Strong attention to detail, accuracy and superior organizational ability.
- Proficient with data processing platforms such as Quantum, Dimensions, UNIX.
- Programming experience in SQL or Python/Pandas.
- Bachelor’s degree or equivalent related experience.


---
layout: post
title: Installing a Serena Dimensions standalone system
tags:
- Application Lifecycle Management
- Serena Dimensions
- Software Configuration Management
status: publish
type: post
published: true
meta:
_edit_last: '451289'
---
Many Dimensions consultants, trainers and administrators have their own personal recipe on setting up a standalone Dimensions CM environment. Here is my latest:
- Base OS: Windows XP Pro SP2 or SP3
- Ensure you have MS .NET framework 1.1 (or above?) installed
- Create Windows user accounts. e.g. for Payroll dmsys, user2, user3,..., user6
- make sure that all Dimensions users have a password
- Install
- Adobe Acrobat Reader
- Install an decent editor, e.g. Vim, to edit configuration files (some are in UNIX text format and confuse notepad)
- MS Loopback Network Adapter (described in the Serena Installation Manual Appendix A)
- Java 2 SDK
- Eclipse Java IDE (if using the IDE integration) and add to start menu
- James Mail Transport Agent and create email accounts into James as described
- Cygwin (required to support directory items and can be used for software building). I place the Cygwin bin directory on the Windows path rather copy the software to the Dimensions prog directory as suggested in the Serena documentation
- 7-Zip (from my experience the compressed folders utility supplied with Windows has trouble with the Zip archives associated with some of this software)
- Create user accounts in MS Outlook Express (exact method will depend on how you plan to use this set-up)
- Configure IE 6 not to re-use windows to open shortcuts
- Disable IE pop up blocker
- Install Oracle as described in the Serena documentation
- Specify the loop back server name when configuring Oracle Networking
- Install Dimensions server and Clients as described in the Serena documentation
- specify the loop back host name as the mail server
- Install and configure the license server if not using EVAL licences. Use the loop back host name
- NB After installing Dimensions 10.1.1 the EVAL license (if used) may fail. Stop Dimensions Server and Dimensions Tomcat, install Dimensions 10.1.3 upgrade. Evaluation license should now work.
Optional Steps:
- Create a dummy base database and use that as the connection paramerter in DM_ROOT/dfs/listner.dat
- Increase the server time outs so that users are not logged off too quickly
- Install Dimensions 10.1.3 documentation
- Install Dimensions Make (used by command line upload and download utilities)
- Install Oracle SQL Developer to browse published views and generate reports
- If running a training course then
- copy any training files and materials
- Set up users default worksets and directories (see SCWS command)
- MS Word, Excel and Powerpoint (or use OpenOffice) to demonstrate using ordinary office tools with Dimensions
Assumptions:
- Dimensions 10.1.3
- Oracle (supplied by Serena)
- Primary network adaptor uses DHCP (if IP is static then skip step 4.3)
TODO:
- Control Centre setup, not in Dimensions 10.1.3
- Test OpenOffice use
- Find a better alternative to Oracle SQL Developer
Notes
- Dimensions 10.1.3 can only be installed as upgrade to Dim 10.1.x
- I do all work from a single account on Windows (not dmsys). I provide the appropriate Windows credentials as required to each Dimensions client. If required I can use the runas command e.g.
runas /profile /user:dmsys cmd.exe
- I also set up all email accounts under a single profile in Outlook Express with filters to place messages for the appropriate account in correctly names email sub folders


This is an annotated PyTorch implementation of the paper A Neural Representation of Sketch Drawings.
Sketch RNN is a sequence-to-sequence variational auto-encoder. Both encoder and decoder are recurrent neural network models. It learns to reconstruct stroke based simple drawings, by predicting a series of strokes. Decoder predicts each stroke as a mixture of Gaussian’s.
Download data from Quick, Draw! Dataset.
There is a link to download npz
files in Sketch-RNN QuickDraw Dataset section of the readme.
Place the downloaded npz
file(s) in data/sketch
folder.
This code is configured to use bicycle
dataset.
You can change this in configurations.
Took help from PyTorch Sketch RNN project by Alexis David Jacq
32import math
33from typing import Optional, Tuple, Any
34
35import numpy as np
36import torch
37import torch.nn as nn
38from matplotlib import pyplot as plt
39from torch import optim
40from torch.utils.data import Dataset, DataLoader
41
42import einops
43from labml import lab, experiment, tracker, monit
44from labml_helpers.device import DeviceConfigs
45from labml_helpers.module import Module
46from labml_helpers.optimizer import OptimizerConfigs
47from labml_helpers.train_valid import TrainValidConfigs, hook_model_outputs, BatchIndex
50class StrokesDataset(Dataset):
dataset
is a list of numpy arrays of shape [seq_len, 3].
It is a sequence of strokes, and each stroke is represented by
3 integers.
First two are the displacements along x and y ($\Delta x$, $\Delta y$)
And the last integer represents the state of the pen - $1$ if it’s touching
the paper and $0$ otherwise.
57 def __init__(self, dataset: np.array, max_seq_length: int, scale: Optional[float] = None):
67 data = []
We iterate through each of the sequences and filter
69 for seq in dataset:
Filter if the length of the the sequence of strokes is within our range
71 if 10 < len(seq) <= max_seq_length:
Clamp $\Delta x$, $\Delta y$ to $[-1000, 1000]$
73 seq = np.minimum(seq, 1000)
74 seq = np.maximum(seq, -1000)
Convert to a floating point array and add to data
76 seq = np.array(seq, dtype=np.float32)
77 data.append(seq)
We then calculate the scaling factor which is the standard deviation of ($\Delta x$, $\Delta y$) combined. Paper notes that the mean is not adjusted for simplicity, since the mean is anyway close to $0$.
83 if scale is None:
84 scale = np.std(np.concatenate([np.ravel(s[:, 0:2]) for s in data]))
85 self.scale = scale
Get the longest sequence length among all sequences
88 longest_seq_len = max([len(seq) for seq in data])
We initialize PyTorch data array with two extra steps for start-of-sequence (sos) and end-of-sequence (eos). Each step is a vector $(\Delta x, \Delta y, p_1, p_2, p_3)$. Only one of $p_1, p_2, p_3$ is $1$ and the others are $0$. They represent pen down, pen up and end-of-sequence in that order. $p_1$ is $1$ if the pen touches the paper in the next step. $p_2$ is $1$ if the pen doesn’t touch the paper in the next step. $p_3$ is $1$ if it is the end of the drawing.
98 self.data = torch.zeros(len(data), longest_seq_len + 2, 5, dtype=torch.float)
The mask array is needs only one extra-step since it is for the outputs of the
decoder, which takes in data[:-1]
and predicts next step.
101 self.mask = torch.zeros(len(data), longest_seq_len + 1)
102
103 for i, seq in enumerate(data):
104 seq = torch.from_numpy(seq)
105 len_seq = len(seq)
Scale and set $\Delta x, \Delta y$
107 self.data[i, 1:len_seq + 1, :2] = seq[:, :2] / scale
$p_1$
109 self.data[i, 1:len_seq + 1, 2] = 1 - seq[:, 2]
$p_2$
111 self.data[i, 1:len_seq + 1, 3] = seq[:, 2]
$p_3$
113 self.data[i, len_seq + 1:, 4] = 1
Mask is on until end of sequence
115 self.mask[i, :len_seq + 1] = 1
Start-of-sequence is $(0, 0, 1, 0, 0)
118 self.data[:, 0, 2] = 1
Size of the dataset
120 def __len__(self):
122 return len(self.data)
Get a sample
124 def __getitem__(self, idx: int):
126 return self.data[idx], self.mask[idx]
The mixture is represented by $\Pi$ and $\mathcal{N}(\mu_{x}, \mu_{y}, \sigma_{x}, \sigma_{y}, \rho_{xy})$. This class adjust temperatures and creates the categorical and gaussian distributions from the parameters.
129class BivariateGaussianMixture:
139 def __init__(self, pi_logits: torch.Tensor, mu_x: torch.Tensor, mu_y: torch.Tensor,
140 sigma_x: torch.Tensor, sigma_y: torch.Tensor, rho_xy: torch.Tensor):
141 self.pi_logits = pi_logits
142 self.mu_x = mu_x
143 self.mu_y = mu_y
144 self.sigma_x = sigma_x
145 self.sigma_y = sigma_y
146 self.rho_xy = rho_xy
Number of distributions in the mixture, $M$
148 @property
149 def n_distributions(self):
151 return self.pi_logits.shape[-1]
Adjust by temperature $\tau$
153 def set_temperature(self, temperature: float):
158 self.pi_logits /= temperature
160 self.sigma_x *= math.sqrt(temperature)
162 self.sigma_y *= math.sqrt(temperature)
164 def get_distribution(self):
Clamp $\sigma_x$, $\sigma_y$ and $\rho_{xy}$ to avoid getting NaN
s
166 sigma_x = torch.clamp_min(self.sigma_x, 1e-5)
167 sigma_y = torch.clamp_min(self.sigma_y, 1e-5)
168 rho_xy = torch.clamp(self.rho_xy, -1 + 1e-5, 1 - 1e-5)
Get means
171 mean = torch.stack([self.mu_x, self.mu_y], -1)
Get covariance matrix
173 cov = torch.stack([
174 sigma_x * sigma_x, rho_xy * sigma_x * sigma_y,
175 rho_xy * sigma_x * sigma_y, sigma_y * sigma_y
176 ], -1)
177 cov = cov.view(*sigma_y.shape, 2, 2)
Create bi-variate normal distribution.
📝 It would be efficient to scale_tril
matrix as [[a, 0], [b, c]]
where
.
But for simplicity we use co-variance matrix.
This is a good resource
if you want to read up more about bi-variate distributions, their co-variance matrix,
and probability density function.
188 multi_dist = torch.distributions.MultivariateNormal(mean, covariance_matrix=cov)
Create categorical distribution $\Pi$ from logits
191 cat_dist = torch.distributions.Categorical(logits=self.pi_logits)
194 return cat_dist, multi_dist
197class EncoderRNN(Module):
204 def __init__(self, d_z: int, enc_hidden_size: int):
205 super().__init__()
Create a bidirectional LSTM takes a sequence of $(\Delta x, \Delta y, p_1, p_2, p_3)$ as input.
208 self.lstm = nn.LSTM(5, enc_hidden_size, bidirectional=True)
Head to get $\mu$
210 self.mu_head = nn.Linear(2 * enc_hidden_size, d_z)
Head to get $\hat{\sigma}$
212 self.sigma_head = nn.Linear(2 * enc_hidden_size, d_z)
214 def __call__(self, inputs: torch.Tensor, state=None):
The hidden state of the bidirectional LSTM is the concatenation of the output of the last token in the forward direction and and first token in the reverse direction. Which is what we want.
222 _, (hidden, cell) = self.lstm(inputs.float(), state)
The state has shape [2, batch_size, hidden_size]
where the first dimension is the direction.
We rearrange it to get $h = [h_{\rightarrow}; h_{\leftarrow}]$
226 hidden = einops.rearrange(hidden, 'fb b h -> b (fb h)')
$\mu$
229 mu = self.mu_head(hidden)
$\hat{\sigma}$
231 sigma_hat = self.sigma_head(hidden)
$\sigma = \exp(\frac{\hat{\sigma}}{2})$
233 sigma = torch.exp(sigma_hat / 2.)
Sample $z = \mu + \sigma \cdot \mathcal{N}(0, I)$
236 z = mu + sigma * torch.normal(mu.new_zeros(mu.shape), mu.new_ones(mu.shape))
239 return z, mu, sigma_hat
242class DecoderRNN(Module):
249 def __init__(self, d_z: int, dec_hidden_size: int, n_distributions: int):
250 super().__init__()
LSTM takes $[(\Delta x, \Delta y, p_1, p_2, p_3); z]$ as input
252 self.lstm = nn.LSTM(d_z + 5, dec_hidden_size)
Initial state of the LSTM is $[h_0; c_0] = \tanh(W_{z}z + b_z)$.
init_state
is the linear transformation for this
256 self.init_state = nn.Linear(d_z, 2 * dec_hidden_size)
This layer produces outputs for each of of the n_distributions
.
Each distribution needs six parameters
$(\hat{\Pi_i}, \mu_{x_i}, \mu_{y_i}, \hat{\sigma_{x_i}}, \hat{\sigma_{y_i}} \hat{\rho_{xy_i}})$
261 self.mixtures = nn.Linear(dec_hidden_size, 6 * n_distributions)
This head is for the logits $(\hat{q_1}, \hat{q_2}, \hat{q_3})$
264 self.q_head = nn.Linear(dec_hidden_size, 3)
This is to calculate $\log(q_k)$ where
267 self.q_log_softmax = nn.LogSoftmax(-1)
These parameters are stored for future reference
270 self.n_distributions = n_distributions
271 self.dec_hidden_size = dec_hidden_size
273 def __call__(self, x: torch.Tensor, z: torch.Tensor, state: Optional[Tuple[torch.Tensor, torch.Tensor]]):
Calculate the initial state
275 if state is None:
$[h_0; c_0] = \tanh(W_{z}z + b_z)$
277 h, c = torch.split(torch.tanh(self.init_state(z)), self.dec_hidden_size, 1)
h
and c
have shapes [batch_size, lstm_size]
. We want to make them
to shape [1, batch_size, lstm_size]
because that’s the shape used in LSTM.
280 state = (h.unsqueeze(0).contiguous(), c.unsqueeze(0).contiguous())
Run the LSTM
283 outputs, state = self.lstm(x, state)
Get $\log(q)$
286 q_logits = self.q_log_softmax(self.q_head(outputs))
Get $(\hat{\Pi_i}, \mu_{x,i}, \mu_{y,i}, \hat{\sigma_{x,i}},
\hat{\sigma_{y,i}} \hat{\rho_{xy,i}})$.
torch.split
splits the output into 6 tensors of size self.n_distribution
across dimension 2
.
292 pi_logits, mu_x, mu_y, sigma_x, sigma_y, rho_xy = \
293 torch.split(self.mixtures(outputs), self.n_distributions, 2)
Create a bi-variate gaussian mixture $\Pi$ and $\mathcal{N}(\mu_{x}, \mu_{y}, \sigma_{x}, \sigma_{y}, \rho_{xy})$ where and
$\Pi$ is the categorical probabilities of choosing the distribution out of the mixture $\mathcal{N}(\mu_{x}, \mu_{y}, \sigma_{x}, \sigma_{y}, \rho_{xy})$.
306 dist = BivariateGaussianMixture(pi_logits, mu_x, mu_y,
307 torch.exp(sigma_x), torch.exp(sigma_y), torch.tanh(rho_xy))
310 return dist, q_logits, state
313class ReconstructionLoss(Module):
318 def __call__(self, mask: torch.Tensor, target: torch.Tensor,
319 dist: 'BivariateGaussianMixture', q_logits: torch.Tensor):
Get $\Pi$ and $\mathcal{N}(\mu_{x}, \mu_{y}, \sigma_{x}, \sigma_{y}, \rho_{xy})$
321 pi, mix = dist.get_distribution()
target
has shape [seq_len, batch_size, 5]
where the last dimension is the features
$(\Delta x, \Delta y, p_1, p_2, p_3)$.
We want to get $\Delta x, \Delta$ and get the probabilities from each of the distributions
in the mixture $\mathcal{N}(\mu_{x}, \mu_{y}, \sigma_{x}, \sigma_{y}, \rho_{xy})$.
xy
will have shape [seq_len, batch_size, n_distributions, 2]
328 xy = target[:, :, 0:2].unsqueeze(-2).expand(-1, -1, dist.n_distributions, -1)
Calculate the probabilities
334 probs = torch.sum(pi.probs * torch.exp(mix.log_prob(xy)), 2)
Although probs
has $N_{max}$ (longest_seq_len
) elements the sum is only taken
upto $N_s$ because the rest are masked out.
It might feel like we should be taking the sum and dividing by $N_s$ and not $N_{max}$, but this will give higher weight for individual predictions in shorter sequences. We give equal weight to each prediction $p(\Delta x, \Delta y)$ when we divide by $N_{max}$
343 loss_stroke = -torch.mean(mask * torch.log(1e-5 + probs))
346 loss_pen = -torch.mean(target[:, :, 2:] * q_logits)
349 return loss_stroke + loss_pen
This calculates the KL divergence between a given normal distribution and $\mathcal{N}(0, 1)$
352class KLDivLoss(Module):
359 def __call__(self, sigma_hat: torch.Tensor, mu: torch.Tensor):
361 return -0.5 * torch.mean(1 + sigma_hat - mu ** 2 - torch.exp(sigma_hat))
364class Sampler:
371 def __init__(self, encoder: EncoderRNN, decoder: DecoderRNN):
372 self.decoder = decoder
373 self.encoder = encoder
375 def sample(self, data: torch.Tensor, temperature: float):
$N_{max}$
377 longest_seq_len = len(data)
Get $z$ from the encoder
380 z, _, _ = self.encoder(data)
Start-of-sequence stroke is $(0, 0, 1, 0, 0)$
383 s = data.new_tensor([0, 0, 1, 0, 0])
384 seq = [s]
Initial decoder is None
.
The decoder will initialize it to $[h_0; c_0] = \tanh(W_{z}z + b_z)$
387 state = None
We don’t need gradients
390 with torch.no_grad():
Sample $N_{max}$ strokes
392 for i in range(longest_seq_len):
$[(\Delta x, \Delta y, p_1, p_2, p_3); z] is the input to the decoder$
394 data = torch.cat([s.view(1, 1, -1), z.unsqueeze(0)], 2)
Get $\Pi$, $\mathcal{N}(\mu_{x}, \mu_{y}, \sigma_{x}, \sigma_{y}, \rho_{xy})$, $q$ and the next state from the decoder
397 dist, q_logits, state = self.decoder(data, z, state)
Sample a stroke
399 s = self._sample_step(dist, q_logits, temperature)
Add the new stroke to the sequence of strokes
401 seq.append(s)
Stop sampling if $p_3 = 1$. This indicates that sketching has stopped
403 if s[4] == 1:
404 break
Create a PyTorch tensor of the sequence of strokes
407 seq = torch.stack(seq)
Plot the sequence of strokes
410 self.plot(seq)
412 @staticmethod
413 def _sample_step(dist: 'BivariateGaussianMixture', q_logits: torch.Tensor, temperature: float):
Set temperature $\tau$ for sampling. This is implemented in class BivariateGaussianMixture
.
415 dist.set_temperature(temperature)
Get temperature adjusted $\Pi$ and $\mathcal{N}(\mu_{x}, \mu_{y}, \sigma_{x}, \sigma_{y}, \rho_{xy})$
417 pi, mix = dist.get_distribution()
Sample from $\Pi$ the index of the distribution to use from the mixture
419 idx = pi.sample()[0, 0]
Create categorical distribution $q$ with log-probabilities q_logits
or $\hat{q}$
422 q = torch.distributions.Categorical(logits=q_logits / temperature)
Sample from $q$
424 q_idx = q.sample()[0, 0]
Sample from the normal distributions in the mixture and pick the one indexed by idx
427 xy = mix.sample()[0, 0, idx]
Create an empty stroke $(\Delta x, \Delta y, q_1, q_2, q_3)$
430 stroke = q_logits.new_zeros(5)
Set $\Delta x, \Delta y$
432 stroke[:2] = xy
Set $q_1, q_2, q_3$
434 stroke[q_idx + 2] = 1
436 return stroke
438 @staticmethod
439 def plot(seq: torch.Tensor):
Take the cumulative sums of $(\Delta x, \Delta y)$ to get $$x, y)$
441 seq[:, 0:2] = torch.cumsum(seq[:, 0:2], dim=0)
Create a new numpy array of the form $(x, y, q_2)$
443 seq[:, 2] = seq[:, 3]
444 seq = seq[:, 0:3].detach().cpu().numpy()
Split the array at points where $q_2$ is $1$. That is split the array of strokes at the points where the pen is lifted from the paper. This gives a list of sequence of strokes.
449 strokes = np.split(seq, np.where(seq[:, 2] > 0)[0] + 1)
Plot each sequence of strokes
451 for s in strokes:
452 plt.plot(s[:, 0], -s[:, 1])
Don’t show axes
454 plt.axis('off')
Show the plot
456 plt.show()
459class Configs(TrainValidConfigs):
Device configurations to pick the device to run the experiment
467 device: torch.device = DeviceConfigs()
469 encoder: EncoderRNN
470 decoder: DecoderRNN
471 optimizer: optim.Adam
472 sampler: Sampler
473
474 dataset_name: str
475 train_loader: DataLoader
476 valid_loader: DataLoader
477 train_dataset: StrokesDataset
478 valid_dataset: StrokesDataset
Encoder and decoder sizes
481 enc_hidden_size = 256
482 dec_hidden_size = 512
Batch size
485 batch_size = 100
Number of features in $z$
488 d_z = 128
Number of distributions in the mixture, $M$
490 n_distributions = 20
Weight of KL divergence loss, $w_{KL}$
493 kl_div_loss_weight = 0.5
Gradient clipping
495 grad_clip = 1.
Temperature $\tau$ for sampling
497 temperature = 0.4
Filter out stroke sequences longer than $200$
500 max_seq_length = 200
501
502 epochs = 100
503
504 kl_div_loss = KLDivLoss()
505 reconstruction_loss = ReconstructionLoss()
507 def init(self):
Initialize encoder & decoder
509 self.encoder = EncoderRNN(self.d_z, self.enc_hidden_size).to(self.device)
510 self.decoder = DecoderRNN(self.d_z, self.dec_hidden_size, self.n_distributions).to(self.device)
Set optimizer, things like type of optimizer and learning rate are configurable
513 optimizer = OptimizerConfigs()
514 optimizer.parameters = list(self.encoder.parameters()) + list(self.decoder.parameters())
515 self.optimizer = optimizer
Create sampler
518 self.sampler = Sampler(self.encoder, self.decoder)
npz
file path is data/sketch/[DATASET NAME].npz
521 path = lab.get_data_path() / 'sketch' / f'{self.dataset_name}.npz'
Load the numpy file.
523 dataset = np.load(str(path), encoding='latin1', allow_pickle=True)
Create training dataset
526 self.train_dataset = StrokesDataset(dataset['train'], self.max_seq_length)
Create validation dataset
528 self.valid_dataset = StrokesDataset(dataset['valid'], self.max_seq_length, self.train_dataset.scale)
Create training data loader
531 self.train_loader = DataLoader(self.train_dataset, self.batch_size, shuffle=True)
Create validation data loader
533 self.valid_loader = DataLoader(self.valid_dataset, self.batch_size)
Add hooks to monitor layer outputs on Tensorboard
536 hook_model_outputs(self.mode, self.encoder, 'encoder')
537 hook_model_outputs(self.mode, self.decoder, 'decoder')
Configure the tracker to print the total train/validation loss
540 tracker.set_scalar("loss.total.*", True)
541
542 self.state_modules = []
544 def step(self, batch: Any, batch_idx: BatchIndex):
545 self.encoder.train(self.mode.is_train)
546 self.decoder.train(self.mode.is_train)
Move data
and mask
to device and swap the sequence and batch dimensions.
data
will have shape [seq_len, batch_size, 5]
and
mask
will have shape [seq_len, batch_size]
.
551 data = batch[0].to(self.device).transpose(0, 1)
552 mask = batch[1].to(self.device).transpose(0, 1)
Increment step in training mode
555 if self.mode.is_train:
556 tracker.add_global_step(len(data))
Encode the sequence of strokes
559 with monit.section("encoder"):
Get $z$, $\mu$, and $\hat{\sigma}$
561 z, mu, sigma_hat = self.encoder(data)
Decode the mixture of distributions and $\hat{q}$
564 with monit.section("decoder"):
Concatenate $[(\Delta x, \Delta y, p_1, p_2, p_3); z]$
566 z_stack = z.unsqueeze(0).expand(data.shape[0] - 1, -1, -1)
567 inputs = torch.cat([data[:-1], z_stack], 2)
Get mixture of distributions and $\hat{q}$
569 dist, q_logits, _ = self.decoder(inputs, z, None)
Compute the loss
572 with monit.section('loss'):
$L_{KL}$
574 kl_loss = self.kl_div_loss(sigma_hat, mu)
$L_R$
576 reconstruction_loss = self.reconstruction_loss(mask, data[1:], dist, q_logits)
$Loss = L_R + w_{KL} L_{KL}$
578 loss = reconstruction_loss + self.kl_div_loss_weight * kl_loss
Track losses
581 tracker.add("loss.kl.", kl_loss)
582 tracker.add("loss.reconstruction.", reconstruction_loss)
583 tracker.add("loss.total.", loss)
Only if we are in training state
586 if self.mode.is_train:
Run optimizer
588 with monit.section('optimize'):
Set grad
to zero
590 self.optimizer.zero_grad()
Compute gradients
592 loss.backward()
Log model parameters and gradients
594 if batch_idx.is_last:
595 tracker.add(encoder=self.encoder, decoder=self.decoder)
Clip gradients
597 nn.utils.clip_grad_norm_(self.encoder.parameters(), self.grad_clip)
598 nn.utils.clip_grad_norm_(self.decoder.parameters(), self.grad_clip)
Optimize
600 self.optimizer.step()
601
602 tracker.save()
604 def sample(self):
Randomly pick a sample from validation dataset to encoder
606 data, *_ = self.valid_dataset[np.random.choice(len(self.valid_dataset))]
Add batch dimension and move it to device
608 data = data.unsqueeze(1).to(self.device)
Sample
610 self.sampler.sample(data, self.temperature)
613def main():
614 configs = Configs()
615 experiment.create(name="sketch_rnn")
Pass a dictionary of configurations
618 experiment.configs(configs, {
619 'optimizer.optimizer': 'Adam',
We use a learning rate of 1e-3
because we can see results faster.
Paper had suggested 1e-4
.
622 'optimizer.learning_rate': 1e-3,
Name of the dataset
624 'dataset_name': 'bicycle',
Number of inner iterations within an epoch to switch between training, validation and sampling.
626 'inner_iterations': 10
627 })
628
629 with experiment.start():
Run the experiment
631 configs.run()
632
633
634if __name__ == "__main__":
635 main()


The optional transport file specifies a mapping from domain hierarchies to
message delivery transports and/or relay hosts. The mapping is used by the
trivial-rewrite(8) daemon.
The format of the transport table is as follows:
- domain mapped to.. transport:nexthop: Mail
for domain is delivered through transport to nexthop.
- .domain mapped to.. transport:nexthop: Mail
for any subdomain of domain is delivered through transport to nexthop.
Note: transport map entries take precedence over domains specified in the
mydestination parameter. If you use the optional transport map, it may
be safer to specify explicit entries for all domains specified in
mydestination, for example:
- hostname.my.domain ... local:
- localhost.my.domain ... local:
The interpretation of the nexthop field is transport dependent. In the case of
SMTP, specify host:service for a non-default server port, and use
[host] or [host:port] in order to disable MX (mail exchanger)
DNS lookups. The [] form can also be used with IP addresses instead of
hostnames.


TResponse
- Type of the response message which can be received.TRequest
- Type of the request message which can be sent.public interface IDuplexTypedMessageSender<TResponse,TRequest> extends IAttachableDuplexOutputChannel
| Modifier and Type | Method and Description |
|---|---|
Event<DuplexChannelEventArgs> |
connectionClosed()
Raised when the service closed the connection with the client.
|
Event<DuplexChannelEventArgs> |
connectionOpened()
Raised when the connection with the receiver is open.
|
Event<TypedResponseReceivedEventArgs<TResponse>> |
responseReceived()
Raised when a response message is received.
|
void |
sendRequestMessage(TRequest message)
Sends message to the service.
|
attachDuplexOutputChannel, detachDuplexOutputChannel, getAttachedDuplexOutputChannel, isDuplexOutputChannelAttached
Event<DuplexChannelEventArgs> connectionOpened()
Event<DuplexChannelEventArgs> connectionClosed()
Event<TypedResponseReceivedEventArgs<TResponse>> responseReceived()
void sendRequestMessage(TRequest message) throws java.lang.Exception
message
- java.lang.Exception


product
Welcome to our page, you can vote to your favorite product and you have 25 times
number of attempts


CodXCrypt is an open-source platform build for all the coding enthusiasts around the world who are searching for the best of the codes to get their mind blowing with new ideas for coding project.We are a young and thriving team of 23, burning our midnight oil to provide you with the best of the projects. Started with the vision of our founder Unnati Chabbra and Co-Founder Shashank Agrawal, our team is diverse with every single member with their unique expertise in different fields ranging from development to social networking.Every member of the team aims to improve our efficiency, create and find useful projects and develop ideas to uplift our community.
Our plan is to provide an open source platform to coders to sharing their creations with the viewers and aiding budding minds. We have Mentors who are experienced and can help you with everything from scratch.
To provides you with well-structured and concise codes of various projects that are created by experienced coders. It contains coding projects ranging from beginner to expert level to give cater to everyone's needs.
Our aim is to build a strong community for prospective attendees and mentors that provide wings to the careers of the coders all around the world acilitating knowledge sharing and discussion.
Learners don't know how to begin, So our idea is to make learners to work on live projects while working


---
layout: post
title: FriendFeed And What Happens When The Party Gets Too Big
date: '2008-06-05T18:31:55-07:00'
tags:
tumblr_url: http://alexhwilliams.tumblr.com/post/37340258/friendfeed-and-what-happens-when-the-party-gets-too-big
---
FriendFeed And What Happens When The Party Gets Too Big


I don't agree dwy, look at the comment
(int64_t)1529910234, // * UNIX timestamp of last checkpoint block
(int64_t)63661, // * total number of transactions between genesis and last checkpoint
// (the tx=... number in the SetBestChain debug.log lines)
(double)2777 // * estimated number of transactions per day after checkpoint
// total number of tx / (checkpoint block height / (24 * 24))


Select a match or group in the match tree to highlight it in the text and replace panes.
In the replace box, you can use group references like $1
Hit the tab key to switch between regex,replace, and text panes


{% load static %}
Rectifica
REGISTER
{% csrf_token %}
FIRST NAME
LAST NAME
USERNAME
PHONE NUMBER
EMAIL ADDRESS
PASSWORD
CONFIRM PASSWORD
Teacher
Student


WE'VE LAUNCHED
Check out the fresh, new and friendly
kudzu.com
We hope our new design makes it even easier to find recommended local services for all of your needs.
DAILY LIFE • AUTO • HOME • HEALTH • PROFESSIONAL
Kudzu Home
|
Sign Up
|
My Account
|
About Us
|
Results
|
Contact
Kudzu, 6205 Peachtree Dunwoody Road, Atlanta, GA, 30328
View our
Business Agreement
|
Manage Your Subscription
|
Unsubscribe


Before Change
4 0 2
// check if the start state is valid
if start_state is not None and self._check_state(start_state):
self.state = start_state
elif start_state is None and self.state is None:
self.state = self.random_state()
sampled = DataFrame(index=range(size), columns=self.variables)
sampled.loc[0] = [self.state[var] for var in self.variables]
for i in range(size - 1):
for var in self.variables:
After Change
for j, (var, st) in enumerate(self.state):
next_st = sample_discrete(list(self.transition_models[var][st].keys()),
list(self.transition_models[var][st].values()))[0]
self.state[j] = State(var, next_st)
sampled.loc[i + 1] = [st for var, st in self.state]
return sampled
def prob_from_sample(self, state, sample=None, window_size=None):


FASMA
Fast Analysis of Spectra Made Automatically
Abundance driver
Obtain abundance from a spectrum.
Line list
T
eff
logg
[Fe/H]
ξ
tur
Email
Submit


--- layout: post status: publish published: true title: ".NET Nullable Types and DBNull Expose Design Flaws" author: display_name: Geoff Lane login: admin email<EMAIL_ADDRESS>url: http://www.zorched.net author_login: admin author_email<EMAIL_ADDRESS>author_url: http://www.zorched.net excerpt: The need for Nullable types included in .NET 2.0 expose what is essentially a major design flaw in the language. date: '2005-11-17 22:03:36 -0500' date_gmt: '2005-11-18 03:03:36 -0500' categories: - Code - ".NET" tags: [] ---
.NET has had DBNull since the beginning. With the release of .NET 2.0 it has also gained the Nullable type. DBNull is used to represent a null value returned from a database or a dataset. The Nullable type was added to give the ability to have null types for integral types. You might ask, "What's going on here? We can already have a null reference to class instance."
This value type is a performance optimzation, but I think it was a bad choice.
null
value type. So, you can see why the DBNull
was added, because .NET needed a way to represent a NULL database value. The bad part is that DBNull.Value != null
so you have to check for DBNull
in many cases. It is also a problem because setting null
into a ADO.NET parameter will cause an error. This is a really terrible semantic for the language. Wouldn't they be able to hide DBNull
within the ADO.NET classes and convert null
to DBNulls within the code? Yes, IF it was possible to have a null value type.
This also wouldn't be a problem if all of the Value types had a corresponding Reference type. int has Int32, string has String, etc. But what about DateTime? DateTime is a struct (a value type) with no corresponding reference type. So you can't have a null
DateTime. Its default value is represented as DateTime.MinValue so you have to compare with that.
What else? Well Value types can not be inherited and can't inherit from other Classes or Structs.  What where they thinking?
Yet another problem with this optimization is that it is only a half optimization. Methods in .NET are by default pass-by-value which means that a copy of a value is passed to the method. (In the case of an Object/Class instance passed to a method, a copy of the pointer to the instance is passed, so it's a small value that is copied.) With value types, because the pointer represents all of the memory space for the values contained in the Struct, when a Struct/Value Object is passed to a method, the entire memory space is copied to a new location. This increases the amount of memory used. So you gain some speed, and lose some memory. Is that a good tradeoff? Depends a lot on where your constraints are
In addition, because of the differences in that pass-by-value behavior, you get differences in the behavior of calling methods, or setting parameters from within a method.
{% highlight csharp %} class Program { class MyClass { public string SomeValue; } struct ValueType { public string SomeValue; } static void Main(string[] args) { MyClass mc = new MyClass(); mc.SomeValue = "MyClass: out of method"; Console.Out.WriteLine(mc.SomeValue); Change(mc); Console.Out.WriteLine(mc.SomeValue); ValueType vt = new ValueType(); vt.SomeValue = "ValueType: out of method"; Console.Out.WriteLine(vt.SomeValue); Change(vt); Console.Out.WriteLine(vt.SomeValue); } private static void Change(MyClass cl) { cl.SomeValue = "MyClass: in method"; } private static void Change(ValueType vt) { vt.SomeValue = "ValueType: in method"; } } {% endhighlight %}
What's the output?: MyClass: out of method MyClass: in method ValueType: out of method ValueType: out of method
Surprised? I was once I realized that was what would happen. These kinds of hidden semantic differences cause a lot of surprise. Surprise like that is not good in programming.


Tennis is amazing because it builds muscle and helps release pent up energy.
The best players are
| Name | Quote | Medals |
|---|---|---|
| Federer | "I have learnt to be even more patient." | 20 |
| Williams | "Tennis just a game, family is forever." | 5 |
| Nadal | “I have no sense of humor about losing.” | 17 |


|
| | Builder (TToolTipBase component) |
| |
| virtual TBuilder | ForceRendering (bool forceRendering) |
| |
| virtual TBuilder | FadeOutDuration (int fadeOutDuration) |
| |
| virtual TBuilder | Anchor (string anchor) |
| | If specified, indicates that the tip should be anchored to a particular side of the target element or mouse pointer ("top", "right", "bottom", or "left"), with an arrow pointing back at the target or mouse pointer. If constrainPosition is enabled, this will be used as a preferred value only and may be flipped as needed. More...
|
| |
| virtual TBuilder | AnchorOffset (int anchorOffset) |
| | A numeric pixel value used to offset the default position of the anchor arrow. When the anchor position is on the top or bottom of the tooltip, anchorOffset will be used as a horizontal offset. Likewise, when the anchor position is on the left or right side, anchorOffset will be used as a vertical offset. Defaults to: 0 More...
|
| |
| virtual TBuilder | AnchorToTarget (bool anchorToTarget) |
| | True to anchor the tooltip to the target element, false to anchor it relative to the mouse coordinates. When anchorToTarget is true, use defaultAlign to control tooltip alignment to the target element. When anchorToTarget is false, use anchor instead to control alignment. Defaults to: true More...
|
| |
| virtual TBuilder | AutoHide (bool autoHide) |
| | True to automatically hide the tooltip after the mouse exits the target element or after the dismissDelay has expired if set (defaults to true). If closable = true a close tool button will be rendered into the tooltip header. More...
|
| |
| virtual TBuilder | Delegate (string _delegate) |
| | A DomQuery selector which allows selection of individual elements within the target element to trigger showing and hiding the ToolTip as the mouse moves within the target. More...
|
| |
| virtual TBuilder | DismissDelay (int dismissDelay) |
| | Delay in milliseconds before the tooltip automatically hides (defaults to 5000). To disable automatic hiding, set dismissDelay = 0. More...
|
| |
| virtual TBuilder | HideAction (string hideAction) |
| |
| virtual TBuilder | HideDelay (int hideDelay) |
| | Delay in milliseconds after the mouse exits the target element but before the tooltip actually hides (defaults to 200). Set to 0 for the tooltip to hide immediately. More...
|
| |
| virtual TBuilder | MouseOffset (int[] mouseOffset) |
| | An XY offset from the mouse position where the tooltip should be shown (defaults to [15,18]). More...
|
| |
| virtual TBuilder | ShowDelay (int showDelay) |
| | Delay in milliseconds before the tooltip displays after the mouse enters the target element (defaults to 500). More...
|
| |
| virtual TBuilder | TargetControl (Action< Control > action) |
| |
| virtual TBuilder | Target (string target) |
| | The target id to associate with this tooltip. More...
|
| |
| virtual TBuilder | TrackMouse (bool trackMouse) |
| | True to have the tooltip follow the mouse as it moves over the target element (defaults to false). More...
|
| |
| | Builder (TTip component) |
| |
| virtual TBuilder | ConstrainPosition (bool constrainPosition) |
| | If true, then the tooltip will be automatically constrained to stay within the browser viewport. Defaults to: true More...
|
| |
| virtual TBuilder | DefaultAlign (string defaultAlign) |
| | Experimental. The default Ext.Element.alignTo anchor position value for this tip relative to its element of origin. Defaults to: "tl-bl?" More...
|
| |
| virtual TBuilder | ShowAt (Unit x, Unit y) |
| |
| virtual TBuilder | ShowBy (string id) |
| |
| virtual TBuilder | ShowBy (string id, string position) |
| |


CENTRAAL BUREAU FONDSENWERVING anthony forkkerweg i 1059 CM AMSTERDAM AMSTERDAM,THE NETHERLANDS. DEAR SIR/MADAM, RE: FUND TO INVEST IN CHARITABLE ORGANIZATIONS IN YOUR COUNTRY TOTALLING FIVE MILLION EUROS (EUROS 5,000,000.00). I am a Director in a non profit organization known as (CENTRAAL BUREAU FONDSENWERVING) in AMSTERDAM,THE NETHERLANDS. We came across your e-mail address, when we organized a random Balotting lottery in searching for a reputable,capable individual or organization in your country that would manage the Funds prudently.As a result,your name was selected. My organization has approved the sum of FIVE MILLION EUROS ONLY (EUROS 5,000,000.00). ) as a NON RE-PAYBLE Fund to be given to you to invest in charitable organizations in your country. Upon the release of this Funds to you, we will send an agent to your country to monitor the impact made to charitable organizations on a periodic basis. If you are ready to obtain the Funds as stated above,kindly e-mail to me your telephone and fax numbers.I will inform you of the next step on the process of securing the Funds. I await your prompt reply. Best Regards, HUBERT KLUIVERT (DIRECTOR). CENTRAAL BUREAU FONDSENWERVING AMSTERDAM,THE NETHERLANDS _________________________________________________________________ MSN 8 helps eliminate e-mail viruses. Get 2 months FREE*. http://join.msn.com/?page=features/virus


MultiplayerSet is a game in which you try to find sets of three cards out of a board of twelve cards. Which cards form sets depends on the four traits that each card has:
A set is three cards where all the traits on the three cards are either all the same…
or all different…
or any mixture of same and different traits. Here the cards have number and shape in common with different color and shading.
If you're not sure if you've found a set, just ask yourself, "Are there only two of something?" If so, then you don't have a set. Here are some examples:
This would be a set except that two of the cards are blue. If they were all blue or there was one of each color, you would have a real set.
Similar problem here: two of the cards are solidly shaded. If all three were solid or there were one of each shading, it'd be correct.
If you want to play with friends, hit start a private game in the top left corner. You can use the URL of your game room to invite your friends.
If you want to get into a game quickly, hit join a public game. You will be placed into a game that will start as soon as three people are present. While the room fills up, you can warm up in an unscored practice game.
Click cards to build sets. To clear your current selection, click on any part of the board. Type messages and hit enter to talk to the other players.
If you need a hint or don't see a set on the board (which can happen), use the HINT button. If the majority of players do this, the game will reveal one card of a set on the board. If there are none, the game will deal three additional cards.


My nick:
My ID:
My Last Login:
Rececent Room:
Next Session:
Total Players:
Name:
Last Name:
PRO STATE:


Licence Expired
Unfortunately, the license for {{institution.name}} has expired. If you would like to continue making use of Mycroft Lectures we suggest you ask your institution to renew their license.
{% extends "base.html" %} {% block page_class %}Portal: {{institution.name}}{% endblock %} {% block content %} {% if user.is_authenticated %} {% if expired %}
Unfortunately, the license for {{institution.name}} has expired. If you would like to continue making use of Mycroft Lectures we suggest you ask your institution to renew their license.


Blood requirement is almost always an emergency. BloodForLife allows you to quickly search for suitable donors in your city, and call them right away.
Blood Donors can register on the website themselves, and easily maintain the date of their last bleed so that their name is not displayed in the results if they are not ready for the next bleed.
BloodForLife.com.pk is a project of Al-Khadija Foundation. To date, several free clinics and a multi-speciality free hospital has served over 1,000,000 patients, and counting.
BloodForLife is a open community project supported by a growing network of volunteers who contribute their time in bring more and more donors in the directory, generating awareness, and even helping people looking for blood donors, by searching the directory and connecting the two.
Come join our hands. Saving lives is saving humanity.
| Donor Name | Age | Contact Number | Mobile Number |
|---|---|---|---|
| {{full_name}} | {{calcAge date_of_birth}} | {{phone}} | {{cell}} |


--- layout: post title: Etiquette of ownership date: type: post parent_id: '0' published: false password: '' status: pitch categories: [] tags: [] meta: _edit_last: '1' _su_title: '' author: login: akropp email<EMAIL_ADDRESS>display_name: akropp first_name: '' last_name: '' permalink: "/2012/09/18/etiquette-of-ownership/" ---
- talk about professionalism when publishing open source or public code
- read between the lines when someone asks a question. try to determine what they are asking, if its a bug, if its not a bug.
- as the creator you know all the details about what you made, give people the benefit of the doubt and be patient when explaining it
- remember that your answers reflect on you and the things you are related to, a poorly judged comment can undermine lots of work
- this applies not only to public source but internal interactions as well


{% extends "base_bootstrap.html" %} {% block content %}
| Planetary system name | Planetary system number of stars | Planetary system number of planets | Planetary system publication reference | Planetary system right ascension sexagesimal | Planetary system right ascension decimal | Planetary system declination sexagesimal | Planetary system declination decimal | Planetary system distance | Planetary system distance err1 | Planetary system distance err2 | Planetary system brightness v magnitude | Planetary system brightness v magnitude err1 | Planetary system brightness v magnitude err2 | Planetary system brightness ks magnitude | Planetary system brightness ks magnitude err1 | Planetary system brightness ks magnitude err2 | Planetary system brightness gaia magnitude | Planetary system brightness gaia magnitude err1 | Planetary system brightness gaia magnitude err2 | Star hd name | Star hip name | Star tic id | Star gaia id | Star publication reference | Star effective temperature | Star effective temperature err1 | Star effective temperature err2 | Star effective temperature limit | Star radius | Star radius err1 | Star radius err2 | Star radius limit | Star mass | Star mass err1 | Star mass err2 | Star mass limit | Star measurement | Star measurement err1 | Star measurement err2 | Star measurement limit | Star metallicity ratio | Star surface gravity | Star surface gravity err1 | Star surface gravity err2 | Star surface gravity limit | Star planetary system id | Star spectral type | planet planetary system | Planet name | Planet planet letter | Planet explicit | Planet discovery year | Planet controversial flag | Planet publication reference | Planet orbital period | Planet orbital period err1 | Planet orbital period err2 | Planet orbital period limit | Planet orbit semi major axis | Planet orbit semi major axis err1 | Planet orbit semi major axis err2 | Planet orbit semi major axis limit | Planet earth radius | Planet earth radius err1 | Planet earth radius err2 | Planet earth radius limit | Planet jupiter radius | Planet jupiter radius err1 | Planet jupiter radius err2 | Planet jupiter radius limit | Planet earth mass | Planet earth mass err1 | Planet earth mass err2 | Planet earth mass limit | Planet jupiter mass | Planet jupiter mass err1 | Planet jupiter mass err2 | Planet jupiter mass limit | Planet mass provenance | Planet eccentricity | Planet eccentricity err1 | Planet eccentricity err2 | Planet eccentricity limit | Planet insolation flux | Planet insolation flux err1 | Planet insolation flux err2 | Planet insolation flux limit | Planet equilibrium temperature | Planet equilibrium temperature err1 | Planet equilibrium temperature err2 | Planet equilibrium temperature limit | Planet transit timing variations | Planet date last update | Planet reference date publication | Planet release date | Planet discovery method name | Planet discovery facility name | Planet solution type name |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| {{ planetary_systems.planetary_system_name }} | {{ planetary_systems.planetary_system_number_of_stars }} | {{ planetary_systems.planetary_system_number_of_planets }} | {{ planetary_systems.planetary_system_publication_reference }} | {{ planetary_systems.planetary_system_right_ascension_sexagesimal }} | {{ planetary_systems.planetary_system_right_ascension_decimal }} | {{ planetary_systems.planetary_system_declination_sexagesimal }} | {{ planetary_systems.planetary_system_declination_decimal }} | {{ planetary_systems.planetary_system_distance }} | {{ planetary_systems.planetary_system_distance_err1 }} | {{ planetary_systems.planetary_system_distance_err2 }} | {{ planetary_systems.planetary_system_brightness_v_magnitude }} | {{ planetary_systems.planetary_system_brightness_v_magnitude_err1 }} | {{ planetary_systems.planetary_system_brightness_v_magnitude_err2 }} | {{ planetary_systems.planetary_system_brightness_ks_magnitude }} | {{ planetary_systems.planetary_system_brightness_ks_magnitude_err1 }} | {{ planetary_systems.planetary_system_brightness_ks_magnitude_err2 }} | {{ planetary_systems.planetary_system_brightness_gaia_magnitude }} | {{ planetary_systems.planetary_system_brightness_gaia_magnitude_err1 }} | {{ planetary_systems.planetary_system_brightness_gaia_magnitude_err2 }} | {{ planetary_systems.star_hd_name }} | {{ planetary_systems.star_hip_name }} | {{ planetary_systems.star_tic_id }} | {{ planetary_systems.star_gaia_id }} | {{ planetary_systems.star_publication_reference }} | {{ planetary_systems.star_effective_temperature }} | {{ planetary_systems.star_effective_temperature_err1 }} | {{ planetary_systems.star_effective_temperature_err2 }} | {{ planetary_systems.star_effective_temperature_limit }} | {{ planetary_systems.star_radius }} | {{ planetary_systems.star_radius_err1 }} | {{ planetary_systems.star_radius_err2 }} | {{ planetary_systems.star_radius_limit }} | {{ planetary_systems.star_mass }} | {{ planetary_systems.star_mass_err1 }} | {{ planetary_systems.star_mass_err2 }} | {{ planetary_systems.star_mass_limit }} | {{ planetary_systems.star_measurement }} | {{ planetary_systems.star_measurement_err1 }} | {{ planetary_systems.star_measurement_err2 }} | {{ planetary_systems.star_measurement_limit }} | {{ planetary_systems.star_metallicity_ratio }} | {{ planetary_systems.star_surface_gravity }} | {{ planetary_systems.star_surface_gravity_err1 }} | {{ planetary_systems.star_surface_gravity_err2 }} | {{ planetary_systems.star_surface_gravity_limit }} | {{ planetary_systems.star_planetary_system_id }} | {{ planetary_systems.star_spectral_type }} | {{ planetary_systems.planet_id }} | {{ planetary_systems.planet_name }} | {{ planetary_systems.planet_planet_letter }} | {{ planetary_systems.planet_explicit }} | {{ planetary_systems.planet_discovery_year }} | {{ planetary_systems.planet_controversial_flag }} | {{ planetary_systems.planet_publication_reference }} | {{ planetary_systems.planet_orbital_period }} | {{ planetary_systems.planet_orbital_period_err1 }} | {{ planetary_systems.planet_orbital_period_err2 }} | {{ planetary_systems.planet_orbital_period_limit }} | {{ planetary_systems.planet_orbit_semi_major_axis }} | {{ planetary_systems.planet_orbit_semi_major_axis_err1 }} | {{ planetary_systems.planet_orbit_semi_major_axis_err2 }} | {{ planetary_systems.planet_orbit_semi_major_axis_limit }} | {{ planetary_systems.planet_earth_radius }} | {{ planetary_systems.planet_earth_radius_err1 }} | {{ planetary_systems.planet_earth_radius_err2 }} | {{ planetary_systems.planet_earth_radius_limit }} | {{ planetary_systems.planet_jupiter_radius }} | {{ planetary_systems.planet_jupiter_radius_err1 }} | {{ planetary_systems.planet_jupiter_radius_err2 }} | {{ planetary_systems.planet_jupiter_radius_limit }} | {{ planetary_systems.planet_earth_mass }} | {{ planetary_systems.planet_earth_mass_err1 }} | {{ planetary_systems.planet_earth_mass_err2 }} | {{ planetary_systems.planet_earth_mass_limit }} | {{ planetary_systems.planet_jupiter_mass }} | {{ planetary_systems.planet_jupiter_mass_err1 }} | {{ planetary_systems.planet_jupiter_mass_err2 }} | {{ planetary_systems.planet_jupiter_mass_limit }} | {{ planetary_systems.planet_mass_provenance }} | {{ planetary_systems.planet_eccentricity }} | {{ planetary_systems.planet_eccentricity_err1 }} | {{ planetary_systems.planet_eccentricity_err2 }} | {{ planetary_systems.planet_eccentricity_limit }} | {{ planetary_systems.planet_insolation_flux }} | {{ planetary_systems.planet_insolation_flux_err1 }} | {{ planetary_systems.planet_insolation_flux_err2 }} | {{ planetary_systems.planet_insolation_flux_limit }} | {{ planetary_systems.planet_equilibrium_temperature }} | {{ planetary_systems.planet_equilibrium_temperature_err1 }} | {{ planetary_systems.planet_equilibrium_temperature_err2 }} | {{ planetary_systems.planet_equilibrium_temperature_limit }} | {{ planetary_systems.planet_transit_timing_variations }} | {{ planetary_systems.planet_date_last_update }} | {{ planetary_systems.planet_reference_date_publication }} | {{ planetary_systems.planet_release_date }} | {{ planetary_systems.planet_discovery_method_name }} | {{ planetary_systems.planet_discovery_facility_name }} | {{ planetary_systems.planet_solution_type_name }} |


The University acquired the laboratories at Willow Run from the War Department, which maintained control of some of the facilities. Willow Run became the site for the first innovations in computing at the University of Michigan.
The Statistical Research Laboratory was established in the basement of the Rackham Building to "provide consultation and statistical service for teaching and research units of the University...". Statistical analysis and calculation was a primary use of early computing technology. Cecil C. Craig was the first director. At the same time, Rackham also housed the Sorting and Tabulating Station.
As computing demand rose, Craig proposed a punch card machine purely for "Educational and Scientific Use." He notes "it is going to be necessary for any first class university not to lag too far behind in making for available for its research workers some of the much more efficient and versatile machines."
Previous to the spread of digital computers, analog computers were primary instruments for data calculation and analysis at the University of Michigan. One of the earliest analog computers was used by the Aeronautical Engineering Department. The computer was called the Electronic Differential Analyzer, and was built at the UM.
Arthur Burks, professor of Philosophy at the UM since 1946, and consultant for the Burroughs Corporation since 1949, began a research project investigating the logical design computers. Burks' research team, funded by Burroughs, developed designs and proofs for data-processing units. The project was funded until 1954.
The first digital computer developed at Michigan--the MIchigan Digital Automatic Computer (MIDAC). In 1951, the design for the MIDAC began. The project was under the sponsorship of the Wright Air Development Center, United States Air Force and the Willow Run Research Center of the Engineering Research Institute, University of Michigan. The MIDAC became operational in 1953.
The MIDAC became operational in August 1953. The computer was said to occupy two small rooms and required approximately 12 tons of refrigeration equipment to keep its 500,000 connections and tubes cool. The MIDAC was operated by Willow Run's Digital Computation Department under the leadership of John Carr III anhttp://www.merit.edu/about/history/article.phpd remained the property of the Air Force until it was removed in 1958.
MAGIC (Michigan Automatic General Integrated Computation) and EASIAC (Easy Instruction Automatic Computer) were automatic programming systems developed for the Michigan Digital Automatic Computer (MIDAC) under the direction of Professor John Carr III.
In 1953, the College of Engineering begins a program of offering intensive short courses for graduate engineers and scientists. In 1959, the Ford Foundation became a co-sponsor of the program by providing a grant that would “encourage engineering faculty members to attend short intensive courses in advanced science and technology.” [1]
The summer conferences included courses in Human Factors EngineeringVision and Visual Displays Biomechanics in Task Design Human Information Processing Concepts. Lecturers included University of Michigan faculty and visiting lecturers such as Dr. Stuart Card from the Xerox Corporation, Palo Alto, California. Engineering Summer Conferences were extremely well attended by engineers across the country and the program lasted over thirty years. [2]
The IBM 650 "was the beginning of routine, large scale research and instructional computing at the University. Faculty members and students devised a language to maximize the machine's capabilities called GAT (Generalized Algorithmic Translator), which greatly increased the utility of the computer for the university community. The IBM 650 was installed in the Statistical Research Lab.
Through the IBM Educational Contribution Program, IBM donated up to 60% of the monthly payment owed on a computer to the university, contingent on the university's agreeing to offer courses in scientific computation and data processing.
The Logic of Computers Group was established as a research collective of faculty with an interest in the relationship between logical formalisms, computers and natural systems. The group was funded by government research agencies and provided "more than half of the research support in the Department of Computer Science." The Group employed several senior researchers, including Dr. Richard A. Laing.
Before joining the UM faculty in 1946, Burks was one of the principal designers and a joint inventor of the Electronic Numerical Integrator and Computer (ENIAC) at the Moore School of Engineering, University of Pennsylvania from 1943 to 1946. Burks came to UM as an assistant professor in the Philosophy Department, eventually becoming full professor in 1954. Among his many activities at the university, he founded the Logic of Computers Group in 1956 and the graduate program in Communication Sciences in 1957.
The Communication Sciences graduate degree program was formed within the College of Literature, Science and the Arts. The program had its roots in two research groups: the Phonetics Laboratory in the Dept. of Speech, and the Logic of Computers Group in the Dept. of Philosophy. The objective of the program "was to understand information processing and communication in both natural and engineered systems." Core curriculum offerings included automata theory, information and probability theory, and analog and digital computers. Arthur Burks was an integral player in developing the program, which enrolled three students in its first year. UM was the first to establish an interdisciplinary program in Communication Sciences, and the first program to award a Ph.D. in 1959, to John Holland. The course offerings first appear in the 1958-59 College of Engineering Announcement. Gordon Peterson served as chairman of the program until it became a department in 1965.
Courses initially offered included: EE232 Analog and Digital Computer Technology; EE235 Digital Computer Design Principles; EE238 Digital Computer Applications
The IBM 704 was the first computer installed at Computing Center. President's Report, 1959-1960. Research News 27, no 1, (January 1976), Division of Research Development and Administration.
Robert Christian Frank Bartels was a professor of Mathematics when he was appointed the first director of the Computing Center. He came to the university in 1938, and was made a full professor in 1957. His research field was numerical analysis, which led him to be involved in many early computing projects, including a study of magnetohydrodynamics at the Oak Ridge National Laboratory in 1954. He served as director of the Computing Center for nearly 20 years, retiring in 1978.
The Institute of Science and Technology was founded by the Board of Regents to provide organizational support for researchers in the sciences and engineering. The Regents' goal was to establish a center that would draw on university faculty expertise and that would cooperate with other private and public institutions in the state. Robert R. White served as director until 1960.
The Ford Grant awarded U-M with a $900,000 three-year grant to "enrich engineering education." It was reported in the Board of Regents meeting that the president "anticipated that the conditions of the grant would make it possible for the University to become a center at which visiting faculty members from other institutions and predoctoral teaching interns may be instructed in the use of computing devices."
The University of Michigan Executive System (UMES) was designed to "facilitate the running of a large number of programs rapidly and efficiently." The system was adapted from a system being used by General Motors by GM staff and Professor Bernard Galler. UMES was used until 1968.
The IBM 7090 "was a transistorized, or solid-state, version of the 709."
The ICPR was a partnership between the Institute for Social Research and twenty-one other universities to provide data support for research in the the social sciences. Warren Miller served as the first director. Now called the Inter-university Consortium for Social-Political Research (ICPSR), it provides access to world's largest archive of computer-based and instructional data for the social sciences.
Dean Haber reported to the Regents that "an entirely new and revolutionary field of study is emerging from several disciplines, each of which has interest in information processing and adaptive systems".
The Merit Network proposal pushed for the creation of an educationally-focused computer network of academic institutions in Michigan. The proposal was written by Stanford Ericksen, the director of the Center for Research on Learning and Teaching, along with Karl Zinn, research scientist.
The Interuniversity Communications Council, later called EDUCOM, was a non-profit organization devoted to the study and implementation of information technology in higher education.
The Ad Hoc Committee, chaired by Donald Katz, advised Vice President Heyns and A.G. Norman on the use and implementation of computers at UM.
The UCCPU grew out of the Ad Hoc Computing Advisory Committee. It provided university administrators with assessments of policies on computing, and investigated ethical concerns rising from the use of computers on campus. It was disbanded in 1985.
Donald LaVerne Katz was a professor of Chemical Engineering at the University of Michigan, starting in 1936. He served as chairman of the Department of Chemical and Metallurgical Engineering from 1951 to 1962. His fields of expertise included underground storage systems and reservoir engineering. He played an active role in the promulgation and use of computers at the University of Michigan particularly in their application to engineering education.
The IBM 360/67 was eight times faster than the previous IBM 7090. The 360/67, however, did not come with a time-sharing operating system. Due to the high demand for this functionality, Computing Center staff designed the Michigan Terminal System (MTS), a program to maximize the efficiency of the computer. The 360/67 was in operation until 1974.
Under the direction of Frank Westervelt, the CONCOMP Project or "Research in the Conversational Use of Computers," involved the design and testing of computer programs for graphical input of problem statements and graphical output of results.
This committee was a research collaboration between the University of Michigan, Wayne State University, and Michigan State University.
Computing Center staff developed an easy-to-use computer language and computer controlling program called MAD Michigan Algorithm Decoder. The programming language was designed to handle a very large number of "relatively small student problems" quickly and efficiently. The Department of Defense Advanced Research Projects Agency provided $1,300,00 for the development of the language.
MERIT was formed out of the Michigan Inter-university Committee on Information Systems. It's mission was to research the effects and possibilities of connecting large research universities together by means of a computer network.
MTS worked as a timesharing system for use on the University's IBM 360/67, allowing for efficient multi-user access to computation. The system was designed by senior staff member Michael Alexander, and was used by other universities in the U.S. and abroad.
The Department of Communication Science's was renamed the Department of Computer and Communication Sciences. The Department was within the College of Literature, Science and Arts.
Campus computing use slowly moved away from the mainframe model as departments and staff began to acquire their own "minicomputers" (also referred to as "microcomputers").
The Computing Center moved from the North University Building (NUBS) into a new building on the corner of Beal Ave. and Glazier Way. The new building featured elevated (false) floors that allowed the computer cables, electrical services and over 900 telephone lines to be safely tucked inside.
The Computer Registration Involving Student Participation (CRISP) concept formed through UM computer course, CSS673, taught by Professor Bernard Galler. The class developed the concept for a computerized system by which they could enroll in classes. CRISP was initiated as the official method of course registration in 1975.
The State Legislature establishes the Environment Research Institute of Michigan (ERIM) and all Willow Run personnel, facilities, and projects disassociate from the University of Michigan, and transfer to this organization.
The IBM 370/168 replaced the IBM 360/67, which had become overloaded. The new IBM was installed at the end of fall term 1974. The 370/168 was, on average, six times greater than that of a single processor on the 360/67." Michigan installed one processor for the 370/168, increasing the CPU capacity by three.
Ph.D. student Robert Parnes developed a conferencing software program called CONFER as "an alternative to face-to-face-communication" for partial fulfillment of his doctoral degree in Philosophy. The first CONFER was called K4HS:RP.Confer. Subsequent confers included ARCH:FORUM, and the first student CONFER was called MEET:STUDENTS. CONFER was widely used by faculty, students and staff until 1999.
The new Amdahl model was used with MTS. This computer was twice as fast as the previous IBM 370/168 mainframe.
Aaron Finerman came to the University of Michigan as director of the Computing Center and professor of Computer and Communication Sciences in 1978 from SUNY Stonybrook. He served as director of the Computing Center until 1986, and became professor emeritus in 1990. He continued to teach for several terms after his retirement.
The "message system may be used to send messages from one user to another user. There are commands to compose and send message, to retrieve and reply to messages, and to display the status of existing messages." Users entered the system by the $MESSAGE command.
The Conference on Easier and More Productive Use of Computers was co-sponsored by the Association of Computing Machinery (ACM), the Special Interest Group on the Social and Behavioral Science of Computing (SIGSOC), and ICPSR. It was held at UM in May 1981. The conference focused on the quality of human interfaces and characteristics of database applications.
The Computing Center scheduled the purchase the Amdahl 5860 for the fall of 1982, to replace the Amdahl 470/ V/8. The new system included 24 megabytes of main memory. The University of Michigan was the first to receive a production model of this mainframe.
The Industrial Technology Institute "serves as a link between academic research and industrial implementation in collaborative ventures with industry." The Institute was a publicly supported, not-for-profit corporation. The UM provided facilities for the center during its first few years and then the Institute built a facility on Baxter Road in 1986.
Through seminars and demonstrations from different vendors on personal computer usage, the Business School began to encourage the use of personal computers, marking the gradual switch from MTS.
UM piloted the Mailnet project, which linked the electronic mail systems in place at several universities" Mailnet will create a technically sound, intercampus electronic mail system for use by scholars, researchers, faculty, and administrators." (Computing Center Newsletter, 1982) The system functioned using the $MESSAGE commands.
CAEN began as part of a plan to expand and intensify the research activities of the College of Engineering in technology management, computer aided engineering and communication.
The Regents and Vice Provost Van Houweling realized the University's need for an administrative structure to support their growing implementation of information technology. The Information Technology Division was formed as an consolidation of several existing technology departments, including the Computing Center, the Office of Administrative Systems, the Center for Information Technology Integration, and the Office of Instructional Technology.
Van Houweling was responsible for the University's strategic direction in information technology in a quickly changing computing environment. In addition to his position as Vice Provost for Information Technology, he was also chairman of the board of MERIT, Inc. when the NSF awarded MERIT the responsibility for management of NSFNET in partnership with IBM, MCI and the Michigan Strategic Fund in 1987. He stepped down as Vice Provost for Information Technology in 1997 when he became the president of UCAID, a consortium of more than 100 universities working with corporate partners and federal agencies to develop Internet2.
The Department of Computer and Communication Sciences ended its affilitation with the College of Literature, Science and the Arts and merged with the Department of Electrical and Computer Engineering to form the department of Electrical Engineering and Computer Sciences (EECS), part of the College of Engineering.
GEAC was the library's first online circulation system available through UMNet. This system contained only the last 8 years of acquisitions and the card catalog remained the "authoritative source" on library holdings. It functioned using the message command: $RUN UNSP:NET PAR-UMLIB.
Dr. Richard Dougherty outlined to the Board of Regents the plan to develop a fully automated library system. Dougherty noted that "when the system becomes a reality, it will allow anyone who has a microcomputer, personal computer to computer terminal that is linked into the campus computer system to access the information in the library's data base."
The laboratory was founded to "further the research and training opportunities in areas of cognitive science and machine intelligence." Professor Gary M. Olson served as director. In 1988 the Regents approved a project to build a Collaboration Technology Suite for the Laboratory in the Business School. Box 1, Cognitive Science and Machine Intelligence Laboratory Records.
In September 1985, a pilot program called ResComp was started in one residence hall. By January 1986, it had expanded to all residential living halls. The primary focus of the program was "to provide educational services for students living in the UM residence halls." The project included a "research program aimed in part at identifying students' computing needs, expectations, and experiences."
The Information and Technology Division used a donated mainframe computer to run the UB MTS system and provide computing accounts to all UM Students, faculty, and staff for the first time.
This new service provided staff members with access to common computing resources like email and word processing.
Regents approve the purchase of the IBM 3090-400 for the Computing Center.
Carolyn Autry-Hunly replaced Aaron Finerman as Director of the Computing Center.
The Center was formed for the purpose of "advanced development and research projects, in partnership with external sponsors" aimed to enhance the University's information technology environment.
The first Mac Truck sale was held February 7 and 8 at the old main hospital. The MacTruck weekend was the largest delivery ever made by Apple to one location. It was also the largest single distribution of any personal computer.
The MERIT Network, under the direction of Eric Aupperle, was awarded oversight of the National Science Foundation's NSFNet. The network would connect thousands of researchers in the sciences and technology at seven regional networks to six NSF supercomputer centers, allowing them to share data, exchange graphics and simulations, and enhance their ability to collaborate. The NSFNet contract resulted in the expansion of MERIT's facilities at the University of Michigan's Computing Center and in the hiring of many more employees, including a 24 hour operations staff.
James J. Duderstadt, 11th president of the University of Michigan, came to the university as an assistant professor of nuclear engineering in 1969. He was known for his "infectious confidence in the ability of educated people to build and control their own futures." His vision for the future was dominated by three elements: knowledge, globalization and pluralism. He was the first University president to bring a personal computer into the Office of the President, and strategically laid the groundwork to ensure that the University was "wired" for the 21st century.
A series of seminars on artificial intelligence were held by the Department of Electrical Engineering and Computer Science.
A "transparent" file transfer system, dubbed IFS was designed to facilitate the transfer and sharing of files between campus computers. IFS was developed with IBM and was implemented by the Center for Information Technology Integration, part of ITD Research Systems. The project "provided file storage and file services to all workstations on campus and was anticipated on more than 30,000 machines. The IFS is a first of its kind system, one that could be used as a model by other universities and businesses whose computing systems link heterogeneous mainframes, minicomputers, and workstations running many different operating systems."
UM Library System put its card catalog into the Michigan Research Library Network (MIRLYN), an electronically searchable card catalog. The system was officially dedicated September 20, 1988. Robert Warner, interim director of the UM library called the arrival of MIRLYN "one of the most important developments in the history of the university library." The conversion of the card catalog was completed in June 1991. The system initially ran on the computing center's IBM 3090-600E available through Merit/UMNet. The effort was funded by a grant from the W.K. Kellogg Foundation, and UM was "one of the few major research libraries to have completed record conversion for its online public catalog" at the time of its release. The library was also the "only large research library known at this time to have completed conversion of its holdings for Chinese, Japanese, Korean as well as Middle East, South Asia and South East Asia program materials."
UMLIBTEXT project, under the direction of John Price-Wilkin, was a pioneering library project to digitize literary, philosophical and historical texts.
The Angell Hall Courtyard, or "Fishbowl" was converted into a computing center as part of the Regent's 1985 plan to grant all students computer access. The new computing cluster, housing 330 computers, was one of the largest single installations of computers in the country.
The Information Technology Division began installation of a fiber optic network as the first phase of a high-speed computer network. The Network acted as a campus-wide backbone network, supporting the widely used Internet TCP/protocols. The network was a "Proteon ProNET-80 high-performance, fiber optic token ring." Transmission speed for the network was reported to be 80 million bits per second.
The Executive Computing Committee (ECC) charged the Strategic Data Planning (SDP) project committee with developing a comprehensive strategy to integrate University administrative data systems and to streamline business processes across organizational boundaries.
CRISP, a course registration system originally designed in 1972, began to use technology which allowed students to register for courses through a touch-tone telephone. The system had been developed and implemented at other American universities.
The Wolverine Access program, developed by ITD, the Registrar's Office, and the Wolverine Access Development Team allowed student access to grades, class schedule, academic report, availability of classes, and account statements. Eventually released online in 1996, it was first available via client server using Macintosh machines at campus computing sites.
The Program for the Study of Complex Systems was established in 1995. Robert Savit served as the first director, and founding members included Arthur Burks, Bob Axelrod, Michael Cohen, and John Holland. The goals of the program included encouraging research in complex adaptive systems and exploring the boundaries and overlaps between the complex systems approach and more traditional approaches. The program became the Center for the Study of Complex Systems in 1999 under the directorship of Carl Simon. In July 2005, the center became a part of the College of Literature, Science and Art.
The SDP report identified more than 55 data and processing projects and 12 projects focused on technical infrastructure improvements operating throughout the university. It recommended that University should integrate databases to facilitate sharing data across organizational boundaries.
Jose Marie-Griffiths came to UM from the University of Tennessee, where she was a professor in the field of Information Sciences. As the new director of the Institutional Technology Division, and the university's Chief Information Officer, Griffiths was responsible for providing strategic planning for technology initiatives at the university, as well as establishing collaborations with schools and administrative departments across the community.
The Media Union opened in the Summer of 1996. The new 250,000 square foot building on North Campus was built to house a variety of multimedia programs such as virtual reality labs, digital libraries, and audio/visual performance and design studios. The building also currently houses the Art Architecture and Engineering Library. In 2003 the Media Union was named for James and Anne Duderstadt in honor of "Jim Duderstadt's deep interest in fostering creativity, engaging with new forms of technology, and developing new ways of learning." (University Record)
The School of Information and Library Studies was rechartered as the School of Information (SI), broadening its mission to study the role of information in computation, cognition, communication and community. Daniel Atkins served as the first dean of the newly named school until 2000, when John L. King was appointed.
The M-Pathways Project was charged with the design and implementation of new administrative information systems. Laura Patterson, Project Manager for M-Pathways stated, "what we are talking about is changing the way the University conducts its administrative processes so that they better serve our students, staff, faculty and citizens of the state."
The PeopleSoft contract was part of the university's interest in streamlining financial, human resources, and student information systems, as well as concern about the impact of Y2K on current systems. "The University's effort to find a new system was hastened by the fact that many of its current systems will not operate correctly in the year 2000 because of the way they store dates". (Record, pg. 11).
Laura Patterson, the University Registrar, was appointed Project Manager of M-Pathways, the UM effort to implement computerized administrative systems. In addition to the project team, Anderson Consulting, Inc. supplied additional resources, particularly guidance in "change management".
The Asset Management module release allowed information on university equipment and property to be shared between departments and units, making tracking of items easier and more efficient. This module was first released within the UM Hospital System, and was then made available to the greater campus community.
In response to the Regents' request, the Year 2000 Information Campaign formed. Led by Jose Marie-Griffiths, the group raised campus awareness about possible consequences of Y2K, and helped to alleviate potential problems caused by the millennium.
The Student Administration module included the Financial Resources System, and Recruiting and Admissions systems.
"Life After M-Pathways" helped the university to transition from the project phase to the organizational phase of the M-Pathways program.
The Michigan Administrative Information Services was created in order to provide support to schools and units for new information technology systems, such as M-Pathways.
Patterson was appointed Vice President for Administrative Systems after serving as University Registrar from 1993-1996, and director of the M-Pathways program since 1996. In her new position she would direct Michigan Administrative Information Services, an organization formed to help administrative units utilize new information technology after M-Pathways.
The final module to be released, student business was completely rolled out, with the exception of the Degree Audit module.
With the implementation of a new form of Wolverine Access, students were able to register for classes online for the first time.
President Bollinger appointed Stephen Director, dean, College of Engineering and John King, dean, School of Information to "think broadly about how the University should respond to the information revolution." The 27 member commission and four subcommissions surveyed the strengths and weaknesses of the university's use of technology.
The University pilots UM Wireless internet access, launching in the Hatcher Graduate Library, the Shapiro Undergraduate Library, and Angell Hall.
The University of Michigan undertook grid computing with the Michigan Grid Research and Infrastructure Development Project (MGRID). Grid computing would allow the sharing not only of information, but of resources, services, and other tools, as well.
The University of Michigan and IBM partnered to develop a Data Asset Management System (DAMS). The system was designed to make the University's digital content easier to access and use.
The Sakai project was a landmark venture to create open-source course management tools. Funded by a 2.3 million dollar grant from the Mellon Foundation, Sakai was directed by Joseph Hardin, also director of the Collaborative Technologies Laboratory at the Media Union.
Michigan State University, University of Michigan, and Wayne State University developed the Michigan LambdaRail (MiLR), a high-performance network capable of transmitting large amounts of data, to help the three universities with their research needs.
On December 14, 2004, the University announced a joint partnership with Google to make 7 million volumes from UM libraries available digitally. Books will be scanned and made searchable, and materials beyond copyright will be available in full-text. The University serves as a site for testing Google's non-destuctive scanning technology and digitization workflow, and was the first site to implement such technology.
The University Library, in partnership with Bentley Historical Library and Information Technology Central Services (ITCS), provide a blogging platform for current faculty, students and staff. The system known as Mblog utilizes Moveable Type software. The system includes an archival component so that bloggers may elect to have their inactive blog appraised for the University Archives.
Starting in Fall of 2005, the University switched over to an online grade submission for all faculty, making the process faster, more efficient, and paperless.
UM researchers produced what was believed to be the first scalable quantum computer chip.
Deep Blue provides public online access to various items of research by University of Michigan scholars. The system is free and searchable and provides digital preservation for unpublished research documentation.
Approval was given for the lease of space in a complex that would house an offsite data center for computing needs, called the Michigan Academic Computing Center. The complex also housed the Michigan Information Technology Center Foundation, Internet2 and the Merit Network.
The College of Literature, Science and the Arts launched a 1.5 million expansion of its wireless network that will bring wireless Ethernet to all classrooms, departments, laboratories and faculty offices within the next 2 years.
The University of Michigan partnered with Google’s Climate Savers program as part of a commitment to ensure campus computers met energy efficiency standards.
Virtual Sites, developed by ITCS, provided the University community remote access to software and printing.
Michigan on iTunes U is launched, providing free access to University lectures, debates, performances, and events through the iTunes store.
The Phoenix Processor, a microchip that uses less power than other chips on the market, is developed at the University of Michigan.
UM researchers, along with researchers at the U.S. Naval Research Laboratory and the University of California at San Diego, demonstrated the fastest quantum computer.
ITCS launched Maize to provide a more attractive interface , new features, and accessibility. Blue, the older email service released in 2002, continued to operate alongside Maize.
A consortium of the nation’s largest research libraries collaborated to create a repository for their digital collections. The repository, called HathiTrust, provides greater access to digital content.
An electrical engineer at UM built a chip composed of nanoscale memristors capable of storing up to 1 kilobit of information, a step towards making the technology scalable.
MWireless is launched, providing faculty, staff, and students access to a secure wireless internet connection.
Virtualization as a Service, which had limited availability previously, expands across the Ann Arbor campus, allowing administrators the functions of a server without actually having one.
A course studying how to turn iPhones into musical instruments is taught for the first time on campus. The class ends with a concert performance.
The University launched NextGen Michigan, a multi-year strategy intended to use advanced technology to further the University’s mission. The strategy has 4 components: moving to a shared services model, creating alignment that includes instituting an IT Governance Structure, the rationalization of IT, and enabling units to focus on technology that differentiates their school or college.
As part of NextGen, a campus wide assessment of IT is conducted. Known as IT Rationalization, the project was designed to determine the best sources for IT services, reduce redundancies, and improve interoperability.
A free iPhone app that provides access to news, events and other university information is created.
CIRRUS, or Computing and Information Resources for Research as a Utility Service, initiative is undertaken. The Initiative, a part of NextGen, will become the foundation for research cyberinfrastructure at the University.
Researchers in the college of LS&A and the College of Engineering piloted a high-performance computing cluster called FLUX. A component of CIRRUS, FLUX delivers research computing resources to users more efficiently and effectively.
University appoints task force to investigate privacy and security in cloud computing. The task force issued a report identifying issues with and recommendations for cloud computing.
ITS received funding for plans to establish a modular data center on North Campus.
Professors in the College of Electrical Engineering and Computer Science developed a millimeter scale computing system that monitors eye pressure in glaucoma patients.
As part of NextGen Michigan, Google is selected as the provider of collaborative tools, and the agreement between UM and Google is finalized.
As part of the IT Rationalization and Strategic Sourcing Initiatives, the University contracted with Hewlett-Packard to provide a standardized selection of laptops and desktops to the university. The contract, which was expected to save the University millions, provided options to meet the University's computing needs while creating more responsible spending. The deal did not affect ordering of Apple computers.
The rollout of Google accounts for UM students, retirees, emeritus faculty, and UM Online subscribers began as the first step in the University’s move to Google Apps for Education.
M+ Box, the University’s commercial data storage solution, became available to Ann Arbor campus faculty and staff, providing them with cloud services.
The University of Michigan starts an account on Weibo, the Chinese microblogging tool, in late April. After one week, the account already had 700 followers.