In 2000, Enron was one of the largest companies in the United States. By 2002, it had collapsed into bankruptcy due to widespread corporate fraud. In the resulting Federal investigation, a significant amount of typically confidential information entered into the public record, including tens of thousands of emails and detailed financial data for top executives.
The goal for this project is to build a person of interest identifier based on the available financial and email data in the Enron scandal. Using machine learning we hope to build a model which is able to accurately predict if a person is a person of interest based on their email and financial data. Using the supervised classification in Machine Learning, we will attempt to fine tune the features and algorithm parameters to come up with a prediction score of 30% and above.
The dataset provided consists of a hand-generated list of persons of interest in the fraud case, which means individuals who were indicted, reached a settlement or plea deal with the government, or testified in exchange for prosecution immunity is provided along with the combined the Enron email and financial data into a dictionary, where each key-value pair in the dictionary corresponds to one person. The dictionary key is the person's name, and the value is another dictionary, which contains the names of all the features and their values for that person. The features in the data fall into three major types, namely financial features, email features and POI labels.
financial features: ['salary', 'deferral_payments', 'total_payments', 'loan_advances', 'bonus', 'restricted_stock_deferred', 'deferred_income', 'total_stock_value', 'expenses', 'exercised_stock_options', 'other', 'long_term_incentive', 'restricted_stock', 'director_fees'] (all units are in US dollars)
email features: ['to_messages', 'email_address', 'from_poi_to_this_person', 'from_messages', 'from_this_person_to_poi', 'shared_receipt_with_poi'] (units are generally number of emails messages; notable exception is ‘email_address’, which is a text string)
POI label: [‘poi’] (boolean, represented as integer)
import copy
import sys
sys.path.append("../tools/")
from poi_id import *
from tester import *
data_dict = load_data()
features_list = select_features(data_dict, .5)
show_data_overview(data_dict, features_list)
There's a total of 146 data points, and out of that number only 18 of them are Person of Interest vs 128 whom are non POIs. There's also a total of 21 features per data point.
Looking for incomplete or missing data in the dataset, we can see that there are a quite a few features which have higher than half of the data is missing or not available, if we intend to use these features to predict the POI the prediction would be highly inaccurate due to the high percentage of missing data. Thus using this as a starting point, we can eliminate those features that have 50% of more of the data that is not available as the first cut. And email address is also skipped because it's not a numeric value and we wouldn't be able to do any useful correlation analysis on it. By doing so we ended up with 14 features:
bonus, to_messages, shared_receipt_with_poi, from_this_person_to_poi, from_poi_to_this_person, from_messages, other, salary, expenses, exercised_stock_options, restricted_stock, total_payments, total_stock_value, poi
to continue the next data exploration stage with.
data = featureFormat(data_dict, features_list)
plotCorrMatrix(data, features_list)
After removing the features that have a higher number of missing data, we can start to analyse the highly correlated features by looking at the correlation matrix for the existing features and checking for the features that have a higher correlation with poi. The generated correlation matrix looks weird with high zero correlation for the features against poi. Let's try to plot the poi against total_payments to see if we're able to detect any anomalies in the data.
plotScatter(data,"poi", "bonus", 0, 1)
print "max salary: ", max(data_dict.items(), key=lambda(k,v):float(v['bonus']))
We did a exploratory scatterplot of the features to check for any outlier or basic patterns, and we found one obvious candidate which can be located way above the top left corner of the plot. The datapoints are marked in two colors, red for poi and and blue for non poi. Checking further into the value we can see that it belongs to the total row. This appears to be a spreadsheet inputting error and thus can be safely removed from the dataset.
Other potential irregularities that is worth removing are those data points that doesn't have any values in their financial data sheet, by narrowing does those data points that does't have any value in the total payments and the total stock value field, we can narrow down to this list of three person below. Based on the insider pay financial data sheet, we're able to see that for LOCKHART EUGENE E, there's no available data hence we would want to include this as another data point to be remove from further processing.
Based on the insider pay datasheet, we're able to find another datapoint which doesn't appear to be a person's name, THE TRAVEL AGENCY IN THE PARK, hence we would want to include this as another point to be removed.
for person, items in data_dict.items():
if(items['total_payments'] == 'NaN' and items['total_stock_value'] == 'NaN'):
print (person)
## removing outliers
clean_data_dict = data_dict
remove_outlier(clean_data_dict)
data = featureFormat(clean_data_dict, features_list)
plotScatter(data,"poi", "bonus", 0, 1)
After removing the outlier we ran the same scatterplot again and it appears to be much correct this time around. So let's first get back to the correlation matrix to see if we're better able to narrow down the list of highly correlated features.
plotCorrMatrix(data, features_list)
And indeed, the correlation matrix now shows a more useful data. Allowing us to group the features correlated to poi to a few groups from zero correlation to high correlation. Surprisingly though, we can see that the from_messages feature has zero correlation to poi. Thus let's begin by looking at other features which are highly correlated (>=0.19) to poi and check for useful hint on how to proceed with the features selection.
plotScatter(data,"salary", "bonus", 8, 1)
Looking the salary against the bonus scatterplot, we don't see a very strong pattern to detect POI even if we choose to ignore the outliers values to the right of the plot. Then again in terms of the distribution of the data that may be because we don't have enough poi data to see a clearer trend. Let's try to do a few more scatterplots to see if we can get to see a clearer pattern in some other plots.
plotScatter(data,"exercised_stock_options", "total_stock_value", 10, 13)
The plot for total_stock_value and the exercised_stock_options look pretty promising which we can see that the poi points appears on the right hand side of the plot although we still see values being mixed on the left side of the plot. This could be useful features that we can try to explore further using Machine Learning. Moving onto the next pair of features which shows higher correlation.
plotScatter(data,"from_poi_to_this_person", "shared_receipt_with_poi", 5, 3)
For the from_poi_to_this_person against shared_receipt_with_poi scatterplot, we're not seeing any clearer pattern as well. So let's look at what other features that we can engineer here which would show even higher correlation that what we've seen so far.
Based on my intuition, I've devised five new features to add to the analysis. The general idea was to find ratio of the emails received or sent to a poi and based on that try to determine if that person himself or herself can also be a poi. And the second approach was to use a total of the either the salary, bonus and the total stock value to determine if those people who have received a total amount of money would be useful in helping us to identify if that person could be a poi.
# make a deep copy for the feature list so that it doesn't get overwritten
new_feature_list = copy.deepcopy(features_list)
clean_data_dict, new_features_list = create_new_features(clean_data_dict, new_feature_list)
data = featureFormat(clean_data_dict, new_features_list)
plotCorrMatrix(data, new_features_list)
Rerunning the correlation matrix shows that even with the total salary stock and total bonus stock, the correlation value we received for those two, .33 and .34 is no better than the individual variable, salary - .34, bonus - .36, total stock value - .38 and exercised stock option - .39 before any additional division or addition. Hence moving forward we want to attempt to use the automatic feature selection method to see if we can do better.
We're going to be utilising the select kbest function and the anova f-stat to get the scoring for our features and also to compare the scores that we get from the new features.
features, labels, sel_features_list = autoselect_features(clean_data_dict, features_list, 'all')
accuracy, precision, recall = get_features_score(features, labels)
print 'initial list',accuracy, precision, recall
Using the existing features list, we ran this through a K-nearest neighbour classifier to assess the initial accuracy, precision and recall scores. Based on this classifier, we're able to get an accuracy score of .7907, precision of .54808 and recall of .52976
final_features, labels, sel_features_list = autoselect_features(clean_data_dict, new_features_list, 'all')
We can see that the f-stat scoring that we received from the five new features are as follows total_bonus_stock: 18.8631, total_salary_stock: 18.2897, total_to_poi_from_poi: 5.2743, ratio_from_poi_fr_msg: 5.1239 and ratio_to_poi_to_msg: 4.0947. Two of the newly engineered features appears to be in the top ten of the features list based on this scoring. Let's check the accuracy, precision and recall scoring by running through the same classifier.
accuracy, precision, recall = get_features_score(final_features, labels)
print 'new features list',accuracy, precision, recall
I was actually expecting to get a slightly higher value for accuracy, precision and recall running it against the same classifier, but the result shows that we're actually getting weaker precision and recall scores of .41463 and .47222 with the same accuracy score of .7907. So the new features definitely have an impact but we probably need to do an additional filtering and not using the list completely.
So I'm going to use select k best once again to help me optimize the number of features to use from our current features list.
dr = []
for k in range(2,len(new_features_list)):
features, labels, sel_features_list = autoselect_features(clean_data_dict, new_features_list, k, False)
accuracy, precision, recall = get_features_score(features, labels)
dr.append([k,accuracy, precision, recall])
print pd.DataFrame(dr, columns=['k','accuracy','precision','recall'])
By mapping all the k from 2 all the way to the max number of features which is 18, we're able to easily compare the most optimal k value in terms of max accuracy, precision and recall scoring to be used for the next section. Since the max accuracy, precision and recall scores that we're able to achieve is .83721, .6859 and .61508 and this happens when k = 2 to k = 5, we're going to be using the largest k value so that we have more parameters to play with in the parameters tuning section.
final_features, labels, sel_features_list = autoselect_features(clean_data_dict, new_features_list, 5, False)
# including poi in the full final features list
final_features_list = ['poi']+sel_features_list[0:len(sel_features_list):1]
print final_features_list
The final features list based on select k best is 'bonus', 'salary', 'exercised_stock_options', 'total_stock_value', 'total_bonus_stock'.
The five selected features are all monetary amount and in terms of the number, they are closer in range but regardless depending on the classifier that we will be chosing for the next section, it's better that we run this through a feature scaling to ensure that any outliers can be handled and to avoid any negative values from the dataset when running the dataset through different ML algorithms later. So we'll be running through three different types of feature scaling and checking the accuracy, precision and recall scoring again based on the k-nearest neighbour classifier.
scaled_features = apply_minmax_feature_scaling(final_features)
accuracy, precision, recall = get_features_score(scaled_features, labels)
print 'minmax',accuracy, precision, recall
scaled_features = apply_standard_feature_scaling(final_features)
accuracy, precision, recall = get_features_score(scaled_features, labels)
print 'standard',accuracy, precision, recall
scaled_features = apply_robust_feature_scaling(final_features)
accuracy, precision, recall = get_features_score(scaled_features, labels)
print 'robust',accuracy, precision, recall
Based on the above, we're going to be using the robust scaler for the feature scaling and using the scaled values to pick to compare against a few machine learning algorithms so that we can proceed to choose a final classifier to continue testing with.
In order to avoid creating a model that is able to predict too well using the test data but not able to do well at all using other than the test data as the test data, we need to incorporate a validation strategy into our model building. In short what we hope to achieve here is to avoid overfitting.
Thus we are going to be using a holdout strategy here by reserving a small part of the original training data, 30%, to be use as test data to predict the correctness of our model once the original model is use to fit with the training data. This will help to eliminate the issue of information leakage by allowing the model to overfit by gaining insights into the whole dataset which includes the final validation dataset.
There's also the potential issue of high variance which can be introduced during the cross validation, if the sample selected from the validation strategy is skewed in some way, but this can be taken care of in the next section, when we will rerun the dataset against the Stratified Shuffle split which will attempt first randomize the data before grouping them into a specific target oriented class to minimize the variance.
(features_train,features_test,labels_train,labels_test,sc_features_train,sc_features_test,sc_labels_train,sc_labels_test) \
= apply_cross_validation(final_features, labels, scaled_features)
Based on a machine learning algorithm selection cheat sheet$^{[7]}$, I've narrow down the selection to four algorithms to use on the dataset. I would be using Linear Support Vector Classification, KNeighbours Classifier, Naive Bayes and Random Forest.
Here are the basic definitions of what these three scores are referring to:
The accuracy refers to the accuracy classification score.
The precision is the ratio tp / (tp + fp) where tp is the number of true positives and fp the number of false positives. The precision is intuitively the ability of the classifier not to label as positive a sample that is negative.
The recall is the ratio tp / (tp + fn) where tp is the number of true positives and fn the number of false negatives. The recall is intuitively the ability of the classifier to find all the positive samples.
Based on the above definition, we can understand that the accuracy reflects how correct our model is in classifying poi as poi and non poi as non poi out all of the whole dataset. And the precision here measures how well our model is able to predict poi as poi and keeping the number of non poi which are labelled as poi to a minimum. Thirdly the recall refers to how well the model is able to correctly identify all the actual poi out of the whole poi dataset.
clfs = apply_classifiers()
datamatrix = compare_algorithms(clfs, features_train, labels_train, features_test, labels_test, sc_features_train, \
sc_labels_train,sc_features_test, sc_labels_test)
pd.DataFrame (datamatrix, columns=['Algorithm','accuracy', 'precision', 'recall','sc_accuracy', 'sc_precision', 'sc_recall'])
Running the Linear SVC, we're getting a score reading of .86047, .92857 and .57143 for accuracy, precision and recall. Comparing these numbers to the scaled features data, we're seeing slight improvement across the accuracy, precision and the recall score values to .88372, .93902 and .64286.
Moving onto the next algorithm, we're using K-nearest neighbours to check if we're able to get a better precision and recall value than Linear SVC. Using this algorithm, we're getting .83721 for accuracy, .6859 and .61508 for both precision and recall. We're seeing improvement across the three scores with .86047, .77083 and .62897 for accuracy, precision and recall. In terms of precision and recall scores, it's scoring higher than Linear SVC.
Next onto Naive Bayes as the algorithm, first going through the unscaled features dataset, we're scoring .83721, .6859 and .61508 for the accuracy, precision and recall. We're getting the same scores for the scaled features. For the unscaled features, we're getting the same scores as k-nearest neighbour but for the scaled features, the precision and recall for k-nearest neighbour classifier is higher.
Lastly, we're going to apply RandomForest on the dataset. With this ensemble algorithm, we're getting an accuracy, precision and recall scores of .86047, .74737 and .68651. For the scaled features, we're getting the same scores as well. The unscaled features model has a higher precision and recall out of the four algorithms compared here but in terms of scaled features, the precision is lower than k-nearest but it has a higher recall score than k-nearest.
So far we have done feature scaling and tried a few machine learning algorithms to train the data and checking the resulting accuracy, precision and recall scores, we're getting decent scores, but we can further fine tune the parameters for the corresponding learning algorithms to tweak it so that we can get a higher accuracy, precision and recall score values. Without proper parameters tuning, we could end up with a model which underfit and doesn't do well in handling new data.
I'm using the GridSearchCV to help me roughly narrow down the significant parameters and it's range, and further manually tweaking it a bit by setting the parameter value range and checking the scores. With these few rounds of trial and error tweaking, we hope to further increase the scores of these models. And any gain in the accuracy, precision or recall of the models is further enlarged depending on how the model is used. For example, an improvement of 1% in the accuracy would mean that we're better able to identify one more POI out of a line up of 100 person.
tuned_clfs = tune_classifier(features_train, labels_train)
Onto the task of tuning the parameters: For LinearSVC, the available parameters for tuning are quite restricted, so I just play with the C parameter by providing a rough range and allowing the GridSearch to point me to the direction of the final value to be use. The C parameter defines for the SVM the level of misclassification that is acceptable, a large C value will allow for a closer fit to be generated and thus less misclassification issue.
For Naive Bayes, we don't need to do any parameter tuning hence we can skip to the next one.
On K Nearest Neighbour, the parameters selected are n_neighbours, weights and algorithms. We're trying to build the best model by using the number of nearest neighbours, the algorithms used to compute the nearest neighbour and weights - which emphasize either equal distribution or more emphasis are given to closer neighbours.
And finally to Random Forest, we're tweaking n estimators - defines number of trees in the forest.
datamatrix = compare_algorithms(tuned_clfs, features_train, labels_train, features_test, labels_test, sc_features_train, \
sc_labels_train,sc_features_test, sc_labels_test)
pd.DataFrame (datamatrix, columns=['Algorithm','accuracy', 'precision', 'recall','sc_accuracy', 'sc_precision', 'sc_recall'])
For the Linear SVC, the accuracy appears to have worsen to .81395 along with the precision to .63421 but recall improved to .60119 .However using the scaled features, we're getting the same score as the pre-tuned tuned classifier, with a score reading of .88372, .93902 and .64286 for accuracy, precision and recall.
Moving onto the next algorithm, K-nearest neighbours, the accuracy score of .83721 was maintained and we see improvements in both precision and recall with score of .69595 and .67262. These scores were returned unimproved for the scaled features dataset.
Lastly, comparing the RandomForest classifier, we're getting the same accuracy, precision and recall scores as before the parameters tuning, I've randomly trial and error different parameters setting but wasn't able to get a better score than .86047, .74737 and .68651.
For the evaluation, we're going to run the same set of classifiers using a stratified shuffle split to eliminate the bias against the dataset and to check which algorithms will yield the best scores in terms of recall and precision according to the project rubric.
test_algorithms(clfs, clean_data_dict, final_features_list)
Using the Stratified Shuffle split to run the dataset against, we're getting lower scores this around, and we're also seeing a few new scores which can be defined as follows:
The F1-Score is the harmonic mean of precision and recall
The F2-Score is a weighted average of precision and recall
Both of these scores measures both recall and precision as a combined score as there's always a tradeoff in getting a higher value in either one of these score, thus a higher F1 or F2 score can encapsulate both the precision and recall factor for a particular model. But for the rest of the evaluation, we will be narrowing it down to just the precision and recall scores.
Comparing against the four classifiers above, we can clearly see that the K nearest neighbour have the the highest precision and recall score, getting a decent .56839 and .3075. The second highest score goes to the Random Forest classifier with a precision and recall score of .53892 and .2375. This is followed by naive bayes classifier with a precision and recall score of .45195 and .2845. And finally by Linear Support Vector classifier with a precision and recall score of .23037 and .3595.
test_algorithms(tuned_clfs, clean_data_dict, final_features_list)
After fine tunning the parameters, we're able to get a decent score for the K-nearest neighbours classifier, with a precision and recall score of .55 and .44, improving on the recall score but getting a slight hit on the precision score. For random forest classifier, we're getting slightly worsening scores in the precision and accuracy with a score of .53715 and .2675. And lastly for linear support vector classifier, we're also seeing worsening precision but still an improved recall with the score of .23426 and .387
Based on these scores, the final selected classifier would be the k-nearest neighbour classifier. And with it we're able to avoid misclassifying non poi 55% of the time and is able to correctly find all the poi out of a line up which include non poi labelled as poi, 44% of the time.
The final precision and recall score for the selected classifier is still quite limited, we can probably do better if we're able to gather more data points which can help to build a stronger pattern recognition for our model. Due to time restriction, we also choose to tune the parameters to get a good enough setting for at least one of the classifier to ensure that the precision and recall scores are over .3, given more time and analysis, we should be able to further improve these scores.
# dumping the settings for external testing
final_clf = tuned_clfs['Tuned KNearestNeighbour']
dump_classifier_results(final_clf, clean_data_dict, final_features_list)
f_clf, f_dataset, f_feature_list = load_classifier_and_data()
test_classifier(f_clf, f_dataset, f_feature_list)


