This function returns information about a file, storing it in the buffer pointed
to by statxbuf. The returned buffer is a structure of the following
type:
struct statx {
__u32 stx_mask; /* Mask of bits indicating
filled fields */
__u32 stx_blksize; /* Block size for filesystem I/O */
__u64 stx_attributes; /* Extra file attribute indicators */
__u32 stx_nlink; /* Number of hard links */
__u32 stx_uid; /* User ID of owner */
__u32 stx_gid; /* Group ID of owner */
__u16 stx_mode; /* File type and mode */
__u64 stx_ino; /* Inode number */
__u64 stx_size; /* Total size in bytes */
__u64 stx_blocks; /* Number of 512B blocks allocated */
__u64 stx_attributes_mask;
/* Mask to show what's supported
in stx_attributes */
/* The following fields are file timestamps */
struct statx_timestamp stx_atime; /* Last access */
struct statx_timestamp stx_btime; /* Creation */
struct statx_timestamp stx_ctime; /* Last status change */
struct statx_timestamp stx_mtime; /* Last modification */
/* If this file represents a device, then the next two
fields contain the ID of the device */
__u32 stx_rdev_major; /* Major ID */
__u32 stx_rdev_minor; /* Minor ID */
/* The next two fields contain the ID of the device
containing the filesystem where the file resides */
__u32 stx_dev_major; /* Major ID */
__u32 stx_dev_minor; /* Minor ID */
};
The file timestamps are structures of the following type:
struct statx_timestamp {
__s64 tv_sec; /* Seconds since the Epoch (UNIX time) */
__u32 tv_nsec; /* Nanoseconds since tv_sec */
};
(Note that reserved space and padding is omitted.)
To access a file's status, no permissions are required on the file itself, but
in the case of statx() with a pathname, execute (search) permission is
required on all of the directories in pathname that lead to the file.
statx() uses pathname, dirfd, and
flags to identify the target file in one of the following ways:
- An absolute pathname
- If pathname begins with a slash, then it is an absolute pathname
that identifies the target file. In this case, dirfd is
ignored.
- A relative pathname
- If pathname is a string that begins with a character other than a
slash and dirfd is AT_FDCWD, then pathname is a
relative pathname that is interpreted relative to the process's current
working directory.
- A directory-relative pathname
- If pathname is a string that begins with a character other than a
slash and dirfd is a file descriptor that refers to a directory,
then pathname is a relative pathname that is interpreted relative
to the directory referred to by dirfd.
- By file descriptor
- If pathname is an empty string and the AT_EMPTY_PATH flag is
specified in flags (see below), then the target file is the one
referred to by the file descriptor dirfd.
flags can be used to influence a pathname-based lookup. A
value for flags is constructed by ORing together zero or more of the
following constants:
- AT_EMPTY_PATH
- If pathname is an empty string, operate on the file referred to by
dirfd (which may have been obtained using the open(2)
O_PATH flag). In this case, dirfd can refer to any type of
file, not just a directory.
- If dirfd is AT_FDCWD, the call operates on the current
working directory.
- This flag is Linux-specific; define _GNU_SOURCE to obtain its
definition.
- AT_NO_AUTOMOUNT
- Don't automount the terminal ("basename") component of
pathname if it is a directory that is an automount point. This
allows the caller to gather attributes of an automount point (rather than
the location it would mount). This flag can be used in tools that scan
directories to prevent mass-automounting of a directory of automount
points. The AT_NO_AUTOMOUNT flag has no effect if the mount point
has already been mounted over. This flag is Linux-specific; define
_GNU_SOURCE to obtain its definition.
- AT_SYMLINK_NOFOLLOW
- If pathname is a symbolic link, do not dereference it: instead
return information about the link itself, like lstat(2).
flags can also be used to control what sort of
synchronization the kernel will do when querying a file on a remote
filesystem. This is done by ORing in one of the following values:
- AT_STATX_SYNC_AS_STAT
- Do whatever stat(2) does. This is the default and is very much
filesystem-specific.
- AT_STATX_FORCE_SYNC
- Force the attributes to be synchronized with the server. This may require
that a network filesystem perform a data writeback to get the timestamps
correct.
- AT_STATX_DONT_SYNC
- Don't synchronize anything, but rather just take whatever the system has
cached if possible. This may mean that the information returned is
approximate, but, on a network filesystem, it may not involve a round trip
to the server - even if no lease is held.
The mask argument to statx() is used to tell the
kernel which fields the caller is interested in. mask is an ORed
combination of the following constants:
| STATX_TYPE |
Want stx_mode & S_IFMT |
| STATX_MODE |
Want stx_mode & ~S_IFMT |
| STATX_NLINK |
Want stx_nlink |
| STATX_UID |
Want stx_uid |
| STATX_GID |
Want stx_gid |
| STATX_ATIME |
Want stx_atime |
| STATX_MTIME |
Want stx_mtime |
| STATX_CTIME |
Want stx_ctime |
| STATX_INO |
Want stx_ino |
| STATX_SIZE |
Want stx_size |
| STATX_BLOCKS |
Want stx_blocks |
| STATX_BASIC_STATS |
[All of the above] |
| STATX_BTIME |
Want stx_btime |
| STATX_ALL |
[All currently available fields] |
Note that, in general, the kernel does not reject values in
mask other than the above. (For an exception, see EINVAL in
errors.) Instead, it simply informs the caller which values are supported by
this kernel and filesystem via the statx.stx_mask field. Therefore,
do not simply set mask to UINT_MAX (all bits set), as
one or more bits may, in the future, be used to specify an extension to the
buffer.
The status information for the target file is returned in the statx
structure pointed to by statxbuf. Included in this is stx_mask
which indicates what other information has been returned. stx_mask has
the same format as the mask argument and bits are set in it to indicate
which fields have been filled in.
It should be noted that the kernel may return fields that weren't
requested and may fail to return fields that were requested, depending on
what the backing filesystem supports. (Fields that are given values despite
being unrequested can just be ignored.) In either case, stx_mask will
not be equal mask.
If a filesystem does not support a field or if it has an
unrepresentable value (for instance, a file with an exotic type), then the
mask bit corresponding to that field will be cleared in stx_mask even
if the user asked for it and a dummy value will be filled in for
compatibility purposes if one is available (e.g., a dummy UID and GID may be
specified to mount under some circumstances).
A filesystem may also fill in fields that the caller didn't ask
for if it has values for them available and the information is available at
no extra cost. If this happens, the corresponding bits will be set in
stx_mask.
Note: for performance and simplicity reasons, different
fields in the statx structure may contain state information from
different moments during the execution of the system call. For example, if
stx_mode or stx_uid is changed by another process by calling
chmod(2) or chown(2), stat() might return the old
stx_mode together with the new stx_uid, or the old
stx_uid together with the new stx_mode.
Apart from stx_mask (which is described above), the fields
in the statx structure are:
- stx_blksize
- The "preferred" block size for efficient filesystem I/O.
(Writing to a file in smaller chunks may cause an inefficient
read-modify-rewrite.)
- stx_attributes
- Further status information about the file (see below for more
information).
- stx_nlink
- The number of hard links on a file.
- stx_uid
- This field contains the user ID of the owner of the file.
- stx_gid
- This field contains the ID of the group owner of the file.
- stx_mode
- The file type and mode. See inode(7) for details.
- stx_ino
- The inode number of the file.
- stx_size
- The size of the file (if it is a regular file or a symbolic link) in
bytes. The size of a symbolic link is the length of the pathname it
contains, without a terminating null byte.
- stx_blocks
- The number of blocks allocated to the file on the medium, in 512-byte
units. (This may be smaller than stx_size/512 when the file has
holes.)
- stx_attributes_mask
- A mask indicating which bits in stx_attributes are supported by the
VFS and the filesystem.
- stx_atime
- The file's last access timestamp.
- stx_btime
- The file's creation timestamp.
- stx_ctime
- The file's last status change timestamp.
- stx_mtime
- The file's last modification timestamp.
- stx_dev_major and stx_dev_minor
- The device on which this file (inode) resides.
- stx_rdev_major and stx_rdev_minor
- The device that this file (inode) represents if the file is of block or
character device type.
For further information on the above fields, see
inode(7).
The stx_attributes field contains a set of ORed flags that indicate
additional attributes of the file. Note that any attribute that is not
indicated as supported by stx_attributes_mask has no usable value here.
The bits in stx_attributes_mask correspond bit-by-bit to
stx_attributes.
The flags are as follows:
- STATX_ATTR_COMPRESSED
- The file is compressed by the filesystem and may take extra resources to
access.
- STATX_ATTR_IMMUTABLE
- The file cannot be modified: it cannot be deleted or renamed, no hard
links can be created to this file and no data can be written to it. See
chattr(1).
- STATX_ATTR_APPEND
- The file can only be opened in append mode for writing. Random access
writing is not permitted. See chattr(1).
- STATX_ATTR_NODUMP
- File is not a candidate for backup when a backup program such as
dump(8) is run. See chattr(1).
- STATX_ATTR_ENCRYPTED
- A key is required for the file to be encrypted by the filesystem.


Call for Speakers Open
We're pleased to announce our Call for Speakers is officially open. If you would like to submit a session, please click the comically large button below.
We're pleased to announce our Call for Speakers is officially open. If you would like to submit a session, please click the comically large button below.
First, let's get the easy stuff out of the way, shall we? The Call for Speakers is officially open. It will remain open until, at least, June 1. The at least is because Chris is speaking up a Music City Code that weekend. He may use the couple extra days to seek out a few more people. Either way, we plan on announcing the sessions on June 15th. As such, you'll probably get an email with whether you were selected or not on about June 12th.
This year, we are offering two session lengths. There are 60 and 30 minute sessions. This decision was partially based on feedback from last year, and partially based on our desire to encourage more people to submit topics. However, I can't tell you how many of each type we are going to select. That completely depends on the number and quality of selection from each type.
I would love to tell you how we pick session, but it will be a bit fluid this year, due to the session lengths. Last year, we printed all the sessions out on cards, stripped of identifying informations, and went all thunderdome. Chris has a few ideas for how to do it, but is willing to throw that all out the window when the time comes.
There is one thing that is always true. We never run two talks on the same topic at the same time. As such, there is a hard limit on the number ot talks from one technology we would accept. That number used to be 11. However, with 30 and 60 minute sessions, it could be as high as 20
We want DevSpace to be about community. The conversation is almost as important as the content. As such, we want speakers and attendees from every area. This shouldn't be limited to development technologies. Talks on testing, design, management, planning, personal improvement, and anything else you can think up will be accepted.
As a non-profit, there is not much I can offer. I will promise you a free ticket to the event. I will also offer you lunch and snacks. Unfortunately, that is all I can promise. If a sponsor steps up, I would like to have a speaker dinner, as well. Anything else will be decided by the remaining budget as we approach the event. Trust me, I will personally bend over backwards to do whatever I can. I even raised the ticket prices this year so I could hopefully take care of you more.
We plan on closing the call on June 1st at 8AM-ish. We hope to send out results by June 15th.
This site is created for the community and by the community. We work on it, in the evenings, after a full day of coding at our day jobs. We try to test it on as many different platforms and browsers as possible. We don't have every device. We miss things. We are very tired.
If you run into a small problem with the site, please let us know. You can always contact us at<EMAIL_ADDRESS>Furthermore, the entire code for the site is open sourced. Feel free to fork the code and submit a pull request. The code is on GitHub at https://github.com/DevSpaceHuntsville/WebsiteAndApi.
It does! If it does not, you found a bug. See above question...
We wanted to do that, but did not have time. I even started working on it over here : https://github.com/DevSpaceHuntsville/WebsiteAndApi/tree/GitHubOAuth. Remember that comment about being very tired?


