Parser specialized for EdX track logs.
|
|
__init__(self,
jsonToRelationConverter,
mainTableName,
logfileID='
' ,
progressEvery=1000,
replaceTables=False,
dbName=' test ' ,
useDisplayNameCache=False)
Constructor |
source code
|
|
|
|
|
|
[<any>]
|
|
|
(String, String, [<any>])
|
resultTriplet(self,
row,
targetTableName,
colNamesToSet=None)
Given an array of column names, and an array of column values,
construct the return triplet needed for JSONToRelation instance to
generate its INSERT statements (see
JSONToRelation.prepareMySQLRow()). |
source code
|
|
|
|
|
|
|
|
|
|
genOneCreateStatement(self,
tableName,
schemaDict,
primaryKeyName=None,
foreignKeyColNames=None,
autoincrement=False)
Given a table name and its ordered schema dict, generate a basic SQL
CREATE TABLE statement. |
source code
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
handleProblemCheck(self,
record,
row,
event)
The problem_check event comes in two flavors (assertained by
observation): The most complex is this one: |
source code
|
|
|
|
|
|
[String]
|
|
|
([String], Dict<String,String>
|
|
|
[String]
|
|
|
[String]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
handleQuestionProblemHidingShowing(self,
record,
row,
event)
Gets a event string like this::
"{"location":"i4x://Education/EDUC115N/combinedopenended/c8af7daea1f54436b0b25930b1631845"}"
After importing from JSON into Python: |
source code
|
|
|
|
handleRubricSelect(self,
record,
row,
event)
Gets a event string like this::
"{"location":"i4x://Education/EDUC115N/combinedopenended/4abb8b47b03d4e3b8c8189b3487f4e8d","selection":"1","category":0}"
{u'category': 0, u'selection': u'1', u'location':
u'i4x://Education/EDUC115N/combinedopenended/4abb8b47b03d4e3b8c8189b3487f4e8d'} |
source code
|
|
|
|
handleOEShowFeedback(self,
record,
row,
event)
All examples seen as of this writing had this field empty:
"{}" |
source code
|
|
|
|
handleOEFeedbackResponseSelected(self,
record,
row,
event)
Gets a event string like this:: "event":
"{"value":"5"}" After JSON import into
Python: {u'value': u'5'} |
source code
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
handleBook(self,
record,
row,
event)
No example of book available |
source code
|
|
|
|
handleShowAnswer(self,
record,
row,
event)
Gets a event string like this:: {"problem_id":
"i4x://Medicine/HRP258/problem/28b525192c4e43daa148dc7308ff495e"} |
source code
|
|
|
|
|
|
|
|
|
|
|
|
|
handleProblemRescore(self,
record,
row,
event)
No example available Fields: state, problemID, orig_score (int),
orig_total(int), new_score(int), new_total(int), correct_map, success
(string 'correct' or 'incorrect'), and attempts(int) |
source code
|
|
|
|
|
|
|
|
|
|
| handleRescoreReset(self,
record,
row,
event) |
source code
|
|
|
|
| handleDeleteStateRescoreSubmission(self,
record,
row,
event) |
source code
|
|
|
|
| handleResetStudentAttempts(self,
record,
row,
event) |
source code
|
|
|
|
| handleGetStudentProgressPage(self,
record,
row,
event) |
source code
|
|
|
|
| handleAddRemoveInstructor(self,
record,
row,
event) |
source code
|
|
|
|
| handleListForumMatters(self,
record,
row,
event) |
source code
|
|
|
|
| handleForumManipulations(self,
record,
row,
event) |
source code
|
|
|
|
| handlePsychometricsHistogramGen(self,
record,
row,
event) |
source code
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
finish(self,
includeCSVLoadCommands=False,
outputDisposition=None)
Called by json_to_relation parent after the last insert for one file
is done. |
source code
|
|
|
|
|
|
|
createMergeAccountTbl(self)
Called at the very end of a load: copies all the entries from the
temporary Account table in the Edx db to the permanent Account table
in EdxPrivate. |
source code
|
|
|
|
|
|
{(String,String) | None}
|
get_course_id(self,
event)
Given a 'pythonized' JSON tracking event object, find the course URL,
and extract the course name from it. |
source code
|
|
|
|
|
|
|
|
|
|
|
|
|
ensureDict(self,
event)
If event is either a dict, or a string with a dict definition inside,
returns a dict. |
source code
|
|
|
|
ensureArray(self,
event)
If event is either a Python array, or a string with an array
definition inside, returns the array. |
source code
|
|
|
String
|
|
|
|
|
|
|
|
|
|
rescueBadJSON(self,
badJSONStr,
row=[ ] )
When JSON strings are not legal, we at least try to extract the
username, host, session, event_type, event_source, and event fields
verbatim, i.e. |
source code
|
|
|
|
|
|
|
getUniqueID(self)
Generate a universally unique key with all characters being legal in
MySQL identifiers. |
source code
|
|
|
|
| getZipAndCountryFromMailAddr(self,
mailAddr,
accountDict) |
source code
|
|
|
String
|
|
|
|
|
|
|
setResourceDisplayName(self,
row,
openEdxHash)
Given an OpenEdx hash of problem ID, video ID, or course ID, set the
resource_display_name in the given row. |
source code
|
|
|
{String | None}
|
extractCanonicalCourseName(self,
trackLogStr)
Given a string believed to be the best course name snippet from a log
entry, use the modulestoreImporter's facilities to get a canonical
name. |
source code
|
|
|
Inherited from object :
__delattr__ ,
__format__ ,
__getattribute__ ,
__hash__ ,
__new__ ,
__reduce__ ,
__reduce_ex__ ,
__repr__ ,
__setattr__ ,
__sizeof__ ,
__str__ ,
__subclasshook__
|
|
|
|
|
|
getReadyForNextRow(self)
To be called after one row has been processed in
processOneJSONObject() of this class or one of its subclasses. |
source code
|
|
|
|
|
|
|
|
|
|
|
|
String
|
|
|
|
|
|
List<<any>>
|
setValInRow(self,
theRow,
colName,
value,
tableName=None)
Given a column name, a value and a partially filled row, add the
column to the row, or set the value in an already existing row. |
source code
|
|


NVTechnology
A cydia repository with useful command tools.
You are almost there!
This page is the Cydia repository.
Copy the address of this page, and paste it into cydia add source tab.
Or, press the button below.
:)


Henry Wadsworth Longfellow: Selected Works
by Henry Wadsworth Longfellow
Midnight Mass for the Dying Year
Additional Information
- Year Published: 2012
- Language: English
- Country of Origin: United States of America
- Source: Henry Wadsworth Longfellow
-
Readability:
- Flesch–Kincaid Level: 8.0
- Word Count: 466
- Genre: Poetry
- ✎ Cite This
Downloads
Yes, the Year is growing old,
And his eye is pale and bleared!
Death, with frosty hand and cold,
Plucks the old man by the beard,
Sorely, sorely!
The leaves are falling, falling,
Solemnly and slow;
Caw! caw! the rooks are calling,
It is a sound of woe,
A sound of woe!
Through woods and mountain passes
The winds, like anthems, roll;
They are chanting solemn masses,
Singing, “Pray for this poor soul,
Pray, pray!”
And the hooded clouds, like friars,
Tell their beads in drops of rain,
And patter their doleful prayers;
But their prayers are all in vain,
All in vain!
There he stands in the foul weather,
The foolish, fond Old Year,
Crowned with wild flowers and with heather,
Like weak, despised Lear,
A king, a king!
Then comes the summer-like day,
Bids the old man rejoice!
His joy! his last! O, the man gray
Loveth that ever-soft voice,
Gentle and low.
To the crimson woods he saith,
To the voice gentle and low
Of the soft air, like a daughter’s breath,
“Pray do not mock me so!
Do not laugh at me!”
And now the sweet day is dead;
Cold in his arms it lies;
No stain from its breath is spread
Over the glassy skies,
No mist or stain!
Then, too, the Old Year dieth,
And the forests utter a moan,
Like the voice of one who crieth
In the wilderness alone,
“Vex not his ghost!”
Then comes, with an awful roar,
Gathering and sounding on,
The storm-wind from Labrador,
The wind Euroclydon,
The storm-wind!
Howl! howl! and from the forest
Sweep the red leaves away!
Would, the sins that thou abhorrest,
O Soul! could thus decay,
And be swept away!
For there shall come a mightier blast,
There shall be a darker day;
And the stars, from heaven down-cast
Like red leaves be swept away!
Kyrie, eleyson!
Christe, eleyson!


We have always been huge Javascript fans and had a ton of experience. We've built complete GoodData Web Application using Javascript. Anyway, we want to unleash everybody who is missing some part of GoodData and want to quickly build it. Tooling? You are in the best place to achieve what you need. You just need to know how to code in Javascript.