Hi, I'm Jerome! I have a passion for technology or anything related to mechanical design, circuit design, or software development . As I grow during my undergraduate career I look to specialize my strengths in leadership and product development . Co-op has taught me a lot about who I am as an engineer and so I am constantly searching for an environment in which I can push my limits. I am currently looking for a 4 month co-op starting late August so let's keep in touch!
I was a part of developing cutting edge technology for a growing market in analyzing binding interactions between proteins, antibodies, DNA, RNA, and more. I was able to get hands-on experience in a fast paced prototyping environment in which I contributed greatly in research and development.
I solely ran a drop-in business to provide PCB fabrication and 3D print services to Post-doc, Graduate, and Undergraduate students. I was able to learn first-hand about the importance of paying attention to detail and managing resources to satisfy dozens of customers on a daily basis.
GPA: 3.56
GPA: 4.0 (Admission Average: 96%)
Apart from engineering, I enjoy being outdoors to relieve stress. During summer times, I play basketball outside daily and I often bike long trails from city to city.
When forced indoors in Canada's long winter months, I listen to audiobooks, learn a new skill online, workout, or just hang out with my siblings.


NF-X2 that binds to the DRA X2-box is activator protein 1.
Abstract
Expression cloning of c-Jun. Human class II MHC Ag are a family of cell surface glycoproteins. Their constitutive expression is limited to B lymphocytes and thymic epithelial cells. In many other cells their expression can be induced by IFN-gamma. Conserved upstream promoter sequences regulate this tissue-specific expression of class II genes. In the DRA promoter, one of these cis-acting regulatory motifs is the X2-box to which nuclear factor X2 (NF-X2) binds. Here, we present the isolation and characterization of the full-length cDNA clone encoding NF-X2. This cDNA clone was isolated by expression cDNA cloning, and encodes the human c-Jun protein, which together with c-Fos forms the heterodimeric activator protein-1 transcription complex. Whereas c-Fos/c-Jun heterodimers do not exist in B cells, they form and bind to the X2-box in class II nonexpressing cells. Thus, c-Fos/c-Jun heterodimers might contribute to the repression of DRA gene expression.