| Apache Felix Configuration Admin Service | 1.0.1 | OK |
| Apache Felix Declarative Services | 1.0.0 | OK |
| Apache Felix Declarative Services | 1.0.2 | OK |
| Apache Felix EventAdmin | 1.0.0 | OK |
| Apache Felix iPOJO Extender Pattern Handler | 0.8.0 | OK |
| Apache Felix iPOJO Temporal Service Dependency Handler | 0.8.1 | OK |
| Apache Felix iPOJO White Board Pattern Handler | 0.8.0 | OK |
| Apache Felix Metatype Service | 1.0.0 | OK |
| Apache Felix Prefrences Service | 1.0.2 | OK |
| Apache Felix Shell Service | 1.0.1 | OK |
| Apache Felix Shell TUI | 1.0.1 | OK |
| Apache Felix UPnP Base Driver | 0.8.0 | OK |
| Apache Felix Web Management Console | 1.0.0 | Missing service - (service=org.osgi.service.http.HttpService) |
| iPOJO | 0.8.0 | OK |
| iPOJO Arch Felix Command | 0.8.0 | OK |
| iPOJO Composite | 0.8.1 | OK |
| OSGi R4 Compendium Bundle | 4.0.0 | OK |
| Servlet 2.1 API | 1.0.0 | OK |


--- layout: post date: 2011-02-19 time: "09:00:00" authors: ["Greg Wilson"] title: Three More Episodes on MATLAB tags: ["Content"] ---
Three more episodes on MATLAB are now available, two on input and output, and one on plotting. Thanks to Tommy Guy for putting them together; as always, feedback is appreciated.


About Me
My name is Dexter Griffith. I am 29 years old, and prouldy Born-and-Raised in a small suburb of Fort Worth called Haltom City. After graduating from Haltom High School, I went on t o attend The University of Texas at Arlington, were I began studying Psychology full time after a few career path swaps. During my time at The University of Texas at Arlington, I joined a collegiate Esports team, and competed in yearly in a Collegiate Esports League, called CSL for short. During this time my passion for video games, and anything involving software began to take off. I finished my degree in Psychology, and work at Parkland Hospital in the Psychiatry Department, as a Mental Health Technician, however it doesnt excite me as much as web development and software development had in the past. Thus, I took the leap! I changed my career, decided to follow my passions and become a web developer.


Let any straight line AB standing on the straight line CD make the angles CBA and ABD.
I say that either the angles CBA and ABD are two right angles or their sum equals two right angles.
Now, if the angle CBA equals the angle ABD, then they are two right angles.
But, if not, draw BE from the point B at right angles to CD. Therefore the angles CBE and EBD are two right angles.
Since the angle CBE equals the sum of the two angles CBA and ABE, add the angle EBD to each, therefore the sum of the angles CBE and EBD equals the sum of the three angles CBA, ABE, and EBD.
Again, since the angle DBA equals the sum of the two angles DBE and EBA, add the angle ABC to each, therefore the sum of the angles DBA and ABC equals the sum of the three angles DBE, EBA, and ABC.
But the sum of the angles CBE and EBD was also proved equal to the sum of the same three angles, and things which equal the same thing also equal one another, therefore the sum of the angles CBE and EBD also equals the sum of the angles DBA and ABC. But the angles CBE and EBD are two right angles, therefore the sum of the angles DBA and ABC also equals two right angles.
Therefore if a straight line stands on a straight line, then it makes either two right angles or angles whose sum equals two right angles.
But that’s not the only addition that occurs here. Euclid also says that the sum of the angles CBE and EBD equals the sum of the three angles CBA, ABE, and EBD. That sum being mentioned is a straight angle, which is not to be considered as an angle according to Euclid. It is a formal sum equal to two right angles. In other propositions formal sums of four right angles occur. These and larger formal sums are not angles themselves, merely sums of angles. Only if an angle sum is less than two right angles can it be identified with a single angle.


Step 3. You should be able to find option "Page Background Pattern" at this point. When you’re done, click "Save & Publish" button.


MI5 to recruit 'working class spies' in a black and ethnic minority diversity drive
Called the Summer Diversity Intelligence Internship it is aimed at black and ethnic minority recruits who are 'full of enthusiasm, with a sense of team spirit and a passion for learning'
by Liz PerkinsJames Bond prefers an Aston Martin – but today’s spy chiefs are after candidates with Ford Fiestas.
MI5 has launched a recruitment programme to lure interns from a wider social background.
The posts are aimed at ethnic minority applicants from working class families.
They must be problem solvers full of enthusiasm, with a sense of team spirit and a passion for learning, who are determined to make a positive impact, says the advert.
Candidates are warned not to discuss their application for the £24,717-a-year post with anyone other than a close family member.
Director general Andrew Parker said: “Keeping the country safe is a challenge that requires the best efforts of the richest mix of the most talented people.
"So it is essential that ours is an inclusive workplace offering rewarding careers for all.”
Earlier this year, the Social Mobility Foundation charity named MI6 one of the top 75 UK employers for promoting social mobility.
Charity boss David Johnston said: “They are very aware of the stereotype – you go to Eton, Oxford and then you become James Bond.
“They also realise that there’s an awful lot of talent in the country that would not even consider working for them or think that they would be suitable candidates.”
MI6 – which was bombarded with interest from working class applicants after last year’s Salisbury poison attack – is looking to appoint 800 new staff over two years.


${ weather.currently.windSpeed | round: 1 }m/s
${ weather.daily.data[0].sunriseTime | epoch: 'HH:mm' }
${ weather.daily.data[0].sunsetTime | epoch: 'HH:mm' }
${ weather.currently.summary }
${ weather.currently.temperature | round: 1 }° (${ weather.currently.apparentTemperature | round: 1 }°)
|
${ day.sunriseTime | epoch: 'ddd' | capitalize }
|
|
${ day.temperatureMin | round: 1 }° til ${ day.temperatureMax | round: 1 }°
|


Toggle navigation
Gram Client
Account
Messages
42
Settings
Profile
Settings
HOME
POST YOU LIKED
SEARCH HASGTAGS
Lorem Ipsum
liked
random
Lorem Ipsum is simply dummy
8:03
simply random
liked
passages
Lorem Ipsum is simply dummy
8:03
standard chunk
liked
model
Lorem Ipsum is simply dummy
8:03
perspiciatis
liked
donating
Lorem Ipsum is simply dummy
8:03


Select2 supports displaying the messages in different languages, as well as providing your own custom messages that can be displayed.
The language does not have to be defined when Select2 is being initialized, but instead can be defined in the
[lang]
attribute of any parent elements as
[lang="es"]
.
Select2 will work on RTL websites if the
dir
attribute is set on the
<select>
or any parents of it. You can also initialize Select2 with
dir: "rtl"
set.
Select2's default matcher will ignore diacritics, making it easier for users to filter results in international selects. Type "aero" into the select below.


I’ve been looking forward to teaching electricity all year. I’ve never done it before and I was excited about the hands-on stuff you can do. Who doesn’t want to play with batteries and light bulbs? Seriously. I split the lab into two days. Rather than prescribing circuits, I knew I wanted to make it inquiry-based. There are limited variables w... Read more 15 Jan 2016 - 2 minute read
I gave up using Jetpack a while ago on my blog because I couldn’t control where it sent information. I wish it was more modular in nature because it is helpful. But, I don’t want visitor (read, your) information sent off to unknown folks to do unknown things. So, I turned it off. I’ve slowly added functionality back since turning it off one plu... Read more 11 Jan 2016 - 2 minute read
We’re working very hard with students on annotating articles in preparation for the new state test sections. The goal is to help them find pertinent information in multiple texts which can be used to construct thorough written responses. We have a standard format…circling unknown words, underlining main ideas, etc, which help students transfer t... Read more 10 Jan 2016 - 1 minute read
We’re playing with magnets this week in class. (We’re actually finishing playing with magnets now.) It’s been great and this is by far one of my favorite units to teach because everything is so hands on. We’ve done lab activities every day. Magnets are accessible. They’re approachable by students. They’re easy to put your hands on and learn from... Read more 07 Jan 2016 - less than 1 minute read
Months ago, I turned off Jetpack on my blog. I use WordPress and Jetpack is a package of apps which handled email subscriptions, comment management, social media posting, etc. Unfortunately, it also collects a ton of information about visitors to the site for their own use. I’m not in the business of passing your information along to another co... Read more 29 Dec 2015 - 1 minute read
My wife had been hinting that she wanted to use recipe cards in the kitchen rather than her phone all the time. So, I took a few hours and made some up using Inkscape. They’re clean and minimal and print out as 4×6 cards on cardstock. The font is a Futura clone, so no need to worry about royalties or licenses. You can download the Inkscape... Read more 29 Dec 2015 - less than 1 minute read
I’m overwhelmed by the feeling of immense blessing and immense wretchedness each year. The birth of Christ – King of Heaven, seated at the right hand of God Himself – born in a barn…the lowest of lows. Entering our world to serve as the perfect sacrifice for our sins, a plan set in motion from the moment the fruit touched the lips of man, as a... Read more 25 Dec 2015 - 2 minute read
I promised Stacy Lovdahl I’d post this the other day and then promptly forgot. Sorry, Stacy. I took a graduate course on curriculum development and implementation this semester through Ball State. Not many of the assignments were open-ended enough to make for interesting blog fodder, so I didn’t post much. For my final project, I chose to redes... Read more 11 Dec 2015 - less than 1 minute read
The end of the semester is bittersweet. It’s exciting to think of the long break coming up. At the same time, the burden of work to be completed feels futile for many. I’ve been fighting significantly lower effort patterns and I don’t really have a good way to bridge the gap. Part of the issue this year is that I missed an entire week to stay ho... Read more 10 Dec 2015 - 1 minute read
In October, I wrote about a bookmark application to get the text of a website for analysis in the Lexile analyzer tool. It’s a pain in the keister to copy text from a website, open a document, paste the text, save as a plain text file, then reupload to the Lexile website. The bookmark tool does the hard part for you (the clicks…all the clicks…) ... Read more 09 Dec 2015 - 1 minute read


Score: 0
You earned points, but it's not enough to win the game...
You reached the water with 700 points.