This post exposes some of the internals, and the SQL behind QueryScript's split. common_schema/QueryScript 1.1 introduces the split statement, which auto-breaks a "large" query (one which operates on large tables as a whole or without keys) into smaller queries, and executes them in sequence.
This makes for easier transactions, less locks held, potentially (depending on the user) more idle time released back to the database. split has similar concepts to oak-chunk-update and pt-archiver, but works differently, and implemented entirely in SQL on server side.
Take the following statement as example:
split (UPDATE sakila.inventory SET last_update = last_update + INTERVAL 6 HOUR) pass;
It yields with (roughly) the following statements:
UPDATE sakila.inventory SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`inventory`.`inventory_id` > '1')) OR ((`inventory`.`inventory_id` = '1'))) AND (((`inventory`.`inventory_id` < '1000')) OR ((`inventory`.`inventory_id` = '1000')))); UPDATE sakila.inventory SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`inventory`.`inventory_id` > '1000'))) AND (((`inventory`.`inventory_id` < '2000')) OR ((`inventory`.`inventory_id` = '2000')))); UPDATE sakila.inventory SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`inventory`.`inventory_id` > '2000'))) AND (((`inventory`.`inventory_id` < '3000')) OR ((`inventory`.`inventory_id` = '3000')))); UPDATE sakila.inventory SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`inventory`.`inventory_id` > '3000'))) AND (((`inventory`.`inventory_id` < '4000')) OR ((`inventory`.`inventory_id` = '4000')))); UPDATE sakila.inventory SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`inventory`.`inventory_id` > '4000'))) AND (((`inventory`.`inventory_id` < '4581')) OR ((`inventory`.`inventory_id` = '4581'))));
(I say "roughly" because internally there are user defined variables at play, but for convenience, I verbose the actual values as constants.)
How does that work?
common_schema works on server side. There is no Perl script or anything. It must therefore use server-side operations to:
- Identify table to be split
- Analyze the table in the first place, deciding how to split it
- Analyze the query, deciding on how to rewrite it
- Split the table (logically) into unique and distinct chunks
- Work out the query on each such chunk
Following is an internal look at how common_schema does all the above.
Identifying the table
When query operates on a single table, split is able to parse the query's SQL and find out that table. When multiple tables are involved, split requires user instruction: which table is it that the query should be split by?
Analyzing the table
Table analysis is done via a similar method to candidate_keys_recommended. It is almost identical, only it uses INFORMATION_SCHEMA optimizations to make the query short and lightweight. Simulating the analysis using candidate_keys_recommended, we get:
mysql> select * from candidate_keys_recommended where table_name='inventory' \G *************************** 1. row *************************** table_schema: sakila table_name: inventory recommended_index_name: PRIMARY has_nullable: 0 is_primary: 1 count_column_in_index: 1 column_names: inventory_id
This is cool, simple and very easy to work with: we choose to split the table via the inventory_id column, which is conveniently an integer. We'll soon see split can handle complex cases as well.
Analyzing the query
This is done in part via Roland's query_analysis_routines, and in part just parsing the query, looking for WHERE, GROUP BY, LIMIT etc. clauses.
The nice part is injecting a WHERE condition, which didn't appear in the original query. That WHERE condition is what limits the query to a distinct chunk of rows.
Splitting the table
With a single INTEGER PRIMARY KEY this sounds simple, right? Take rows 1..1,000, then 1,001..2,000, then 2,001..3,000 etc.
Wrong: even with this simple scenario, things are much more complex. Are the numbers successive? What if there are holes? What if there is a 1,000,000 gap between every two numbers? What if there are multiple holes of differing size and frequency?
And if we have two columns in our UNIQUE KEY? What if one of them is textual, not an INTEGER, the other a TIMESTAMP, not an INTEGER either?
split doesn't work in that naive way. It makes no assumptions on the density of values. It only requires:
- some UNIQUE KEY to work with,
- which has no NULL values.
Given the above, it uses User Defined Variables to setup the chunks. With our single INTEGER column, the minimum value is set like this:
select inventory_id from `sakila`.`inventory` order by inventory_id ASC limit 1 into @_split_column_variable_min_1 ;
This sets the first value of the first chunk. What value terminates this chunk? It is calculated like this:
select inventory_id from ( select inventory_id from `sakila`.`inventory` where (((`inventory`.`inventory_id` > @_split_column_variable_range_start_1)) OR ((`inventory`.`inventory_id` = @_split_column_variable_range_start_1))) and (((`inventory`.`inventory_id` < @_split_column_variable_max_1)) OR ((`inventory`.`inventory_id` = @_split_column_variable_max_1))) order by inventory_id ASC limit 1000 ) sel_split_range order by inventory_id DESC limit 1 into @_split_column_variable_range_end_1 ;
Now there's a query you wouldn't want to work by hand, now would you?
The cool part here is that the above works well for any type of column; this doesn't have to be an INTEGER. Dates, strings etc. are all just fine.
The above also works well for multiple columns, where the query gets more complicated (see following).
Working out the query per chunk
This part is the easy one, now that all the hard work is done. We know ho to manipulate the query, we know the lower and upper boundaries of the chunk, so we just fill in the values and execute.
Multi-columns keys
Consider a similar query on sakila.film_actor, where the PRIMARY KEY is a compound of two columns:
split (UPDATE sakila.film_actor SET last_update = last_update + INTERVAL 6 HOUR) throttle 2;
The chunked queries will look like this:
UPDATE sakila.film_actor SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`film_actor`.`actor_id` > '1')) OR ((`film_actor`.`actor_id` = '1') AND (`film_actor`.`film_id` > '1')) OR ((`film_actor`.`actor_id` = '1') AND (`film_actor`.`film_id` = '1'))) AND (((`film_actor`.`actor_id` < '39')) OR ((`film_actor`.`actor_id` = '39') AND (`film_actor`.`film_id` < '293')) OR ((`film_actor`.`actor_id` = '39') AND (`film_actor`.`film_id` = '293')))); UPDATE sakila.film_actor SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`film_actor`.`actor_id` > '39')) OR ((`film_actor`.`actor_id` = '39') AND (`film_actor`.`film_id` > '293'))) AND (((`film_actor`.`actor_id` < '76')) OR ((`film_actor`.`actor_id` = '76') AND (`film_actor`.`film_id` < '234')) OR ((`film_actor`.`actor_id` = '76') AND (`film_actor`.`film_id` = '234')))); UPDATE sakila.film_actor SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`film_actor`.`actor_id` > '76')) OR ((`film_actor`.`actor_id` = '76') AND (`film_actor`.`film_id` > '234'))) AND (((`film_actor`.`actor_id` < '110')) OR ((`film_actor`.`actor_id` = '110') AND (`film_actor`.`film_id` < '513')) OR ((`film_actor`.`actor_id` = '110') AND (`film_actor`.`film_id` = '513')))); UPDATE sakila.film_actor SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`film_actor`.`actor_id` > '110')) OR ((`film_actor`.`actor_id` = '110') AND (`film_actor`.`film_id` > '513'))) AND (((`film_actor`.`actor_id` < '146')) OR ((`film_actor`.`actor_id` = '146') AND (`film_actor`.`film_id` < '278')) OR ((`film_actor`.`actor_id` = '146') AND (`film_actor`.`film_id` = '278')))); UPDATE sakila.film_actor SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`film_actor`.`actor_id` > '146')) OR ((`film_actor`.`actor_id` = '146') AND (`film_actor`.`film_id` > '278'))) AND (((`film_actor`.`actor_id` < '183')) OR ((`film_actor`.`actor_id` = '183') AND (`film_actor`.`film_id` < '862')) OR ((`film_actor`.`actor_id` = '183') AND (`film_actor`.`film_id` = '862')))); UPDATE sakila.film_actor SET last_update = last_update + INTERVAL 6 HOUR WHERE ((((`film_actor`.`actor_id` > '183')) OR ((`film_actor`.`actor_id` = '183') AND (`film_actor`.`film_id` > '862'))) AND (((`film_actor`.`actor_id` < '200')) OR ((`film_actor`.`actor_id` = '200') AND (`film_actor`.`film_id` < '993')) OR ((`film_actor`.`actor_id` = '200') AND (`film_actor`.`film_id` = '993'))));
View the complete command to realize just how much more complex each query is, and how much more complex the chunking becomes. Here's how I evaluate the chunk's "next range end" variables:
select actor_id, film_id from ( select actor_id, film_id from `sakila`.`film_actor` where (((`film_actor`.`actor_id` > @_split_column_variable_range_start_1)) OR ((`film_actor`. `actor_id` = @_split_column_variable_range_start_1) AND (`film_actor`.`film_id` > @_split_column_variable_range_start_2))) and (((`film_actor`.`actor_id` < @_split_column_variable_max_1)) OR ((`film_actor`.`actor_id` = @_split_column_variable_max_1) AND (`film_actor`.`film_id` < @_split_column_variable_max_2)) OR ((`film_actor`.`actor_id` = @_split_column_variable_max_1) AND (`film_actor`.`film_id` = @_split_column_variable_max_2))) order by actor_id ASC, film_id ASC limit 1000 ) sel_split_range order by actor_id DESC, film_id DESC limit 1 into @_split_column_variable_range_end_1, @_split_column_variable_range_end_2 ;
By the way, you may recall that everything is done server side. The WHERE condition for the chunked queries is in itself generated via SQL statement, and not too much by programmatic logic. Here's part of the query which computes the limiting condition:
select group_concat('(', partial_comparison, ')' order by n separator ' OR ') as comparison from ( select n, group_concat('(', column_name, ' ', if(is_last, comparison_operator, '='), ' ', variable_name, ')' order by column_order separator ' AND ') as partial_comparison from ( select n, CONCAT(mysql_qualify(split_table_name), '.', mysql_qualify(column_name)) AS column_name, case split_variable_type when 'range_start' then range_start_variable_name when 'range_end' then range_end_variable_name when 'max' then max_variable_name end as variable_name, _split_column_names_table.column_order, _split_column_names_table.column_order = n as is_last from numbers, _split_column_names_table where n between _split_column_names_table.column_order and num_split_columns order by n, _split_column_names_table.column_order ) s1 group by n ) s2 into return_value ;
There is a lot of complexity to split to make it able to provide with as clean a syntax for the user as possible.
comments powered by Disqus


CJ Wilson
From Zero to Zen: Software Development is Practice
Loops in JavaScript
Looping in Ruby vs. JavaScript
February 26, 2015
Loops, loops, and more loops--during my brief time programming, it's hard to recall a program I've written that didn't benefit from a loop. Loops help programmers repeat sequences of code succinctly. Simply put they're vital operators to most programs. The two main types of loops are ones that perform an action a certain number of times and ones that perform an action until a condition is met. Ruby and Javascript both perform these loops, but there are some differences worth reviewing.
Ruby has several built-in methods like each, map, and times
to easily specify how many times to perform an action. Take the following example:
1..5.times {|x| puts "I like repeating myself in Ruby."}
I like repeating myself in Ruby!
I like repeating myself in Ruby!
I like repeating myself in Ruby!
I like repeating myself in Ruby!
I like repeating myself in Ruby!
Above I simply specify a range (1 through 5) and call the times method to perform whatever is inside the curly braces (block) for the specified number of times. Pretty easy! Additionally Ruby can perform an action until a specific condition is met. Let's review a simple loop:num=0
while num <=5 do
puts num
num+=1
end
0
1
2
3
4
5
Again we have another easy to read loop. We define num as 0 and tell the program that we want to perform the body of the code while num is less than or equal to 5. We put num then add 1 to the value of num for every iteration of the loop. The loop stops once num=5.
Although the syntax is different, Javascript is certainly capable of handling loops. The biggest difference between the two languages is that Javascript does not have numerous built in methods to iterate a certain number of times--the keyword for
is the only available method to perform an action a certain number of times. This unfortunately looks slightly more complicated at first glance.
for (var x=0; x < 5; x++) {console.log("I like to repeat myself in Javascript!")}; I like to repeat myself in Javascript! I like to repeat myself in Javascript! I like to repeat myself in Javascript! I like to repeat myself in Javascript! I like to repeat myself in Javascript!In the code above, we have an initialization statement (var x=0) that defines our variable in order to initialize a counter variable. Next we have a condition (x < 5) that tells the code to execute when x is less than 5. By default the condition statement will default to true. If the condition is true, the code will execute. Next we have our final-expression (x++) which tells the code what to do after each execution of the loop. In this case, ++ adds 1 to x. This is the same as saying x=+ 1, which we are familiar with from Ruby. Finally we have our block of code that we want to perform for each iteration.
Javascript uses a while statement similar to Ruby; the main difference here is the syntax. Below we define our variable num to equal 0. Then we start our while statement--the conditional is inside parentheses immediately following the while. Inside our block, we print out the value for num then add 1 to the value of num for each execution of the loop. The code iterates through the loop for numbers 0-5 then returns the final value of num.
var num=0; while (num<=5) { console.log(num) num++; } 0 1 2 3 4 5 =>5Javascript looks daunting and confusing at first, but just like with Ruby, the more you use loops, the easier they become to write. In a way Javascript has a pretty neat and clean way to type out a loop statement. Onto more practice!