Web-Based Safe Palette
Use left click on the left cell and apply the preferable radix
Decimal
Hexadecimal
The most browsers supports safe palette where red, green and blue components are limited by the next values:


Direction keys (clockwise) for all 8 directions are: W, E, D, C, X, Z, A, Q. To wait for a turn, press: S. Pickup items ("*") with G. Enemy thugs are represented by the character 't'.
I made this to learn how to use rot.js, an absolutely delightful Javascript library for writing roguelikes. If you're at all interested in learning to make roguelikes, rot.js provides loads of utilities, but isn't opinionated about how you use them. I'm also using NES.css for the styling.
Inventory
Social
Follow @brad_io for more indie gamedev stuff


Roman Numberals
Enter a number to be converted to a roman numerals:
Receive your numberal!
Roman Numberals:


Azmin claims hidden hands behind withdrawal of PKR Youth Congress invitation
KUALA LUMPUR, Nov 14 — PKR deputy president Mohamed Azmin Ali described the decision to revoke his invitation to officiate the opening of the party’s Youth National Congress as unprecedented.
He said it was up to the PKR Youth (AMK) to take further action on the matter.
“I received the invitation letter and have replied that I will be attending but recently the invitation was cancelled. I am confident the Youth chief would not have done such a thing without outside interference.
“This is not about me, but it is about the position of the president and deputy president,” he told the media after his speech at Institut Tadbiran Awam Negara (INTAN) Ministerial Forum Series 2019 at Bukit Kiara here today.
Mohamed Azmin also questioned the cancellation of the invitation which he said was to prevent him from speaking at the party’s youth wing congress.
Yesterday, AMK chief Akmal Nasrullah Mohd Nasir was reported to have said that the decision to invite Datuk Seri Dr Wan Azizah Wan Ismail to officiate the National Youth Congress in Melaka on December 6 was made at the youth wing’s central leadership meeting on October 20.
Akmal Nasrullah reportedly said the outcome of the meeting had been formally communicated to the Central Political Bureau which is chaired by PKR president Datuk Seri Anwar Ibrahim. — Bernama