An analogy to explain the differences between HTML and CSS could be a painting.
The HTML is
represented
by the canvas where you draw the elements you are going to paint. The drawing provides guidelines for
the painter to follow.
CSS is the set of colors and tools the
painter is going to use to bring his sketch alive: acrylics or oils paints, colors needed, type of
brushes to achive a particular effects and so on.
The control flow is the order in which the computer executes statements in a
script.
Usually when code runs, it starts from the first line to the last one, but if the computer
bumps into some program structure, like conditionals and loops, the order of execution changes.
A conditional statement allows you to carry out an action based on a condition.
If statement : the code is executed if a condition is true.
If it’s raining, take your umbrella!
If...else statement : else statement is executed if the condition is false.
If the light in the control panel of the oven turn off, put the food into the oven, otherwise
wait.
If..else if..else statement : this statement specifies a new condition if the first
condition is false.
If your body temperature is > 40°C go to the hospital, else if it's > 37°C take
some medicine, else take some rest.
A loop allows you to repeat an action a certain number of times. Different kinds of loop
mechanisms enable you to define the start and the end of a loop.
For statement : the loop repeats until a specified condition evaluates to false.
Go through each item on a grocery list until all the items have been stricken off and there is
nothing more left.
Do...while statement : is always executed once before the condition is checked and the
loop repeats until a specified condition evaluates to false.
Keep your glasses on, while you are reading a book.
While statement : executes its statements as long as a specified condition evaluates to
true.
While the glass is empty, pur water.
The DOM stands for “Document Object Model” and it’s created from the Browser when a page
is loaded.
It’s separated into 3 different parts: Core DOM, XML DOM, HTML DOM.
The HTML DOM is an object representation, an interface to an HTML document.
It is structured as a tree of Objects and each element in the DOM is called “node”. Example of
nodes are
elements, attributes, text content, comments, document-related stuff and other things; this list does
not include pseudo-elements (e.g. ::after) and hidden elements (e.g. with display: none).
The DOM allows JavaScript to access the text content and elements of the website document as
objects
by using properties and methods.
When you're interested in a particular DOM node, Inspect is an easy and fast way to open
DevTools and
investigate that node.
The below images show how the DOM can be modified by client-side Javascript:
You can also edit, hide or move the nodes by doing double-click on the content you want to change, or drag it if you want to move it, and see how those changes affect the page.
Each item in an array is identified by a number called its index.
let myFlowersArray = [“orchid”, ”rose”, ”lily”];
Arrays use zero-based indexing, so the first element in an array is element 0.
orchid: index 0; rose: index 1; lily: index 2;
You can access a particular element by passing its index to the array name within square brackets.
myFlowersArray[0]; // orchid
myFlowersArray[1]; // rose
myFlowersArray[2]; // lily
An object is created by using figure brackets {} with a list of properties.
let movie = { "name": “Pride & Prejudice”, "year-released": 2005, "director": “Joe Wright”
}
You can access a particular property by using dot notation or square brackets.
console.log(movie.name); → output: Pride & Prejudice
console.log(movie.[‘director’]); → output: Joe Wright
Functions are reusable blocks of code that groups together a set of statements to perform a specific task. A code inside functions is run whenever that function is called. (see example below).
They are useful when you have a few lines of code that needs to be used several times.
Also, in Javascript, a function is an object, that means that we can assign it to variables,
to array elements and to other objects; we can pass it as parameter into another
function, or it can be returned from another function (see example below).


The lovely and eccentric producer of our show.
Neuroscience student and researcher with experience in political organizing, she is responsible
for overseeing the behind-the-scenes action, maintaining the podcast’s quality of information
and the group’s morale. Forged in marxist theory and sharpened by neuroscience, Artie is the
brains behind the operation. With minutious research and quick fact checking she ensures our
bros are always factually and metaphysically correct. Besides being rigid she’s always ready to
listen and bring unique points of view into the discussion. During free time she watches anime
and plays card games. Her love for data is only matched by her love for tea and plush toys.


I grew up in Venice, Florida right on the Gulf of Mexico.Through most of my life I have traveled to different States but eventually settled in Michigan in a town called St. Joseph which is where I attended Lakeshore High School. Go LANCERS!
Travelling has become a passion of mine and with the world shifting to a more remote lifestyle, I found that now was the best time to make a career change and learn programming. It is my hope that it may fuel my passion for travelling and experiencing new cultures.