--- layout: default title: About published: true ---
We are group of young people from Latvia, Lithuania, Estonia and Belarus, who with a help of Erasmus+ funding got a chance to discover Latvian borderline and its hidden treasures. During the youth exchange project „Reach The Border” (23.07.15.-02.08.15.) 23 young people came to Sigulda to share their love for travel and discovery, challenge themselves, learn about each other and work as a group with one aim – to travel to different borderline parts of Latvia by bus or hitchhiking, to camp or stay with locals and make a research about the people they encounter, to learn what the border means for them and how they are living there.
Our group was divided in seven teams, with three members in each, who went to Daugavpils/Zarasai, Eleja/Žagarai, Liepāja, Ventspils, Kolka/Roja, Ainaži/Ikla and Valka/Valga. We explored the borders with Lithuania, Estonia and even the sea, which nowadays does not seem like a border anymore in people minds.
During our travels we saw that there are so many different borders. Physical borders are between one country and another, as a fence between one house and the neighbouring one, as a line you need permission to cross. Even if nowadays these borders between Latvia, Lithuania and Estonia are not there anymore, it is easy to cross them and sometimes even hard to notice that you have arrived in a new country (only road quality changes..). Even the sea is open for everyone; but talking with older locals we saw that it was not always like this. Did you know that even to get to the seaside, for example, at Roja, you needed a special permission? Today, if you ask younger people, they do not think any more about this line where land meets sea as a border and it is only an opportunity to fish or to swim.
Today when physical borders are gone between sea, Lithuania, Latvia and Estonia, they are visible only in language where it becomes the most important border between two groups of people. Like it was in Valka/Valga situation where mobility in city is easy but people still are separated in two groups because of language differences. We observed that on the borderline locals feel responsibility to know both languages because it is a way to show respect. The language border was possible to see also in Daugavpils where one of the locals even described the people as something different to other citizens of Latvia because of the language differences. Also in Zemgale children used language as a reason for division between two children groups – Latvians and Lithuanians.
But while we were searching for borders we found out how flexible they are and how well the cooperation can be created. In border between Latvia and Lithuania locals talked about their belonging to a country and as an example used sports. If they are watching hockey, they will go for team of Latvia, but while watching basketball, they will go for Lithuania.
The border is not just a fence between groups of citizens. People on borderline have relatives on both sides of border; many of them knew both languages or were born on the other country.
When locals were asked about the border crossing, usually they emphasised that they are going after something on the other side and there always was one thing that the other side of border had better than here. For example, people went for shops, saunas or some special food that is very good or just cheaper than on their side. The border still exists in people minds because they know, that they arrive in a different land that is not theirs, they arrive in a different group, where they do not feel themselves as belonging, but the many opportunities other side brings is a reason for mobility and destruction of borders. However raising mobility becomes a reason for migration when the young people decide to leave the land of their parents and search for opportunities in bigger cities; therefore the villages and smaller cities of borderline were mostly inhabited with old people.
this team travelled to Eleja (LV) and Žagirai (LT) so they even crossed the border, learned about the division and cooperation between Latvians and Lithuanians and wrote a story with pictures of locals.
they chose the part of Latvia where the border between sea and land meets with the border between Latvia and Estonia. They met people in villages that became a source of interesting photos (Even though the cameraman managed to mess up 3 of the 5 important photos).
their road went to Roja and Kolka where they saw the meeting point of two seas and the land. During discussions with locals they learned about migration and the borderline in history that allowed collecting diverse stories and creating videos with interviews.
this team used a chance to learn more about Ventspils, borderline with a sea and talked with locals and tourists in this city to make pictures and even drawings about their impressions.
this teams road went to Liepāja where they looked not only on the border between land and sea, but also looked deeper for the borders in their own minds.
this team made the long travel to Daugavpils and learned how warm and welcoming are the people in this region. They have made pictures and video from interviews.
the team decided to cross Vidzeme and go to Valka/Valga to talk with locals and observe how one city can be divided by two nationalities. They have made pictures and video story about their trips with statistics of their travel.
Summer 2015


Hi,
I'am Cyrus Kunwar
Software Developer
Resume
About Me
I'm analytical minded Junior student at Alcorn State University, interested in the position of Software Developer. Coming with sound knowledge of basic computer system analysis, design, testing, debugging, and maintenance techniques and practices; and ability to develop programs and program specifications.
Relevant CourseWork
Skills
Profesional Skills
C++
90%
Python
85%
HTML&CSS
60%
JavaScript
45%


| ID | Client ID | Client IP | Status | Client Type | Connected At | Disconnected At | Created At |
|---|---|---|---|---|---|---|---|
| {{ client.id }} | {{ client.client_id }} | {{ client.client_ip }} | {{ client.status }} | {{ client.type }} | {{ client.connected_at }} | {{ client.disconnected_at }} | {{ client.created_at }} |


[True / False] The following expression is a syntactically correct SLang 1 program.
expression
Review the syntax for the five types of expressions in SLang 1.
Pay particular attention to the positions of spaces and commas.
This exercise is about syntax, not semantics. A syntactically correct program only has to have a parse tree according to the grammar for SLang 1; it does not have to make sense!
hint4