← Back
Exercise 1
Install a screen reader (list below)
Open this page with the screen reader on
Turn down the brightness on your computer
Fill in the form below!
List of Screen Readers
VoiceOver for Mac
basic commands
.
JAWS
NVDA
Chrome Screen Reader
Fill out this form:
Favorite Color
First Name
Last Name
Age


Economic prospects dip but optimism remains 09 Dec 2019, 11:24 by Staff Reporter Home \ Front Page News \ Economic prospects dip but optimism remains - New Era Live


The 2017 CILIP Kate Greenaway Medal longlist has been announced. The prize was established in 1955 and is named after a 19th century artist renowned for her brilliant illustrations and designs for children. It celebrates the best-illustrated children’s and Young Adult editions from the past year.
Barroux - Alpha: Abidjan to Gare du Nord (written by Bessora, translated by Sarah Ardizzone)
“Alpha Coulibaly is emblematic of the refugee crisis today - just one of millions on the move, at the mercy of people traffickers, endlessly frustrated, endangered and exploited as he attempts to rejoin his family already in Europe.
“With a visa, Alpha’s journey would take a matter of hours; without one he is adrift for 18 months. Along the way he meets an unforgettable cast of characters, each one giving another human face to the crisis.”
Aaron Becker - Return
“Aaron Becker, creator of the award-winning Journey and its stunning, celebrated sequel, Quest, presents the final chapter in his luminous, wordless fantasy.
“Failing to get the attention of her busy father, a lonely girl turns back to a fantastic world for friendship and adventure. It’s her third journey into the enticing realm of kings and emperors, castles and canals, exotic creatures and enchanting landscapes. But this time, it will take something truly powerful to persuade her to return home.”
Dieter Braun - Wild Animals of the North (translated by Jen Calleja)
“From the polar bears of the Arctic to the North American pumas and pandas in Asia, this book takes children on an exciting journey of discovery. The drawings show these animals in all their natural majesty and the witty and charming descriptions will teach children all about their new favourite animals!”
Marion Deuchars - Bob the Artist
“Bob the bird is just like all his friends, apart from his skinny legs. When Bob is teased, he decides to try and change himself to fit in. But little does he know where all his efforts will lead him.”
Jim Field - The Lion Inside (written by Rachel Bright)
“Follow the journey of one little mouse trying to make himself heard and discovering along the way that even the smallest of us has the heart of a lion.”
Cathy Fisher - Perfect (written by Nicola Davies)
“Perfect tells the story of a young boy who learns to accept that his baby sister has a disability but that she is still perfect in every way. Written from the perspective of the boy, the story is suffused with natural imagery and is an ideal tool for opening up the subject of disability with children.”
Emily Gravett - Tidy
“Pete the badger likes everything to be neat and tidy at all times, but what starts as the collecting of one fallen leaf escalates quickly and ends with the complete destruction of the forest! Will Pete realise the error of his ways and set things right?”
William Grill - The Wolves of Currumpaw
“The Wolves of Currumpaw is a beautifully illustrated modern retelling of Ernest Thompson Seton’s epic wilderness drama Lobo, the King of Currumpaw, originally published in 1898.
“Set in the dying days of the old west, Seton’s drama unfolds in the vast planes of New Mexico, at a time when man’s relationship with nature was often marked by exploitations and misunderstanding.”
Jim Kay - Harry Potter and the Philosopher’s Stone (written by J. K. Rowling)
“Harry Potter lives in a cupboard under the stairs at his Aunt and Uncle’s house.  But then Harry is transported to a world of magic and excitement.”
Ethan Murrow - The Whale (written by Vita Murrow)
“There is a legend that a Great Spotted Whale lives in the ocean; local fisherman still talk of it, although the first sighting 50 years ago was never corroborated.
“Now, two young whale watchers each set out to find the whale, one armed with sound recording equipment, the other a camera. Mid-ocean their boats collide, so they pool their resources and set off together to capture incontrovertible proof that the mythical Great Spotted Whale exists.”
Levi Pinfold - Greenling
“Mr Barleycorn picks a green baby growing in his garden, letting loose the incredible power of nature. When courgettes flower in the kitchen and carrots sprout out of their television, his wife tells Mr Barleycorn that the greenling has to go. But the bounty and beauty of nature has a strange power - the power to bring a whole community together.
Chris Riddell - A Great Big Cuddle: poems for the very young (written by Michael Rosen)
“Two of the biggest names in children’s publishing, Michael Rosen and Chris Riddell, come together in this poetry collection. The poems fizz off the page with sound and rhythm, energy and laughter, as Rosen captures in the most remarkable way what it means to be very, very young.”
David Roberts - A Beginner’s Guide to Bear Spotting (written by Michelle Robinson)
“Bear spotting is a dangerous business - you ought to take it seriously, you know. So here’s what you need to know for starters - black bears are dangerous and black, brown bears are dangerous and brown.  Are you following? You really need to focus here. If you do, this guide will tell you all you need to know when walking in bear country. Don’t leave home without it. Are you ready? Good! Let’s go.”
Francesca Sanna - The Journey
“With haunting echoes of current affairs, this beautifully illustrated book explores the unimaginable decisions made as a family leave their home and everything they know to escape the turmoil and tragedy brought by war.”
Brian Selznick - The Marvels
“In The Marvels, Selznick crafts another remarkable artistic and bookmaking achievement that weaves together two seemingly unrelated stories - one in words, the other in pictures - with spellbinding synergy.
“The illustrated story begins in 1766 with Billy Marvel, the lone survivor of a shipwreck, and charts the adventures of his family of actors over five generations. The prose story opens in 1990 and follows Joseph, who has run away from school to an estranged uncle’s puzzling house in London, where he, along with the reader, must piece together many mysteries.”
Lane Smith - There is a Tribe of Kids
“Did you ever want to waddle with a colony of penguins? Wriggle with an army of caterpillars? Or march with a troop of monkeys?
“Legendary illustrator Lane Smith takes us on a colourful adventure through the natural world, following a child as he weaves through the jungle, dives under the ocean, and soars into the sky. Along the way he makes friends and causes mischief with a dazzling array of creatures both large and small - but can he find a tribe of his own?”
Sam Usher - Rain
“Sam wants to go out but it’s pouring with rain, so he and Grandpa decide to stay inside until the rain stops. Sam drinks hot chocolate and reads his books and dreams of adventures while Grandpa gets on with his important paperwork. Grandpa seems to have a very important letter to write. Then that very important letter has to be posted, despite the rain and floods. As they finally go outside, Sam and Grandpa have a magical adventure.”
Stephen Walton - Counting Lions: portraits from the wild (written by Virginia McKenna and Katie Cotton)
“An art-inspired gift that makes learning to name and explore wildlife a family adventure. Larger-than-life charcoal drawings are paired with poetic texts that reveal the ways in which endangered creatures live on Earth, giving little ones the chance to get up close and personal with nature’s wildest creatures.”
Jo Weaver - Little One
“Big Bear stepped out of her winter den. By her side, half asleep and blinking in the spring sunshine, wobbled a tiny cub. Spring is here and new life is stirring. There is so much for Big Bear to teach her new cub as they step out into the forest. Their journey will take them through summer and autumn and winter, always together, always discovering.”
James Weston Lewis - The Great Fire of London (written by Emma Adams)
“In 1666, London’s citizens woke to see the skyline above their city’s cramped wooden houses ablaze. The Great Fire of London is a hauntingly beautiful visual retelling of one of the most well-known disasters in the city’s history.”