Yaidom is a uniform XML query API, written in Scala and leveraging its Collections API. Moreover, yaidom provides several specific-purpose DOM-like tree implementations offering this XML query API.
In this article, the yaidom library is introduced, using examples from XMPP (eXtensible Messaging and Presence Protocol) and XBRL (eXtensible Business Reporting Language).
This article introduces the yaidom XML query library, using examples in the domains of XBRL (eXtensible Business Reporting Language) and XMPP (eXtensible Messaging and Presence Protocol). Yaidom is not coupled to any of these domains, however. Moreover, the domains of XMPP and XBRL are not in any way related, although it is quite possible to use XBRL data as "payload" in XMPP messages. Still, yaidom does make it easy to create support for specific XML domains, as will be shown later.
It is assumed that the reader has some experience with XML processing in Java (e.g. JAXP) or another OO programming language (such as Scala or C#).
XSLT, XQuery and XPath are standard XML transformation/query languages, yet in this article yaidom (with Scala) is introduced as an alternative approach to in-memory XML querying/transformation and validation, leveraging the Scala programming language. Still, yaidom can also be used together with standard languages such as XQuery, for example when using an XML database.
The remainder of this article is organized as follows:
As mentioned above, after introducing Scala and Scala Collections, yaidom is introduced, using XMPP examples. After that, a brief introduction to XBRL follows. XBRL is an XML-based business reporting standard. Business reports in XBRL format are called XBRL instances. XBRL instances must obey many requirements, in order for them to be considered valid. After the brief XBRL introduction, the remainder of this paper shows how many of these rules can be expressed using yaidom and Scala. It will be shown that using Scala and yaidom instead of standard XML query and transformation languages actually makes expressing these rules relatively easy.
The Scala programming language is the most popular alternative to the Java language on the Java virtual machine. It is object-oriented (more so than Java) and also functional, in that functions are first-class objects. It is statically typed, but it feels like a dynamically typed language, because of features like type inference.
Scala is a safe and expressive language, typically leading to good productivity and low bug counts in skilled disciplined teams. Its rich Collections API, its strong support for immutable data structures, and its focus on expressions rather than statements enables programmers to work at a higher level of abstraction in Scala than in Java.
The Collections API of a programming language (which in the case of Scala and Java is a part of the standard library of the language, not of the core language) often says a lot about the expressive power of that language. Below follows some Scala code that manipulates collections, to illustrate Scala's expressiveness.
Consider a collection of sensor readings and some queries about them. The example is inspired by XEP-0323: Internet of Things - Sensor Data. The Scala code is as follows:
case class NumericValue(name: String, value: String, valueUnit: String)
case class Timestamp(value: DateTime, numericValues: List[NumericValue])
val someTimestamps =
List(
Timestamp(
DateTime.parse("2013-03-07T18:00:00"),
List(
NumericValue(name = "Temperature", value = "23.4", valueUnit = "°C"),
NumericValue(name = "Runtime", value = "12345", valueUnit = "h"))),
Timestamp(
DateTime.parse("2013-03-07T19:00:00"),
List(
NumericValue(name = "Temperature, Max", value = "25.9", valueUnit = "°C"),
NumericValue(name = "Temperature, Min", value = "18.7", valueUnit = "°C"),
NumericValue(name = "Temperature, Mean", value = "22.5", valueUnit = "°C"))),
Timestamp(
DateTime.parse("2013-03-07T20:00:00"),
List(
NumericValue(name = "Temperature", value = "24.5", valueUnit = "°C"))),
Timestamp(
DateTime.parse("2013-03-07T21:00:00"),
List(
NumericValue(name = "Temperature", value = "25.1", valueUnit = "°C"))),
Timestamp(
DateTime.parse("2013-03-07T22:00:00"),
List(
NumericValue(name = "Temperature", value = "25.2", valueUnit = "°C")))
)
// Return all timestamps until 2013-03-07T20:30:00 (i.e. the first 3 timestamps)
val someDateTime = DateTime.parse("2013-03-07T20:30:00")
val oldTimestamps =
someTimestamps.filter(timestamp => timestamp.value.isBefore(someDateTime))
// Return all timestamps having a temperature over 25°C (i.e. the last 2 timestamps)
def hasTemperatureExceeding(timestamp: Timestamp, minTemp: Double): Boolean = {
timestamp.numericValues.exists(v =>
v.name == "Temperature" && v.valueUnit == "°C" && v.value.toDouble > minTemp)
}
val timestampsWithHighTemperatures =
someTimestamps.filter(timestamp => hasTemperatureExceeding(timestamp, 25))
// Return all temperatures
val allTemperatures =
someTimestamps.flatMap(timestamp =>
timestamp.numericValues.filter(v => v.name == "Temperature" && v.valueUnit == "°C"))
// Return the maximum temperature
val maxTemp = allTemperatures.map(v => v.value.toDouble).max
Note how the queries in prose naturally map to their counterparts in Scala code, using a small vocabulary of higher-order functions such as map
,
flatMap
and filter
. The code shows the "what" more than the "how". In that respect, the Scala code is more like XQuery than Java (especially than Java before
version 8). In a sense, the Scala core language along with its Collections API form a universal query (and transformation) language. Of course, Scala is a lot more than that, but
for the purposes of this article this is a fitting description.
The yaidom library can be used for querying and transforming XML in Scala. It interoperates very well with the Scala Collections API.
It was mentioned above that Scala and its Collections API can be used as a universal query and transformation language. The yaidom library offers an XML element query API that turns elements into Scala collections of elements. So yaidom can be said to turn a universal query and transformation language into an XML querying and transformation language. In other words, Scala + its Collections API + yaidom can be used as an "XML querying/transformation stack". Below it will become clear that yaidom can plug in different "XML backends", thus making the "XML stack" very powerful.
Using the sensor data example above, some simple yaidom XML queries are shown below. The XML is as follows:
// The sensor data XML
<node nodeId="Device01" xmlns="urn:xmpp:iot:sensordata">
<timestamp value="2013-03-07T18:00:00">
<numeric name="Temperature" value="23.4" unit="°C"/>
<numeric name="Runtime" value="12345" unit="h"/>
</timestamp>
<timestamp value="2013-03-07T19:00:00">
<numeric name="Temperature, Max" value="25.9" unit="°C"/>
<numeric name="Temperature, Min" value="18.7" unit="°C"/>
<numeric name="Temperature, Mean" value="22.5" unit="°C"/>
</timestamp>
<timestamp value="2013-03-07T20:00:00">
<numeric name="Temperature" value="24.5" unit="°C"/>
</timestamp>
<timestamp value="2013-03-07T21:00:00">
<numeric name="Temperature" value="25.1" unit="°C"/>
</timestamp>
<timestamp value="2013-03-07T22:00:00">
<numeric name="Temperature" value="25.2" unit="°C"/>
</timestamp>
</node>
Below follow the yaidom XML queries corresponding to the (non-XML) queries above. Written rather verbosely, they are as follows:
// Assume a root element called node.
// Return all timestamps until 2013-03-07T20:30:00 (i.e. the first 3 timestamps)
val someDateTime = DateTime.parse("2013-03-07T20:30:00")
val oldTimestamps =
node.filterChildElems(e => e.localName == "timestamp" &&
DateTime.parse(e.attribute(EName("value"))).isBefore(someDateTime))
// Return all timestamps having a temperature over 25°C (i.e. the last 2 timestamps)
def hasTemperatureExceeding(timestamp: simple.Elem, minTemp: Double): Boolean = {
require(timestamp.localName == "timestamp")
val temperatures =
timestamp.filterChildElems(e => e.attribute(EName("name")) == "Temperature" &&
e.attribute(EName("unit")) == "°C")
temperatures.exists(e => e.attribute(EName("value")).toDouble > minTemp)
}
val timestampsWithHighTemperatures =
node.filterChildElems(e => e.localName == "timestamp" &&
hasTemperatureExceeding(e, 25))
// Return all temperatures
val allTemperatures =
node.filterElems(e => e.localName == "numeric" &&
e.attribute(EName("name")) == "Temperature" && e.attribute(EName("unit")) == "°C")
// Return the maximum temperature
val maxTemp =
allTemperatures.map(e => e.attribute(EName("value")).toDouble).max
Above, the EName
type stands for "expanded name". It corresponds to Java's javax.lang.namespace.QName
, except that it does not retain the prefix, if any.
For clarity, these XML queries were written more verbosely than needed. Even when writing these queries in a less verbose way than has been done above, there would still be some verbosity related to XML handling. This is intentional: yaidom is a precise XML query API. For example, yaidom does not abstract away the distinction between elements and attributes, or between names with a namespace and those without any namespace. Despite the syntax dedicated by yaidom to XML node manipulation, the yaidom query examples are not that much more verbose than the non-XML query examples presented earlier. Compared to ad-hoc XML querying in Java (using JAXP), however, ad-hoc XML querying in Scala using yaidom is much less verbose. Even when invoking XPath queries (returning node sets) from Java code, the processing of the resulting node sets would add "syntactic clutter" that the use of Scala with yaidom could have prevented.
Why use yaidom and not Scala's own XML library? As will become apparent in this article, yaidom has very precise support for XML namespaces, more so than Scala XML. Using the yaidom API it is always clear if queries are namespace-aware. If it is intentional to query for elements that have specific local names, regardless of the namespace, then yaidom forces the user to be explicit about that. Precise namespace support in yaidom even goes as far as the ability to express a simple theory of XML namespaces (relating namespace declarations, in-scope namespaces, "qualified names" and "expanded names") in yaidom code itself, outside of any particular XML tree!
There are more reasons why yaidom may be preferable to Scala's own XML library. For example, yaidom has a precise uniform XML query API that is offered by
multiple "XML backend" implementations. Not only does yaidom offer own native DOM-like tree ("XML backend") implementations with different strengths and weaknesses, but
it is also possible to wrap existing XML library tree implementations (DOM, JDOM, XOM, Saxon etc.) in yaidom, offering the same yaidom query API.
For example, yaidom wrappers around Saxon-EE NodeInfo
trees offer the best of Saxon and the Scala-yaidom combination: on the one hand the completeness and
schema-type-awareness of Saxon-EE, and on the other hand a "Scala Collections API querying experience", using yaidom as the natural bridge between Saxon "nodes" and Scala collections processing.
Unlike yaidom, the Scala XML library does not offer multiple tree implementations backing the same query API.
Why not just use standards such as XSLT or XQuery? XBRL processing is a good example where yaidom shines, as will become clear below. After all, XBRL is a lot more than "just" XML, so XBRL processing is a lot more than "just" XML processing. Performing most or all of this processing in Scala using yaidom offers the following advantages:
Surely yaidom can be used with XQuery when using an XML(-enabled) database, where XQuery joins and filters database XML data into "raw result sets", which are further processed using yaidom queries. Still, it makes sense to keep the number of boundaries between XQuery and yaidom/Scala relatively low, for each such boundary has some (syntactic and semantical) costs. In summary, the more some XML processing task can benefit from the use of Scala, the more attractive the use of yaidom becomes.
So far, this article has introduced Scala and yaidom, using only simple sensor data examples. In the remainder of this article, yaidom examples in the domain of XBRL are used. First, this section gives a very brief introduction to XBRL.
XBRL (eXtensible Business Reporting Language) is a standard for business reporting. Many (but not all) XBRL reports are financial statements. XBRL reports ("XBRL instances") are XML documents, following a specified structure.
Suppose we want to report that for a given organization (CIK-number<PHONE_NUMBER>) the average number of employees in 2003 was 220, and that the corresponding numbers for 2004 and 2005 were 240 and 250, respectively.
More precisely, concept gaap:AverageNumberEmployees
(described by the so-called US-GAAP XBRL taxonomy) has the value 220
in the given
context (CIK-number<PHONE_NUMBER>, year 2003). Then we can report the 3 facts above in XBRL format as follows:
<xbrl xmlns="http://www.xbrl.org/2003/instance" xmlns:gaap="http://xasb.org/gaap">
<context id="D-2003">
<entity>
<identifier scheme="http://www.sec.gov/CIK">1234567890</identifier>
</entity>
<period>
<startDate>2003-01-01</startDate>
<endDate>2003-12-31</endDate>
</period>
</context>
<context id="D-2004">
<entity>
<identifier scheme="http://www.sec.gov/CIK">1234567890</identifier>
</entity>
<period>
<startDate>2004-01-01</startDate>
<endDate>2004-12-31</endDate>
</period>
</context>
<context id="D-2005">
<entity>
<identifier scheme="http://www.sec.gov/CIK">1234567890</identifier>
</entity>
<period>
<startDate>2005-01-01</startDate>
<endDate>2005-12-31</endDate>
</period>
</context>
<unit id="U-Pure">
<measure>pure</measure>
</unit>
<gaap:AverageNumberEmployees contextRef="D-2003" unitRef="U-Pure" decimals="INF">220</gaap:AverageNumberEmployees>
<gaap:AverageNumberEmployees contextRef="D-2004" unitRef="U-Pure" decimals="INF">240</gaap:AverageNumberEmployees>
<gaap:AverageNumberEmployees contextRef="D-2005" unitRef="U-Pure" decimals="INF">250</gaap:AverageNumberEmployees>
</xbrl>
This example comes from a non-trivial sample XBRL instance written by Charles Hoffman, also known as "the father of XBRL".
There are many requirements that have to be met in order for an XBRL instance to be valid. The XBRL Core specification (as well as other XBRL specifications) describes many of these requirements. There are also many common best practices that have been formalized as complementary rules. For example, the international FRIS standard places additional constraints on XBRL instances.
Most of the remainder of this article will show how many validation rules can be written naturally as Scala expressions using yaidom. Yaidom is in no way married to XBRL, but XBRL validations are good XML processing examples where Scala and yaidom really shine.
The XBRL snippet above is part of this sample instance. In this section, some simple yaidom XML queries are performed on the XBRL instance.
Before showing these queries on this XBRL instance, it should be noted that knowing only 3 yaidom query API methods to some extent means knowing them all. These 3 methods are
filterChildElems
, filterElems
and filterElemsOrSelf
. They all filter elements, based on the passed element predicate function. The difference
is that they filter child elements, descendant elements, and descendant-or-self elements, respectively. The word "descendant" is left out from the
method names.
It should also be noted that methods filterChildElems
and filterElemsOrSelf
have shorthands \
and \\
, respectively.
Method attributeOption
has shorthand \@
. Moreover, some element predicate functions have names, such as withLocalName
and
withEName
.
Some yaidom queries on the sample XBRL instance are as follows:
// Let's first parse the XBRL instance document
val docParser = DocumentParserUsingSax.newInstance
val doc = docParser.parse(sampleXbrlInstanceFile)
// Check that all gaap:AverageNumberEmployees facts have unit U-Pure.
val xmlNs = "http://www.w3.org/XML/1998/namespace"
val xbrliNs = "http://www.xbrl.org/2003/instance"
val gaapNs = "http://xasb.org/gaap"
val avgNumEmployeesFacts =
doc.documentElement.filterChildElems(withEName(gaapNs, "AverageNumberEmployees"))
println(avgNumEmployeesFacts.size) // prints 7
val onlyUPure =
avgNumEmployeesFacts.forall(fact => fact.attributeOption(EName("unitRef")) == Some("U-Pure"))
println(onlyUPure) // prints true
// Check the unit itself, minding the default namespace
val uPureUnit =
doc.documentElement.getChildElem(e =>
e.resolvedName == EName(xbrliNs, "unit") && (e \@ EName("id")) == Some("U-Pure"))
println(uPureUnit.getChildElem(withEName(xbrliNs, "measure")).text) // prints "pure"
// Now we get the measure element text, as QName, resolving it to an EName (expanded name)
println(uPureUnit.getChildElem(withEName(xbrliNs, "measure")).textAsResolvedQName)
// prints EName(xbrliNs, "pure")
// Knowing the units are the same, the gaap:AverageNumberEmployees facts are uniquely identified by contexts.
val avgNumEmployeesFactsByContext: Map[String, simple.Elem] =
avgNumEmployeesFacts.groupBy(_.attribute(EName("contextRef"))).mapValues(_.head)
println(avgNumEmployeesFactsByContext.keySet)
// prints Set("D-2003", "D-2004", "D-2005", "D-2007-BS1", "D-2007-BS2", "D-2006", "D-2007")
println(avgNumEmployeesFactsByContext("D-2003").text) // prints 220
The uniform query API of yaidom consists of several query API traits. They are like LEGO blocks, that can easily be combined.
Yaidom (native and wrapper) element tree implementations all mix in some or most of these query API traits. The example queries
above are not bound to any particular element implementation, but use a common query API trait, namely
ScopedElemApi
, which is itself a combination of query API traits. This trait offers
methods like filterElemsOrSelf
, filterChildElems
(from trait ElemApi
),
as well as methods to get text content, qualified names, expanded names, attributes etc. In other words,
it offers a query API abstraction that is valid for almost all element implementations.
The query API traits themselves are not visible in normal yaidom client code. They are relevant for creators of custom yaidom element implementations, for example wrappers around elements offered by existing XML libraries. Yaidom users that do not extend yaidom may still want to know which query API traits are offered by some XML tree implementation, of course.
Sometimes we want to use methods that are only offered by specific element implementations, and not by any query API traits.
The default native yaidom element implementation is simple.Elem
. It knows about
elements and text content (as per the mixed-in ScopedElemApi
trait), but it also
knows about comments, processing instructions and CDATA sections (if passed by the XML parser). For example:
println(doc.comments.map(_.text.trim).mkString)
// prints "Created by Charles Hoffman, CPA, 2008-03-27"
val contexts = doc.documentElement.filterChildElems(withEName(xbrliNs, "context"))
println(contexts forall (e => !e.commentChildren.isEmpty)) // prints true: all contexts have comments
// Being lazy, and forgetting about the namespace here
val facts =
doc.documentElement.filterChildElems(withLocalName("ManagementDiscussionAndAnalysisTextBlock"))
println(facts.flatMap(e => e.textChildren.filter(_.isCData)).size >= 1) // prints true
Yaidom has very precise namespace support. Like the article Understanding Namespaces,
yaidom distinguishes qualified names from expanded names, and namespace declarations from in-scope namespaces. Their yaidom counterparts are immutable
classes QName
, EName
, Declarations
and Scope
. Having these 4 distinct concepts, their
relationships can be expressed very precisely, even in yaidom code, and even outside of the context of any particular XML tree!
In the example XBRL instance above, all namespace declarations are in the root element, and therefore all descendant-or-self elements have the same in-scope namespaces. In code:
val rootScope = doc.documentElement.scope
val sameScopeEverywhere =
doc.documentElement.findAllElemsOrSelf.forall(e => e.scope == rootScope)
println(sameScopeEverywhere) // prints true
Let's consider the first FRIS rule taken from the international FRIS standard, expressed in yaidom. Rule 2.1.5 states that some commonly used namespaces should use their "preferred" namespace prefixes in XBRL instances. The rule can be expressed in yaidom as follows:
val standardScope = Scope.from(
"xbrli" -> "http://www.xbrl.org/2003/instance",
"xlink" -> "http://www.w3.org/1999/xlink",
"link" -> "http://www.xbrl.org/2003/linkbase",
"xsi" -> "http://www.w3.org/2001/XMLSchema-instance",
"iso4217" -> "http://www.xbrl.org/2003/iso4217")
val standardPrefixes = standardScope.keySet
val standardNamespaceUris = standardScope.inverse.keySet
// Naive implementation: expects only namespace declarations in root element
def usesExpectedNamespacePrefixes(xbrlInstance: simple.Elem): Boolean = {
val rootScope = xbrlInstance.scope
require(xbrlInstance.findAllElemsOrSelf.forall(e => e.scope == rootScope))
val subscope = xbrlInstance.scope.withoutDefaultNamespace filter {
case (pref, ns) =>
standardPrefixes.contains(pref) || standardNamespaceUris.contains(ns)
}
subscope.subScopeOf(standardScope)
}
Above, there is no useful error reporting, but that is easy to add, because the implementation is entirely in the rich Scala programming language.
In prose, method usesExpectedNamespacePrefixes
checks that if some of the 5 namespace prefixes above are used, that they all map to the expected namespace URIs.
The method also checks the other side: if some of the namespace URIs are in-scope, then the corresponding namespace prefixes are the expected ones, with the exception that
they may be the default namespace.
The example above illustrates yaidom's precise support for namespaces in the uniform query API, and therefore offered by diverse element tree implementations. Yet the namespace support goes further than that. As article Understanding Namespaces makes clear, namespaces are not only used in element and attribute names, but can also be used in text content and attribute values.
FRIS rule 2.1.7 must take namespaces in text content and attribute values into account, because it states that XBRL instances should not have any unused namespace declarations.
Yet how do we detect the use of namespaces in text content or attribute values? We know this from the XML schema(s) describing XBRL instances. For example, the xbrli:measure
element has type xs:QName
. So the text content of an xbrli:measure
should be interpreted as an "expanded name". The namespace of that expanded name is therefore
one of the namespaces used in the XBRL instance.
Yaidom makes it possible to code a DocumentENameExtractor
strategy, holding information about ENames and therefore namespaces occurring in text content or attribute values.
So, looking at the XML schema(s), we can easily code such a strategy ourselves (yaidom itself has no XML Schema awareness). Then, using method NamespaceUtils.findAllNamespaces
,
all namespaces used in the XBRL instance can be found.
Method NamespaceUtils.findAllNamespaces
does not work on the default "simple" elements, however, because "simple" elements do not know their ancestry. To that extent, yaidom
offers so-called "indexed" elements, that do know their ancestry. Like "simple" elements, "indexed" elements are immutable, because they are just wrappers around a root as "simple" element along
with an "index" into that element tree. The "indexed" and "simple" elements also share most of the query API, in particular the ScopedElemApi
query API trait.
Let's now implement FRIS rule 2.1.7, but only for the sample XBRL instance:
val xbrliDocumentENameExtractor: DocumentENameExtractor = {
// Not complete, but good enough for this example!
new DocumentENameExtractor {
def findElemTextENameExtractor(elem: indexed.Elem): Option[TextENameExtractor] = elem.resolvedName match {
case EName(Some(xbrliNs), "measure") if elem.path.containsName(EName(xbrliNs, "unit")) =>
Some(SimpleTextENameExtractor)
case EName(Some(xbrldiNs), "explicitMember") =>
Some(SimpleTextENameExtractor)
case _ => None
}
def findAttributeValueENameExtractor(elem: indexed.Elem, attributeEName: EName): Option[TextENameExtractor] = elem.resolvedName match {
case EName(Some(xbrldiNs), "explicitMember") if attributeEName == EName("dimension") =>
Some(SimpleTextENameExtractor)
case _ => None
}
}
}
val indexedDoc = indexed.Document(doc)
val namespaceUrisDeclared = indexedDoc.documentElement.scope.inverse.keySet
import NamespaceUtils._
// Check that the used namespaces are almost exactly those declared in the root element (approximately rule 2.1.7)
val companyNs = "http://www.example.com/company"
val usedNamespaces =
findAllNamespaces(indexedDoc.documentElement, xbrliDocumentENameExtractor).diff(Set(xmlNs))
// The "company namespace" is an unused namespace in our sample XBRL instance
require(usedNamespaces == namespaceUrisDeclared.diff(Set(companyNs)))
Although yaidom itself has no XML Schema awareness, yaidom can still be useful in a context where schema-awareness is needed. For example, Saxon-EE NodeInfo objects can be wrapped as yaidom trees, thus getting the best of Scala Collections processing and Saxon-EE XML and XML Schema support.
Let's now remove the unused namespaces (the "company" namespace in this example), and compare the result with the original XBRL instance. Yet how do we compare
two XML trees (as "simple" elements) for equality? In order to do so, note that namespace prefixes are irrelevant to equality comparisons, but namespace URIs do count.
(Be careful with prefixes in text content and attribute values!) Yaidom offers an XML element implementation in which namespace prefixes do not occur. These elements are
called "resolved" elements. They share much of the same query API with "simple" and "indexed" elements, but not all of it. After all, "resolved" elements do not know
about namespace prefixes, so they do not know about qualified names. Therefore they do not mix in the ScopedElemApi
trait, but they do mix in traits like
ElemApi
and HasTextApi
, that is, all traits extended by ScopedElemApi
that do not know about qualified names. Hence, "resolved"
elements still have much of the yaidom query API in common with "simple" and "indexed" elements.
The following code strips unused namespaces, and shows that the result is the same, when comparing the trees as "resolved" elements.
val editedRootElem =
stripUnusedNamespaces(indexedDoc.documentElement, xbrliDocumentENameExtractor)
val areEqual =
resolved.Elem(indexedDoc.document.documentElement) == resolved.Elem(editedRootElem)
println(areEqual) // prints true
Above, all XBRL instance processing was coded as normal XML processing, mostly using yaidom "simple" and "indexed" elements. That's not very convenient. It would be nice if we could talk about contexts, units, facts etc., instead of just XML elements that happen to be contexts, units, facts, etc. In general, it would be nice if yaidom would make it easy to support custom XML dialects. That is indeed the case. We already knew that yaidom is extensible, in that new element implementations offering the same yaidom query API can easily be added. Yet, what's more, yaidom also facilitates a "yaidom querying experience" for custom XML dialects, such as XBRL instances (or DocBook files, or Maven POM files, or XMPP message formats, or any other XML dialect described by schemas).
To that end, yaidom offers the SubtypeAwareElemApi
query API trait. Whereas the ElemApi
trait offers querying for child/descendant/descendant-or-self
elements, trait SubtypeAwareElemApi
extends this to class hierarchies (for XML dialects), offering querying for child/descendant/descendant-or-self elements of specific
sub-types of the root class of the class hierarchy.
In this XBRL instance class hierarchy we can see this action. Each part of an XBRL
instance is of type XbrliElem
or a sub-type. Common sub-types are those for contexts, units, item facts, tuple facts, and, of course, XBRL instances themselves.
Super-type XbrliElem
mixes in traits ScopedElemApi
and SubtypeAwareElemApi
. Trait ScopedElemApi
offers the most common
yaidom element query API, as we know, and trait SubtypeAwareElemApi
makes it easy to query for elements of specific types, with little boilerplate. The latter is used
internally in the code of the XbrliElem
class hierarchy, but can also be used in client code, if need be.
For the remaining FRIS validations in this article, we will use the XbrliElem
class hierarchy.
Consider FRIS rule 2.1.10. It states that there is a specific expected order of the child elements of the root element. One way to code that is as follows:
// Assume xbrlInstance variable of type XbrlInstance
val remainingChildElems =
xbrlInstance.findAllChildElems dropWhile {
case e: SchemaRef => true
case e => false
} dropWhile {
case e: LinkbaseRef => true
case e => false
} dropWhile {
case e: RoleRef => true
case e => false
} dropWhile {
case e: ArcroleRef => true
case e => false
} dropWhile {
case e: XbrliContext => true
case e => false
} dropWhile {
case e: XbrliUnit => true
case e => false
} dropWhile {
case e: Fact => true
case e => false
} dropWhile {
case e: FootnoteLink => true
case e => false
}
require(remainingChildElems.isEmpty)
Now consider FRIS rule 2.4.2 stating that all contexts must be used. It is also checked that all context references indeed refer to existing contexts. Note in this case how friendly the XBRL instance model is compared to raw XML elements:
val contextIds = xbrlInstance.allContextsById.keySet
val usedContextIds = xbrlInstance.findAllItems.map(_.contextRef).toSet
require(usedContextIds.subsetOf(contextIds))
// Oops, some contexts are not used, namely I-2004, D-2007-LI-ALL and I-2003
println(contextIds.diff(usedContextIds))
The next rule is more complex. FRIS rule 2.4.1 states that S-equal contexts should not occur. S-equality ("structural equality") is defined in the Core XBRL specification. A good implementation of S-equality requires type information. Therefore Saxon-EE backed yaidom wrappers would be a good choice. A very naive approximation is given below:
def transformContextForSEqualityComparison(context: XbrliContext): resolved.Elem = {
// Ignoring "normalization" of dates and QNames, as well as order of dimensions etc.
val elem = context.indexedElem.elem.copy(attributes = Vector())
resolved.Elem(elem).coalesceAndNormalizeAllText.removeAllInterElementWhitespace
}
Then rule 2.4.1 applied to our XBRL instance is as follows:
val contextsBySEqualityGroup =
xbrlInstance.allContexts.groupBy(e => transformContextForSEqualityComparison(e))
require(contextsBySEqualityGroup.size == xbrlInstance.allContexts.size)
As we can see, the more complex the rules, the more we profit from the fact that all code is Scala code, and that there is no needed effort in bridging between Scala and XSLT, for example. The Scala language, its Collections API, and yaidom form a powerful combination.
Finally, consider FRIS rule 2.8.3, stating that concepts are either top-level or nested in tuples, but not both. Using the XBRL instance model, the code is simple:
val topLevelConceptNames = xbrlInstance.allTopLevelFactsByEName.keySet
val nestedConceptNames =
xbrlInstance.allTopLevelTuples.flatMap(_.findAllFacts).map(_.resolvedName).toSet
require(topLevelConceptNames.intersect(nestedConceptNames).isEmpty)
In this article, the yaidom Scala XML query library was introduced. We used examples from XBRL and XMPP. It turned out that Scala, its Collections API, and the yaidom library form a powerful precise XML processing "stack". This "stack" is even more powerful when using custom mature yaidom "backends" as Saxon-EE. It also turned out that yaidom makes it easy to support custom XML dialects (such as XBRL instances), offering more type-safety and leading to less boilerplate. The extensibility of yaidom (in more than 1 way) is one of its strengths, along with its precise namespace support and uniform precise element query API (offered by numerous XML "backends").
The FRIS rule examples show that a programming language like Scala is a natural fit for implementing those rules. Had we used XSLT or XQuery instead, how would we easily have found unused namespaces, for example? Moreover, how would we have supported custom XML dialects in the same way that yaidom facilitates such support?
The examples only used XMPP data and XBRL instances. These XBRL instances are described by XBRL taxonomies. Such taxonomies have to obey many rules as well. Taxonomies typically span many files, and their validation is usually much more complex than instance validation. The advantages of using a "Scala yaidom XML stack" would even be greater than for XBRL instances.
As a concluding remark, yaidom is used in production code developed at www.ebpi.nl. Its usage in several projects has certainly helped it mature. I want to thank my colleagues Jan-Paul van der Velden, Andrea Desole, Johan Walters and Nicholas Evans for their valuable feedback on earlier versions of yaidom.


DevOps Tools Mad Scientist
Vagrant isolates dependencies and their configurations within a single, disposable, and consistent environment.
The development environment is modeled in code so we can use the same tools and principles as we would for software development.
Let's take a quick look at some Vagrant features.
$ vagrant up
$ vagrant ssh
$ vagrant halt
$ vagrant destroy
$ vagrant box list
$ vagrant box remove ubuntu-dev
For further study:


Sababa Ventures Taps Randi Zuckerberg as Partner, Targets $35 Million Fund
The new fund will focus on early-stage Israeli tech companies in the media, entertainment, sports, and commerce sectors
by Adi PickRandi Zuckerberg, former spokesperson for Facebook and Mark Zuckerberg’s sister, has joined New York-based investment fund Sababa Ventures as general partner, the fund announced Thursday. The new fund aims to raise $35 million in commitments to invest in early-stage Israeli tech companies in the media, entertainment, sports, and commerce sectors.
The fund currently has $7 million in assets under management, according to Pitchbook data. Sababa Ventures has offices in New York, Tel Aviv, and Los Angeles.


This example provides an introduction to the Attribute utility, showing how you can use it to add attribute support to your own custom classes.
It is geared towards users who want to create their own classes from scratch and add Attribute support. In most cases you should consider extending the Base
class when you need managed attribute support,
instead of augmenting Attribute directly, especially if you expect your class to be extended. Base
does the work described in this example for you, in addition to making it easier for users to extend you class.


On news addiction and reading good things not more things.
Patterns that reduce uncertainty about some aspect of the world are called information. Open your curtains in the morning, see a certain amount of light. Opening your window gives you some information about what time of the morning it is. More light is a pretty reliable way of approximating the time during sunrise.
Speaking generally, it always seems right that more information is a good thing. If getting more information reduces our uncertainty and we want to be more certain, then collect as much information as possible. This feels right. In fact, it feels so right that it is the default operating mode for most people. Reading news daily or watching news hourly is a pretty common pasttime. The goal here must be to reduce the uncertainty we have about the world. When the news isn't out with a straighforward mission to decieve us we'll be getting some good nuggets of information that we can store away for later use in our quest to understand the world. Sure, some of those nuggets will be worse than others but we believe that information accumulates so we'll take what we can get.
Is more information always a good thing? In some circumstances it surely is. Here is a common scenario. There is a fixed pool of information sources that vary in their quality. If we sample them all and then combine them in a rational way then the total information will always be greater with more sources. So that is +1 for the more information camp. The cable news addicts.
Change the setup a little bit. I'm going to change it in a way that is a little more realistic (not much) for how we actually use information.
Let's say that there is fixed pool of information bearing samples. The samples vary in their quality, some are low information some are high. Then let's say that we can't sample all the sources -- we can only sample a fixed subset of those samples. Think of this like having a large collection of memories about the world but only a couple of them can be recalled in a given instant while we're thinking about something. Furthermore, for simplicity, assume that which samples form the subset are random. This is also kind of consistent with how memory works. There is obviously some structure to which events appear in memory, but there is also a arbitrary random quality to them as well. Now, once this subset of samples has been encoded we combine them in a rational way. This is a case where more information is not always better.
If the low quality samples increase in proportion to the high quality samples then the probability of selecting a high quality information sample goes down. The result is that the overall information is lower. If all you have access to is good information then total information will be good.
We can compare these two situations exactly using a simple simulation. The code is at the bottom of the page.
For situation 1 set n.good equal to total.samples. Set p.bad to 0. This means there are only good samples. Information increases.
Information is not clearly defined here. It is not in "bits" or "nats" -- units that result from a typical definition of information. The units here are related to how well a binary stimulus can be classified. Larger numbers mean we have more information to classify with. These units could be converted into Shannon information and we would get the same result.
For situation 2 set n.good to some number and set total.samples to some value lower than that. Then increase p.bad and see what happens. What this does is increase the proportion of low information samples relative to high information samples. The figures show what happens.
In the following, the proportion of bad samples increases and information goes down.


Dismayed by the state of politics in the land of Yonder, you decided to research political science. With no source material available beyond the sacred texts of Vulpes Nuntium, you conclude that only the dankest of memes can be used to win back sanity in your lands. Since dank things are generally found underground, you set forth into the Dankest Dungeon, seeking to find the Amulet of Winning - and restore political sanity to the land.
This is a 7-Day Roguelike, created as an exercise in finding out what Emscripten can do these days. Please enjoy it, and provide feedback to /u/thebracket on Reddit. This program is provided as-is. No warranty, express or implied, is provided. Any resemblance to real-life characters is purely coincidental. In other words - have fun, please don't sue me, and remember that this was written for fun not security - so please don't give me any secrets to protect!
This game is built around designing dungeons, and sharing them with other adventurers. As such, you need a user account - so we know which dungeons are yours. Very little effort has been put into security, so please don't use a password that you care about, or use for anything important!
You can also login as guest with the password guest if you feel uncomfortable with logins. This will prevent you from being attributed for any levels you create, but otherwise has full access.


Preparation time
1-2 hours
Cooking time
10 to 30 mins
Serves
Makes 20 toffee twists
Dietary
Traditional, rich and creamy butter toffee is easier to make than you might think.
Equipment and preparation: you will need a sugar thermometer.
Lightly oil a baking tray with groundnut oil.
Put the sugar, butter, cream of tartar and 75ml/2½fl oz water into a heavy-bottomed pan. Heat the mixture on a moderate heat, stirring all the time until the sugar has dissolved. Place a sugar thermometer in the pan, bring the mixture to the boil and bubble until the temperature reaches 137C/280F. (CAUTION: boiling sugar is extremely hot. Handle very carefully. Use a deep pan to avoid bubbling over.)
Quickly pour the mixture onto the prepared baking tray, taking care as the mixture is very hot.
Leave for about 20 minutes until cool enough to handle.
Put on rubber gloves and oil them with groundnut oil.
Take two diagonally opposite corners of the toffee and pull them over into the middle of the toffee. Then take the other two opposite corners and pull them into the middle to almost meet the others. Take two corners and stretch the toffee out like a long sausage, then take the ends and fold them into the middle. Take hold of the two ‘new’ ends and pull them out like a sausage again, fold them into the centre and keep repeating. Keep doing this about 10 or 15 times. The toffee will turn into spaghetti-type strands. Now twist the strands together like a corkscrew to form tight barley twist ringlets. Chop into 2.5cm/1in long sticks using some sturdy scissors.
Wrap in individual parchment twist wraps or pretty cellophane. The toffee will keep for a long time so long as it is wrapped and kept dry.


Home
Products
Order Now
Contact Us
Be Solid
To Eat Dried Natural Products
Order Now
Available Items
Cashew Nuts
Bhadam
Mixed DryFruits
Green Kismis
Yellow Kismis
Black Kismis
Walnuts
Anjeer
Apricots
Salt Pista
Kimia Dates
Dry Dates
Munka
Pumpkin Seeds
WaterMelon Seeds
SunFlower Seeds
Order Now
Order Through Whatsapp
+91 93984 71614 Order Through Call
Contact Us
+91 93984 71614
+91<PHONE_NUMBER>
<EMAIL_ADDRESS>Order Now
Home


Overkill is the dust that settles on the stuff that took a lot of energy to build or buy, but turned out not to be necessary.
Overkill is the dust that settles on the stuff that took a lot of energy to build or buy, but turned out not to be necessary.


{% extends PATH + "/inc/layout.html" %} {% block staff_content %} {{ horizontal_nav() }}
| Name | Condition | Status | Status updated | Claim submitted |
|---|---|---|---|---|
| Oliver Reed - Trainee Manager, McDonalds #2 | Autism | New appliction | 5 June 2017 | 5 June 2017 |
| Oliver Reed - Salesman, Carphone Warehouse | Autism | New appliction | 5 June 2017 | 5 June 2017 |
| Oliver Reed - Crew Member, McDonalds #1 | Autism | Offer accepted | 7 April 2014 | 5 July 2014 |


Akshay's Personal Website
Home
About Me
Work Experience
Extra Curriculars
Contact Me
Here is my work experience in reverse chronological order!
Please click on company image below to know more details about the firm!
S.No
Duration
Company
Position
1
July-Aug 2016
Yes Bank Ltd
Operations Intern
2
July-Aug 2015
Tata Teleservices Ltd
Technology Intern
3
June-July 2014
Embarc Information Techlogy
Summer Trainee


#Genuary2021
January 17th
Prompt
Draw a line, pick a new color, move a bit.
Interpretation
The colors used for the new lines are picked from this photo by Felix Dubois-Robert on Unsplash
Draw a line, pick a new color, move a bit.
The colors used for the new lines are picked from this photo by Felix Dubois-Robert on Unsplash


Most modern applications are attached to the web to synchronize data. When synchronizing data, you need to identify who the user is. Chrome packaged apps come with an identity API that makes it easy to integrate either with Google accounts or with any other service that supports OAuth.
Warning:
Apps with authentication require the experimental permission in the
manifest.json
and, until they came out of experimental state,
they cannot be uploaded to the Chrome Web Store.
If you prefer, you can choose to skip this lab.
We are working on a very easy integration flow for apps that authenticate with Google accounts. However, this flow is not yet available for general use. In the meantime, you may still use the third-party flow described below, even for Google services.
Chrome packaged apps have a dedicated API for lauching the authentication flow to any third-party OAuth2 service, called $ref:experimental.identity.launchWebAuthFlow. To show how this flow works, we're going to update our sample to import Google Tasks into the Todo list.
To use a third-party OAuth2 provider, you will first need to register your application with the provider. Each provider has a different way of registering applications, but in general it will be in a section called Developer or API at the provider's website.
Here we are treating Google as a third-party service. Just follow Google's own registration procedure for apps requiring API access below:
https://<YOURAPP_ID>.chromiumapp.org/
,
replacing <YOURAPP_ID> with your app ID (this is the app's long alphanumeric ID you can find in chrome://extensions
).Update the AngularJS manifest.json or JavaScript manifest.json to use "experimental" features. Note that we've also requested permission to make XHR requests to the Tasks service URL - for security reasons, you need to request explicit permission in the manifest for every URL you will call via XHR.
{ ... , "permissions": ["storage", "experimental", "https://www.googleapis.com/tasks/*"] }
Now we are ready to ask user's authorization, so we can connect to the Tasks service and import his tasks into our Todo list. First, we will need to request an access token - which, at the first run will automatically pops up an authentication and authorization window to the user. Once we have this token, we are able to call the Google Tasks API directly.
Since this is time consuming and error prone, you can cheat and copy our JavaScript that handles the authentication to the Google Tasks API from here: Angular gapi_tasks.js
and JavaScript gapi_tasks.js are the same.
This script calls launchWebFlow
and
gets a valid access token for the specified client ID.
It also has simple JavaScript methods that, after authenticated,
goes to the Tasks API and gets the user's task lists and the corresponding tasks.
Note: This script is NOT intented to be used in production - it is just a very simple, limited and definitely not robust piece of code intented to highlight the basic authentication and API calls.
Add a new method to the existing AngularJS controller.js or JavaScript controller.js that, using the methods from the script of the previous step, authenticates the user and imports his Google tasks into the Todo list:
$scope.importFromGTasks = function() { var api = new TasksAPI(); var clientId = "<GET_YOURS_AT_https://code.google.com/apis/console>"; api.authenticate(clientId, function() { api.getLists(function(result) { console.log(result); if (!result || !result.items || result.items.length==0) { throw "No task lists available"; } var listId=result.items[0].id; api.getTasks(listId, function(tasks) { console.log(tasks); for (var j=0; j<tasks.items.length; j++) { $scope.$apply(function() { $scope.todos.push({text:tasks.items[j].title, done:tasks.items[j].status!="needsAction"}); }); } }); }); }); }
document.getElementById('importGTasks').addEventListener('click', function() { var api = new TasksAPI(); var clientId = "<GET_YOURS_AT_https://code.google.com/apis/console>"; api.authenticate(clientId, function() { api.getLists(function(result) { console.log(result); if (!result || !result.items || result.items.length==0) { throw "No task lists available"; } var listId=result.items[0].id; api.getTasks(listId, function(tasks) { console.log(tasks); for (var j=0; j<tasks.items.length; j++) { model.addTodo(tasks.items[j].title, tasks.items[j].status!='needsAction'); } }); }); }); });
Replace the following line in the code above:
var clientId = "<GET_YOURS_AT_https://code.google.com/apis/console>";with your own project's Client ID that you got from the Google API Console. Should look like this:
var clientId = "xxxxxxxxxxxxxx.apps.googleusercontent.com";
Now we just need a button that starts the import process. Update the index.html
to include gapi_tasks.js
and add a new button to call importFromGTasks
:
<script src="gapi_tasks.js"></script> ... <button ng-click="importFromGTasks()">import tasks from GTasks</button>
<button id="importGTasks">import tasks from GTasks</button> ... <script src="gapi_tasks.js"></script>
If you get stuck and want to see the app in action,
go to chrome://extensions
,
load the unpacked
AngularJS app or
JavaScript app,
and launch the app from a new tab.
Identify User tutorial
In 7 - Access Web Resources, you will learn how to load and show images from a remote URL.
Note: Up until now, the code in each lab builds upon the previous lab code sample.
We've decided not to include the user identification code changes in the remainder of the lab since the identity API
is still experimental and as such it would prevent you from publishing your final code to the Chrome Web Store.


Runs instance of the JPWorld
component inside the stand-alone application with own JFrame
.
More...
Public Member Functions | |
| RunStandalone () | |
Adds main component JPWorld to the content pane. | |
Static Public Member Functions | |
| static void | main (String[] args) |
| Main program entry that creates and shows GUI. | |
Private Attributes | |
| JPWorld | wopComponent = new JPWorld () |
Main component is instance of the JPWorld . | |
Static Private Attributes | |
| static final long | serialVersionUID = -6852878245259708233L |
| Implements java.io.Serializable interface. |
Runs instance of the JPWorld
component inside the stand-alone application with own JFrame
.
Definition at line 15 of file RunStandalone.java.
| RunStandalone.RunStandalone | ( | ) |
Adds main component JPWorld
to the content pane.
Definition at line 30 of file RunStandalone.java.
References JPWorld.startTests(), and wopComponent.
Referenced by main().
{ super( "IP1-1.1: Multithreaded World of Particles (inefficient but educational)" ); setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); /* Adjust window dimensions not to exceed screen dimensions ... */ Dimension win = new Dimension( 1024, 600 ); Dimension scsz = Toolkit.getDefaultToolkit().getScreenSize(); win.width = Math.min( win.width, scsz.width ); win.height = Math.min( win.height, scsz.height - 40 ); setSize( win ); setMinimumSize( new Dimension( 330, 100 ) ); /* ... then center window on the screen. */ setLocation( ( scsz.width - win.width )/2, ( scsz.height - 40 - win.height )/2 ); /* Register the thread tester component, then make frame visible */ add( wopComponent ); addKeyListener( wopComponent ); setVisible( true ); /* Start T1 & T2 tests delayed for 1 sec */ wopComponent.startTests( 1f /*sec delay*/ ); }
| static void RunStandalone.main | ( | String[] | args ) | [static] |
Main program entry that creates and shows GUI.
| args | main program arguments |
Definition at line 67 of file RunStandalone.java.
References RunStandalone().
{ /* Create and show GUI */ Runnable doCreateAndShowGUI = new Runnable () { public void run () { new RunStandalone (); } }; SwingUtilities.invokeLater( doCreateAndShowGUI ); }
final long RunStandalone.serialVersionUID = -6852878245259708233L [static, private] |
Implements java.io.Serializable interface.
Definition at line 20 of file RunStandalone.java.
JPWorld RunStandalone.wopComponent = new JPWorld () [private] |
Main component is instance of the JPWorld
.
Definition at line 25 of file RunStandalone.java.
Referenced by RunStandalone().


