"""
Some simple logging functionality, inspired by rllab's logging.
Logs to a tab-separated-values file (path/to/output_directory/progress.txt)
"""
import json
import joblib
import shutil
import numpy as np
import tensorflow as tf
import os.path as osp, time, atexit, os
from spinup.utils.mpi_tools import proc_id, mpi_statistics_scalar
from spinup.utils.serialization_utils import convert_json
color2num = dict(
gray=30,
red=31,
green=32,
yellow=33,
blue=34,
magenta=35,
cyan=36,
white=37,
crimson=38
)
def colorize(string, color, bold=False, highlight=False):
"""
Colorize a string.
This function was originally written by John Schulman.
"""
attr = []
num = color2num[color]
if highlight: num += 10
attr.append(str(num))
if bold: attr.append('1')
return '\x1b[%sm%s\x1b[0m' % (';'.join(attr), string)
[docs]def restore_tf_graph(sess, fpath):
"""
Loads graphs saved by Logger.
Will output a dictionary whose keys and values are from the 'inputs'
and 'outputs' dict you specified with logger.setup_tf_saver().
Args:
sess: A Tensorflow session.
fpath: Filepath to save directory.
Returns:
A dictionary mapping from keys to tensors in the computation graph
loaded from ``fpath``.
"""
tf.saved_model.loader.load(
sess,
[tf.saved_model.tag_constants.SERVING],
fpath
)
model_info = joblib.load(osp.join(fpath, 'model_info.pkl'))
graph = tf.get_default_graph()
model = dict()
model.update({k: graph.get_tensor_by_name(v) for k,v in model_info['inputs'].items()})
model.update({k: graph.get_tensor_by_name(v) for k,v in model_info['outputs'].items()})
return model
[docs]class Logger:
"""
A general-purpose logger.
Makes it easy to save diagnostics, hyperparameter configurations, the
state of a training run, and the trained model.
"""
[docs] def __init__(self, output_dir=None, output_fname='progress.txt', exp_name=None):
"""
Initialize a Logger.
Args:
output_dir (string): A directory for saving results to. If
``None``, defaults to a temp directory of the form
``/tmp/experiments/somerandomnumber``.
output_fname (string): Name for the tab-separated-value file
containing metrics logged throughout a training run.
Defaults to ``progress.txt``.
exp_name (string): Experiment name. If you run multiple training
runs and give them all the same ``exp_name``, the plotter
will know to group them. (Use case: if you run the same
hyperparameter configuration with multiple random seeds, you
should give them all the same ``exp_name``.)
"""
if proc_id()==0:
self.output_dir = output_dir or "/tmp/experiments/%i"%int(time.time())
if osp.exists(self.output_dir):
print("Warning: Log dir %s already exists! Storing info there anyway."%self.output_dir)
else:
os.makedirs(self.output_dir)
self.output_file = open(osp.join(self.output_dir, output_fname), 'w')
atexit.register(self.output_file.close)
print(colorize("Logging data to %s"%self.output_file.name, 'green', bold=True))
else:
self.output_dir = None
self.output_file = None
self.first_row=True
self.log_headers = []
self.log_current_row = {}
self.exp_name = exp_name
[docs] def log(self, msg, color='green'):
"""Print a colorized message to stdout."""
if proc_id()==0:
print(colorize(msg, color, bold=True))
[docs] def log_tabular(self, key, val):
"""
Log a value of some diagnostic.
Call this only once for each diagnostic quantity, each iteration.
After using ``log_tabular`` to store values for each diagnostic,
make sure to call ``dump_tabular`` to write them out to file and
stdout (otherwise they will not get saved anywhere).
"""
if self.first_row:
self.log_headers.append(key)
else:
assert key in self.log_headers, "Trying to introduce a new key %s that you didn't include in the first iteration"%key
assert key not in self.log_current_row, "You already set %s this iteration. Maybe you forgot to call dump_tabular()"%key
self.log_current_row[key] = val
[docs] def save_config(self, config):
"""
Log an experiment configuration.
Call this once at the top of your experiment, passing in all important
config vars as a dict. This will serialize the config to JSON, while
handling anything which can't be serialized in a graceful way (writing
as informative a string as possible).
Example use:
.. code-block:: python
logger = EpochLogger(**logger_kwargs)
logger.save_config(locals())
"""
config_json = convert_json(config)
if self.exp_name is not None:
config_json['exp_name'] = self.exp_name
if proc_id()==0:
output = json.dumps(config_json, separators=(',',':\t'), indent=4, sort_keys=True)
print(colorize('Saving config:\n', color='cyan', bold=True))
print(output)
with open(osp.join(self.output_dir, "config.json"), 'w') as out:
out.write(output)
[docs] def save_state(self, state_dict, itr=None):
"""
Saves the state of an experiment.
To be clear: this is about saving *state*, not logging diagnostics.
All diagnostic logging is separate from this function. This function
will save whatever is in ``state_dict``---usually just a copy of the
environment---and the most recent parameters for the model you
previously set up saving for with ``setup_tf_saver``.
Call with any frequency you prefer. If you only want to maintain a
single state and overwrite it at each call with the most recent
version, leave ``itr=None``. If you want to keep all of the states you
save, provide unique (increasing) values for 'itr'.
Args:
state_dict (dict): Dictionary containing essential elements to
describe the current state of training.
itr: An int, or None. Current iteration of training.
"""
if proc_id()==0:
fname = 'vars.pkl' if itr is None else 'vars%d.pkl'%itr
try:
joblib.dump(state_dict, osp.join(self.output_dir, fname))
except:
self.log('Warning: could not pickle state_dict.', color='red')
if hasattr(self, 'tf_saver_elements'):
self._tf_simple_save(itr)
[docs] def setup_tf_saver(self, sess, inputs, outputs):
"""
Set up easy model saving for tensorflow.
Call once, after defining your computation graph but before training.
Args:
sess: The Tensorflow session in which you train your computation
graph.
inputs (dict): A dictionary that maps from keys of your choice
to the tensorflow placeholders that serve as inputs to the
computation graph. Make sure that *all* of the placeholders
needed for your outputs are included!
outputs (dict): A dictionary that maps from keys of your choice
to the outputs from your computation graph.
"""
self.tf_saver_elements = dict(session=sess, inputs=inputs, outputs=outputs)
self.tf_saver_info = {'inputs': {k:v.name for k,v in inputs.items()},
'outputs': {k:v.name for k,v in outputs.items()}}
def _tf_simple_save(self, itr=None):
"""
Uses simple_save to save a trained model, plus info to make it easy
to associated tensors to variables after restore.
"""
if proc_id()==0:
assert hasattr(self, 'tf_saver_elements'), \
"First have to setup saving with self.setup_tf_saver"
fpath = 'simple_save' + ('%d'%itr if itr is not None else '')
fpath = osp.join(self.output_dir, fpath)
if osp.exists(fpath):
# simple_save refuses to be useful if fpath already exists,
# so just delete fpath if it's there.
shutil.rmtree(fpath)
tf.saved_model.simple_save(export_dir=fpath, **self.tf_saver_elements)
joblib.dump(self.tf_saver_info, osp.join(fpath, 'model_info.pkl'))
[docs] def dump_tabular(self):
"""
Write all of the diagnostics from the current iteration.
Writes both to stdout, and to the output file.
"""
if proc_id()==0:
vals = []
key_lens = [len(key) for key in self.log_headers]
max_key_len = max(15,max(key_lens))
keystr = '%'+'%d'%max_key_len
fmt = "| " + keystr + "s | %15s |"
n_slashes = 22 + max_key_len
print("-"*n_slashes)
for key in self.log_headers:
val = self.log_current_row.get(key, "")
valstr = "%8.3g"%val if hasattr(val, "__float__") else val
print(fmt%(key, valstr))
vals.append(val)
print("-"*n_slashes)
if self.output_file is not None:
if self.first_row:
self.output_file.write("\t".join(self.log_headers)+"\n")
self.output_file.write("\t".join(map(str,vals))+"\n")
self.output_file.flush()
self.log_current_row.clear()
self.first_row=False
[docs]class EpochLogger(Logger):
"""
A variant of Logger tailored for tracking average values over epochs.
Typical use case: there is some quantity which is calculated many times
throughout an epoch, and at the end of the epoch, you would like to
report the average / std / min / max value of that quantity.
With an EpochLogger, each time the quantity is calculated, you would
use
.. code-block:: python
epoch_logger.store(NameOfQuantity=quantity_value)
to load it into the EpochLogger's state. Then at the end of the epoch, you
would use
.. code-block:: python
epoch_logger.log_tabular(NameOfQuantity, **options)
to record the desired values.
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.epoch_dict = dict()
[docs] def store(self, **kwargs):
"""
Save something into the epoch_logger's current state.
Provide an arbitrary number of keyword arguments with numerical
values.
"""
for k,v in kwargs.items():
if not(k in self.epoch_dict.keys()):
self.epoch_dict[k] = []
self.epoch_dict[k].append(v)
[docs] def log_tabular(self, key, val=None, with_min_and_max=False, average_only=False):
"""
Log a value or possibly the mean/std/min/max values of a diagnostic.
Args:
key (string): The name of the diagnostic. If you are logging a
diagnostic whose state has previously been saved with
``store``, the key here has to match the key you used there.
val: A value for the diagnostic. If you have previously saved
values for this key via ``store``, do *not* provide a ``val``
here.
with_min_and_max (bool): If true, log min and max values of the
diagnostic over the epoch.
average_only (bool): If true, do not log the standard deviation
of the diagnostic over the epoch.
"""
if val is not None:
super().log_tabular(key,val)
else:
v = self.epoch_dict[key]
vals = np.concatenate(v) if isinstance(v[0], np.ndarray) and len(v[0].shape)>0 else v
stats = mpi_statistics_scalar(vals, with_min_and_max=with_min_and_max)
super().log_tabular(key if average_only else 'Average' + key, stats[0])
if not(average_only):
super().log_tabular('Std'+key, stats[1])
if with_min_and_max:
super().log_tabular('Max'+key, stats[3])
super().log_tabular('Min'+key, stats[2])
self.epoch_dict[key] = []
[docs] def get_stats(self, key):
"""
Lets an algorithm ask the logger for mean/std/min/max of a diagnostic.
"""
v = self.epoch_dict[key]
vals = np.concatenate(v) if isinstance(v[0], np.ndarray) and len(v[0].shape)>0 else v
return mpi_statistics_scalar(vals)


Submit
Team Name
Name (Team Head)
Registration Number
Branch/Specialization
Semester
Institution
Phone Number
Email ID
Upload a file:
Team Name
Name (Team Head)
Registration Number
Branch/Specialization
Semester
Institution
Phone Number
Email ID
Upload a file:


I am a passionate, detail-oriented Web Developer with relentless curiosity and a love of elegant solutions.
My background in medical speech-language pathology gears me towards methodical problem-solving and empathy. Working with patients in rehabilitation taught me about the value of human connection, which I strive to bring to the way we experience the web.
I also have an academic background in linguistics, which cultivated a passion for understanding how language works -- a passion which has expanded to include computer languages as well as human ones.
I've spent the past three months immersing myself in learning the fundamentals of web development at General Assembly, and I'm thrilled to continue that journey of learning, growing, and building.
Here are some recent projects.
The Wind Rises is an application designed for travelers who want to log, plan, and show the trips they've taken, whether across the country or around the world! My love for traveling informed this app's design process and features were built based on useful tools that I've always wanted easily accessible while on trips. While planning this project, I knew I wanted to build something practical, easily accessible, and useful for an avid traveler.
Whether going on a month-long backpacking trip through Asia, or just getting home from a cross-country road trip, travelers are often asked the questions "where have you been?" and "where are you going next?" The Wind Rises was designed to be a visual aid to answering that question. Travelers can create trips, log a chronological collection of stops they made along their journey, and see all of their stops plotted on an interactive map.
Travelers should also be able to leverage the power of portable technology to while abroad, and I wanted to design app functionality that is useful to the traveler during the journey. To that end, I incorporated several third-party APIs to compile real-time weather data for each stop, a translation feature, and an image to text (optical character recognition) feature that translates text from an image file into English and displays both the native text and translated text.
Check out the GitHub Repo for more techincal details or to check out the code.
Anything but Trivial began as a group project which was completed by myself and three other devlopers in three days. Working on a team was an excellent way to experience contributing to a codebase with multiple authors, and I served as the version-control lead for my team. I absolutely grew as a developer in my understanding of version control and of the power of git.
This project was created using full-stack JavaScript, and we chose to use a non-relational database (MongoDB) to take advantage of nested sub-documents, which made sense for the question/answer data we were persisting to the database. We also utilized Mongoose to add some structure and quasi-relationships to documents.
After the project, I wanted to continue working on the project, which became a complete overhaul of the GUI, a reworking of the database schema, and lots of experience gained along the way. Check out the README for links to the project before my revisions.
TASK is my first true full-stack single page web application. Built using a Rails backend with nested routes as API endpoints, I was able to dive into building a true relational database.  There are also myriad examples of to-do apps, which both helped me gain inspiration as well as allow me to rely on convention and focus on the development process. This project was built from the ground-up in 4 days.
View the app in a new tab* or check out the GitHub repo.Tic Tac Toe was my first project while at General Assembly. Since I was new to programming, I focused on keeping code clean and well commented, being diligent in version control, and managing the scope of the project. I keep this project on my portfolio to showcase how far I've come since beginning my journey as a developer.
Try playing the embedded game! If you really want a challenge, click the hashtag (#) in the game to play against AI.
View deployed game in a new tab or check out the GitHub repo.


Finding Lost & Found: Designer ’s Notes from the Process of Creating a Jewish Game for Learning
This article provides context for and examines aspects of the design process of a game for learning. Lost & Found (2017a, 2017b) is a tabletop-to-mobile game series designed to teach medieval religious legal systems, beginning with Moses Maimonides’ Mishneh Torah (1180). The aim of this article is to provide insight into a number of the specific decisions faced by the design team in the creation of the first game in the series. Creating games for learning is always a dual-design process, that of creating an engrossing game system for the players while also following the research in games and learning, focusing on enhancing formal and informal learning environments...


VR200 works with applications for the effective use and management of sales and customer data. These applications provide powerful support for the centralized management and analysis of information. *Applications are not preinstalled. Sold separately.
Additional highlights of the V-R200 include the 10.4" operator color touch screen, a built-in 80mm thermal printer, a pop-up 2x20 customer display, an Ethernet port for high speed communications between terminals and the internet, multiple serial ports for peripheral connectivity, cash connector and an SD Card for program ...


The solutions given below are just one way of obtaining the desired plots! There are probably several different ways you could code to get the same plots.
For the exercises in the first two lab sessions: R introduction
and the ggplot basics 1
, all you need to do is to replace the filename raw_counts.txt
with each of the different files to look at the differences between different normalization methods.
Task Plot 1:
gc_raw <- read.table(file = "data/counts_raw.txt", sep = "\t", header = T)
gc_filt <- read.table(file = "data/counts_filtered.txt", sep = "\t", header = T)
gc_vst <- read.table(file = "data/counts_vst.txt", sep = "\t", header = T)
gc_deseq <- read.table(file = "data/counts_deseq2.txt", sep = "\t", header = T)
md <- read.table("data/metadata_raw.csv", header = T, sep = ";")
gene_counts_all <-
gc_raw %>% gather(Sample_ID, Raw, -Gene) %>%
full_join(gc_filt %>% gather(Sample_ID, Filtered, -Gene), by = c("Gene", "Sample_ID")) %>%
full_join(gc_vst %>% gather(Sample_ID, VST, -Gene), by = c("Gene", "Sample_ID")) %>%
full_join(gc_deseq %>% gather(Sample_ID, DESeq2, -Gene), by = c("Gene", "Sample_ID")) %>%
gather(Method, count, Raw:DESeq2) %>%
filter(!is.na(count)) %>%
full_join(md, by = "Sample_ID")
gene_counts_all$Time <- factor(gene_counts_all$Time, levels = c("t0","t2","t6","t24"))
gene_counts_all$Replicate <- factor(gene_counts_all$Replicate, levels = c("A","B","C"))
gene_counts_all$Method <- factor(gene_counts_all$Method, levels = c("Raw","Filtered","DESeq2","VST"))
gene_counts_all %>%
group_by(Time, Replicate, Method) %>%
summarise(mean=mean(log10(count +1)),se=se(log10(count +1))) %>%
ggplot(aes(x= Time, y= mean, fill = Replicate)) +
geom_bar(position = position_dodge2(), stat = "identity") +
geom_errorbar(aes(ymin=mean-se, ymax=mean+se), position = position_dodge2(.9, padding = .6)) +
facet_wrap(~Method, scales = "free")
Task Plot 2:
gc_long %>%
group_by(Time, Replicate) %>%
summarise(mean=mean(log10(count +1)),se=se(log10(count +1))) %>%
ggplot(aes(x=Time, y=mean, color = Replicate)) +
facet_wrap(~Replicate) +
geom_line(aes(group=1), stat= "identity", size = 2) +
scale_x_discrete(limits= c("t0", "t2", "t24")) +
scale_y_continuous(limits = c(0.4,0.8), breaks = seq(0.4,0.8,0.05)) +
guides(color="none") +
ylab(label = "mean(log10(count + 1))") +
theme_light() +
theme(axis.text = element_text(face="bold", size=12),
axis.title = element_text(face="bold", color = "#C84DF9", size=14),
axis.ticks = element_blank())
p4 <- ggplot(data=iris,mapping=aes(x=Sepal.Length, y = Sepal.Width, color = Species)) +
geom_point(size = 3, alpha = 0.6) +
theme_classic(base_size = 12) +
border()
d1 <- ggplot(data=iris,mapping=aes(Sepal.Length, fill = Species)) +
geom_density(alpha = 0.6) +
theme_classic() +
clean_theme() +
theme(legend.position = "none")
d2 <- ggplot(data=iris,mapping=aes(Sepal.Width, fill = Species)) +
geom_density(alpha = 0.6) +
theme_classic() +
clean_theme() +
theme(legend.position = "none") +
rotate()
ggarrange(d1, NULL, p4, d2,
ncol = 2, nrow = 2, align = "hv",
widths = c(3, 1), heights = c(1, 3),
common.legend = TRUE)
Eigenvalues <- gc_mds$eig
Variance <- Eigenvalues / sum(Eigenvalues)
Variance1 <- 100 * signif(Variance[1], 3)
Variance2 <- 100 * signif(Variance[2], 3)
gc_mds_long <- gc_mds$points %>%
as.data.frame() %>%
rownames_to_column("Sample_ID") %>%
full_join(md, by = "Sample_ID")
gc_mds_long$Sample_Name <- factor(gc_mds_long$Sample_Name, levels = c("t0_A","t0_B","t0_C","t2_A","t2_B","t2_C","t6_A","t6_B","t6_C","t24_A","t24_B","t24_C"))
gc_mds_long$Time <- factor(gc_mds_long$Time, levels = c("t0","t2","t6","t24"))
gc_mds_long$Replicate <- factor(gc_mds_long$Replicate, levels = c("A","B","C"))
ggplot(gc_mds_long, aes(x=V1, y=V2, color = Time)) +
geom_point(size = 3, aes(shape = Replicate)) +
xlab(paste("PCO1: ", Variance1, "%")) +
ylab(paste("PCO2: ", Variance2, "%")) +
geom_vline(xintercept = 0, linetype=2) +
geom_hline(yintercept = 0, linetype=2) +
theme_bw() +
theme(panel.grid.major = element_blank(),
panel.grid.minor = element_blank())
End of document


MessageScheduler¶
Scheduler for external input messages
-
class
messageScheduler.
MessageScheduler
[source]¶ An efficient implementation of a message scheduler for the inputQueue, it supports very fast invalidations (O(1)) and fast retrievals of first element (O(log(n) in average case)
-
cleanFirst
()[source]¶ Clean all invalid messages at the front of the list. Method MUST be called before any accesses should happen to the first element, otherwise this first element might be a message that was just invalidated
-
cleanup
(time)[source]¶ Clean up the processed list, also removes all invalid elements
Parameters: time – time up to which cleanups are allowed to happen
-
extract
(model_ids)[source]¶ Extract messages from the message scheduler for when a model gets removed from this kernel.
Parameters: model_ids – iterable of model_ids of models that will be removed from this node Returns: tuple – extraction that needs to be passed to the insert method of another scheduler
-
insert
(extraction, model_list)[source]¶ Insert several messages that were created elsewhere and merge them in.
Parameters: - extraction – the output of the extract method on the other message scheduler
- model_list – models that are inserted and for which extraction happened
-
massUnschedule
(uuids)[source]¶ Unschedule several messages, this way it will no longer be processed.
Parameters: uuids – iterable of UUIDs that need to be removed
-
purgeFirst
()[source]¶ Notify that the first (valid) message must be removed
Returns: msg – the next first message that is valid
-
readFirst
()[source]¶ Returns the first (valid) message. Not necessarily O(1), as it could be the case that a lot of invalid messages are still to be deleted.
-
removeFirst
()[source]¶ Notify that the first (valid) message is processed.
Returns: msg – the next first message that is valid
-


An attractive little fishing harbour at the northern end of the east coast.
Position 15° 32'37"N, 61° 17'09"W (harbour entrance)
There is a sheltered fishing port here, but whether it has berthing for yachts is unknown.
Last updated April 2016.


Otium is a platform where people find job offers that match their abilities, knowledge and interests.
Early 2019
Apollo is a website for retail sellers, it allows them to store all the information of their businesses such as sales, inventories, etc.
Early 2019
Livre is a reading recommendation platform, it achieves this by collecting user information such as age, interests and previous readings.
Now
Machine Learning
Data mining
Cybersecurity


cvs2svn Features
The primary goal of cvs2svn is to migrate as much information as
possible from your old CVS repository to your new Subversion or git
repository.
Unfortunately, CVS doesn't record complete information about your
project's history. For example, CVS doesn't record what file
modifications took place together in the same CVS commit. Therefore,
cvs2svn attempts to infer from CVS's incomplete information what
really happened in the history of your repository. So the
second goal of cvs2svn is to reconstruct as much of your CVS
repository's history as possible.
The third goal of cvs2svn is to allow you to customize the
conversion process and the form of your output repository as flexibly
as possible. cvs2svn has very many conversion options that can be
used from the command line, many more that can be configured via an
options file, and provides many hooks to allow even more extreme
customization by writing Python code.
- No information lost
- cvs2svn works hard to avoid losing any information from your CVS
repository (unless you specifically ask for a partial conversion
using --trunk-only or --exclude).
- Changesets
- CVS records modifications file-by-file, and does not keep track
of what files were modified at the same time. cvs2svn uses
information like the file modification times, log messages, and
dependency information to deduce the original changesets. cvs2svn
allows changesets that affect multiple branches and/or multiple
projects (as is allowed by CVS), or it can be configured to split
such changesets up into separate commits
(--no-cross-branch-commits; see also options file).
- Multiproject conversions
- cvs2svn can convert a CVS repository that contains multiple
projects into a single Subversion repository with the conventional
multiproject directory layout. See the FAQ for more information.
- Branch vs. tag
- CVS allows the same symbol name to be used sometimes as a
branch, sometimes as a tag. cvs2svn has options and heuristics to
decide how to convert such "mixed" symbols
(--symbol-hints, --force-branch,
--force-tag, --symbol-default).
- Branch/tag exclusion
- cvs2svn allows the user to specify branches and/or tags that
should be excluded from the conversion altogether
(--symbol-hints, --exclude). It checks that the
exclusions are self-consistent (e.g., it doesn't allow a branch to
be excluded if a branch that sprouts from it is not excluded).
- Branch/tag renaming
- cvs2svn can rename branches and tags during the conversion using
regular-expression patterns (--symbol-transform).
- Choosing SVN paths for branches/tags
- You can choose what SVN paths to use as the trunk/branches/tags
directories (--trunk, --branches,
--tags), or set arbitrary paths for specific CVS
branches/tags (--symbol-hints). For example, you might
want to store some tags to the project/tags directory,
but others to project/releases.
- Branch and tag parents
- In many cases, the CVS history is ambiguous about which branch
served as the parent of another branch or tag. cvs2svn determines
the most plausible parent for symbols using cross-file
information. You can override cvs2svn's choices on a case-by-case
basis by using the --symbol-hints option.
- Branch and tag creation times
- CVS does not record when branches and tags are created. cvs2svn
creates branches and tags at a reasonable time, consistent with
the file revisions that were tagged, and tries to create each one
within a single Subversion commit if possible.
- Mime types
- CVS does not record files' mime types. cvs2svn provides several
mechanisms for choosing reasonable file mime types
(--mime-types, --auto-props).
- Binary vs. text
- Many CVS users do not systematically record which files are
binary and which are text. (This is mostly important if the
repository is used on non-Unix systems.) cvs2svn provides a
number of ways to infer this information
(--eol-from-mime-type, --default-eol,
--keywords-off, --auto-props).
- Subversion file properties
- Subversion allows arbitrary text properties to be attached to
files. cvs2svn provides a mechanism to set such properties when a
file is first added to the repository
(--auto-props) as well as a hook that users can use to
set arbitrary file properties via Python code.
- Handling of .cvsignore
- .cvsignore files in the CVS repository are converted
into the equivalent svn:ignore properties in the output.
By default, the .cvsignore files themselves are
not included in the output; this behavior can be changed
by specifying the --keep-cvsignore option.
- Subversion repository customization
- cvs2svn provides many options that allow you to customize the
structure of the resulting Subversion repository
(--trunk, --branches, --tags,
--include-empty-directories, --no-prune,
--symbol-transform, etc.; see also the additional
customization options available by using the --options-file
method).
- Support for multiple character encodings
- CVS does not record which character encoding was used to store
metainformation like file names, author names and log messages.
cvs2svn provides options to help convert such text into UTF-8
(--encoding, --fallback-encoding).
- Vendor branches
- CVS supports "vendor branches", which (under some circumstances)
affect the contents of the main line of development. cvs2svn
detects vendor branches whenever possible and handles them
intelligently. For example,
- cvs2svn explicitly copies vendor branch revisions back to
trunk so that a checkout of trunk gives the same results under
SVN as under CVS.
- If a vendor branch is excluded from the conversion, cvs2svn
grafts the relevant vendor branch revisions onto trunk so that
the contents of trunk are still the same as in CVS. If other
tags or branches sprout from these revisions, they are grafted
to trunk as well.
- When a file is imported into CVS, CVS creates two revisions
("1.1" and "<IP_ADDRESS>") with the same contents. cvs2svn
discards the redundant "1.1" revision in such cases (since
revision "<IP_ADDRESS>" will be copied to trunk anyway).
- Often users create vendor branches unnecessarily by using
"cvs import" to import their own sources into the CVS
repository. Such vendor branches do not contain any useful
information, so by default cvs2svn excludes any vendor branch
that was only used for a single import. You can change this
default behavior by specifying the
--keep-trivial-imports option.
- CVS quirks
- cvs2svn goes to great length to deal with CVS's many quirks.
For example,
- CVS introduces spurious "1.1" revisions when a file is added
on a branch. cvs2svn discards these revisions.
- If a file is added on a branch, CVS introduces a spurious
"dead" revision at the beginning of the branch to indicate
that the file did not exist when the branch was created.
cvs2svn deletes these spurious revisions and adds the file on
the branch at the correct time.
- Robust against repository corruption
- cvs2svn knows how to handle several types of CVS repository
corruption that have been reported frequently, and gives
informative error messages in other cases:
- An RCS file that exists both in and out of the "Attic"
directory.
- Multiple deltatext blocks for a single CVS file
revision.
- Multiple revision headers for the same CVS file
revision.
- Tags and branches that refer to non-existent revisions or
ill-formed revision numbers.
- Repeated definitions of a symbol name to the same revision
number.
- Branches that have no associated labels.
- A directory name that conflicts with a file name (in or out
of the Attic).
- Filenames that contain forbidden characters.
- Log messages with variant end-of-line styles.
- Vendor branch declarations that refer to non-existent
branches.
- Timestamp error correction
- Many CVS repositories contain timestamp errors due to servers'
clocks being set incorrectly during part of the repository's
history. cvs2svn's history reconstruction is relatively robust
against timestamp errors and it writes monotonic timestamps to the
Subversion repository.
- Scalable
- cvs2svn stores most intermediate data to on-disk databases so
that it can convert very large CVS repositories using a reasonable
amount of RAM. Conversions are organized as multiple passes and
can be restarted at an arbitrary pass in the case of
problems.
- Configurable/extensible using Python
- Many aspects of the conversion can be customized using Python
plugins that interact with cvs2svn through documented interfaces
(--options).


Data Center with Divine Blessings
Posted by Stephan H Wissel on 29 December 2007 | Comments (4) | categories: Technology
Usability - Productivity - Business - The web - Singapore & Twins
Posted by Stephan H Wissel on 29 December 2007 | Comments (4) | categories: Technology
Posted by Stephan H Wissel on 25 December 2007 | Comments (0) | categories: Singapore Twins
Posted by Stephan H Wissel on 18 December 2007 | Comments (5) | categories: IBM Notes Lotus Notes
NotesStream.write(someStringInside)the compiler will not warn you, that you shall not provide String where Byte is needed. But the runtime will take care of you!  And don't get me started on Streams, Transformers and character sets. . With this little hickups Blizz is progressing.
Posted by Stephan H Wissel on 17 December 2007 | Comments (0) | categories: Show-N-Tell Thursday
ServletOrTag.getResult {
stuffRenderer.render(configName, parameters) -> OutputStream {
configFetcher.fetch(configName) -> configObject;
stuffTransformer.setSession(dxp2Session);
stuffTransformer.transform(configObject, parameters) -> OutputStream {
stuffFilter.setSession(dxp2Session);
stuffFilter.filter(configObject,parameters) -> OutputStream {
stuffFetcher.setSession(dxp2Session);
stuffFetcher.fetch(configObject,parameters) -> OutputStream;
}
}
}
}
Posted by Stephan H Wissel on 16 December 2007 | Comments (0) | categories: IBM Notes Lotus Notes
Posted by Stephan H Wissel on 12 December 2007 | Comments (3) | categories: Blog
Posted by Stephan H Wissel on 10 December 2007 | Comments (0) | categories: Blog
Posted by Stephan H Wissel on 09 December 2007 | Comments (0) | categories: After hours
Posted by Stephan H Wissel on 09 December 2007 | Comments (0) | categories: IBM Notes Lotus Notes
Posted by Stephan H Wissel on 07 December 2007 | Comments (0) | categories: Software


High school, involved in lots of school club activities.
Attending the DSH/German courses with the aim of studying Informatik.
Web-based simulation of the EBICOS 900 traffic management and dispatching system used in the Istanbul Metro M1 line
Visit websiteAn Apple Swift Student Challenge project that teaches users how UPC-A type barcodes work (accepted, in 2021)
Visit GitHub repoBasic 3D simulation of the Istanbul Metro M2 Line's first phase stations, made with C3DL
Visit websiteThis UI was developed in accordance with the ERA_ERTMS_015560 "ETCS Driver Machine Interface" standard. Some rules were overriden because of being not compatible with websites.
Visit the standards' website


Network decomposition: Introduction
08 Apr 2020This post is an introduction (and a table of contents) for a series of posts on distributed network decomposition.
One of the important papers of these recent years in distributed graph algorithms will appear at STOC this summer:
“Polylogarithmic-Time Deterministic Network Decomposition and Distributed Derandomization” by Václav Rozhoň and Mohsen Ghaffari from ETH Zurich.
It is basically the description of a distributed algorithm that performs what is called a network decomposition, faster than before. This decomposition can then be used to do many other things fast, and the paper solves several important open problems of the field.
I quickly looked at the paper when it appeared on arxiv, but I want to understand it better, and writing a series of posts about it is good way to do this.
Here is the my current plan for this series:
- Local algorithms, an introduction to local algorithm, with the example of the maximal independent set problem.
- Impact for distributed algorithms, that is, why is a network decomposition so useful.
- Centralized construction, how to build a network decomposition with good parameters in a centralized manner.
- Weak and strong decomposition, some useful precisions about the decomposition
- The algorithm of Ghaffari and Rozhon.


fun <T> transient(initializer: () -> T): PropertyDelegate<T>
A simple wrapper that enables the use of Kotlin's val x by transient { ... }
syntax. Such a property
will not be serialized, and if it's missing (or the first time it's accessed), the initializer will be
used to set it up.


With deep expertise in every stage from ideation to execution, my greatest strengths are applied in both doing and driving design. My creative eye is underscored by a deep understanding of front-end development, marketing/advertising, and user interaction (UI). I’ve threaded these experiences together to amplify customer success across diverse roles at Microsoft, AT&T, Turner Broadcasting, and CNN.
Naturally curious, I like to explore the inner and outer limits of design trends and style. Driven by an innate ability for intended design, I find inspiration in both meeting the need on the head or going against the grain to cultivate fresh new experiences that inspire and delight the customer.


Salmon Cookies
Home
Salmon Cookies Sales Figures
Create new cookie store:
Store Location
Min Customers Per Hour:
Max Customers Per Hour:
Average Cookies Per Sale:
Submit


Malaysia’s Last Sumatran Rhino Dies
by Cameron FrewMalaysia’s last Sumatran rhino has died, making the species extinct in the country.
Advertisements
The last-known living creature, a 25-year-old female named Iman, passed away on Saturday, November 23, in the state of Sabah on the island of Borneo, after battling cancer.
Iman had been suffering from uterine tumours ever since she was captured in March 2014. It was only in May this year that Malaysia’s last male Sumatran rhino also died – efforts to breed the species have so far proved unsuccessful.
Advertisements
The Sumatran rhino was once a prolific animal across Asia. However, with fewer than 100 animals believed to exist and following its extinction in Malaysia, the species is now critically endangered.
Augustine Tuuga, director of the Sabah wildlife department, told The Guardian:
Iman’s death came rather sooner than we had expected, but we knew that she was starting to suffer significant pain.
Sabah’s environment minister Christina Liew added: ‘Despite us knowing that this would happen sooner rather than later, we are so very saddened by this news.’
Iman had came close to death several times over the past five years due to immense blood loss: however, each time she started to slip away, wildlife officials nursed her back to health.
Advertisements
As per the BBC, Liew added:
Its death was a natural one, and the immediate cause has been categorised as shock. Iman was given the very best care and attention since her capture in March 2014 right up to the moment she passed.
The smallest of the rhinoceros species, the World Wildlife Fund estimates that there are only around 80 left across the globe, with most living in the wild in Sumatra.
According to conservation group International Rhino Foundation, their nature means they’re more isolated and unlikely to breed – meaning they may go extinct within the next few decades.
Advertisements
The Sumatran rhino (along with the Black and Javan species) are listed by the International Union for the Conservation of Nature’s red list as being critically endangered. African and Sumatran rhinoceros have two horns, while Indian and Javan rhinoceros have a single horn.
Rhinos’ horns are sold on the black market due to their alleged medical benefits. Although they are made primarily of keratin – the same material that makes up hair and fingernails – the horns are ground up and swallowed, used as treatments for fevers or convulsions.
After graduating from Glasgow Caledonian University with an NCTJ and BCTJ-accredited Multimedia Journalism degree, Cameron ventured into the world of print journalism at The National, while also working as a freelance film journalist on the side, becoming an accredited Rotten Tomatoes critic in the process. He’s now left his Scottish homelands and took up residence at UNILAD as a journalist.


CONNECTED TO : 0X3489C7169CAFB98DAAA17F564B44561FD1481F83
Dashboard
Account Information
Register Hashtag
My Hashtags
Refer & Earn
Track Earning
Track Referrals
Logout


{%extends 'mgmt/index.html'%} {% load static%} {% block content %}
Search, Create and Export all Inventory orders! Note, everything with a unique indentifier, such as a Serial number, will be represented as a single entry.
| Description | Type | P # | Allocated To: | Ordered By: | Qty | Waybill | Unit Price | Date Ordered | ||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| {{instance.description}} | {{instance.part_type}} | {{instance.part_number}} | {{instance.tail_number}} | {{instance.ordered_by}} | {{instance.order_quantity}} | {% if instance.waybill %}{%else%} | ADD | {% endif %} {% if instance.price %}$ {{instance.price}} | {%else%}ADD | {% endif %}{{instance.date_ordered|date:"M d, Y"}} | Delete | Recieve |


Hire AngularJS experts
See what is already running on AngularJS
Why Angular
By watching the above list, you can easily make out that companies ranging from Fortune 100 to startups are using AngularJS for developing their websites, apps and products.
- Third most popular project on Github. That speaks for itself.Angular on GitHub
- Instead of buidling separate Android, iOS, blackberry, windows app, just build a responsive Angular app and use it everywhere.
- Ease of maintenance - When there is a problem, we don't want to spend hours debugging. we should be able to make day-to-day minor changes with ease.
- Efficiency of building new features - When I want to build something new, does the framework help me or hinder me?
- Engagement of the community - When the community is large and strong, it can overcome many issues within the framework. The community contributes to the framework, but then also builds many complentary libraries that work alongside the framework and make it even more powerful.
- AngularJS Gets Rid of Ritual and Ceremony
- AngularJS Allows Developers to Express UI Declaratively and Reduce Side Effects