{% extends 'layout.html' %} {% set pageHeading = "Check if you can apply for a Test and Trace Support Payment" %} {% block pageTitle %} {{pageHeading}} | {{serviceName}} {% endblock %} {% block beforeContent %} {% endblock %} {% block content %}
You can use this service if the NHS COVID-19 app has detected that you have been in contact with a person who has coronavirus. This means you are advised to self-isolate.
You may be entitled to a payment of £500 from your local authority under the Test and Trace Support Payment scheme if you are:
You will need to answer some questions in the next section to check whether you could be eligible.
You cannot claim this payment more than once within a self-isolation period. You can claim it for separate self-isolation periods, as long as they do not overlap with each other.
If you have technical problems while you are using this service, select the ‘Financial support’ button in the app and find the link for Help to apply for the Test and Trace Support Payment.
{{ insetText({ "HTML": "Before you can apply for the payment, you will need to register with NHS Test and Trace, as we need to know who you are to check your eligibility. You have left the app to do this because in the app you are anonymous.
To claim this payment, you need to register before your self-isolation period finishes. You can check this using the self-isolation countdown timer in the app.
" }) }}


This article is a demo of Story’s beautiful typography.
Story is designed to showcase long-form content such as essays and technical blog posts. It is built for readability and grace in both screen and print media at all sizes.
Try opening your print dialog and saving this page as a PDF. Now try viewing this page on a cellphone.
Story supports text justification and hyphenation. Click here to toggle hyphenation and justification. These features can
be enabled or disabled with the feature-[no]hyphenate
and
feature-[no]justify
feature flags.
Moby-Dick; Or, The Whale: Heading Level 3
Story reserves H1 and H2 for its own use, and assumes you’ll use H3 in your content.
To hide subtitles, use the feature-nosubtitle
feature.
Floated images occasionally interfere with content, usually headings.
Story provides feature flags to add clears (left, right, and both) to

elements.
Call me Ishmael. Some years ago—never mind how long precisely—having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. It is a way I have of driving off the spleen and regulating the circulation. Whenever I find myself growing grim about the mouth; whenever it is a damp, drizzly November in my soul; whenever I find myself involuntarily pausing before coffin warehouses, and bringing up the rear of every funeral I meet; and especially whenever my hypos get such an upper hand of me, that it requires a strong moral principle to prevent me from deliberately stepping into the street, and methodically knocking people’s hats off—then, I account it high time to get to sea as soon as I can.
Fleuron and Dinkus: Heading Level 4
An

tag can be rendered as a fleuron, with the feature-hrfleuron
flag. It
can also be a dinkus if you like; use the feature-hrdinkus
flag. Both are
negatable and implemented in CSS. Here’s a demo. You can toggle these features
with feature-hrfleuron and feature-hrdinkus.
Call me Ishmael. Some years ago—never mind how long precisely—having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. It is a way I have of driving off the spleen and regulating the circulation.
Story has support for syntax highlighting inside of code blocks. It uses
highlight.js for this. This feature is controlled with the feature-[no]highlight
flag.
function $initHighlight(block, cls) {
try {
if (cls.search(/\bno\-highlight\b/) != -1)
return process(block, true, 0x0F) +
` class="${cls}"`;
} catch (e) {
/* handle exception */
}
for (var i = 0 / 2; i < classes.length; i++) {
if (checkCondition(classes[i]) === undefined)
console.log('undefined');
}
}
export $initHighlight;
Here is text with emphasis and boldness; strikethrough.^[A footnote]
This is a blockquote. I thought I would sail about the unimaginative incomprehensibilities of the watery part of the world. It is a way I have of driving off the spleen and regulating the circulation. (This quote is a demo of justification and hyphenation.)
Blockquotes can nest.
Here is an unordered list:
- Item one
- Item two
- Item three is longer. I thought I would sail about a little and see the unimaginative incomprehensibilities of the watery part of the world. It is a way I have of driving off the spleen and regulating the circulation. (This is a justification and hyphenation demo.)
And an ordered list:
- Item one
- Item two
- Item three is longer. I thought I would sail about a little and see the unimaginative incomprehensibilities of the watery part of the world. It is a way I have of driving off the spleen and regulating the circulation. (This is a justification and hyphenation demo.)
Quotes That Link To Tweets
If you don’t like embedding tweets, Story has a cleaner way to quote and link to a tweet. Just blockquote the content and begin it with a link containing the author’s name and the tweet’s permalink, and enable the feature-tweetquote
flag. Story will transform the quote to resemble a simplistic tweet styling. If the flag isn’t enabled, normal blockquote styling applies.
Monitoring tells you whether the system works. Observability lets you ask why it’s not working.
Read next: Story’s MailChimp subscribe forms and RSS feeds.


influenza al.: infants vaccination Influenza vaccine pregnancy months virus antibodies younger infection maternal women Infect {border-style pregnant px;} #ffffff;} Recommendation laboratory-confirmed young Dis.;():–. IIV age old protection higher hospitalizations children respiratory South disease severe vaccines antibody burden illness mothers Med.;():–. associated effect efficacy hospitalization influenza-associated trial viruses weeks inactivated pandemic reported review safety studies transfer ./j.vaccine... African Engl HIV-infected Maternal Research clinical deaths different hemagglutinin levels lower px; rates risk study systematic vaccinated year {font-family adverse attenuated born font-size immunization immunogenicity live need pediatric preventing randomized seasonal trials years Global However, IgG Prevention Vaccination double; increased infant infections life pregnancy, received responses role ./NEJMoa ./S-()- HIV-uninfected Safety USA United border-color border-width breastmilk compared demonstrated fetal fetus highest immune mother neonatal neonates number observational older outpatient similar solid; time transferred transport trivalent {font-style {font-weight Africa Bangladesh Dis Furthermore, HIV-exposed Health Infants Pregnancy States, Vaccine acute antigenic antigens approved available bacterial bold causes common complications concentrations controlled courier; data death delivery detected early em; especially evidence hospitalized human immunity immunoglobulin including infants, infants: infection, influenza-specific mortality occur old. outcomes placebo pregnancy: prevent prevention provide pt;} recent season second use used versus viral


FindOpenSceneGraph¶
Find OpenSceneGraph (3D graphics application programming interface)
This module searches for the OpenSceneGraph core “osg” library as well
as FindOpenThreads
, and whatever additional COMPONENTS
(nodekits) that you specify.
See http://www.openscenegraph.org
NOTE: To use this module effectively you must either require CMake >=
2.6.3
with cmake_minimum_required(VERSION 2.6.3)
or download
and place FindOpenThreads
, Findosg
functions,
Findosg
and Find<etc>.cmake
files into your
CMAKE_MODULE_PATH
.
This module accepts the following variables (note mixed case)
OpenSceneGraph_DEBUG - Enable debugging output
OpenSceneGraph_MARK_AS_ADVANCED - Mark cache variables as advanced
automatically
The following environment variables are also respected for finding the
OSG and it’s various components. CMAKE_PREFIX_PATH
can also be
used for this (see find_library()
CMake documentation).
<MODULE>_DIR
- (where
MODULE
is of the form “OSGVOLUME” and there is aFindosgVolume
.cmake` file) OSG_DIR
OSGDIR
OSG_ROOT
[CMake 2.8.10]: The CMake variable OSG_DIR
can now be used as well to
influence detection, instead of needing to specify an environment
variable.
This module defines the following output variables:
OPENSCENEGRAPH_FOUND - Was the OSG and all of the specified components found?
OPENSCENEGRAPH_VERSION - The version of the OSG which was found
OPENSCENEGRAPH_INCLUDE_DIRS - Where to find the headers
OPENSCENEGRAPH_LIBRARIES - The OSG libraries
================================== Example Usage:
find_package(OpenSceneGraph 2.0.0 REQUIRED osgDB osgUtil)
# libOpenThreads & libosg automatically searched
include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS})
add_executable(foo foo.cc)
target_link_libraries(foo ${OPENSCENEGRAPH_LIBRARIES})


Puppy Squad
"San Diego's Premiere Dog Meetup Site!"
Login/Sign Up
My Profile
Account Settings
Logout
Toggle navigation
Events
Create Event
About/FAQ
×
Login or Sign Up
Email
Password
No Account? Sign Up
Here
!
Back
Full Name
Email
Password
Confirm Password
Business Account
Yes
No
Account made! Enjoy the site.
<EMAIL_ADDRESS>Upload Photo
My Dogs
My Attending Events
My Created Events


Thanks for dropping by! I'm originally from a small town in Fairfield County Connecticut and attended Skidmore College in upstate New York. I studied Government and Anthropology. After graduating in 2011, I took a leap and moved to Chicago - my current home. I started doing sales for a large startup and continued my sales career at LinkedIn.
In October of 2015, I welcomed my French Bulldog companion Tinkerbell into my life. We're best buds and enjoy exploring the city every chance we get! I'm a connoisseur of dog friendly establishments and when the weather permits, we can be found soaking up rays on a dog-friendly patio.


Login
Logout
Transfer
Call Contract
Vote
Generate Key
Query Account By Name
Get Balance
Check Extension
getArbitrarySignature


Toggle navigation
User Management System
New User
4 minutes ago
New User
6 minutes ago
New User
10 minutes ago
New User
14 minutes ago
New User
22 minutes ago
See All Alerts
User registration
User list


The Boost C++ Libraries
This book is licensed under a Creative Commons License.
The Boost C++ Library Serialization allows to convert objects in a C++ application into a sequence of bytes that can be saved and loaded again at a later time to restore the objects. Different data formats, including XML, are available that specify the rules after which the sequence of bytes is generated. All of the formats supported by Boost.Serialization are proprietary in some respect. For example, the XML format cannot be used to exchange data with other applications that were not developed in C++ using Boost.Serialization. All data stored in the XML format is geared towards restoring the same C++ objects previously saved. The solely advantage of the XML format is the better understanding of serialized C++ objects which is helpful during e.g. debugging.
The main concept of Boost.Serialization is the archive. An archive is a sequence of bytes representing serialized C++ objects. Objects can be added to an archive to serialize them or be loaded from one, respectively. In order to restore the same C++ objects previously saved, the same data types are presumed.
The following is a simple example.
#include <boost/archive/text_oarchive.hpp> #include <iostream> int main() { boost::archive::text_oarchive oa(std::cout); int i = 1; oa << i; }
Boost.Serialization provides multiple archive classes such as boost::archive::text_oarchive
defined in boost/archive/text_oarchive.hpp
. boost::archive::text_oarchive
allows the serialization of objects as a text stream. The above application writes 22 serialization::archive 5 1
to the standard output stream.
As can be seen, the object oa of type boost::archive::text_oarchive
can be used just like a stream to serialize a variable via <<
. Nonetheless, archives should not be considered as regular streams storing arbitrary data. In order to restore the data at a later point, it is necessary to use the same data types in the same order they were previously saved. The following example serializes and restores the variable of type int
.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <iostream> #include <fstream> void save() { std::ofstream file("archiv.txt"); boost::archive::text_oarchive oa(file); int i = 1; oa << i; } void load() { std::ifstream file("archiv.txt"); boost::archive::text_iarchive ia(file); int i = 0; ia >> i; std::cout << i << std::endl; } int main() { save(); load(); }
While boost::archive::text_oarchive
is used to serialize data as a text stream, boost::archive::text_iarchive
is used to restore data from such a text stream. In order to use the class, the header file boost/archive/text_iarchive.hpp
must be included.
Constructors of archives expect an input or output stream as the argument. The stream is used to serialize or to restore data, respectively. While above application accesses a file, other streams such as a stringstream could be used alternatively.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <iostream> #include <sstream> std::stringstream ss; void save() { boost::archive::text_oarchive oa(ss); int i = 1; oa << i; } void load() { boost::archive::text_iarchive ia(ss); int i = 0; ia >> i; std::cout << i << std::endl; } int main() { save(); load(); }
The application also writes 1
to the standard output stream. However, opposed to the previous one, data is serialized using a stringstream instead.
So far, primitive data types have been serialized. The following example shows how to serialize objects of user defined data types.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <iostream> #include <sstream> std::stringstream ss; class person { public: person() { } person(int age) : age_(age) { } int age() const { return age_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & age_; } int age_; }; void save() { boost::archive::text_oarchive oa(ss); person p(31); oa << p; } void load() { boost::archive::text_iarchive ia(ss); person p; ia >> p; std::cout << p.age() << std::endl; } int main() { save(); load(); }
In order to serialize objects of user defined data types, a method named serialize()
must be defined which is called if the object is serialized to or restored from a byte stream. Since serialize()
is used for both serializing and restoring, Boost.Serialization offers the operator &
in addition to the <<
and >>
ones. If used, there is no longer the need to distinguish between serializing and restoring within the serialize()
method.
serialize()
is automatically called any time an object is serialized or restored. It should never be called explicitly and thus should be declared as private. In this case, the class boost::serialization::access
must be declared as friend which allows Boost.Serialization to access the method.
There may be situations that do not allow to modify an existing class in order to add the serialize()
method. This is for example true for classes from the C++ standard or any other library.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <iostream> #include <sstream> std::stringstream ss; class person { public: person() { } person(int age) : age_(age) { } int age() const { return age_; } private: friend class boost::serialization::access; template <typename Archive> friend void serialize(Archive &ar, person &p, const unsigned int version); int age_; }; template <typename Archive> void serialize(Archive &ar, person &p, const unsigned int version) { ar & p.age_; } void save() { boost::archive::text_oarchive oa(ss); person p(31); oa << p; } void load() { boost::archive::text_iarchive ia(ss); person p; ia >> p; std::cout << p.age() << std::endl; } int main() { save(); load(); }
In order to serialize data types that cannot be modified, the free-standing function serialize()
can be defined as shown in the above example. The function expects a reference to an object of the corresponding data type as its second argument.
If the data type to be serialized contains private properties which cannot be accessed via public methods, things get more complicated. In this case, the data type may need to be modified. The serialize()
function in the above application would not be able to access the age_ property without the friend
declaration.
Fortunately, Boost.Serialization provides corresponding serialize()
functions for many classes of the C++ standard. To serialize objects based on C++ standard classes, additional header files need to be included.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/string.hpp> #include <iostream> #include <sstream> #include <string> std::stringstream ss; class person { public: person() { } person(int age, const std::string &name) : age_(age), name_(name) { } int age() const { return age_; } std::string name() const { return name_; } private: friend class boost::serialization::access; template <typename Archive> friend void serialize(Archive &ar, person &p, const unsigned int version); int age_; std::string name_; }; template <typename Archive> void serialize(Archive &ar, person &p, const unsigned int version) { ar & p.age_; ar & p.name_; } void save() { boost::archive::text_oarchive oa(ss); person p(31, "Boris"); oa << p; } void load() { boost::archive::text_iarchive ia(ss); person p; ia >> p; std::cout << p.age() << std::endl; std::cout << p.name() << std::endl; } int main() { save(); load(); }
The example extends the person
class by a name of type std::string
. In order to serialize this property, the header file boost/serialization/string.hpp
must be included which offers the appropriate free-standing serialize()
function.
As mentioned before, Boost.Serialization defines serialize()
functions for many classes of the C++ standard. These are defined in header files that carry the same name as the corresponding header files from the C++ standard. In order to serialize objects of type std::string
, the header file boost/serialization/string.hpp
must be included. For serializing an object of type std::vector
, the header file boost/serialization/vector.hpp
must be used instead. It is therefore fairly obvious which header file must be included in any given scenario.
One argument of serialize()
, which has been ignored so far, is version. This argument is relevant if archives should be forward compatible to support future versions of the given application. The next example considers archives of the person
class as being forward compatible. Since the original version of person
did not contain any name, the new version of person
still should be able to manage old archives created without the name.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/string.hpp> #include <iostream> #include <sstream> #include <string> std::stringstream ss; class person { public: person() { } person(int age, const std::string &name) : age_(age), name_(name) { } int age() const { return age_; } std::string name() const { return name_; } private: friend class boost::serialization::access; template <typename Archive> friend void serialize(Archive &ar, person &p, const unsigned int version); int age_; std::string name_; }; template <typename Archive> void serialize(Archive &ar, person &p, const unsigned int version) { ar & p.age_; if (version > 0) ar & p.name_; } BOOST_CLASS_VERSION(person, 1) void save() { boost::archive::text_oarchive oa(ss); person p(31, "Boris"); oa << p; } void load() { boost::archive::text_iarchive ia(ss); person p; ia >> p; std::cout << p.age() << std::endl; std::cout << p.name() << std::endl; } int main() { save(); load(); }
The macro BOOST_CLASS_VERSION
is used to specify a version number to a class. The version number for the person
class in the above application is set to 1. If BOOST_CLASS_VERSION
is not used, the version number is 0 by default.
The version number is stored within the archive and thus is part of it. While the version number specified for a particular class via the BOOST_CLASS_VERSION
macro is used during serialization, the version argument of serialize()
is set to the value stored in the archive when the object is restored. If the new version of person
accesses an archive containing an object serialized with the old version, the name_ property would not be restored since the old version did not contain such a property. Forward compatible archives are therefore supported by Boost.Serialization via this mechanism.
Boost.Serialization can also serialize pointers and references. Since a pointer stores the address of an object, serializing the address certainly does not make much sense. While serializing pointers and references, the object referenced is automatically serialized instead.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <iostream> #include <sstream> std::stringstream ss; class person { public: person() { } person(int age) : age_(age) { } int age() const { return age_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & age_; } int age_; }; void save() { boost::archive::text_oarchive oa(ss); person *p = new person(31); oa << p; std::cout << std::hex << p << std::endl; delete p; } void load() { boost::archive::text_iarchive ia(ss); person *p; ia >> p; std::cout << std::hex << p << std::endl; std::cout << p->age() << std::endl; delete p; } int main() { save(); load(); }
The above application creates a new object of type person
using new
and assigns it to the pointer p. The pointer - not *p
- is then serialized. Boost.Serialization automatically serializes the object itself as referenced by p and not the address of the object.
If the archive is restored, p does not necessarily refer to the same address. A new object is created and its address is assigned to p instead. Boost.Serialization only guarantees that the object is identical to the one serialized, not that its address is the same.
Since modern C++ uses smart pointers in connection with dynamically allocated memory, Boost.Serialization provides support accordingly.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/scoped_ptr.hpp> #include <boost/scoped_ptr.hpp> #include <iostream> #include <sstream> std::stringstream ss; class person { public: person() { } person(int age) : age_(age) { } int age() const { return age_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & age_; } int age_; }; void save() { boost::archive::text_oarchive oa(ss); boost::scoped_ptr<person> p(new person(31)); oa << p; } void load() { boost::archive::text_iarchive ia(ss); boost::scoped_ptr<person> p; ia >> p; std::cout << p->age() << std::endl; } int main() { save(); load(); }
The example uses the smart pointer boost::scoped_ptr
to manage a dynamically allocated object of type person
. In order to serialize such a pointer, the header file boost/serialization/scoped_ptr.hpp
must be included.
In case a smart pointer of type boost::shared_ptr
should be serialized, the header file boost/serialization/shared_ptr.hpp
must be used instead.
The following application now uses a reference in place of a pointer.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <iostream> #include <sstream> std::stringstream ss; class person { public: person() { } person(int age) : age_(age) { } int age() const { return age_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & age_; } int age_; }; void save() { boost::archive::text_oarchive oa(ss); person p(31); person &pp = p; oa << pp; } void load() { boost::archive::text_iarchive ia(ss); person p; person &pp = p; ia >> pp; std::cout << pp.age() << std::endl; } int main() { save(); load(); }
As shown, Boost.Serialization can also serialize references without any issue. Just like with pointers, the referenced object is serialized automatically.
In order to serialize objects based on class hierarchies, the child classes must access the boost::serialization::base_object()
function inside the serialize()
method. This function guarantees that inherited properties of base classes are correctly serialized as well. The following example shows a class named developer
which is derived from person
.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/string.hpp> #include <iostream> #include <sstream> #include <string> std::stringstream ss; class person { public: person() { } person(int age) : age_(age) { } int age() const { return age_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & age_; } int age_; }; class developer : public person { public: developer() { } developer(int age, const std::string &language) : person(age), language_(language) { } std::string language() const { return language_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & boost::serialization::base_object<person>(*this); ar & language_; } std::string language_; }; void save() { boost::archive::text_oarchive oa(ss); developer d(31, "C++"); oa << d; } void load() { boost::archive::text_iarchive ia(ss); developer d; ia >> d; std::cout << d.age() << std::endl; std::cout << d.language() << std::endl; } int main() { save(); load(); }
Both person
and developer
contain a private serialize()
method allowing objects based on either class to be serialized. Since developer
is derived from person
, the serialize()
method must ensure that properties inherited from person
are also serialized.
Inherited properties are serialized by accessing the base class inside the serialize()
method of the child class using boost::serialization::base_object()
. It is mandatory to use this function over e.g. static_cast
since only boost::serialization::base_object()
ensures correct serialization.
Addresses of objects dynamically created can be assigned to pointers of the corresponding base class type. The following example shows that Boost.Serialization still serializes them correctly.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/string.hpp> #include <boost/serialization/export.hpp> #include <iostream> #include <sstream> #include <string> std::stringstream ss; class person { public: person() { } person(int age) : age_(age) { } virtual int age() const { return age_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & age_; } int age_; }; class developer : public person { public: developer() { } developer(int age, const std::string &language) : person(age), language_(language) { } std::string language() const { return language_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & boost::serialization::base_object<person>(*this); ar & language_; } std::string language_; }; BOOST_CLASS_EXPORT(developer) void save() { boost::archive::text_oarchive oa(ss); person *p = new developer(31, "C++"); oa << p; delete p; } void load() { boost::archive::text_iarchive ia(ss); person *p; ia >> p; std::cout << p->age() << std::endl; delete p; } int main() { save(); load(); }
The application creates an object of type developer
inside the save()
function and assigns it to a pointer of type person*
which in turn is serialized via <<
accordingly.
As mentioned in the previous section, the referenced object is automatically serialized. In order to have Boost.Serialization recognize that an object of type developer
must be serialized even though the pointer is of type person*
, the class developer
needs to be declared accordingly. This is done via the BOOST_CLASS_EXPORT
macro defined in boost/serialization/export.hpp
. Since the type developer
does not appear in the pointer definition, Boost.Serialization would not be able to serialize an object of type developer
correctly without the macro.
The macro BOOST_CLASS_EXPORT
must be used if objects of child classes should be serialized via a pointer to their corresponding base class.
Because of the static registration, one disadvantage of BOOST_CLASS_EXPORT
is the registration of classes that may not be serialized at all. Boost.Serialization offers a solution for exactly this scenario though.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/string.hpp> #include <boost/serialization/export.hpp> #include <iostream> #include <sstream> #include <string> std::stringstream ss; class person { public: person() { } person(int age) : age_(age) { } virtual int age() const { return age_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & age_; } int age_; }; class developer : public person { public: developer() { } developer(int age, const std::string &language) : person(age), language_(language) { } std::string language() const { return language_; } private: friend class boost::serialization::access; template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & boost::serialization::base_object<person>(*this); ar & language_; } std::string language_; }; void save() { boost::archive::text_oarchive oa(ss); oa.register_type<developer>(); person *p = new developer(31, "C++"); oa << p; delete p; } void load() { boost::archive::text_iarchive ia(ss); ia.register_type<developer>(); person *p; ia >> p; std::cout << p->age() << std::endl; delete p; } int main() { save(); load(); }
Instead of using the BOOST_CLASS_EXPORT
macro, the above application calls the template method register_type()
instead. The type to be registered is passed as the template argument accordingly.
Please note that register_type()
must be called both in save()
and load()
.
The advantage of register_type()
is that only classes used for serialization must be registered. While developing e.g. a library, one does not know which classes a developer may use for serialization later on. While the macro BOOST_CLASS_EXPORT
certainly makes it easy, it may register types that are not going to be serialized.
After understanding how to serialize objects, this section introduces wrapper functions to optimize the serialization process. By using these functions, objects are kind of marked to allow Boost.Serialization to apply certain optimization techniques.
The following example uses Boost.Serialization without any wrapper function.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/array.hpp> #include <iostream> #include <sstream> std::stringstream ss; void save() { boost::archive::text_oarchive oa(ss); boost::array<int, 3> a = { 0, 1, 2 }; oa << a; } void load() { boost::archive::text_iarchive ia(ss); boost::array<int, 3> a; ia >> a; std::cout << a[0] << ", " << a[1] << ", " << a[2] << std::endl; } int main() { save(); load(); }
The above application creates and writes the text stream 22 serialization::archive 5 0 0 3 0 1 2
to the standard output stream. Using the wrapper function boost::serialization::make_array()
, the output can be shortened to 22 serialization::archive 5 0 1 2
.
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/array.hpp> #include <boost/array.hpp> #include <iostream> #include <sstream> std::stringstream ss; void save() { boost::archive::text_oarchive oa(ss); boost::array<int, 3> a = { 0, 1, 2 }; oa << boost::serialization::make_array(a.data(), a.size()); } void load() { boost::archive::text_iarchive ia(ss); boost::array<int, 3> a; ia >> boost::serialization::make_array(a.data(), a.size()); std::cout << a[0] << ", " << a[1] << ", " << a[2] << std::endl; } int main() { save(); load(); }
boost::serialization::make_array()
expects the address and the length of an array. Since the length is hard-coded, it does not need to be serialized as part of the object of type boost::array
. The function can be used whenever classes such as boost::array
or std::vector
contain an array that can be directly serialized. Additional properties that normally would be serialized are not serialized.
Another wrapper function provided by Boost.Serialization is boost::serialization::make_binary_object()
. Similar to boost::serialization::make_array()
, it expects an address and a length. boost::serialization::make_binary_object()
is used solely for binary data without any underlying structure while boost::serialization::make_array()
is used for arrays.
You can buy solutions to all exercises in this book as a ZIP file.
Develop an application able to serialize and restore arbitrary number of records consisting of the name, the department and a unique identification number of employees in a file. Records should be displayed on the screen after restoring them. Use sample records to test the application.
Extend the application by storing the birth date for each employee. The application should still be able to restore records serialized with the older version created in the previous exercise.
Copyright © 2008-2010 Boris Schäling


This game is being developed by Sairaj Naik.
We are currently pursuing Computer Science Programme ,III year
at IIT Roorkee


Question
Question -represents a question for the plugin CLI
Constructor Summary
| Public Constructor | ||
| public |
constructor(name: string, question: string, answerType: Type, defaultAnswer: type) constructor - Question |
Member Summary
| Public Members | ||
| public |
answerType: * |
|
| public |
|
|
| public |
name: * |
|
| public |
question: * |


|
|
def | __init__ |
| |
|
def | app_id |
| |
|
def | set_app_id |
| |
|
def | clear_app_id |
| |
|
def | has_app_id |
| |
|
def | queue_name_size |
| |
|
def | queue_name_list |
| |
|
def | queue_name |
| |
|
def | set_queue_name |
| |
|
def | add_queue_name |
| |
|
def | clear_queue_name |
| |
|
def | max_num_tasks |
| |
|
def | set_max_num_tasks |
| |
|
def | clear_max_num_tasks |
| |
|
def | has_max_num_tasks |
| |
|
def | MergeFrom |
| |
|
def | Equals |
| |
|
def | IsInitialized |
| |
|
def | ByteSize |
| |
|
def | ByteSizePartial |
| |
|
def | Clear |
| |
|
def | OutputUnchecked |
| |
|
def | OutputPartial |
| |
|
def | TryMerge |
| |
|
def | __str__ |
| |
|
|
| queue_name_ |
| |
|
| has_app_id_ |
| |
|
| app_id_ |
| |
|
| has_max_num_tasks_ |
| |
|
| max_num_tasks_ |
| |
|
|
int | has_app_id_ = 0 |
| |
|
string | app_id_ = "" |
| |
|
int | has_max_num_tasks_ = 0 |
| |
|
int | max_num_tasks_ = 0 |
| |
|
int | kapp_id = 1 |
| |
|
int | kqueue_name = 2 |
| |
|
int | kmax_num_tasks = 3 |
| |
The documentation for this class was generated from the following file:
- code/googleappengine-read-only/python/google/appengine/api/taskqueue/taskqueue_service_pb.py


Drag the following 3 in the grey box on the right and Click on Convert.
Text field
Radio buttons
Submit Button
Modal here!
Convert
×
Modal title
hi modal here!
Although I don't do anything!


👩💻 She Codes is a Coding Workshop for Women
Access a new career in Technology
She Codes teaches coding, design and management skills to women
Limited amount of spots!
Apply Now


Jeff Diers
Hi there, I am a web developer living in Denver, CO. If you would like to work with me or say hello, please email or give me a call.
phone:<PHONE_NUMBER>
email: jeff.diers@gmail.com


Based on ideal line length 50-75 characters.
As you can see... blah blah blah
this is a multi-line block
This is another multi line block
that I have created
Here is some Markdown for your viewing pleasure:
A list perhaps?
I think that sounds grand!
Spectacular
This works too


Returns a member from a prior time period as the specified or default time member.
Syntax
ParallelPeriod ( [layer [,index [,member [, hierarchy ]]]])
| Parameter | Description |
|---|---|
|
Optional layer specification. If omitted, the same layer is assumed. |
|
index |
Number of time periods to count back in the specified layer. |
|
Optional member specification. If omitted, the default member is assumed (for more information, see Defaultmember). |
|
|
Optional. A specific hierarchy within the time dimension. |
Notes
If layer, index, and member are present, this function determines the member ANCESTOR1, which is computed as
Ancestor(member, layer)
The member ANCESTOR2 is then computed as
Lag(ANCESTOR1, index)
The return value of this function is then computed as
Cousin(member, ANCESTOR2)
If layer and index are present and member is absent, member is taken to be the current member along the dimension associated with layer. The returned value is determined as above.
If only layer is present, index is taken to be 1, and member is taken to be the current member along the dimension associated with layer. The returned value is determined as above.
If layer, index, and member are all absent, member is taken to be CurrentMember along TIME Dimension, index is taken to be 1, and layer is taken to be the generation of the parent of member. The returned value is determined as above.


Table Class
Table is essentially the main entry point of Casson
Object Mapping.
Constructor
Table
-
init_columns
Parameters:
-
init_columns
Key/valueinitializes the columns
Example:
Table.contruct('mytable', {'a' : 5, 'b' : 'str', '_PRIMARY_KEYS' : ['a']});
A table called 'mytable' will be created in Cassandra with two
columns named a and b of types integer and text, where a is the
primary key. The types are derived from values of the
variables. The default derived types are text, int, bigint, float, boolean, timeuuid, or otherwise blob. The collection types list, set, and map, for example, are given like ['set', 'int']
, ['list', 'text']
or ['map', 'text', 'float']
.
You can use mytable like any regular javascirpt Object, but with the full power of Cassandra behind it.
This simple case might enough for many situations. Of course, to do much more please keep reading. A more multi-step approach would be:
t = Table.contruct('mytable', {'_PRIMARY_KEYS' : [ 'a' ]);
t.a = 1;
t.b = 3;
t.setColumnType({'b' : 'float'});
getBasicType and setColumnTypes have more information.
The versatility of the Table will becomes more obvious when you look at Select, Insert, and Update.
Item Index
Methods
Methods
appendPrimaryKeys
()
private
Append primary keys to the create statement
appendWiths
()
private
Append WITH properties to the create statement
construct
-
table_name
-
init_columns
Construct a class using the supplied table name
Parameters:
-
table_name
String -
init_columns
Key/valuecolumn names and example values
dbCreate
()
String | Error
Craate query statement
Returns:
query
dbCreateIndex
-
column_name
-
index_name
Craate index on a column
Parameters:
-
column_name
String -
index_name
String
Returns:
query
dbDrop
()
String
Drop query
Returns:
query
getBasicType
-
col
-
collection
Basic column types are picked based on typeof and few a other basic patterns and values:
string
: With suitable hex string representationtimeuuid
picked instead oftext
for strings.number
: Numbers areint
orbigint
depending on whether it can be represented by 32 bits or not, otherwise it is afloat
.boolean
: Boolean is obvious.[ ]
: it is alist
and each element istext
, unless a first element is a value of one of the other basic types.{ }
:map
is selected for objects with a sample key,value determining types, otherwise 'text' is picked for both.
Of course, these can be overridden easily by setColumnTypes
Parameters:
-
col
Stringthe column
-
collection
Booleantype also considered
Returns:
indicating the type
getColumns
()
Array
private
Get mapped column names
Returns:
getPrimaryKeys
()
Array
private
Get primary key array
Returns:
setColumnType
-
column
-
column
Set or derive individual col types
Parameters:
-
column
Stringname
-
column
String | Arraytype; Array when collection type
setColumnTypes
-
column_types
Set the column types.
In addition to the basic types mentioned in getBasicType,
collection types (List, Set and Map) are available and
given as an array like [list, (simple_type)]
or [map, (simple_type), (simple_type)]
. It appears that are meant for small tasks in Cassandra and cannot be
bigger 256 items.
Parameters:
-
column_types
Key/valueProperty list with column name as the key
Returns:
setOptions
-
option
Set table options (see Cassandra documentation)
Parameters:
-
option
Key/valuename, value pairs
Returns:
setPrimaryKeys
-
keys
Sets the primary keys. As per Cassandra requirement, it can be of the following forms:
['p']
['p', 'b', 'c']
, where 'b' and 'c' are clustering key[['p', 'q'], 'b']
, where 'p' and 'q' together is a compoiste key and 'b' is a clustering key.
Same convention is used to specify _PRIMARY_KEYS
property during
intialization.
Parameters:
-
keys
Arrayis an array of keys


To Buy:
Buy {{ item.quantity }} of {{ item.name }}
Bought
Everything is bought!
Already Bought:
Bought {{ item.quantity }} of {{ item.name }}
Nothing bought yet.


Guidance
Describes the job role an apprentice will be doing and the skills required of them by the furniture sector.
PDF , 575KB , 17 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 81.4KB , 13 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
This document is relevant to:
The approved standard outlines the skills, knowledge and behaviours required of the apprentice and the job they will need to be able to do by the time they have completed their apprenticeship.
This standard is ready to use.
If you’d like to get involved and contribute to the development of the furniture manufacturer standard, please read the guidance for trailblazers , and email the trailblazer contact<EMAIL_ADDRESS>.
The standard for a furniture manufacturer was developed by:
Funding band (6 = highest 1 = lowest): 3
Maximum core government contribution: £6,000
Read the funding rules for apprenticeship standards for further information.
Published: 12 March 2015
Updated: 7 September 2016
From: Skills Funding Agency
Part of: Apprenticeship standards Apprenticeships


--- layout: page description: "Product Manager | Ex-Amazon | Wharton MBA '17 | MIT '11" header-img: "img/contact-bg.jpg" ---
Hello, I'm a recent MBA graduate from The Wharton School and obtained my bachelor's degree from MIT.
In the summer of 2016, I interned at Amazon as a product manager in the Alexa Smart Home team. I also previously worked as product manager at SEEK Asia (known as JobStreet before it was acquired) and a consultant with The Boston Consulting Group.
I love hiking, having done so in Antarctica, Patagonia, Nepal and a couple of other interesting places. I also love dogs (golden retriever and goldendoodle) as well as good food. Ping me up if you want to talk about product management, hiking, dogs, food or just life in general.


{% extends "_base_framed.html" %}
{% block title %}Our Travel Brochures and Cruise Package Collection{% endblock %}
{% block description %}Browse all our travel brochures for all-inclusive trips, guided tours, and luxury travel packages.{% endblock %}
{% block iframe %}//fliphtml5.com/bookcase/bdob/silver{% endblock %}


The RSP package contains the service or applications in the virtual machine and RSP-specific configuration files. RSP packages contain a service or application running in a virtual machine. RSP packages also contain Riverbed configuration files specifying the package VNIs, and how the package interacts with the Steelhead appliance, a .vmx file, and one or more .vmdk files. Do not open or modify any of the files in the package. The package files can be quite large, and can take up several GBs of disk space.
Before installing a package, you must install the RSP installation image. For details, Installing the RSP Image. After installing the RSP image, you must start the RSP service and then you can download and install packages.
You can download any number of packages to the Steelhead appliance, but you can only run up to five packages at a time. The exact number depends on the package size, the amount of resources available, and your Steelhead appliance model.
For the Steelhead xx50 model appliances, Riverbed provides an option to purchase fully licensed OEM Microsoft Windows 2008 Standard package. If you purchase this option, the RSP package is already installed on the Steelhead appliance with a Certificate of Authenticity (COA) sticker containing your license key attached to the appliance. To obtain the package, simply browse for it and the file ms_windows_2008_standard<version>.pkg appears. The package name varies based on the version installed.
When you install an RSP package you must select an RSP slot. A slot is a directory on disk. When you install a package into a slot, the system unpacks the VM into the directory. When you uninstall a VM from a slot, the system removes the VM and deletes the files from the slot.


In Seattle, coffee shops line the streets, from the city's native juggernaut, Starbucks, to the most quaint, precious pour-over stands this side of the Cascades. This site is for the city’s essential jolts for every palate, from tried-and-true roasters to espresso-pullers, from global chains to mom-and-pops. Cheers to tasting Seattle's second, third, and yet-to-be-defined fourth waves of coffee.


An editor like the Toolkit can also control the Digital Chroma by sending messages to it. All program and parameter {_NRPN NRPNs} are supported, including queries, as are the few miscellaneous messages for accessing the Digital Chroma's clock, or invoking Undo/Redo. The editor input channel doesn't recognize notes or controls, though. If the editor channel conflicts with external or playback input, the editor takes precedence.


Creates an instance of Sharder.
The unique instanceID of the current sharder
Options to pass on to modules
Custom modules to start with
Connect to a new peer instance
The registered instanceID of the new peer
Resolves once peer is added
Create a new instance
Resolves when config is fetched and modules are created
Initiate the instance
Resolves when the instance is fully initiated
Fetch updated peer instance configuration
The registered instanceID of the updated peer
Resolves once peer has been updated
Reshard the clusters managed by the current instance
The first shard ID of the new set
The last shard ID of the new set
The total amount of shards for the bot
Resolves once resharding is complete
Update local instance's configuration
New instance configuration
Resolves once instance config has been updated
Generated using TypeDoc
Main Sharder class


{% extends "/email/email_base.html" %} {% block page_content %}
Dear {{ user.first_name }},
A paper titled: "{{ title }}" in conference: "{{conference}}" with you as a co-author has been updated.
Sincerely,
Conferency


DISSERTATION
KINETICS OF THE CERIUM (IV)-VANADIUM (IV)
REACTION IN AQUEOUS PERCHLORIC ACID SOLUTION
Submitted by
Robert Leighton Taylor
In partial fulfillment of the requirements for the Degree of Doctor of Philosophy Colorado State University Fort Collins, Colorado
August, 1970
Reproduced with permission of the copyright owner. Further reproduction prohibited without permission.


There are two different ways to access an object property:
You can use person.property or person["property"].


Vladyslav Nazarenko, 25 years old.
Location: Ukraine, Kyiv, Dorohozhytska 3
English: upper intermediate.
I have a big desire for learning, self-improvement and development. I'm punctual, decent, diligent, attentive person. Responsible at work and not afraid of difficulties.
Do not hesitate to contact me, I will gladly answer any of your questions.
<EMAIL_ADDRESS>+380 50 440 2858


|
Perl Weekly
Issue #227 - 2015-11-30 - The schedule for LPW is out!
latest | archive | by Neil Bowers
|
|
The talk schedule for the London Perl Workshop has been published,
the dates for YAPC::EU 2016 have been published,
and the call for papers for the German Perl Workshop came out.
Buddy Burden has published the next chapter of his Date and Time odyssey,
and Dave Rolsky declared that Perl 6 is fun, just in time for this issue.
Neil
|
|
|
|
Sponsors
|
Senior Applications Engineer
Uniregistry is looking for a talented and passionate engineer to build and maintain a world-class registry and registrar. This position requires the ability to analyze and implement elegant solutions to complex problems while contributing to the development of reusable components
|
|
Supporting the Perl Weekly?
by Gabor Szabo (SZABGAB)
Would you like to support the Perl Weekly? A Perl Job ad in the Perl Weekly, like the one above, will reach almost 6000 Perl developers. People like you, who are enthusiastic about Perl and not just use it as an add-on tool.
|
|
|
CPAN News
|
|
|
|
|
|
|
|
|
Perl 5
|
|
|
|
|
|
|
|
|
Perl 6
|
Perl 6 is Fun
by Dave Rolsky (DROLSKY)
Dave's been playing with Perl a bit recently, and shares some of the things he likes. In summary: "Pretty much everything I love in Perl 5 is still part of Perl 6, but almost everything I hate is gone too".
|
|
|
|
|
|
Community
|
24 Pull Requests
by Neil Bowers (NEILB)
It's that time of year again! This is another pull request challenge, but for this one you need to do 24 pull requests in the first 24 days of December.  Frew presents two of the ways you can ensure that all of your descendent processes get cleaned up, and Tim Bunce pointed out another one in the comments.
|
|
|
What happens to tests that are never run?
by Sinan Unur (NANIS)
Sinan spotted a test in a widely used module that was meant to be checking one thing, but was checking something slightly different. A great example of why code reviews are a good idea.
|
|
|
Module design
|
|
|
|
|
|
|
Events
|
|
|
Dates for YAPC::EU 2016 announced
YAPC::Europe is going to be on 24th to 26th August next year. Reserve that space in your calendars, and start learning Transylvanian!
|
|
Call for papers - gpw2016 - Nuremberg
by Steffen Winkler (STEFFENW)
The German Perl workshop will be on the 11th and 12th March in Nuremberg next year, and now they're inviting talk submissions, for talks of 20 or 40 minutes, or lightning talks.
|
|
|
Not Perl
|
|
|
A review of "Git for Teams"
I haven't read this book myself, but it sounds like not only a good book for teams using Git, but also about how teams can/should work together.
|
|
The End of Dynamic Languages
This blog post has been popping up all over the place, and has prompted a lot of follow-up posts (eg here and there). Elben believes that dynamic languages have had their day, and that typed languages like Scala and Haskell will eventually win out. When you've been programming long enough, you realise that proclamations of both outright victory or demise tend not to pan out.
|
|
You know, you could get the Perl Weekly right in your mailbox. Every Week. Free of charge!
|


Buffalo Milk Cheeses in Malaysia
Cheese Please!
Introduction:
|
Considerations |
Buffalo Milk is used in cheeses, yogurts, drinks, ice creams and other products |
Cheese Please!
Why Buffalo Milk:
|
Considerations |
Quality Control and Halal Certification By controlling the raw material supply (operations) and producing the cheese on-site (production) we control the quality of the end product from “seed to plate” which will allow for a superior “farm fresh” product. Use of Halal animal rennet or synthetic rennet will be explored to allow both the production facility and primary dairy products to be certified Halal. These production methods will provide significant differentiation in the marketplace. |


NPFL: Rangers name new coach after Akwa Starlet humiliation
by Bowale OdutolaThe Rangers International of Enugu has named former national team assistant coach, Sylvanus Okpala, as new coach after firing the entire technical crew of the team led by Coach Benedict Ugwu.
The Rangers team suffered an embarrassing loss to Akwa Starlets of Uyo in Enugu on Sunday.
This was announced immediately after the match, which saw Rangers, who were 13th on the Nigeria Professional Football League table before the match, slump to a two nil loss at the Nnamdi Azikiwe Stadium.
A lacklustre performance from the 2016 league champions saw Akwa Starlets race into a two goal lead in the first half.
Rangers’ second half performance only proved that the team was lacking in confidence and direction as the Uyo team kept pilling pressure on the Flying Antelopes.
The defeat, which is the Rangers’ third straight loss in the league, came as a huge shock to fans at the stadium as it has condemned the team to relegation battle.


WITNESS LIST State Affairs Committee May 19, 2003 - 8:00A HB 1274 Registering, but not testifying: On: McGeehan, Ann (SOS), Austin, TX HB 1517 Registering, but not testifying: For: Rountree, Meredith Martin (ACLU of Texas, NAACP Voter Empowerment Fund), Austin, TX On: McGeehan, Ann (SOS), Austin, TX Winn, Elizabeth Hanshaw (Secretary of State), Austin, TX HB 1576 Registering, but not testifying: On: Esquivel, Eddie (Dept. of Information Resources), Austin, TX HB 1695 ON: McGeehan, Ann (SOS), Austin, TX HB 1696 Registering, but not testifying: On: McGeehan, Ann (SOS), Austin, TX Winn, Elizabeth Hanshaw (Secretary of State), Austin, TX HB 2032 Registering, but not testifying: For: Fenz, Caton (Harris County Commissioners Court), Houston, TX HB 2149 Registering, but not testifying: On: McGeehan, Ann (SOS), Austin, TX Winn, Elizabeth Hanshaw (Secretary of State), Austin, TX HB 2152 Registering, but not testifying: On: McGeehan, Ann (SOS), Austin, TX Winn, Elizabeth Hanshaw (Secretary of State), Austin, TX HB 2153 Registering, but not testifying: On: McGeehan, Ann (SOS), Austin, TX Winn, Elizabeth Hanshaw (Secretary of State), Austin, TX HB 2154 ON: McGeehan, Ann (SOS), Austin, TX Winn, Elizabeth Hanshaw (Secretary of State), Austin, TX HB 2158 ON: Kilgo, Elizabeth (Texas Judicial Council), Austin, TX HB 3109 FOR: Block, Kathryn (Envoy Medical Systems), Austin, TX Chin, Dan (Envoy Medical Systems), Austin, TX Prudhomme, Gilbert (Independent Review Inc.), Austin, TX ON: Bingham, Bill (Texas Department of Insurance), Austin, TX HJR 54 FOR: Lawson, John E. (Houston Police Officers' Pension System), Houston, TX Registering, but not testifying: For: Aghamalian, Brandon (City of Fort Worth), Fort Worth, TX Andersen, Cris (San Antonio Police Officers' Association), San Antonio, TX Bresnen, Steve (Ft. Worth Professional Fire Fighters Assoc.), Ft. Worth, TX Elkin, W.M. "Bill" (Houston Police Retired Officers Association), Houston, TX Higgins, Mike (Texas State Association of Fire Fighters), Austin, TX Jordan, Sampson K. (City of Austin Police Retirement System), Austin, TX Montero, James E. (Houston Police Officers Pension System), Houston, TX Navarro, Jr., Wilfred (Houston Police Retired Off's Association), Houston, TX Rendon, Feliciano (San Antonio Police Officers Association), San Antonio, TX On: Burney, Frank (Fire & Police Pension Fund, San Antonio), San Antonio, TX Schott, Warren (San Antonio Fire & Police Pension Fund), San Antonio, TX HJR 59 Registering, but not testifying: For: Warndof, Donna (Bexar County Commissioners Court), Austin, TX On: McGeehan, Ann (SOS), Austin, TX HJR 62 FOR: Warndof, Donna (Bexar County Commissioners Court), Austin, TX ON: McGeehan, Ann (Secretary of State), Austin, TX SB 1951 Registering, but not testifying: On: Aston, LaNell (General Land Office), Austin, TX SJR 4 Registering, but not testifying: On: Aston, LaNell (General Land Office), Austin, TX


@ Unity Technologies
4 yrs 7 mos
<@title>Software Developer, Quality@title>
<@date>Aug 2018 – Present : 1 yrs 10 mos@date>
<@location>Denmark, Copenhagen@location>
<@resp>
Creating and maintaining various internal tools like continuous integration, test data storage, performance data visualization (C#).
Fixing bugs and improving functionality in legacy codebase (C++).
Improving team's organizational velocity, meeting quality, plannings.
Finding and escalating quality, test coverage, workflow problems. Looking for best solutions to fix them.
@resp>
<@skills>
MySQL with MS Entity Framework
Socket programming and Rest APIs
Agile/Kanban
More C++ and C# in general
@skills>
<@filling>
In Addition to this I also:
- Created imported asset artifact debugging tool inside Unity Engine (mostly UI and C# parts)
@filling>
<@title>Software Development Engineer in Test (SDET)@title>
<@date>Jun 2016 – Aug 2018 : 2 yrs 3 mos@date>
<@location>Lithuania, Vilnius@location>
<@resp>
Work with the team in an Agile Environment (Team consists of Devs, UX, Designers, Testers, Project/Product managers).
Write full 95-100% functional and decision test coverage on both unit tests, integration tests, performance tests, regression tests, etc.
Make sure everybody (Devs) on a team knows and does write tests.
Make sure everybody have the right tools to write tests and view test data.
Make sure everybody is aware of current quality status, current bugs and automation status.
@resp>
<@skills>
Broadened C# knowledge.
NUnit testing framework.
C++ knowledge on real life projects.
A bit of Python and Perl for small scripts solving miscellaneous problems
QA theory in general, visited many testing and test automation related conferences.
Agile/Scrum/Jira
@skills>
<@filling>@filling>
<@title>QA Tester at Unity Technologies@title>
<@date>Nov 2015 – Jun 2016 : 8 mos@date>
<@location>Lithuania, Vilnius@location>
<@resp>
Communicate with customers, find and reproduce their issues.
Provide developers relevant info about bugs and other issues from customers.
Verify fixed issue in released builds.
@resp>
<@skills>
C#, Unity Game Engine.
Fogbugz & Confluence
Communication skills between customers and developers.
Formal and polite English.
Table tennis and football.
@skills>
<@filling>@filling>


Docker User Introduction
teaches a new user about what Docker is and how it compares to virtualization
Key Topics on Docker
& Concepts
What is virtualization
What is Docker
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security allow you to run many containers simultaneously on a given host.This means you can run more containers on a given hardware combination than if you were using virtual machines.
What is Containerization
Containerization is a strategy of bringing Virtualization to the OS-level. Though Virtualization is an abstraction to the hardware, containerization brings abstraction of OS. Containerization is more efficient because there is no guest OS to utilize a host’s OS and do not have to share relevant libraries and resources, unlike virtual machines.
What is Virtualization
It is a general approach for getting out of in-house hardware assets. In the beginning, this technique was a revelation because it allowed developers to run multiple OS(Operating system) in different VMs (virtuals machines) all running on the same host. This dissolved the need for extra hardware resources.
Basic Linux Commands
We will show a list of basic linux commands and how do they work.
Developing with Docker
Developing apps today requires so much more than writing code. Multiple languages, frameworks, architectures, and discontinuous interfaces between tools for each lifecycle stage creates enormous complexity. Docker simplifies and accelerates your workflow, while giving developers the freedom to innovate with their choice of tools, application stacks, and deployment environments for each project.
Containers were just the Beginning
Docker introduced what would become the industry standard for containers. Containers are a standardized unit of software that allows developers to isolate their app from its environment, solving the “it works on my machine” headache. For millions of developers today, Docker is the de facto standard to build and share containerized apps - from desktop, to the cloud. We are building on our unique connected experience from code to cloud for developers and developer teams.
Developers Love Docker
Docker the #1 in "Most Loved " and #2 "Most Wanted" platform" in the 2019 StackOverflow Survey. But you also told us that Docker “Just works” is “better than chocolate cake” and is the “Best tool ever, I'm in love.” We love hearing how you love Docker.
Play with Docker
Cloud-based docker environment to try out docker and learn the ropes.
Play with Docker


If, for whatever reason, you want to contact me, you can reach me through email or Discord, though I check Discord way more often.
Email<EMAIL_ADDRESS>Discord: Yey007#3321
If, for whatever reason, you want to contact me, you can reach me through email or Discord, though I check Discord way more often.
Email<EMAIL_ADDRESS>Discord: Yey007#3321


| MPI_GRAPH_CREATE(comm_old, nnodes, index, edges, reorder, comm_graph) | |
| IN comm_old | input communicator (handle) |
| IN nnodes | number of nodes in graph (integer) |
| IN index | array of integers describing node degrees (see below) |
| IN edges | array of integers describing graph edges (see below) |
| IN reorder | ranking may be reordered ( true) or not ( false) (logical) |
| OUT comm_graph | communicator with graph topology added (handle) |
int MPI_Graph_create(MPI_Comm comm_old, int nnodes, int *index, int *edges, int reorder, MPI_Comm *comm_graph)
MPI_GRAPH_CREATE(COMM_OLD, NNODES, INDEX, EDGES, REORDER, COMM_GRAPH, IERROR)
The three parameters nnodes, index and edges define the graph
structure.
nnodes is the number of nodes of the graph. The nodes are numbered
from 0 to nnodes-1.
The
i-th
entry of array index stores the total number of
neighbors of the first i graph nodes. The lists of neighbors of
nodes 0, 1, ..., nnodes-1 are stored in consecutive locations in array
edges. The array edges is a flattened representation
of the edge lists.
The total number of entries in index is nnodes and
the total number of entries in edges is equal to the number of
graph edges.
The definitions of the arguments nnodes, index, and
edges are illustrated with the following simple example.
Then, the input arguments are:
Thus, in C, index[0] is the degree of node zero, and index[i] -
index[i-1] is the degree of node i, i=1, ..., nnodes-1;
the list of neighbors of node zero is stored in edges[j], for
and the list of neighbors of node i,
i > 0,
is stored in edges[j],
.
In Fortran, index(1) is the degree of node zero, and index(i+1) -
index(i) is the degree of node i, i=1, ..., nnodes-1;
the list of neighbors of node zero is stored in edges(j), for
and the list of neighbors of node
i, i > 0,
is stored in edges(j),
.
A single process is allowed to be defined multiple times in the list of
neighbors of a process (i.e., there may be multiple edges between two
processes). A process is also allowed to be a neighbor to itself (i.e., a self
loop in the graph). The adjacency matrix is allowed to be non-symmetric.
Performance implications of using multiple edges or a non-symmetric
adjacency matrix are not defined. The definition of a node-neighbor
edge does not imply a direction of the communication.
( End of advice to users.)
The following topology information is likely to be stored with a communicator:
INTEGER COMM_OLD, NNODES, INDEX(*), EDGES(*), COMM_GRAPH, IERROR
LOGICAL REORDER
{ MPI::Graphcomm MPI::Intracomm::Create_graph(int nnodes, const int index[], const int edges[], bool reorder) const (binding deprecated, see Section Deprecated since MPI-2.2
) }
MPI_GRAPH_CREATE returns a handle to a new communicator to which the
graph topology information is attached. If reorder = false then the
rank of each process in the new group is identical to its rank in the old
group. Otherwise, the function may reorder the processes. If the size,
nnodes, of the graph is smaller than the size of the group of
comm, then some processes are returned MPI_COMM_NULL, in
analogy to MPI_CART_CREATE and MPI_COMM_SPLIT.
If the graph is empty, i.e., nnodes == 0,
then MPI_COMM_NULL is returned in all processes.
The call
is erroneous if it specifies a graph that is larger than the group size of the
input communicator.
Example
Assume there are four processes 0, 1, 2, 3 with the following
adjacency matrix:
process neighbors
0 1, 3
1 0
2 3
3 0, 2
nnodes = 4
index = 2, 3, 4, 6
edges = 1, 3, 0, 3, 0, 2
Advice to users.
Advice
to implementors.
1. ndims (number of dimensions),
2. dims (numbers of processes per coordinate direction),
3. periods (periodicity information),
4. own_position (own position in grid, could also be computed
from rank and dims)
1. index,
which are the vectors defining the graph structure.
2. edges,
For a graph structure the number of nodes is equal to the number of processes
in the group. Therefore, the number of nodes does not have to be stored explicitly. An
additional zero entry at the start of array index simplifies
access to the topology information.
( End of advice to implementors.)
Up: Topology Constructors
Next: Distributed (Graph) Constructor
Previous: Cartesian Convenience Function: MPI_DIMS_CREATE
Return to MPI-2.2 Standard Index
Return to MPI Forum Home Page
(Unofficial) MPI-2.2 of September 4, 2009
HTML Generated on September 10, 2009


Spring MVC Security Example
Test application for Spring MVC with security
Logged user data
Username
Unknown
Authorities
No authorities