{% extends "global/Page.html" %} {% load otree %} {% block title %} Story 8 {% endblock %} {% block content %} Please read the following story:
Despite her sincere appreciation for the nicer things in life, she decided to give it all up to pursue her dream.
{% formfields%}
{% next_button %} {{ form.errors }} {% endblock %}


[gecode-users] gecode-0.9.0-20051122.tar.gz
Christian Schulte
schulte at imit.kth.se
Wed Nov 23 09:50:54 CET 2005
Thanks, as you say this is a bug from yesterday...
Christian
--
Christian Schulte, http://www.imit.kth.se/~schulte/
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of Luis Quesada
Sent: Tuesday, November 22, 2005 12:59 PM
To: users at gecode.org
Subject: [gecode-users] gecode-0.9.0-20051122.tar.gz
Dear all,
The version of gecode available through the following link does not compile:
http://www.gecode.org/download/gecode-0.9.0-20051122.tar.gz
When compiling we get the following error:
./int/arithmetic/mult.icc: In member function 'virtual
Gecode::ExecStatus
Gecode::Int::Arithmetic::Mult<View>::propagate(Gecode::Space*)':
./int/arithmetic/mult.icc:300: error: jump to label 'prop_pz'
./int/arithmetic/mult.icc:274: error: from here
./int/arithmetic/mult.icc:283: error: crosses initialization of 'double
x0u_x1u'
./int/arithmetic/mult.icc:282: error: crosses initialization of 'double
x0u_x1l'
./int/arithmetic/mult.icc:281: error: crosses initialization of 'double
x0l_x1u'
./int/arithmetic/mult.icc:280: error: crosses initialization of 'double
x0l_x1l'
./int/arithmetic/mult.icc:300: error: jump to label 'prop_pz'
./int/arithmetic/mult.icc:270: error: from here
./int/arithmetic/mult.icc:283: error: crosses initialization of 'double
x0u_x1u'
./int/arithmetic/mult.icc:282: error: crosses initialization of 'double
x0u_x1l'
./int/arithmetic/mult.icc:281: error: crosses initialization of 'double
x0l_x1u'
./int/arithmetic/mult.icc:280: error: crosses initialization of 'double
x0l_x1l'
./int/arithmetic/mult.icc:315: error: jump to label 'prop_nz'
./int/arithmetic/mult.icc:277: error: from here
./int/arithmetic/mult.icc:283: error: crosses initialization of 'double
x0u_x1u'
./int/arithmetic/mult.icc:282: error: crosses initialization of 'double
x0u_x1l'
./int/arithmetic/mult.icc:281: error: crosses initialization of 'double
x0l_x1u'
./int/arithmetic/mult.icc:280: error: crosses initialization of 'double
x0l_x1l'
./int/arithmetic/mult.icc:315: error: jump to label 'prop_nz'
./int/arithmetic/mult.icc:272: error: from here
./int/arithmetic/mult.icc:283: error: crosses initialization of 'double
x0u_x1u'
./int/arithmetic/mult.icc:282: error: crosses initialization of 'double
x0u_x1l'
./int/arithmetic/mult.icc:281: error: crosses initialization of 'double
x0l_x1u'
./int/arithmetic/mult.icc:280: error: crosses initialization of 'double
x0l_x1l'
make: *** [int/arithmetic.o] Error 1
The today's svn version is compiling without any problem with g++4.0.2.
Andres + Luis
_______________________________________________
Gecode users mailing list
users at gecode.org https://www.gecode.org/mailman/listinfo/gecode-users
More information about the gecode-users
mailing list