You don't have enough credits to schedule this class.
{{vm.course.course_location.name}}
Credits: {{vm.course.course_credit}}
{{vm.date.date | date: "MMMM d, y"}}
{{vm.getTime(vm.date.courseStart) | date: "h:mm a"}}
{{vm.getTime(vm.date.courseEnd) | date: "h:mm a"}}
{{vm.course.max_student}}


Events and Delegates
A delegate is an object representing a function pointer. It is defined with a method signature (the return type and argument).
public delegate string MyDelegate(bool isOK);
- Note multicast delegates (such as events) must return void.
- The arguments by convention are Object sender and a derived class of EventArgs.
An event tells subscribers that they must use a method that looks like the delegate.
public event MyDelegate MyEvent;
In .Net 2 you can avoid creating a delegate with the generic EventHandler (msdn)
public event EventHandler<MyEventArgs> MyEvent;
Declare Event
A generic EventArgs<T> : EventArgs is handy for passing strong typed data (strings, int, object)
public class Worker
{
public event EventHandler<GenericEventArgs<string>> WorkDone;
public void Execute(string m)
{
EventHandler<GenericEventArgs<string>> handler = WorkDone;
if (handler != null) handler(this, new GenericEventArgs<string>(m));
}
}
public class GenericEventArgs<T> : EventArgs
{
public GenericEventArgs(T data)
{
Data = data;
}
public T Data { get; set; }
}
Raise Event
To raise the event (publish it):
//cast the delegate as the event. If there is no subscriber, the event is null
MyDelegate handler = MyEvent;
if (handler != null) handler(this, args);
You must use the raise event pattern (see C# faq). NB: if you don't assign the copy, it's not thread safe (there's a race condition between the check and the useage).
if (MyEvent != null) MyEvent(this, EventArgs.Empty); //compiles but not thread safe!!
In C# 6.0 the ?. null conditional operator is thread-safe.
MyEvent?.Invoke(this, EventArgs.Empty);
Consume Event
To consume it from a subscriber:
WorkClass wc = new WorkClass(); //scope needs to be class level
wc.MyEvent += new WorkClass.MyDelegate(MySubscriberMethod); //the new EventHandler syntax is optional...
wc.MyEvent += MySubscriberMethod; //works too!
You can inline it and use local variables:
decimal totalWeight; // Local
wc.FoundWeight +=
(delegate(object sender, GenericEventArgs<decimal> e) { totalWeight += e.Data; });
//or v3 lamdba style
shipper.RecordCTotalWeight += ((sender, e) => totalWeight += e.Data);


Home
About
Contact
[NAME OF SITE]
Task planner and organiser
Support<EMAIL_ADDRESS>Bug reports<EMAIL_ADDRESS>Business: business@nameofsite.co.uk


INDIAN INSTITUTE OF TECHNOLOGY (INDIAN SCHOOL OF MINES), DHANBAD IS ONE OF THE MOST REPUTED UNIVERSITIES FOR TECHNOLOGICAL EDUCATION AND RESEARCH IN INDIA. FROM ITS INCEPTION IN 1926 THE SCHOOL HAD A NATIONAL OUTLOOK. WHAT STARTED AS AN INSTITUTION TO IMPART MINING EDUCATION HAS GRADUATED INTO A FULL FLEDGED TECHNICAL INSTITUTION OF INTERNATIONAL ACCLAIM OFFERING PROGRAMS LIKE B.TECH, DUAL DEGREE, INTEGRATED M.SC., INTEGRATED M.SC.TECH, M.TECH, M.PHIL, M.SC, M.SC. TECH. AND MBA. THE SCHOOL HAS RELATIONS WITH REPUTED UNIVERSITIES WORLDWIDE AND IS FORAYING INTO NEWER AREAS OF ACADEMIC ENDEAVOURS. THE TRAINING & PLACEMENT CELL IS THE NODAL POINT OF CONTACT FOR COMPANIES SEEKING TO ESTABLISH A CONSTRUCTIVE RELATIONSHIP WITH IIT (ISM).
THE SERENE CAMPUS COMPRISES ACADEMIC BUILDINGS, STUDENT HOSTELS AND 100% RESIDENTIAL FACILITIES FOR FACULTY AND STAFF APART FROM OTHER INFRASTRUCTURE FACILITIES FOR A COSMOPOLITAN COMMUNITY. THE SCHOOL HAS LINKS WITH REPUTED UNIVERSITIES AND INSTITUTES ACROSS THE GLOBE AND HAS AN ALUMNI BASE ALL OVER THE WORLD. THE SCHOOL TODAY IS MAKING FORAY INTO THE NEWER AREAS OF ACADEMIC ENDEAVOURS IN TUNE WITH THE CHANGING TIMES.
Get Started


Remove surrounding $() to avoid executing output.
if $(which epstopdf)
then
echo "Found epstopdf"
fi
if which epstopdf
then
echo "Found epstopdf"
fi
ShellCheck has detected that you have a command that just consists of a command substitution.
This is typically done in order to try to get the shell to execute a command, because $(..)
does indeed execute commands. However, it's also replaced by the output of that command.
When you run echo "The date is $(date +%F)"
, bash evalutes the $(..)
. The command then becomes echo "The date is 2015-04-29"
, which writes out the string The date is 2015-04-29
The problem is when you use $(date +%F)
alone as a command. Bash evaluates the $(..)
, and the command then becomes 2015-04-29
. There is no command called 2015-04-29
, so you get bash: 2015-04-29: command not found
.
Sometimes this results in this confounding command not found
messages. Other times you get even stranger issues, like the example problematic code which always evaluates to false.
The solution is simply to remove the surrounding $()
. This will execute the command instead of the command's output.
If you really want to execute the output of a command rather than the command itself, you can ignore this message or assign the output to a new variable first:
readonly command_to_execute="$(print_the_command)"
$command_to_execute


--- layout: page title: About header-img: "img/about-bg.png" ---
Aellon is a full stack web developer based in Brooklyn, NY.


At the heart of our success is a group of people who are passionate about technology,
programming and human interactions with demanding customers and colleagues.
| Title | Competence & qualification | Contract type | Status | Option |
|---|---|---|---|---|
| Developer Engineer | Bac +5 | Short term | open | |
| DevOps Engineer | Bac +5 / Certificaton DevOps | Long term | open | |
| Account Manager | Bac +5 / certificaton PMP | Long term | open | |
| Sales representative | Bac +5 | Stage | open |


AssetAmount(amount: UnsignedLong, asset: Asset = Asset(ECHO_ASSET_ID))
Class used to represent a specific amount of a certain asset
Author Dmitriy Bushuev
Author Dasha Pechkovskaya


Import filters are defined in an Extensible Markup Language (XML) file. This file can be found in: C:\..\HEC-DSSVue\Plugins\ImportFilters.xml
. XML files are well-structured, plain text files which can be edited by text editors or dedicated xml-editors.
Two different types of input filters can be defined:
Depending on the import filter type, different configuraton parameters need to be specified within the import filters xml-file.


VERY FAST DEVELOPMENT & INTEGRATION
Build Enterprise class IoT Applications & Platforms
Bring your own IoT Sensors & devices
Libraries in 36 Languages (Java, Scala, Groovy, Node.js, ...) Integrate them on the fly.
Wealth of Platform Components
Script your complex business rules dynamically Raise your Alerts, Events & Notifications
Built with Clustering & High Availability
Industry Standard IoT Protocols MQTT, COAP, UDP, Http, GCM, FCM, APN
Visually appealing UX
Design your Web & Mobile UX by Drag & Drop Exponentially growing widget libraries
BOODSKAP


The filter list accepts literal values with wildcards (*) or Javascript regular expressions. Asterisks can be escaped with a prefixed backslash (\) to avoid being interpretted as a wildcard character.
Both lists are case-insensitive. Put one entry per line.


While the default Windows implementation of Freecell only supports playing Freecell with 4 initial freecells, it can be played with any number of them. In order to make the game more challenging, some people are playing it with a fewer number of freecells.
As of today, the Freecell FAQ says that "With two freecells, there are at least 24,161 solvable deals [in the Microsoft 32,000 deals].". However, at the course of researching those layouts using Freecell Solver (after constructing a solver configuration optimised for solving two-freecell deals), we have found out that more deals can be provably solved.
Below one can find the report about the solvability of 2-freecell deals. The executive summary is that:
Solvable
By using the "tea-for-two" meta-moves preset: 25,143.
By using -to 01ABCDE : 172.
By using -l foss-nessy : 38.
By using the extended range (8,200,000 iterations) -to 01ABCDE scan: grep -l '^This game is solv' *.sol | wc -l yields: 14.
Total: 25,367.
Definitely unsolvable
Fully traversed in the atomic moves preset: 6,513.
Found using grep -l '^I could not solve' *.sol | xargs grep -h '^Total number of states checked' | grep 1200000 | wc -l.
Fully traversed in the extended-range atomic moves preset: 87.
Found using grep -l '^I could not solve' *.sol | xargs grep -h '^Total number of states checked' | grep -v 8200000 | wc -l.
Total: 6,600.
After the atomic scan: 172.
Found using grep -l '^I could not solve' *.sol | xargs grep -l '^Total number of states checked is 1200000\.' | wc -l
After the foss-nessy scan: 134.
After the 8,200,000 range atomic scan:
Killed by the Out-of-memory Killer: ls | perl -lne 'print if -z' | xargs ls -l | wc -l : 17.
Reached the iterations limit:
grep -l '^I could not solve' *.sol | xargs grep -l '^Total number of states checked is 8200000\.' | wc -l: 16.
Total: 33.
Conclusion and Future Directions
The 33 deals that we could not determine whether they were unsolvable or not are: 891, 982, 3129, 5435, 6090, 7214, 7728, 9034, 11266, 12038, 12064, 13659, 13705, 14262, 14445, 14790, 15804, 15957, 16322, 16462, 17184, 17684, 17760, 17880, 18446, 19671, 19678, 20792, 21779, 26124, 27799, 28188, 29577. We would appreciate any further insights about whether they can be solved or not and one option would be to use Freecell solver to solve them on a 64-bit machine with more memory available than what I have.
In the future, we'd like to work on the "States calculated from the original" feature which should reduce memory consumption considerably, especially on 64-bit architectures. After reading the report of Kevin Atkinson's and Shari Holstege's solver it seems that we can also save space by re-using old positions that have been determined to be dead-ends, so we'd like to explore that. We'd also like to explore using an on-disk storage to store the states / positions such as Tokyo Cabinet. That or we can try adding a bigger swap partition.


The page title is displayed prominently in the Action Bar. This is helpful for the user to know exactly where they are.
Display main actions within the Action bar. This allows for users to find important page actions in a consistent area no matter what page they are on within the application.
When there are several main actions for a page, consider displaying them under a contextual menu. This allows the user to look in the same position they are used to but avoids cluttering the action bar with more than 3-4 actions. This also works well for a responsive/adaptive application.


Knowledge extract from FFNN trained on MNIST
Below images are generated "on the fly" by reverse analysis of pre-trained feed forward neural network used in handwritten digits recognition
Approach description and sources on GitHub
| 0 | |
| 1 | |
| 2 | |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 | |
| 9 |
Below images are generated "on the fly" by reverse analysis of pre-trained feed forward neural network used in handwritten digits recognition
Approach description and sources on GitHub
| 0 | |
| 1 | |
| 2 | |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 | |
| 9 |


{%extends "layout.html"%} {%block content%}
We live in a world of evergrowing technology and an overflowing pool of opinions surfing across the various social media platforms particularly Twitter. Therefore, it is the need of the hour for us to be more cautious and considerate of the things we write on the internet to ensure safety, inclusion and respect of all communities. Tweet Analysis gives us a rough idea about the trending hashtags. Try it yourself!


| Class | Description |
|---|---|
| BasisSplineForwardRate |
BasisSplineForwardRate manages the Forward Latent State, using the Forward Rate as the State Response
Representation.
|
| DerivedFXBasis |
DerivedFXBasis manages the constant forward basis based FX Basis Curve holder object.
|
| DerivedFXForward |
DerivedFXForward manages the constant forward based FX Forward Curve holder object.
|
| DerivedZeroRate |
DerivedZeroRate implements the delegated ZeroCurve functionality.
|
| DiscountFactorDiscountCurve |
DiscountFactorDiscountCurve manages the Discounting Latent State, using the Discount Factor as the State
Response Representation.
|
| FlatForwardDiscountCurve |
FlatForwardDiscountCurve manages the Discounting Latent State, using the Forward Rate as the State
Response Representation.
|
| ForwardHazardCreditCurve |
ForwardHazardCreditCurve manages the Survival Latent State, using the Hazard Rate as the State Response
Representation.
|
| NonlinearDiscountFactorDiscountCurve |
NonlinearDiscountFactorDiscountCurve manages the Discounting Latent State, using the Forward Rate as the
State Response Representation.
|
| ZeroRateDiscountCurve |
ZeroRateDiscountCurve manages the Discounting Latent State, using the Zero Rate as the State
Response Representation.
|


{% include "render_form.html" %} {% with form=second_form %} {% include "render_form.html" %} {% endwith %}


@(description: TrailblockDescription, isFront: Boolean, edition: Option[Edition] = None)(implicit request: RequestHeader)


If you have comments or questions send mail to<EMAIL_ADDRESS>Go is a game with simple rules, but can take a lifetime to
master.
Stones
are placed on the board one at a time and cannot be moved. There
are
only
4 simple rules are:
- When a group of stones is completely surrounded they are
captured. Each
capture counts as 1 point at the end.
- Every empty space completely surrounded by a group of stones
of
one
color
counts as a point.
- The board cannot look like it did at any time in the past
(rule
of ko).
- When the 2 players have passed in succession, the game is
over.
If you are not familiar with the rules of go or the following
terms,
see
Mathematical Go by Berlekamp and Wolfe (appendix B).
Terms: liberty, atari, snapback, ko, seki, string, group,
dame
eye, false eye, big
eye, dead stone, independently alive group,
territory, bent 4,
moyo, nobi, ikken tobi, nikken tobi, kogeima
I will try to adhere to Modern Chinese rules.
Here are the unique aspects of Chinese rules that differ
from
other common rulesets:
1) any suicide move is considered illegal
2) When you pass, your opponent gets a point.
(not implemented yet)
For computer go, this is useful
because
it forces
decision/completion of groups to
help
determine life and death and a proper score.
3) the game terminates when the 2 players pass
consecutively
4) score = komi (5.5) + stones on board of player +
player
territory (note: captures not counted)
The computer keeps track of hierarchies of stones. The
pecking
order is:
stones - individual spaces. They can be empty
or
occupied.
strings - tightly connected collections of
stones
(nobi connections only)
groups - connected collections of strings
(nikken
tobi, and kogeima)
armies - loosely connected collections of
groups
(still to do).
Here is a somewhat out of date dependency diagram of the classes
and subpackages:
Things still to do
Estimated days to implement are in ()'s after each item. I
have about 8 hours a weekend. This lists only grows. As I complete
one
task, I typically
add 2 more.
If the list grows no more, it will take me a year until I'm
finished at my current rate.
In reality, I'll probably never finish. That's ok, I'm not
sure I want to. I enjoy doing it.
High Priority Features
- Implement accurate scoring (allow for different types of rule
systems). Score what
it can, and allow for player dispute for score (2)
- If the computer or player resigns, the playerWon vars
should be set and the strength of the win should be large. (1)
- Add test cases for every little method of every class. Use
clover
to verify. (10)
- Parallelize minimax
(http://www.cs.vu.nl/~aske/mtdf.html#abmem)
- Parallelize UCT search (should be easier than concurrent
minimax)
- Parallelize move evaluation. (low priority)
- First 2 plys should look at global moves and do more local
evaluation for deeper levels. (1)
- Consider groups involved in capturing race (semi-eye) (1)
- Recognize seki. No points for either player. (2)
- Only pass if player cannot improve score by playing. Do not
fill
liberties. Fill dames. (1)
- Fix multi-player. Existing open source framework? get simple
case
working.
- Add resignation button.
(1)
- Remember moves that were once deemed important. (2)
- Use runner-up caching (moves that were good in the past are likely to be still good).
- Remember good moves that have
not yet been played. On a big board, they will probably remain good
moves.
These good moves should be at the head of a list when possible
moves are being generated. (2)
- Do automatic weight optimization so it can learn
to play better (4)
- If the computer or player resigns, the playerWon vars should
be
set and the strength of the win should be large.
- Improve performance with profiling (1)
Medium Priority Features
- We could avoid a lot of subclasses if we just specify game
specific classes in the plugin xml and then create the classes
using
reflection in the base class. (1)
- Need to replace sgf (from jigo) files with standard jar.
This may require submitting changes to open source project. (2)
- Same with image processing lib from jhlabs. (2)
- Support for komi (0.5, 5.5 or 6.5).
- Add randomness to computer moves (have option
to disable since sometimes its undesirable) (1)
- Adhere to Chinese rules, add other rulesets as
options. (4)
- Consider monkey jump connections.
- Bill seems to think that I should remove setSize and reset
from
the GameBoard api and just use the constructor.
- Alpha-beta and queiscent setter/getter
methods could be properties of the SearchStrategy instead of the
game
controller.
- Use InputVerifier to validate text type ins.
- Disable << >> buttons as appropriate
- Have female voice repeat all text if sound
on.
(1)
- Run the search in a different thread so
we can quit while animating, and so we can update the game tree
while
animating. Visualize how pruning works. Animate the
game tree rendering. Use VCR like controls to control animation
(2)
- Use kiseido (or GoGui) for front end? (3)
- Try compiling to a native executable with GCJ to improve
performance on windows.
- Defaults for options should come from config/preferences
file rather than hardcode (1) (see jdk1.4 preferences)
- Handle time limits and options. Byo-yomi, etc (2)
- have it play automatically on Kiseido/IGS without intervention
(like many faces of go does) (8)
- Investigate VASSAL framework. Moyoman. Freya Game engine.
- Allow undo/redo of moves in a computer vs. computer game.
- Quick keys (kbd shortcuts).
- Determine end of game. Allow computer to resign.
Bugs
- Reporting that the wrong player has won.
- Don't play in territory at end of game.
- Back up and play black, back up again and play white.
- Profiler timing java.lang.AssertionError: The sum of the child
times(23411) cannot be greater than the parent time (23296)
- pause/continue not working in tree dialog.
- Computer should pass when appropriate. (pretty much working
now)
Packaging issues
- Upgrade to junit 4
- ant deploy could use significant cleanup.
- images on index web page should link directly to applets
(or webstart).
- auto generate images for index page.
- make this text a web page and add a link to it.
- add high level descriptions of class interactions to package
level javadoc (i.e. the architecture) (1).
- cleanup all java doc (2)
- remove all circular dependencies (use pasta from optimalJ) (1)
- put game defaults in a config file rather than having as
constants in controller classes.
- make opensource (3)
- make this a web page
- add html documentation describing architecture
(3)
- write a book about it. Targeting teens year
olds. (50)
Bugs and Verification
- After reloading an SGF file its the wrong player's
turn. (fixed?)
- At end of game, computer plays in its own eyes instead of
passing.
- Confirm can play suicidal move when if captures enemy
stones (1)
- Correct handling of snapbacks (1)
- Sound/speech not working (in applet only? missing libs?)
- When the computer plays in your eye, the eye goes away. It
should
not.


--- layout: page title: About permalink: /about/ display_page_title: false main_image_path: /assets/images/505a04021f008.jpg main_image_caption: Jeni Ross in the studio display_image: false images_first: true frontpage: false homepage_description_markdown: '' frontpagetitle: About display_title: true thumb_crop: false images: - image_path: /uploads/img-2566.jpg image_title: Detail of Woven Tapestry image_description_markdown: - image_path: /assets/images/505a04021f008.jpg image_title: In the studio image_description_markdown: _options: layout: hidden: true main_image_path: width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg image_path: width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg _comments: title: Page title permalink: Be careful editing this display_page_title: Show the page title at the top of the page main_image_path: Image used to represent your page display_image: Show the featured image at the top of the page images_first: display gallery of images BEFORE the main text frontpage: Show this page on the homepage homepage_description_markdown: Text used on homepage if shown frontpagetitle: Alternative title for home page use display_title: Show image titles below images images: Add and edit images here image_description_markdown: Might only be shown in the close up of an image ---
Jeni Ross designs and makes contemporary handwoven tapestries. She also uses mixed media, paint and collages and has designed rugs and tufted wall hangings. Working with yarns offers richness and depth of colour and allows her strong colourful designs to bring texture and content to both homes and public buildings.
Jeni’s work can be seen across the UK, in hospitals, theatres, museums and government buildings.
Jeni is primarily concerned with colour and movement. Influences come from many sources; fine art, performance, literature. Her designs use layers, contrasts and cycles; earth and air, night and day, negative and positive. These are interpreted using qualities of theatre; colour and illumination, the interplay of planes and textures.
Crafts Council Directory selected member.


Gitflow Workflow
What is Gitflow
The Gitflow Workflow is an ideology and a set of operational best practices for DevOps teams. It is a branch-based flow specifically suited for teams and projects with regularly scheduled release cycle.Gitflow is the idea of a workflow for Git projects. The workflow specifies the kinds of branches that should be used and how they should be merged together. The gitflow is basically a set of command line tools and their corresponding installation processes. The installation process for git-flow is extremely easy and straightforward. You can download the packages on almost all operating systems. After installing gitflow you can use it in your project by executing git flow init.
The basic idea of Gitflow is to allow for a divide and conquer approach to development. With the project broken out into multiple parts, different people or groups can work on individual features or ideas without interfering with the main project or each other. This makes it easier for teams to collaborate and allows for the easy distribution of work among large groups as well as small teams.
Gitflow steps:
- A sub-branch called develop is created from the master branch
- Within the develop branch, a release branch is created
- Inside of the release branch, multiple feature branches are created
- When a feature is ready for deployment, it is merged into the develop branch
- When the release branch is done it is merged into develop and master branches
- If an issue in master is detected a hotfix branch is created from master
- Once the hotfix is complete, it is merged to both develop and master
More info about GitFlow Workflow can be found at: datasift.github.io


We received some messages across the world, so we have attached several of them here.
Africa
Please contact us<EMAIL_ADDRESS>if you see other international tributes and we will add it to this page


Originally written for Huddle.com, grumble.js provides special tooltips without the usual limitations of north/east/south/west positioning.
A grumble can be rotated around a given element at any angle, all 360 degrees. Any distance can be specified. Any CSS style can be applied. There's auto-magic size adjustment for use with localised text. FX queues for animating multiple grumbles. And it works in IE6+, and modern browsers.
grumble.js is currently written as a jquery plugin and can be found on Github
$('h1').grumble({ text: 'Bubble-tastic!', angle: 85, distance: 100, showAfter: 500 });
Examples
The following code animates a set of grumbles, click here to see it in action.
No text Different style With close button Enlarged for text$('#grumble1').grumble( { text: '', angle: 200, distance: 3, showAfter: 1000, hideAfter: 2000 } ); $('#grumble2').grumble( { text: 'Ohh, blue...', angle: 180, distance: 0, showAfter: 2000, type: 'alt-', hideAfter: 2000 } ); $('#grumble3').grumble( { text: 'Click me!', angle: 150, distance: 3, showAfter: 3000, hideAfter: false, hasHideButton: true, buttonHideText: 'Pop!' } ); $('#grumble4').grumble( { text: 'Whoaaa, this is a lot of text that i couldn\'t predict', angle: 85, distance: 50, showAfter: 4000, hideAfter: 2000, } ); );


Education
| University College Cork | Business Information Systems 2019-2023: I started studying BIS in 2019 In UCC. I was always interested in this course Because I have a huge interest in bussiness and technology. |
| Scoil Mhuire College |
I attended scoil mhuire in 2013-2019. I sat my Leaving Certification in 2019.
Leaving cert point:495 |
Work Experience
| Fota Island Resort - 2016 |
- Worked as an elf for the believe experience
- Entertained children and aldults
- Helped and served customers
- Always punctual an enthusiastic about whatever job i had to do.
|
| Pairc Ui Caoimhe - 2017-2018 |
- Worked in serving and catering for very important coorporte events
- Prepared food to serve to customers
- Provided exceptional, friendly and fast service
|
Benetton 2019 |
-Work as a sales assistent and maintain excellent customer relations
- Operate the till and handle financial transactions
- Restock the stock room, prepare the clothes for sale
|