|
Learning with Texts - Fork 2.8.1-fork
Learn foreign languages with texts
|
Import terms from file or Text area. More...
Functions | |
| my_str_getcsv ($input) | |
| upload_words_import_terms ($fields, $tabs, $file_upl, $col, $lang) | |
| upload_words_import_tags ($fields, $tabs, $file_upl) | |
| upload_words_import () | |
| upload_words_display () | |
Variables | |
| if(isset($_REQUEST['op'])) | else |
Import terms from file or Text area.
Call: upload_words.php?.... ... op=Import ... do the import
| my_str_getcsv | ( | $input | ) |
Get the CSV from a string.
| string | $input | Input string. |
@psalm-return false|non-empty-list<null|string>|null
| upload_words_display | ( | ) |
Display the main for adding new words.
Show a supplementary field depending on long text import mode.
| upload_words_import | ( | ) |
Import terms of tags to the database.
@global string $tbpref Database table prefix
| upload_words_import_tags | ( | $fields, | |
| $tabs, | |||
| $file_upl | |||
| ) |
Import term tags only to the database.
| array | $fields | Fields indexes |
| string | $tabs | Columns separator |
| bool | $file_upl | If the input text is an uploaded file |
@global string $tbpref Database table prefix
| upload_words_import_terms | ( | $fields, | |
| $tabs, | |||
| $file_upl, | |||
| $col, | |||
| $lang | |||
| ) |
Import terms to the database.
| array | $fields | Fields indexes |
| string | $tabs | Columns separator |
| bool | $file_upl | If the input text is an uploaded file |
| array<int,string> | $col Columns names | |
| int | $lang | Language ID |
@global string $tbpref Database table prefix
| if (isset( $_REQUEST[ 'op'])) else |


Wasm Math Helper
(click me)
Wasm
Is Prime Number?
Check
...
JS
Is Prime Number?
Check
...
Wasm
How Many Primes?
Check
...
JS
How Many Primes?
Check
...


Pat the lamb shanks dry with paper towels and season generously with salt and pepper.
Let it sit for 30 minutes.
Melt butter in large skillet over medium heat. Add onions and toss to coat with butter.
Cover and slowly cook onions, stirring occasionally, for 10 minutes or until a golden color is reached. Turn heat up to medium high and begin to brown the onions, stirring constantly about 10 more minutes.
Reserve it for garnish.
Heat a large pot with a tight fitting lid, over high heat. Add the clarified butter and heat.
Add the lamb shanks to the hot oil and evenly brown on all sides, about 4 to 5 minutes per side.
Transfer shanks to a plate and keep warm.
Add the cardamom, cloves, cinnamon, peppercorns, star anise, bay leaves, and cook, stirring continuously until very fragrant, about 2 minutes.
Add the garlic, ginger, celery, onions, tomatoes, and tomato paste to the pot, and cook, stirring occasionally, until the mixture is dry, about 6 to 8 minutes.
Add the red wine to the vegetables and stir continuously, scraping up any browned bits that cling to the pot. Bring to a boil and cook until the wine is syrupy, about 5 minutes.
Add the shanks and chicken broth to the mixture and bring it to a boil, cover, and transfer to the oven. Cook about 1 1/2 to 2 hours, turning the shanks occasionally, until the meat is just falling off the bone.
Serve hot garnished with caramelized onions.


==== Password Policy ====
By enumerating the systems password policy the ability to brute force and crack passwords becomes much more efficient, for example knowing that the minimum password length is 8 characters you can remove any word less than 8 characters from a dictionar


Help us plant one million trees with Mirror's campaign to restore our forests
Working with the Woodland Trust, we are giving away 20,000 native trees – two each to 10,000 readers – for you to plant at home or in your community as part of the Daily Mirror's MillionMirrorTrees campaign
by Nada Farhoud, https://www.mirror.co.uk/authors/nada-farhoud/Right now we are facing the gravest ever threat to modern life on Earth and scientists are clear that urgent action is needed.
What we do now will shape the future of our planet for generations to come.
All of us can make a difference in the fight against climate change and today we are helping you do just that.
Working with the Woodland Trust, we are giving away 20,000 native trees – two each to 10,000 readers – for you to plant at home or in your community.
It marks the beginning of a brilliant new MillionMirrorTrees campaign, which we are working on with A Trillion Trees, a joint venture of the world’s largest conservation charities – WWF, BirdLife International and Wildlife Conservation Society who are together fighting deforestation and to restore forests around the world.
Ben Fogle joined in by planting a mountain ash at Queen Katherine School in Kendal, Cumbria yesterday, with Paul Crossland from Hayes Garden World, Ambleside who supplied the tree.
The campaign is poignant for the TV star who fears precious regions he has visited, such as Antarctica, may “become extinct geographies in my children’s lifetimes”. He said: “Anyone can plant a tree.
“It doesn’t have to cost anything. This is why I back the Mirror’s campaign.”
Our aim is to plant at least one million trees over five years, and help protect the ones we have. But this is just a start.
Today just 13% of the UK is covered in trees, compared to the EU average of 37%. Globally 10 billion more are cut down than are planted every year.
According to the Committee on Climate Change, the Government’s statutory advisers on the climate crisis, the UK should have 1.5billion new trees by 2050 to meet its net zero carbon target.
But last year just 1,420 hectares of its 5,000-hectare yearly target were planted.
Daily Mirror editor Alison Phillips urged readers to “make a difference”.
She said: “It can feel the climate crisis is so extreme there is nothing normal people at home, like us, can do about it.
“But planting a tree will have some impact. And raising the issue of climate crisis in your community is invaluable.”
Darren Moorcroft, head of the Woodland Trust which is holding a national planting day on November 30, said trees were “warriors” against climate change.
“We hope Mirror readers apply for trees and dig for all our futures,” he said.


Outside Providence (1999) Reviewed by Eugene Novikov http://www.ultimate-movie.com Member: Online Film Critics Society
** out of four
"It's a prep school." "What's a prep school?" "It's to prepare you for me not breaking your neck."
Starring Shawn Hatosy, Alec Baldwin, Amy Smart. Rated R.
Those who believed the ads trying to convince the American Public that Outside Providence is another There's Something About Mary are in for a shock. It bears no resemblance to the horrifyingly popular 1998 gross- out laugh-fest; unfortunately it's not anywhere near as good, either. It's meant to be an outrageous coming-of-age comedy, but the laughs are few and far between. As for the coming-of-age part, let's just say it is beaten out in that department by The Thirteenth Warrior.
The reason behind all of the comparisons is that Outside Providence was scripted by Peter Farrelly, one of the men responsible for Mary. However the film is directed by Michael Corrente (American Buffalo) and doesn't have Mary's take-no-prisoners attitude. That's the problem: it is more interested in lackluster drama rather than comedy.
The concept itself isn't particularly tantalizing: the film is about Timothy Dunphy a.k.a. "Dildo", a deadbeat, troublemaking high-schooler who is sent to a fancy prep school by his father (Alec Baldwin). He doesn't seem to fit in: he is surrounded by smart kids while he himself isn't particularly bright; he likes getting stoned but though some of his schoolmates do as well, they, unlike him, know that studying is important. It gets worse when he meets opposition from the typically evil schoolmaster (Timothy Crowe); an authority figure intent on catching Timothy breaking a rule.
Of course Tim meets a girl. Of course Tim likes the girl.  That's the coming-of-age portion of the film... will Tim take responsibility for his own actions or will he remain a freeloader, potentially for the rest of his life?
This is the kind of movie where I leave the theater in a bad mood -- not because I hated what I just saw, but because it was sheer mediocrity from beginning to end. Outside Providence didn't fill me with dislike, as a matter of fact, it failed to evoke any sort of cognizable emotional reaction from me. I laughed a couple of times. Smiled a few. Nothing more. The movie built up a little dramatic momentum at a few points. Nothing more. I didn't hate the film. Part of me wishes I did.
The only way to fix this mess would be to go to the core of the problem: the script. It tries to balance comedy and drama and fails; as a result we get a movie that isn't very funny or very, um, dramatic. There are a few moments in Outside Providence when I was wishing for the script to take a particular gag or concept farther. The subplot about the schoolmaster demonstrates this perfectly: the man is almost the villain in the story; almost a funny caricature. If the film was going to go in this direction, I thought to myself, why not go all the way?. Why not go a step further and make it genuinely funny? Instead, it stopped short; chickened out, if you will.
Shawn Hatosy (The Faculty) is as unexceptional as everything else in Outside Providence. He looks so stoned throughout the first two-thirds of the movie that when we get to the point where we are supposed to believe that his Tim is a changed man, we can't. Amy Smart's (Starship Troopers) whole performance is the good-girl-with-a-wild-side cliche; a shame since her character is so central to the plot.
I suppose this isn't such a bad film. I've seen worse. Outside Providence is a movie where everything that is tried fails to rise above the merely adequate. To have made the film better it would have to have been completely revamped, something big-shot Peter Farrelly would probably never have permitted: this has been his pet project. I don't know why. As I said, there's nothing remotely tantalizing about the idea or the final result. It isn't horrible, either. It's just... there. And that sucks. ©1999 Eugene Novikov
Sent via Deja.com http://www.deja.com/ Share what you know. Learn what you don't.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Notebooks
Story: Burial; also avenging a death
Burial; also avenging a death
Title
Burial; also avenging a death
Collection
Summary
When one of the !kun dies, the people dig a grave and put the dead person into it. The body is covered in earth and the grave is filled in.  His people put the relative into the earth and the women cried for him. If a stranger is killed they do not bury him. The account includes mention of how tobacco is shared with a stranger. If the man returns with none to share he is killed.
Comments
1) p.10 262v: |uma from personal observation, 2) p.10 267v: the ||'i thorn-tree, 3) p.10 269v: the !kun do not refuse a stranger tobacco; when the person returns he brings tobacco for them in return; if the man returns without tobacco he is killed, 4) See also Dress after death and Burial and Burial (another account), 5) This story is found in Book XIII & XIV-1
Contributors
Date
25 October 1881 (started)
Categories
Keywords
burial (also avenging a death) , burial (and a thorn-tree called ||'i) , burial (the actions of the burial party) , burial (the actions of the relations of the deceased) , burial (the actions of men and women) , burial (when the dead are buried or left lying on the ground) , burial (of strangers) , burial (methods of) , burial (the grave) , burial (!kun customs relating to) , death (burial and avenging a death) , death (and murder) , death (and the treatment of strangers) , death (and graves) , death (and the !kun) , death (avenging) , death (of |uma's relative killed by an arrow) , grave (the digging of) , grave (and burial) , grave (!kun methods of making) , grave (a thorn-tree is placed on top of) , grave (burial and avenging a death) , smoking (and strangers) , smoking (customs relating to) , smoking (burial and avenging a death) , strangers (people who are different) , strangers (death of) , strangers (are not buried) , strangers (sharing of tobacco with) , strangers (and smoking) , strangers (the murder or killing of) , strangers (and people in |uma's country) , strangers (the treatment of) , strangers (customs relating to) , strangers (burial and avenging a death) , tree (burial and avenging a death) , tree (name of a thorn tree) , tree (placed on top of the grave) , tree (the use of a thorn-tree called ||'i in burial) , name (of a thorn tree used in burial called ||'i) , relations (the actions of those of the deceased) , relations (the burial party) , relations (burial and avenging a death) , sharing (of tobacco) , sharing (burial and avenging a death) , sharing (tobacco with strangers) , arrow (|uma relates the death of one of his relatives who was killed by one) , arrow (burial and avenging a death) , |uma (his relative killed by an arrow) , |uma (burial and avenging a death) , strangers (burial and avenging a death) , strangers (death of) , strangers (are not buried) , strangers (sharing of tobacco with)
Story Pages
10 263-10 272