| Opcode/Instruction | Op/En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
| 0F F1 /r1 PSLLW mm, mm/m64 | RM | V/V | MMX | Shift words in mm left mm/m64 while shifting in 0s. |
| 66 0F F1 /r PSLLW xmm1, xmm2/m128 | RM | V/V | SSE2 | Shift words in xmm1 left by xmm2/m128 while shifting in 0s. |
| 0F 71 /6 ib PSLLW mm1, imm8 | MI | V/V | MMX | Shift words in mm left by imm8 while shifting in 0s. |
| 66 0F 71 /6 ib PSLLW xmm1, imm8 | MI | V/V | SSE2 | Shift words in xmm1 left by imm8 while shifting in 0s. |
| 0F F2 /r1 PSLLD mm, mm/m64 | RM | V/V | MMX | Shift doublewords in mm left by mm/m64 while shifting in 0s. |
| 66 0F F2 /r PSLLD xmm1, xmm2/m128 | RM | V/V | SSE2 | Shift doublewords in xmm1 left by xmm2/m128 while shifting in 0s. |
| 0F 72 /6 ib1 PSLLD mm, imm8 | MI | V/V | MMX | Shift doublewords in mm left by imm8 while shifting in 0s. |
| 66 0F 72 /6 ib PSLLD xmm1, imm8 | MI | V/V | SSE2 | Shift doublewords in xmm1 left by imm8 while shifting in 0s. |
| 0F F3 /r1 PSLLQ mm, mm/m64 | RM | V/V | MMX | Shift quadword in mm left by mm/m64 while shifting in 0s. |
| 66 0F F3 /r PSLLQ xmm1, xmm2/m128 | RM | V/V | SSE2 | Shift quadwords in xmm1 left by xmm2/m128 while shifting in 0s. |
| 0F 73 /6 ib1 PSLLQ mm, imm8 | MI | V/V | MMX | Shift quadword in mm left by imm8 while shifting in 0s. |
| 66 0F 73 /6 ib PSLLQ xmm1, imm8 | MI | V/V | SSE2 | Shift quadwords in xmm1 left by imm8 while shifting in 0s. |
| VEX.NDS.128.66.0F.WIG F1 /r VPSLLW xmm1, xmm2, xmm3/m128 | RVM | V/V | AVX | Shift words in xmm2 left by amount specified in xmm3/m128 while shifting in 0s. |
| VEX.NDD.128.66.0F.WIG 71 /6 ib VPSLLW xmm1, xmm2, imm8 | VMI | V/V | AVX | Shift words in xmm2 left by imm8 while shifting in 0s. |
| VEX.NDS.128.66.0F.WIG F2 /r VPSLLD xmm1, xmm2, xmm3/m128 | RVM | V/V | AVX | Shift doublewords in xmm2 left by amount specified in xmm3/m128 while shifting in 0s. |
| VEX.NDD.128.66.0F.WIG 72 /6 ib VPSLLD xmm1, xmm2, imm8 | VMI | V/V | AVX | Shift doublewords in xmm2 left by imm8 while shifting in 0s. |
| VEX.NDS.128.66.0F.WIG F3 /r VPSLLQ xmm1, xmm2, xmm3/m128 | RVM | V/V | AVX | Shift quadwords in xmm2 left by amount specified in xmm3/m128 while shifting in 0s. |
| VEX.NDD.128.66.0F.WIG 73 /6 ib VPSLLQ xmm1, xmm2, imm8 | VMI | V/V | AVX | Shift quadwords in xmm2 left by imm8 while shifting in 0s. |
| VEX.NDS.256.66.0F.WIG F1 /r VPSLLW ymm1, ymm2, xmm3/m128 | RVM | V/V | AVX2 | Shift words in ymm2 left by amount specified in xmm3/m128 while shifting in 0s. |
| VEX.NDD.256.66.0F.WIG 71 /6 ib VPSLLW ymm1, ymm2, imm8 | VMI | V/V | AVX2 | Shift words in ymm2 left by imm8 while shifting in 0s. |
| VEX.NDS.256.66.0F.WIG F2 /r VPSLLD ymm1, ymm2, xmm3/m128 | RVM | V/V | AVX2 | Shift doublewords in ymm2 left by amount specified in xmm3/m128 while shifting in 0s. |
| VEX.NDD.256.66.0F.WIG 72 /6 ib VPSLLD ymm1, ymm2, imm8 | VMI | V/V | AVX2 | Shift doublewords in ymm2 left by imm8 while shifting in 0s. |
| VEX.NDS.256.66.0F.WIG F3 /r VPSLLQ ymm1, ymm2, xmm3/m128 | RVM | V/V | AVX2 | Shift quadwords in ymm2 left by amount specified in xmm3/m128 while shifting in 0s. |
| VEX.NDD.256.66.0F.WIG 73 /6 ib VPSLLQ ymm1, ymm2, imm8 | VMI | V/V | AVX2 | Shift quadwords in ymm2 left by imm8 while shifting in 0s. |
Notes: 1. See note in Section 2.4, “Instruction Exception Specification” in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 2A and Section 22.25.3, “Exception Conditions of Legacy SIMD Instructions Operating on MMX Registers” in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A.
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| RM | ModRM:reg (r, w) | ModRM:r/m (r) | NA | NA |
| MI | ModRM:r/m (r, w) | imm8 | NA | NA |
| RVM | ModRM:reg (w) | VEX.vvvv (r) | ModRM:r/m (r) | NA |
| VMI | VEX.vvvv (w) | ModRM:r/m (r) | imm8 | NA |
Shifts the bits in the individual data elements (words, doublewords, or quadword) in the destination operand (first operand) to the left by the number of bits specified in the count operand (second operand). As the bits in the data elements are shifted left, the empty low-order bits are cleared (set to 0). If the value specified by the count operand is greater than 15 (for words), 31 (for doublewords), or 63 (for a quadword), then the destination operand is set to all 0s. Figure 4-13 gives an example of shifting words in a 64-bit operand.
Pre-Shift
| X3 PSLLW, PSLLD, and PSLLQ Instruction Operation Using 64-bit Operand | X2 X2 << COUNT | X1 X1 << COUNT | X0 DEST Shift Left with Zero Extension X0 << COUNT DEST Figure 4-13. |
The (V)PSLLW instruction shifts each of the words in the destination operand to the left by the number of bits specified in the count operand; the (V)PSLLD instruction shifts each of the doublewords in the destination operand; and the (V)PSLLQ instruction shifts the quadword (or quadwords) in the destination operand.
In 64-bit mode, using a REX prefix in the form of REX.R permits this instruction to access additional registers (XMM8-XMM15).
Legacy SSE instructions: The destination operand is an MMX technology register; the count operand can be either an MMX technology register or an 64-bit memory location. 128-bit Legacy SSE version: The destination and first source operands are XMM registers. Bits (VLMAX-1:128) of the corresponding YMM destination register remain unchanged. The count operand can be either an XMM register or a 128-bit memory location or an 8-bit immediate. If the count operand is a memory address, 128 bits are loaded but the upper 64 bits are ignored.
VEX.128 encoded version: The destination and first source operands are XMM registers. Bits (VLMAX-1:128) of the destination YMM register are zeroed. The count operand can be either an XMM register or a 128-bit memory location or an 8-bit immediate. If the count operand is a memory address, 128 bits are loaded but the upper 64 bits are ignored. VEX.256 encoded version: The destination and first source operands are YMM registers. The count operand can be either an XMM register or a 128-bit memory location or an 8-bit immediate.
Note: For shifts with an immediate count (VEX.128.66.0F 71-73 /6), VEX.vvvv encodes the destination register, and VEX.B + ModRM.r/m encodes the source register. VEX.L must be 0, otherwise instructions will #UD.
PSLLW (with 64-bit operand) IF (COUNT > 15) THEN DEST[64:0] ←<PHONE_NUMBER>000000H; ELSE DEST[15:0] ← ZeroExtend(DEST[15:0] << COUNT); (* Repeat shift operation for 2nd and 3rd words *) DEST[63:48] ← ZeroExtend(DEST[63:48] << COUNT); FI; PSLLD (with 64-bit operand) IF (COUNT > 31) THEN DEST[64:0] ←<PHONE_NUMBER>000000H; ELSE DEST[31:0] ← ZeroExtend(DEST[31:0] << COUNT); DEST[63:32] ← ZeroExtend(DEST[63:32] << COUNT); FI; PSLLQ (with 64-bit operand) IF (COUNT > 63) THEN DEST[64:0] ←<PHONE_NUMBER>000000H; ELSE DEST ← ZeroExtend(DEST << COUNT); FI; PSLLW (with 128-bit operand) COUNT ← COUNT_SOURCE[63:0]; IF (COUNT > 15) THEN DEST[128:0] ←<PHONE_NUMBER>0000000000000000000000H; ELSE DEST[15:0] (* Repeat shift operation for 2nd through 7th words *) DEST[127:112] ← ZeroExtend(DEST[127:112] << COUNT); FI; PSLLD (with 128-bit operand) COUNT ← COUNT_SOURCE[63:0]; IF (COUNT > 31) THEN DEST[128:0] ←<PHONE_NUMBER>0000000000000000000000H; ELSE DEST[31:0] (* Repeat shift operation for 2nd and 3rd doublewords *) DEST[127:96] ← ZeroExtend(DEST[127:96] << COUNT); FI; PSLLQ (with 128-bit operand) COUNT ← COUNT_SOURCE[63:0]; IF (COUNT > 63) THEN DEST[128:0] ←<PHONE_NUMBER>0000000000000000000000H; ELSE DEST[63:0] DEST[127:64] ← ZeroExtend(DEST[127:64] << COUNT); FI; PSLLW (xmm, xmm, xmm/m128) DEST[127:0] ← LOGICAL_LEFT_SHIFT_WORDS(DEST, SRC) DEST[VLMAX-1:128] (Unmodified) PSLLW (xmm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_WORDS(DEST, imm8) DEST[VLMAX-1:128] (Unmodified) VPSLLD (xmm, xmm, xmm/m128) DEST[127:0] ← LOGICAL_LEFT_SHIFT_DWORDS(SRC1, SRC2) DEST[VLMAX-1:128] ← 0 VPSLLD (xmm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_DWORDS(SRC1, imm8) DEST[VLMAX-1:128] ← 0 PSLLD (xmm, xmm, xmm/m128) DEST[127:0] ← LOGICAL_LEFT_SHIFT_DWORDS(DEST, SRC) DEST[VLMAX-1:128] (Unmodified) PSLLD (xmm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_DWORDS(DEST, imm8) DEST[VLMAX-1:128] (Unmodified) VPSLLQ (xmm, xmm, xmm/m128) DEST[127:0] ← LOGICAL_LEFT_SHIFT_QWORDS(SRC1, SRC2) DEST[VLMAX-1:128] ← 0 VPSLLQ (xmm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_QWORDS(SRC1, imm8) DEST[VLMAX-1:128] ← 0 PSLLQ (xmm, xmm, xmm/m128) DEST[127:0] ← LOGICAL_LEFT_SHIFT_QWORDS(DEST, SRC) DEST[VLMAX-1:128] (Unmodified) PSLLQ (xmm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_QWORDS(DEST, imm8) DEST[VLMAX-1:128] (Unmodified) VPSLLW (xmm, xmm, xmm/m128) DEST[127:0] ← LOGICAL_LEFT_SHIFT_WORDS(SRC1, SRC2) DEST[VLMAX-1:128] ← 0 VPSLLW (xmm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_WORDS(SRC1, imm8) DEST[VLMAX-1:128] ← 0 PSLLW (xmm, xmm, xmm/m128) DEST[127:0] ← LOGICAL_LEFT_SHIFT_WORDS(DEST, SRC) DEST[VLMAX-1:128] (Unmodified) PSLLW (xmm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_WORDS(DEST, imm8) DEST[VLMAX-1:128] (Unmodified) VPSLLD (xmm, xmm, xmm/m128) DEST[127:0] ← LOGICAL_LEFT_SHIFT_DWORDS(SRC1, SRC2) DEST[VLMAX-1:128] ← 0 VPSLLD (xmm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_DWORDS(SRC1, imm8) DEST[VLMAX-1:128] ← 0 VPSLLW (ymm, ymm, xmm/m128) DEST[255:0] ← LOGICAL_LEFT_SHIFT_WORDS_256b(SRC1, SRC2) VPSLLW (ymm, imm8) DEST[255:0] ← LOGICAL_LEFT_SHIFT_WORD_256bS(SRC1, imm8) VPSLLD (ymm, ymm, xmm/m128) DEST[255:0] ← LOGICAL_LEFT_SHIFT_DWORDS_256b(SRC1, SRC2) VPSLLD (ymm, imm8) DEST[127:0] ← LOGICAL_LEFT_SHIFT_DWORDS_256b(SRC1, imm8) VPSLLQ (ymm, ymm, xmm/m128) DEST[255:0] ← LOGICAL_LEFT_SHIFT_QWORDS_256b(SRC1, SRC2) VPSLLQ (ymm, imm8) DEST[255:0] ← LOGICAL_LEFT_SHIFT_QWORDS_256b(SRC1, imm8)
| PSLLW: | __m64 _mm_slli_pi16 (__m64 m, int count) |
| PSLLW: | __m64 _mm_sll_pi16(__m64 m, __m64 count) |
| (V)PSLLW: | __m128i _mm_slli_pi16(__m64 m, int count) |
| (V)PSLLW: | __m128i _mm_slli_pi16(__m128i m, __m128i count) |
| VPSLLW: | __m256i _mm256_slli_epi16 (__m256i m, int count) |
| VPSLLW: | __m256i _mm256_sll_epi16 (__m256i m, __m128i count) |
| PSLLD: | count) |
| PSLLD: | __m64 _mm_sll_pi32(__m64 m, __m64 count) |
| (V)PSLLD: | count) |
| (V)PSLLD: | __m128i _mm_sll_epi32(__m128i m, __m128i count) |
| VPSLLD: | __m256i _mm256_slli_epi32 (__m256i m, int count) |
| VPSLLD: | __m256i _mm256_sll_epi32 (__m256i m, __m128i count) |
| PSLLQ: | count) |
| PSLLQ: | __m64 _mm_sll_si64(__m64 m, __m64 count) |
| (V)PSLLQ: | count) |
| (V)PSLLQ: | __m128i _mm_sll_epi64(__m128i m, __m128i count) |
| VPSLLQ: | __m256i _mm256_slli_epi64 (__m256i m, int count) |
| VPSLLQ: | __m256i _mm256_sll_epi64 (__m256i m, __m128i count) |
None.
None.
See Exceptions Type 4 and 7 for non-VEX-encoded instructions; additionally
| #UD | If VEX.L = 1. |


Tablet of Vision:
There's no sign of Hindemith, just the silvery bone powder scattered around the tablet. He must've gone to find the next Stone of Commune.
Commune with the Tablet of Vision.


All the time, things go wrong in the garden. It matters if you are trying to win a gold medal at the Chelsea Flower show. It matters if it interferes with your ability to enjoy your garden. Otherwise, it doesn’t matter. These are plants, not children, and you can always get or grow another one.
Sometimes plants die. It may be part of their natural cycle; it may be because you did something, or didn’t do something; or it may be just because it died. Our corkscrew willow tree died. We don’t know why. I planted that tree about 14 years ago and it must have been a couple of years old already. My clematis armandii may have carked it. It’s been in the garden since we move here, so more than 10 years, and I don’t know why. The armandii growing up the dead willow, by the way, is still fine. WTF?
I’ve been telling everyone I know that I don’t seem to be able to grow foxgloves. But the weed growing in front of the green house door, which I have been standing on once a month and meaning to remove, has just flowered. Bloody Digitalis Purpurea 'Sutton's Apricot'. My lobelia didn’t germinate. Turns out the seeds were in the pot with the thyme. I definitely did not put them there (on purpose).
This year, as an experiment, I have been wantonly chucking the rest of the flowers seeds from a packet that I didn’t use down the back of the flower bed. Maybe some of them will grow better without my help.
Here at the Dead Plants Society we aim to celebrate everything that goes wrong in our gardens, so we can learn and share our learning. Send us your pictures and tell us what you think went wrong. Like children, every garden is different and none come with a manual.
Check back here for more blog posts or sign up for our newsletter.


Debbie Pan
Project Portfolio
Debbie Pan is a 4th year Cog Sci HCI Major.
Projects
- Waiting in Line
Through observation and prototypes, I proposed a way to make waiting in lines more efficient.
- Flyers
Here you can see some of the flyers that I have designed using Photoshop.
- Websites
This is a collection of the websites that I have worked on.


[§245-24] Sales through financial institutions. The department may enter into agreements to permit the sale of stamps by designated financial institutions located within the State. A list of financial institutions designated to sell stamps shall be made available at the department. [L 2000, c 249, pt of §1, §20(2); am L 2002, c 94, §3]


| Completed At | Completition | Created At | Currentuseranswers | First Question | First Question | First Reminder | Is Complete | Matched Videos | Maternal Video Complete | Maternal Video Number | Maternal Video Position | Pediatric Video Complete | Pediatric Video Number | Pediatric Video Position | Question Count | Second Reminder | Survey | User | Video Source Version | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| {{instance.completed_at}} | {{instance.completition}} | {{instance.created_at}} | {{instance.currentuseranswers}} | {{instance.first_question}} | {{instance.first_question_id}} | {{instance.first_reminder}} | {{instance.is_complete}} | {{instance.matched_videos}} | {{instance.maternal_video_complete}} | {{instance.maternal_video_number}} | {{instance.maternal_video_position}} | {{instance.pediatric_video_complete}} | {{instance.pediatric_video_number}} | {{instance.pediatric_video_position}} | {{instance.question_count}} | {{instance.second_reminder}} | {{instance.survey_id}} | {{instance.user_id}} | {{instance.video_source_version}} |


Class hookexecutor
hookexecutor contains functions which can modify the game executable during the startup hook functions OnStart and OnLocaleLoad.
Functions defined here are temporary, and will likely move in the future once more of the internal game tables are exposed through the Lua interface.
Methods
| hookexecutor:ReplacePerk (perkTable, perkId) | ReplacePerk changes the data for a perk in the Fallout: Tactics perk table. |
| hookexecutor:AddLocaleString (key, value) | AddLocaleString adds a locale string mapping from within the Lua script. |
Types
| hookexecutor.PerkTable | PerkTable format used in ReplacePerk. |
Methods
- hookexecutor:ReplacePerk (perkTable, perkId)
-
ReplacePerk changes the data for a perk in the Fallout: Tactics perk table.
This allows for the requirements and permanent bonuses from perks to be changed, and for currently disabled perk slots to be used for custom behavior.
Parameters:
- perkTable A table formatted as PerkTable, with the new parameters to use for the perk.
- perkId The index into the perk table to modify. This can be determined by finding the location of the desired perk slot in the entity editor, and starts from 0.
Returns:
-
None.
- hookexecutor:AddLocaleString (key, value)
-
AddLocaleString adds a locale string mapping from within the Lua script.
This allows a script to provide a translation string without having to edit the BOS locale files.
Parameters:
- key The key (name) of the locale string to add.
- value The text (value) of the locale string to add.
Returns:
-
None.
Types
- hookexecutor.PerkTable
-
PerkTable format used in ReplacePerk.
All fields are optional. If defaulted, integer parameters default to 0, and strings default to empty string, "".
Fields:
- minlevel The minimum character level required to be eligible to select this perk.
- maxperktaken The number of times a player is allowed to select this perk for a character.
- bonusstat If a perk applies a permanent bonus to a stat, provide the name of the stat here. The name should match the name of the stat in the Entity editor. Leave as an empty string, "", if no bonus should be applied.
- bonusamt How much to add or remove from the bonus stat.
- requiredstat1 The first skill requirement, for perks which have minimum skill levels to be selected. If no skill requirement is needed for the perk, leave as an empty string, "".
- requiredamt1 The minimum skill level of the skill listed in requiredstat1.
- and_or_flag For perks with two skill requirements, this flag indicates whether only one of the two requirements must be met (value of 1), or if both requirements need to be met (value of 2).
- requiredstat2 The second skill requirement, if any, for perks which have minimum skill levels to be selected. If no second skill requirement is needed for the perk, leave as an empty string, "".
- requiredamt2 The minimum skill level of the skill listed in requiredstat2.
- requiredST The minimum Strength attribute in order to use this perk.
- requiredPE The minimum Perception attribute in order to use this perk.
- requiredEN The minimum Endurance attribute in order to use this perk.
- requiredCH The minimum Charisma attribute in order to use this perk.
- requiredIN The minimum Intelligence attribute in order to use this perk.
- requiredAG The minimum Agility attribute in order to use this perk.
- requiredLK The minimum Luck attribute in order to use this perk.
- prohibitedRace A comma-separated list of races which are prohibited from selecting the perk. If no prohibition, leave as an empty string, "".
- requiredRace A string indicating the only race allowed to select the perk. If no limitation, leave as an empty string, "".


--- layout: post title: Installing Anafora Text Annotation Tool (version 1.1) on Ubuntu Linux excerpt: How to install the Anafora Text Annotation Tool (version 1.1) on Ubuntu Linux categories: nlp ---
There have been some breaking changes in Anafora 1.1, so I'm updating this in the event you are installing version 1.1.
As part of a project I'm currently working on we've been looking for a centralized text annotation tool that we can use. After looking at several (eHost, Brat, Semantator, Knowtator all had something that didn't meet our requirements) we found Anafora. It's pretty raw in some respects, but we were able to get it working and it seems to meet most of our requirements for now.
Since we spent a couple days working through issues I thought I'd write up a guide for how to install the tool on an Ubuntu Linux box. That has been tested on an Ubuntu Linux 14.04 EC2 instance running on Amazon Web Services utilizing Anafora version 1.0.0. We're utilizing the Apache web server.
Anafora is a Python Django web app, so it requires Python, Django and the Apache WSGI module be installed to run. The wiki document from the project was very helpful in getting this going.
Create a user and install the Anafora software in the new user's home directory using the following
sequence of commands. You will need to be logged in as a user with sudo
permissions.
sudo useradd -m -d /home/anafora anafora sudo passwd anafora sudo groupadd anaforaadmin su - anafora wget https://github.com/weitechen/anafora/archive/v1.1.tar.gz cd /home/anafora tar xvfz anafora-1.1.tar.gz exit sudo chgrp -R www-data /home/anafora/anafora-1.0.0 sudo chmod -R g+rw /home/anafora/anafora-1.0.0
mod_wsgi
sudo apt-get install apache2 apache2-utils python-django libapache2-mod-wsgi
mod_auth_digest
and create auth_user
file with initial user anaforasudo ln -sf /etc/apache2/mods-available/auth_digest.load /etc/apache2/mods-enabled/auth-digest.load su - anafora htdigest -c /home/anafora/anafora-1.0.0/anafora.htdigest anafora anafora echo "annotatorGroup: anafora" > /home/anafora/anafora-1.0.0/anafora.authgroup
Insert the following block inside the <VirtualHost *:80></VirtualHost>
tags in the
/etc/apache2/sites-available/000-default.conf
file
<Location /anafora> AuthType Digest AuthName "anafora" AuthDigestProvider file AuthUserFile /home/anafora/anafora-1.1/anafora.htdigest Require valid-user </Location> <Location /anaforajs> AuthType Digest AuthName "anafora" AuthDigestProvider file AuthUserFile /home/anafora/anafora-1.1/anafora.htdigest Require valid-user </Location> <Location /anaforacss> AuthType Digest AuthName "anafora" AuthDigestProvider file AuthUserFile /home/anafora/anafora-1.1/anafora.htdigest Require valid-user </Location>
In the /etc/apache2/mods-available/alias.conf
file put the following inside the <IfModule alias_module></IfModule>
tags.
Alias /anafora/static /home/anafora/anafora-1.1/src/main/static Alias /anaforajs /home/anafora/anafora-1.1/src/main/static/js Alias /anaforacss /home/anafora/anafora-1.1/src/main/static/css
At the end of the /etc/apache2/apache2.conf
file put the following
WSGIScriptAlias /anafora /home/anafora/anafora-1.1/src/main/web/wsgi.py
Edit the /home/anafora/anafora-1.1/src/main/web/wsgi.py
file. Replace all of the content with one
of the following depending on your version of Python:
Python 2.6:
import os, sys if '/home/anafora/anafora-1.0.0/src/main' not in sys.path: sys.path.append('/home/anafora/anafora-1.0.0/src/main') os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' import django.core.handlers.wsgi application = django.core.handlers.wsgi.WSGIHandler()
Python 2.7:
import os, sys if '/home/anafora/anafora-1.0.0/src/main' not in sys.path: sys.path.append('/home/anafora/anafora-1.0.0/src/main') os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' from django.core.wsgi import get_wsgi_application application = get_wsgi_application()
First we have to get the settings.py
file in the right place
mv /home/anafora/anafora-1.1/src/main/web/settings.py /home/anafora/anafora-1.1/src/main
Now go into the settings.py
file and set the following variables to the given value
TIME_ZONE = 'America/Chicago' STATIC_ROOT = '/home/anafora/anafora-1.1/src/main/static' STATIC_URL = '/static/' ROOT_URL = '/anafora' SECRET_KEY = 'changeme' TEMPLATE_DIRS = ("/home/anafora/anafora-1.0.0/src/Templates",) ANAFORA_PROJECT_FILE_ROOT = "/home/anafora/anafora-project-root" GROUP_FILE = '/home/anafora/anafora-1.1/anafora.authgroup' ADMIN_GROUPNAME = 'anaforaadmin' ANAFORA_PROJECT_SETTING_FILENAME = ".setting.xml"
There is some problem with some of the references to static files in the pages, so we need to copy
the themes
directory
cp -av /home/anafora/anafora-1.1/src/main/static/css/themes /home/anafora/anafora-1.1/src/main/static
That's it! Your installation is ready to go. You will have to create a project in the
/home/anafora/anafora-project-root
directory. Follow the excellent Anafora User/Administrator
Manual to setup a project.
Once you have your project setup you can run apache start
or apache restart
as appropriate and
go to http://myanaphora/anafora to get started.
I'll do a quick write up of a few operational things (like creating new users, formatting an Anafora corpus, etc) in a follow up post soon.


Budget
Kinect
Home
Demos
Demo 1-1
Demo 1-2
Demo 1-3
About me
Contact
An AI driven platform for motion controlled games with just your webcam*.
*No accessories required
Demo
Train Actions
Play Games
Actions
+
No classes added yet. Click on the "+" Button to add new classes to train.
Start Train
Preview Actions Here
Toggle WebCam
Predict!
test
Train Class i


DiveKit
The development of DiveKit started to fulfill the need for diving calculations in the ongoing rewrite of my iOS application, Guam Dive Guide. My goal for DiveKit is to be a robust library of scuba diving calculations.
I will continue to develop this codebase to include more calculations and refactor code to provide the most accurate calculations with syntax that is both easy to use and easy to understand.
Initialization
import UIKit
import DiveKit
class ViewController: UIViewController {
var diveKit: DiveKit!
override func viewDidLoad() {
super.viewDidLoad()
// Initialize diveKit with default values of salt water and imperial units
diveKit = DiveKit.default
// Initialize diveKit with fresh water and metric units
diveKit = DiveKit.init(waterType: .freshWater, measurementUnit: .metric)
// Initialize diveKit with water type of fresh water and default value of imperial
diveKit = DiveKit.init(waterType: .freshWater)
// Initialize diveKit with metric measurements and default water type of salt water
diveKit = DiveKit.init(measurementUnit: .metric)
}
}
Usage
Calculate MOD of an Enriched Air Nitrox (EANx) Blend
import DiveKit
// Calclate MOD for EANx32 at PPO2 of 1.4 (Salt Water and Imperial Units)
let enrichedAirCalc = DKEnrichedAir.init(waterType: .saltWater, measurementUnit: .imperial)
do {
let gas = try Gas.enrichedAir(32)
let mod = try enrichedAirCalc.maximumOperatingDepth(fractionOxygen: 1.4, gas: gas)
print(mod) // 111 (feet)
} catch {
// Handle Error
print(error.localizedDescription)
}
Installation
CocoaPods
DiveKit is available through CocoaPods. To install it, simply add the following line to your Podfile:
pod 'DiveKit', '~> 0.11.0'
Swift Package Manager with Xcode 11
Add the following line to the dependencies in your Package.swift
file:
.package(url: "https://github.com/jaytrisw/DiveKit.git", from: "0.11.0"),
…and then include "DiveKit"
as a dependency for your executable target:
.product(name: "DiveKit", package: "DiveKit"),
Note: Because
DiveKit
is under active development, source-stability will only guaranteed after the release of version1.0
, breaking changes may occur until then.
Author
Joshua T. Wood<EMAIL_ADDRESS>| @joshuatw
License
DiveKit is available under the MIT license. See the LICENSE file for more info.


Academy of Art University, San Francisco, CA
Mac Support Specialist L2, 06.2013 - Present
More
Information Technology Department, Mac Systems Group. Member of a 7-person team servicing 750 Computers and thousands of users in classrooms, offices, and labs spread across the Academy’s distributed campus (15+ buildings).
- Support a user-base with diverse needs, high turnover and demand for fast response-time.
- Rapidly ingest, image and customize desktops and laptops for use in a variety of deployment scenarios leveraging Deploy Studio, the Casper Suite and Apple Servers.
- Leverage scalable Casper management system to manage configurations of company assets, tailoring settings and functionality to departments, classrooms, and individuals.
- Support Mac Servers providing point-of-sale, Open Directory, File Sharing, Profile Manager, networked diagnostics, NetInstall services.
- Train users to operate Mac OS X, Microsoft Office, fileservers, networked databases, VPN connections, and creative applications including the Adobe Creative Cloud 2014 Suite.
- Diagnose and repair Mac desktops and laptops in-house.
- Configure Peripherals including Printers, Copiers, Projectors, Graphics Tablets and Networked Peripherals.
Lead Music Technician, 02.2010 – 06.2013
More
School of Music Production and Sound Design for Visual Media. Headed the Lab Technician staff that grew the school from a single classroom with 25 students to 7 classrooms, 8 studios and labs, and over 300 students.
- Supervise Lab Technician staff and coordinate day-to-day operations of studios and classrooms.
- Responsible for department technical infrastructure including a file server, Profile Management, image design and deployment and coordination with Academy IT departments.
- Coordinate curriculum development by meeting with faculty course-writers, drafting syllabi, and processing administrative tasks.
- Provide technical assistance for students, teachers, and staff both in and out of classroom setting.
- Contribute to annual budget process by researching assets, procuring vendor quotes, and drafting equipment and facilities budget.
- Codify, document and created, as-needed, internal procedures and protocols defining asset management, staff scheduling, classroom support and troubleshooting workflow.
- As an Instructor in Digital Audio Workstations, create syllabus, lesson plans, assignment assets. Teach entry-level students the Pro Tools software toolset and workflow.
- Maintain fluency in Audio Editing Platforms including Pro Tools, Logic Pro and Ableton Live. Track updates and feature changes to major audio software and digital asset packages in use at the Academy for future budgets and deployment.


Assignment #{{ assignment.id }} {{ assignment.desc }} {{ assignment.detail }} Your Score: {{ grade.grade }}


|
SideCar
|
Go to the source code of this file.
Data Structures | |
| class | SideCar::IO::Channel |
| Representation of a named and typed data channel. More... | |
| class | SideCar::IO::ChannelVector |
| Collection of Channel objects. More... | |
Namespaces | |
| Logger | |
| Namespace for the Log logging device and support classes. | |
| SideCar | |
| Namespace for all entities specific to the 331 SideCar project. | |
| SideCar::IO | |
| Namespace for entities that handle SideCar data I/O. | |


Hash Computing Network
Distributed system in a browser.
Learn more
0
worker processes connected.
Hash
Answer
Hash
Submit


--- layout: page title: About header-img: "img/about-bg.png" ---
My name is Ahmed , I was a dentist . Originally I'm from Iraq , but raised in Ukraine .


The Security screen allows the system admin or compliance officer to add and maintain securities. Click the Security in the left navigation menu under Firm policy and a new Security Tab folder will be created in the right panel. There are 3 sub-Tab folders: Search Security, Search Result Security and Create New Security.
Search Criteria
| Field Name | Description |
|---|---|
| Symbol | The symbol of the security. |
| Security Name | The name of the security. |
| Cusip | The Cusip of the security. |
| Sedol | The Sedol of the security. |
| Isin | The Isin of the security. |
| Ric | The Ric of the security. |
| Exchange | The exchange where the security trades; eg. NYSE, NASDAQ etc. |
| Capital Type | Large, Medium, Small or unknown |
| CreatedByDate | Date and Time when this entry is created. |
| CreatedByUser | User who create this entry. |
| ModifiedByDate | Last modified date and time. |
| ModifiedByUser | Last modified user. |
| AND | Select AND radio box if you want those criteria added together. |
| OR | Select OR radio box if you want to get the result if either of the criteria are met. |
The top part is the table which shows the list of the security that meet the search criteria. The bottom part is the details of the selected entry.
Double Click the selected record in the table to modify this entry. A new Tab folder “Update/Delete Security” will be added, as shown below.
Select the “Create New Security” Tab to create a new entry.
| Field Name | Description |
|---|---|
| Symbol | The symbol of the security. |
| Security Name | The name of the security. |
| Cusip | The Cusip of the security. |
| Sedol | The Sedol of the security. |
| Isin | The Isin of the security. |
| Ric | The Ric of the security. |
| Security Type | Type of the secuirty; eg Equity, EFT, etc. |
| Exchange | The exchange where the security trades; eg. NYSE, NASDAQ, etc. |
| Issuer | The issuer. |
| Industry | The industry that this security belongs to. |
| Issue Country | The country of the issuer. |
| Capital Type | Large, Medium, Small, or unknown. |
| Security Class | The security class. |
| CreatedByDate | Date and Time when this list entry is created. It is a read only field. |
| CreatedByUser | User who create this this list entry. It is a read only field. |
| ModifiedByDate | Last modified date and time; It is a read only field. |
| ModifiedByUser | Last modified user; It is a read only field. |


{% extends "website/framework/base_success.html" %} {% block message %} Commit for issue {{ issue.name }} has been updated successfully. {% endblock %} {% block javascript %} location.reload(); {% endblock %}


Module Name: PanelGroupModule
Panels are used to organize components in the view.
All Angular Supported Events can be used on this component.


We would not be anywhere without our trusted investors. We thank each of them for where we are today.
PCPNCTC was formed in 2008 to hold the telecommunications services, media, and IT businesses of Penglai Communications and Post LTD, a multinational mass media and telecommunications company. PCPL provides broadband subscription television services, fixed telephone, and mobile telephone across 20 countries and 3 continents.
What makes us awesome sauce and not your typical venture firm? Backed by over three decades of experience and partnering successfully with entrepreneurs, Tenderloin Capital was founded to serve the needs of early-stage founders. It’s not just our experience that sets us apart; we relate to our entrepreneurs as people, not just as investments. Tenderloin Capital backs entrepreneurs who are building market-disrupting social-mobile-local-machine learned-artificially-intelligent cognitive experiences.
The Barn is an institution for primarily incubating chicken eggs as well as the next revolutions in precision agriculture technology. The Barn created the industry defining model for funding sustainable, humane, non-GMO, and fairtrade early stage businesses in animal husbandry. We look forward to working with you.
Wild Rydes has a talented Board of Directors which advises the company on strategy and enabling business success. Using its collective leadership intangibles, the Board works with Wild Rydes to ideate solutions and form audacious ideas to the company’s most pressing business challenges. The Board and the Company work together to make informed problem solving decisions using process optimization and agile decision making techniques.
Chairman of the Board, Grand Master of the Serverless Rite
EIR at Awesome Sauce Capital
Partner at The Barn
Managing Partner at Tenderloin Capital
Chairman of the Central Committee for Planning at PENGLAI COMMUNICATIONS AND POST NEW CENTURY TECHNOLOGY CORPORATION LTD


Large python crashes through spa ceiling in China
by Ben HooperNov. 19 (UPI) -- Workers at a spa in China were shocked when a 10-foot python fell through the ceiling -- and experts said it may have been there for up to 10 years.
An employee at the spa in Foshan, Guangdong Province, reported hearing a loud noise Nov. 12 and investigated to discover a large python had crashed into the business through the ceiling.
Police and a reptile handler were summoned to the scene to capture the python, which was measured at about 10 feet long.
The snake handler said it appeared the python had been living in the ceiling for some time, possibly up to 10 years. The expert said there are many restaurants in the area, which attracted rats for the python to eat.
(0) Leave a comment
upi.com/6960390
Latest Headlines
Odd News // 11 hours ago
Police help rescue coyote stuck in vehicle bumper
Nov. 19 (UPI) -- Authorities in Illinois came to the rescue of an unlucky coyote that was struck by a vehicle and ended up stuck in the bumper.
Odd News // 11 hours ago
Georgia deputy rescues deer stuck between fence bars
Nov. 19 (UPI) -- A Georgia sheriff's deputy's body camera was recording when he came to the rescue of a small deer that had become stuck between the bars of a fence.
Odd News // 13 hours ago
Family spends 153 days creating world's largest handwritten Bible
Nov. 19 (UPI) -- A United Arab Emirates family said they spent 153 days attempting a Guinness World Record for the world's largest handwritten Bible.
Odd News // 14 hours ago
Missing Oregon cat found 5 years later in New Mexico
Nov. 19 (UPI) -- An Oregon family's cat was found more than 1,200 miles away in New Mexico after disappearing five years earlier.
Odd News // 14 hours ago
Chinese crab found wandering German street might be kitchen escapee
Nov. 19 (UPI) -- Animal rescuers in Germany said a Chinese crab found wandering on a city street may have escaped from a restaurant kitchen.
Odd News // 15 hours ago
Bagel store manager drives 7 hours to return customer's lost keys
Nov. 19 (UPI) -- A New York state bagel store clerk is being hailed as a hero after taking a 7-hour round-trip drive to return a set of keys left behind by a customer.
Odd News // 15 hours ago
Scottish artist creates 4,520-square-foot drawing for Guinness record
Nov. 19 (UPI) -- A Scottish artist created a 4,520-square-foot drawing of black-and-white flowers in under 12 hours to break a Guinness World Record.
Odd News // 15 hours ago
Escaped monkey at British zoo was a stuffed toy
Nov. 19 (UPI) -- The Blackpool Zoo in England said reports of an escaped animal inside the facility were the result of a planned drill involving a stuffed toy monkey.
Odd News // 1 day ago
Dubai bar offering women free drinks based on their weight
Nov. 18 (UPI) -- A Dubai bar is drawing in female customers with an unusual promotion -- the more they weigh, the more free drinks they receive.
Odd News // 1 day ago
Raccoons fall through ceiling into New York CVS store
Nov. 18 (UPI) -- A pair of raccoons made a scene at a CVS store in New York state when they fell through the ceiling and went for a stroll through the store.


Across: 9. Modern form of football played by South American, as Inca is too rough (11) 10. Stouter heart exposed (3) 11,24. They took on 15 22 down in 7 19 4 9 opener... their five on court worry like ten by moving lots (3 4 7) 12. Almost heresy to disrupt gratitude expressed for famous Mother (7) 13. Notice real inclusion in 4 down perhaps (5) 14. On air, decides I've allowed comeback, not having iced (9) 16. In South American house, small and valuable root, a starchy foodstuff (7) 18. License to change lack of voice (7) 20. Latin Thor running in multi-discipline event (9) 22. Set is awful in places (5) 24. see 11 26. Charms of backward Southern romance (no opening for "coloreds") (7) 27. As mentioned in tongue twister about one such, sells becoming seashells (3) 28.  Teases one involved in failed stunt (6) 2. Reformed hood saws timbers for guitars perhaps (8) 3. Account briefly incurred financial penalty for attack (6) 4. Second request: somehow bet the lot in one game (10) 5. Animation time: present (4) 6. Strangely invert and reverse 15 break (8) 7. Provided for XX crowd with signs? (5'1) 8. Losing head, gripped arrows the wrong way (put legs around!) (8) 15,22. Lopez famously sang the finale with less reserve (and serious front) for the team that met 11 24 in 7 19 4 9 opener (3 7 6) 16. Kitty given salty concoction, which gets things happening (8) 17. Psyche, perhaps, or maybe testosterone? (8) 19. Worked on a Latin American perhaps? (8) 21. Silly, dumb, i.e. soaked (6) 22. see 15 23. Resist abuse, for your fellow female (6) 25. Inevitably, you mimic stock endings, and that's very offputting (4)


lattice-core
A crystal-lang framework build on kemal that takes a WebSocket-first approach to web development.
Background
Developing a website with data that updates in realtime -- instantly updating the page with changes as the occur on the server -- has always a challenging task: you are creating event models for two objects: one on the server (an object), and in the browser (a DOM node), and trying to maintain state between them.
That's challenging enough on its own. Adding to the complexity is the fact that http is inherently stateless, and now every update needs a whole setup and teardown process as the browser creates a new request, the server creates up a new response with authentication happening along the way. Add the subsequent teardown, and you're looking at a ton of work to update an element on a page.
The axiomatic way to do this has been use some javascript libarary that ulimately performs these updates over AJAX. The updates still happen in a stateless manner -- it's just that a lot of the complexity and overhead is invisibly buried and discarded by the javascript that performs the ajax. But make no mistake browser and the server still work a lot to update a little element on your page.
Enter WebSockets. They are new, part of the HTML5 spec. They will only work on modern browsers. And to be clear, there is no intention of making this framework work without them. Think of it as a platform-specific framework: Instead of Android or iOS, it's the "socket-ready browser" platform. And it just so happens that most Android and iOS browsers, as well as Chrome and FireFox on Windows, Mac, and Linux, all support WebSockets.
Require websockets? Why be so limiting?
I've been programming for a long time. I've tried to learn different frameworks, and I've played around many times with the "new language of the month." It's incredibly overwhelming to be faced with a new language that can do something a litle better, or that promises some big advantage of last month's language darling. The bottom line is there are a ton of frameworks out there already that do far more than I could ever hope to accomplish.
But something happened for me as I started experimenting with Crystal. I can't (and won't) make any promises that you'll feel the same way. Crystal's standard http library includes a nice implementation of WebSockets that's augmented by kemalcr. Up until a few months ago, I thought WebSockets was something you used if you wanted to include video chats on your web page. Never once had I written javascript to open a websocket. But kemal has a quick and dirty chat app that intrigued me with its simplicity. So I dug. I'll freely admit I became a little obsessed.
As I dug deeper, I found WebSockets to be incredibly powerful for developing web apps that have eliminate nearly all of the overhead and complexity that comes with ajax-first development. It has an awe-inspiring "the world is my oyster" power that I've experienced only a few times as a programmer (off the top of my head: Visual FoxPro for Windows, and Ruby come to mind).
In fact, your entire mindset changes - you stop thinking in terms of routing to pages that render a view, and start thinking in terms of events. Elements on your page are wired directly to the object on the server and vice-versa. A button click instantly changes server state, and those changes instantly go to everyone looking at that object.
Is This Thing Ready To Use For Anything?
Yes, it's ready for experimentation, but that's about it.
The API is not fleshed out yet. There's no databse integration, no user management.
But the goal is to have a real, useful, fast framework to develop truly immersive websites that are a joy to use and fun to code.
Show Me An Example
Ok, take a look at card_game. It is designed to illustrate the power of WebSockets in general, and this framework in particular. You can clone it, update the shards, and run it in a few lines.
Installation
Add this to your application's shard.yml
:
dependencies:
lattice-core:
github: jasonl99/lattice-core
Usage
require "lattice-core"
TODO Write usage instructions here
Development
TODO Write development instructions here
Contributing
- Fork it ( https://github.com/[your-github-name]/lattice-core/fork )
- Create your feature branch (git checkout -b my-new-feature)
- Commit your changes (git commit -am 'Add some feature')
- Push to the branch (git push origin my-new-feature)
- Create a new Pull Request
Contributors
- [your-github-name Jason Landry - creator, maintainer


--- layout: post title: B-Translator as a Software Engineering Project date: 2012-08-28 12:23:00 summary: Using the project B-Translator as an example for illustrating some of software development concepts and practices. tags: [Software Engineering, Programing, B-Translator] ---
The project B-Translator will be presented, trying to illustrate through it some software development/engineering concepts and practices (how they are actually applied in this project).
Software Engineering is an interdisciplinary branch between programing and project management, that tries to make efficient and effective the process of developing new software, by identifying and trying to use principles and practices that have proved to be successful on the past projects. It was born as a response to the failures in software projects for a long time.
Programing is an art, and so is the project management. As a result software engineering cannot be an exact discipline, although the word 'engineering' seems to imply a set of well defined steps and rules. However, some guiding principles can be useful when applied wisely to the current situation. Anyway, the most important factor still remains the experience: you are good at managing software projects if you have enough experience with doing it.
There are several models (or methods, or approaches, or paradigms) for managing a software project. The simples (and oldest) one is the waterfall model. The basic steps of the waterfall model are these:
These steps should be performed in the life cycle of every software development project. However the waterfall model is not very realistic, because in practice is very difficult to get everything right with the first attempt. For example while gathering the software requirement, most probably we can miss something; or maybe later there can be a request for updating the requirements.
A better approach is the Iterative and Incremental model. The basic steps are the same, however the development is performed in several cycles, with each of these steps performed in almost each cycle. During the cycles the software is improved from an initial prototype to a full featured product.
There are other methodologies and variations as well, like Agile Software Development, Extreme Programing, etc. However the bottom line remains that the best method to use depends on the concrete software that is to be developed, and any method that can be used should be adopted to match the current case.
Therefore, here I will describe what I have done on the project B-Translator, trying to identify the principles and practices of Software Engineering that are used, instead of trying to fit this project to one of the standard approaches.
Before a software starts to be built, the idea of such a software has to come somehow to mind. The idea for building such a software usually comes to mind because there is some problem to be solved, or some need to be fulfilled, which for some reasons, cannot be done (or cannot be done properly) by the existing software. Before anything else, a software engineer/developer should have a clear idea of the problem (or problems) that the software is trying to solve, and the overall aim (or goal) or the software.
First of all, B-Translator is a software that helps to get feedback about l10n (localization, translations of programs into other languages). It also helps to unify all the different translations and to ensure consistency among the translations. It is intended to be used for the translations of programs into Albanian, but it can be used for any other languages as well.
The motivation for developing such a software is that the traditional (current) l10n work-flow requires highly dedicated people, and does not allow (or at least does not facilitate) small contributions from random people that do not have such a high dedication, determination and enough free time.
Also, the process of reviewing and correcting translations is not easy and does not facilitate the feedback from the users of the translated programs. Although the translators are usually very good and professional, they can make mistakes too, and sometimes they may miss the best translation for some certain terms. Some feedback from the crowd of the users would be more than welcome, if there are tools to collect and facilitate it.
Another problem with translations is that sometimes they are not consistent. The same string has different translations in different programs, and sometimes even the same translator may have provided different translations for the same string in different cases. This happens mainly because each program/project has its own translations and there is no central repository for all the translations.
To summarize, the goals of this software are these:
To my knowledge, there are no such existing tools. People frequently ask how B-Translator is different from Pootle. Pootle, as far as I know, is just an online PO file editor; it doesn't have any features for collecting feedback from a crowd of people that are not translators.
The name of the software is not the most important thing, however it should be somehow related to the basic idea of the software and to its goals, and it should be different from any other software.
The codename B-Translator can be decoded like Bee Translator, since it aims at collecting very small translation contributions from a wide crowd of people and to dilute them into something useful.
It can also be decoded like Be Translator, as an invitation to anybody to give his small contribution for translating programs or making their translations better.
After having a clear idea of the overall aim and goals of the software, the software engineer should go into details about the features that the software should have and how it should work, so that it can properly achieve its goals. This is mainly a description of what the software should do and how it should do it, preferably in a simple language that even non-technical people (non-developers) can understand.
Maybe we cannot get everything 100% correct right from the beginning, however this approach is much better than starting to code right away, having just some vague ideas of what we are trying to build. Of course, we will take the chance later to correct and improve the feature requirements, as things become more clear.
Here is a description of the main desired features of B-Translator.
Everybody should be able to use the system for the purpose of getting translation suggestions for a certain string, even unauthenticated (anonymous/guest) users. Furthermore, it should be possible to use an API (web services), so that these suggestions can be retrieved and used even by external applications.
Submitting votes or new suggestions will be allowed only for the subscribed users (which have agreed to help and contribute). No contributions from anonymous/guests will be accepted.
Votes and suggestions will not be anonymous. For each vote or suggestion, the user who submitted it will be recorded and saved. This will allow the user to see all the strings that he has already voted for, and also to change any of the votes, if he later changed his mind. At the same time it will prevent multiple votes by the same user for the same translation.
The system should have a flexible configuration and customization page. This means that the user should be able to customize how much he would like to help and contribute. For example:
The contribution and performance of the users should be measured and evaluated using certain algorithms and/or heuristics. The users will be awarded points based on their performance. Probably some rewarding mechanisms can be integrated later for the top contributors.
Different kinds of reports and statistics related to users, projects, activity etc. should be supported and provided.
Project translators will continue to work with their preferred tools (like Pootle, Lokalize, etc.). They will also continue to use their preferred workflows (the way that they coordinate their translation work with each-other and with the project releases).
This system should help them to get feedback and possibly any new suggestions or translations from a big crowd of the contributors. The system should provide means and tools for easy integration with the workflow of the project translations.
For example, it should allow the translation maintainers to import their existing translation files (PO files), and to export translation files that contain the most voted translations, as well as new suggestions (for translated strings) or new translations (for untranslated strings). It should also allow them to get the latest changes (suggestions, translations, etc.) since the last time that they checked, or since a predefined moment in the past.
The latest changes should be exported in a format that is easy to review, modify and apply (diff or ediff).
In the previous sections we discussed defining the aim and scope of the software (conception) and describing the desired features and functionality in general terms. Both of these steps belong to the phase called defining requirements of the software. The next step (or phase) is to analyze in more details how the software is supposed to work, and it is called analysis (or functional analysis).
Functional analysis is usually performed by identifying the actors (users or other programs/components that are interacting with our software/system), by identifying use cases (all the different cases when the actors need to interact with our software/system), and describing each use case (the details of how each interaction is done).
In order to be clear and concise in describing such things, diagrams are often useful. The standard for drawing diagrams in software engineering domain is UML (Unified Modeling Language).
The actors and use-cases that can be identified for B-Translator are these:
These actors and use-cases are also presented in the following diagram (which is drawn using Umlet):
There are also the cases when the software is accessed through a third party application (for example a Facebook, LinkedIn, Google+, Android, iPhone, or desktop application), through a web-service API, however these use-cases can be reduced to either the guest or contributor cases.
I am not going to describe the details of each use-case because it would take lots of space. Anyway, most of them are almost obvious.
This is the form where the (authenticated) user is presented with an English string and several translation suggestions for it, and he votes the one that he thinks is the best, or provides another suggestion which he thinks is better.
The string to be translated is selected randomly, unless the user has selected 'sequential' on his settings. The selection of the string is also done so that it complies with the restrictions imposed by the user on his settings (for example only from a certain project).
The selection of the string should be also influenced by certain algorithms and heuristics, which should try to give more exposure to the strings that need more votes. For example if a string already got 10 votes and another one got just 2 votes, the second one should be more likely to be selected.
This interface should be able to integrate somehow with facebook, email, google+, etc.
On this form anybody (registered user or anonymous) can supply a string in English, and the system will return the translation suggestions related to it and the corresponding votes that each suggestion has.
If the English string does not have an exact match on the DB, a list of similar strings will be returned and the user will choose to check one of them.
This functionality of querying suggestions will be offered also by a web service so that it can be used by any external programs.
Here the user customizes his settings, as described in the functional requirements. Some of the things that he can customize are:
Usually everybody can export PO files, but only the users with certain permissions can import.
The admin should be able to customize the overall behavior of the module, to check activity, to get reports and statistics, to maintain the data (backup, restore, update) etc.
Design is a description in logical (abstract) terms of the parts and components that will make up the software, how they are composed, how they interact with each-other, etc. The UML diagrams can be useful again for describing concisely and clearly the entities, their relationships and interactions. It is the last layer of abstract description, before the implementation (coding) of the software starts. However frequently there is not a clear distinction line between analysis and design, and between design and implementation.
The design usually describes the database entities and relationships, the interfaces of the application, APIs (Application Programing Interfaces), classes and objects and their relationships, the most important processes and algorithms, etc. A good design should try to capture only the most important things, leaving out the obvious or unimportant things.
The DB tables and their fields:
Files, Templates, Locations and Projects are related to the import/export of the PO files. Snapshots and Diffs are used to export/extract the suggestions . Projects and Categories can be used to limit the scope of the search (and other operations).
A project contains the translations of a certain application (software). A project can have several template (POT) files. A template file can have several PO files (one for each different language). Each of these PO files has many PO entries, which are stored in the table Locations.
The table Locations stores only the comments, line references, flags, previous strings, etc. of each PO entry.
The msgid (and msgctxt) of the entry is stored on the table Strings. A string can be connected to several locations, since the same string can be used on different projects.
Each string can have several translations (or suggestions) in each language. Each translation can have many votes. Each vote is given by a certain user.
Implementation is the process of actually building the software. Before the implementation starts, several decisions have to be done, like:
For B-Translator it was obvious that it was going to be a web application, running on a LAMP platform (Linux+Apache+MySQL+PHP). Moreover, I decided to implement it as a Drupal module, in order to take advantage of the other existing Drupal modules. Drupal is a powerful framework for building web application, it has a powerful API, and there are lots of available modules that implement various features. This way I could focus on building only the functionality that is specific for my problem, and use the available modules for building a fully functional web application. Furthermore, I decided to use Drupal7, since that was the latest version of Drupal when I started, although the support of the additional modules was not so good at that time.
For programing and development I use the Emacs editor, which is quite powerful. Also this is the editor that I am most familiar with, and I always use it for my programing tasks.
As a version control system I use git. Actually the repository of the project is hosted on github.com (https://github.com/dashohoxha/B-Translator). Usage of a version control system is a must for every software development project, because:
The coding style and standards of B-Translator are those used by Drupal. For unit testing and functional testing the module 'simpletest' of Drupal is used. It works by defining several test cases, and then making sure that the module passes successfully all of them.
For communication/discussions among the developers there is an IRC chatroom named #btranslator on irc.freenode.net. There is also the group/forum/mailing-list B-Translator on Google, for notifications, discussions, etc. There is as well the channel @btranslator on Twitter, mostly for notifications.
Actually, right now I am the only developer of the project, however I do hope that in the future there will be other developers and contributors as well. If you are interested to help, please contact me (at<EMAIL_ADDRESS>or join the forum above.
Software engineering is not just about programing or development, but it is also about project management. Project management includes making a plan about how we are going to build the software, defining the things or tasks that need to be done, breaking down the tasks into smaller ones, assigning importance or priorities to the tasks, deciding which ones should be done earlier and which ones can be done later, defining milestones and grouping tasks to them (according to the time that they should be completed), assigning tasks to people, etc.
The majority of tasks usually are related to programing and implementation, however anything else can be a task (for example, collecting requirements, performing the functional analysis, etc.).
There are some steps or phases that are common for all software engineering projects, like:
How these phases are combined together depends on the software that is to be build. If you have enough experience with building such kind of software, and you have a clear idea from the beginning about what is to be built, then a waterfall approach might be OK.
However, in most cases things are not very clear right from the beginning, and they become more clear as you work on the project, do some implementation and testing, get feedback from the users, etc. This is especially true if the software that you are trying to build is kind of innovative, something that nobody else has tried to build before. In this case an 'iterative and incremental' model could be more suitable. In this model you build and release an initial product (or prototype), and with the experience collected during the process and any feedback from the users, start again from the beginning and refine the requirements, analysis etc. and build another release of the software. These cycles can be repeated as many times as necessary, and in each cycle incremental changes/improvements are made to the software.
B-Translator has followed an iterative and incremental life cycle. Although from the previous sections it may appear that things happened in a clean waterfall model, the truth is that the current requirements, functional analysis, design, etc. are the result of several iterations (cycles). For example:
The tool that I use for keeping the project organized is the mode-org of Emacs. It is a wonderful tool, simple and flexible, but has also advanced features if you need them. It can be used for keeping notes, for task management, and also for documentation writing (all the documents related to B-Translator, including this one, are composed with it). Its wiki-like syntax, combined with the power of Emacs, make it very practical.
Right now, for bug reporting, feature requests, etc. the issues section on GitHub can be used: https://github.com/dashohoxha/B-Translator/issues . Later maybe I can install trac, which is nice tool for software project management.
Documentation describes how to install the software, how it works, how it should be used, etc.
A full distro including Drupal core (with patches) and the btranslation installation profile can be built like this:
cd /var/www/ sudo git clone https://github.com/dashohoxha/B-Translator.git sudo B-Translator/install/all.sh
For more detailed information about installation see: https://github.com/dashohoxha/B-Translator/blob/master/docs/INSTALL.org
The source of the translation data used by the software are the POT/PO files of the projects. The PO template files (POT) contain the list of translatable strings of a project (in English), and the PO translation files contain the strings and the corresponding translations for a certain language. (More information and details about PO/POT formats and the translation process is provided by `info gettext`.)
These PO files are imported into the DB of the software. This import creates a dictionary of strings and their corresponding translations. The same string can be used in more than one projects, but in the dictionary it is stored only once. However, if the same string has different translations in several projects, all of the distinct translations will be stored into the DB.
These strings and the corresponding translations are presented for review to a large community of reviewers/users. The reviewers indicate which translation they think is the best by voting for it. They can also suggest any new translations (or suggest translations for strings that are yet un-translated). These new translations and the votes/likes of the reviewers are stored in the DB as well
The review process happens slowly and gradually during a long time. We can assume that each reviewer checks only one string each day, and that there is a very large number of reviewers that give feedback each day. The feedback can be collected through different channels, like web interface, social networks (Facebook, Google+, Twitter), email, mobile apps, etc.
Besides the dictionary of strings and translations, the import of PO files saves also the structure of these files and all the relevant data that are needed to export them again from the DB. However, during the export of the PO files, the most voted translations for each string are retrieved from the DB, instead of the original translations that were imported. This is how the input/feedback of the reviewers is transferred into the PO files. These exported PO files can then be uploaded/committed into the repositories of the corresponding projects.
According to the steps described above, the process/workflow for a project that has no translation yet, would be like this:
This process works well if there are no traditional translators to the project, and there is no other translation workflow happening concurrently (in parallel) with this one. Otherwise there would be a need to integrate these two workflows so that they don't override each-other.
In practice actually there is an existing translation workflow for almost all the projects. This translation is done either by using a Pootle system or by using PO editors. So, it is important that our workflow integrates with this existing workflow.
This integration is helped by exporting diffs instead of exporting PO files. These diffs are retrieved by the maintainers of the existing translation workflow (translators), and they contain the latest translation suggestions made by the reviewers through the feedback system. Such diffs can then be easily checked by the translators, and if they find them appropriate they can apply them to the PO files on the existing workflow.
Diffs are made between the current state of translations and the last snapshot of the translations. This ensures that diffs do not contain any suggestions that have been included already in the previous diffs, and so making more easy the work of the translators. The translator is usually interested only on the last diff, however the previous diffs are saved in the DB as well, in order to have a full history of the suggested translations over the time. Whenever a translator checks the latest diff, he should also make a snapshot, so that the translations that have been already suggested to him are not suggested again. Making a snapshot will also generate the diff with the previous snapshot and store this diff on the DB as well.
The process/workflow for the case when the feedback provided by the system is integrated in the mainstream translation workflow is like this:
This interface presents a string and its available translations to the user. The user will vote one of them as the best translation, or will provide a new translation that he thinks is better.
<sguid> is the hash of the string that is being translated. If not given, then a random string will be selected.
The original string is usually presented in English, but additional languages can be presented as well, if the user is not confident with English. (He can select these options on the user settings page as well.)
Displays a list of strings and the corresponding suggestions, which match some filter conditions. Filter conditions can be modified on the interface. Search can be done by the content of the strings and suggestions, and can be limited in scope by the project, by the author of suggestions, by the submission date, etc.
From the displayed list, it is also possible to view details (for string or suggestion), to submit votes, etc.
The user can set:
The translation files that are imported into the DB are retrieved
from the repository of the corresponding projects. This is done by
the scripts in the directory get/
, which checkout (or update)
these files from each projects' repository.
The way of getting these files is slightly different for different
projects. However all of them are placed in the directory
$data_root
, which is defined in config.sh
. Besides $data_root
,
config.sh
defines also the variable $languages
, which is a list
of the codes of the languages that are supported by the system.
Projects on the $data_root
are also grouped (categorized) by
origin. For example all the GNOME projects are placed on the same
directory, all the KDE projects on another directory, and so on.
Under the 'origin' directory, there is a subdirectory for each
language, and under it usually there is a subdirectory for each
project, containing all the translation files of the project, in
any structure that is suitable for the project.
Some projects have just a single translation (PO) file (for example those of GNOME or ubuntu), some others have several translation files (like those of KDE), and some others have many translation files (like those of LibreOffice and Mozilla).
In the case of Mozilla, translation files are not in gettext format,
so they are converted to PO files using moz2po
(from Translation
Toolkit).
Translation files are imported into the database by the scripts in
the directory import/
.
Importing is done in two steps: the first step is to import the template (POT) files of the project, and the second step is to import the translation (PO) files for each language. A POT file usually has a corresponding PO file for each language.
The template (POT) files contain the translatable strings of the project, with empty translations (this is why they are called templates). The translation (PO) files contain the same strings as the POT files, but with the corresponding translations for a certain language. In the import scripts, usually the French (fr) translation files are used as template files.
Template files are imported by pot_import.php
, which is called
like this:
$ ./pot_import.php Usage: ./pot_import.php origin project tplname file.pot origin -- The origin of the project (ubuntu, GNOME, KDE, LibreOffice, etc.) project -- The name of the project that is being imported. tplname -- The name of the PO template. file.pot -- The POT file of the project. Examples: ./pot_import.php KDE kdeedu kturtle test/kturtle.pot ./pot_import.php KDE kdeedu kturtle test/kturtle_fr.po
pot_import.php
creates a new template and a new project (if
needed). If the given origin+project already exists, then the
existing project is used. However, if the given template already
exists (for this project), then it is deleted first (along with the
locations and files related to it), and then recreated.
Along with the template, locations that are contained in this template are created as well. The string corresponding to each location is created only if it does not already exist. Otherwise the existing string is referenced instead (and the reference count of the string is incremented).
Translation files are imported by po_import.php
, which is called
like this:
$ ./po_import.php Usage: ./po_import.php origin project tplname lng file.po origin -- The origin of the project (ubuntu, GNOME, KDE, LibreOffice, etc.) project -- The name of the project. tplname -- The name of the PO template. lng -- The language of translation (de, fr, sq, en_GB, etc.). file.po -- The PO file to be imported. Example: ./po_import.php KDE kdeedu kturtle fr test/kturtle.po
po_import.php
imports a new PO (translation) file. It assumes
that the POT file of the project has already been imported,
otherwise it will quit without doing anything. If the file has
been already imported, then it is skipped.
For each file, all the information that is needed for exporting it is stored, like the file name and path, the headers of the file, the content of the file, etc.
Along with the file, it also inserts the translations for the corresponding strings, when such translations do not exist.
The most simple example of importing a project is pingus.sh
. The
other scripts import many projects from the same origin at once,
and have logic about getting the project name, finding the files,
etc. Also, they may have several (or many) template files for each
project, which makes the logic even more complex.
The basic import code of pingus.sh
is this:
### make last snapshots before re-import make-last-snapshot $origin $project fr make-last-snapshot $origin $project sq ### import the template potemplate=pingus ./pot_import.php $origin $project $potemplate $po_dir/pingus-fr.po ### import the PO files ./po_import.php $origin $project $potemplate fr $po_dir/pingus-fr.po ./po_import.php $origin $project $potemplate sq $po_dir/pingus-sq.po ## make initial snapshots after (re)import make-snapshot $origin $project fr $po_dir/pingus-fr.po make-snapshot $origin $project sq $po_dir/pingus-sq.po
The main import code is: importing first the template, and then
importing the translation file for each language. However, before
the import we make a last snapshot of the existing project, and
after the import we also make a snapshot. These two functions,
make-last-snapshot
and make-snapshot
are defined on
make-snapshot.sh
, which is included in pingus.sh
. They will be
discussed in more details in the section about the snapshots and
diffs.
The other scripts in the directory import are used to import
projects from a certain origin. For example kde.sh
imports (or
re-imports) all the KDE projects, office.sh
imports/re-imports
all the LibreOffice projects, and so on.
If a list of projects is passed on the command-line to these scripts, then only the specified projects will be imported (instead of all the projects.)
As we have seen, besides the strings and translations, the import of PO files saves also the structure of these files and all the relevant data that are needed to export them again from the DB.
Export scripts are in the directory export/
.
The script po_export.php
is used to export a single PO file. It
is used like this:
$ ./po_export.php Usage: ./po_export.php origin project tplname lng [file.po [export_mode]] origin -- the origin of the project (ubuntu, GNOME, KDE, etc.) project -- the name of the project to be exported tplname -- The name of the PO template. lng -- translation to be exported (de, fr, sq, en_GB, etc.) file.po -- output file (stdout if not given) export_mode -- 'most_voted' (default) or 'original' The export mode 'most_voted' (which is the default one) exports the most voted translations and suggestions. The export mode 'original' exports the translations of the original file that was imported (useful for making an initial snapshot of the project). If the export mode is not given as an argument, then the env variable PO_EXPORT_MODE will be tried. Examples: ./po_export.php KDE kdeedu kturtle fr > test/kturtle_fr.po ./po_export.php KDE kdeedu kturtle fr test/kturtle_fr.po original
The PO file to be exported is identified by {origin, project,
tplname, lng}
.
If the export mode is original, then the same translations that were imported are exported again. This is useful for making initial snapshots and diffs, which we will discuss later. However it should be noted that the exported file is not exactly the same as the imported file. One reason is that the formatting can be different, although the strings and translations are the same. Another reason is that during import some entries are skipped. like 'translator-credits' etc.
If the export mode is most_voted, and some of the translations
have been voted, then the most voted translation is exported
instead. This is how the input/feedback of the reviewers is
transferred into the PO files. But since the formatting of the
exported file is not exactly the same as the imported file, this
exported file cannot be used directly to be committed to the project
repository. Instead it is merged somehow with the existing PO file
of the project. This merge can be simply done by msgmerge
, or by
tools like lokalize
that facilitate merging of PO files. Another
option is to get the differences between the exported file and the
original file and to apply them to the current PO file.
To export all the PO files of a project, the script export.sh
is
used:
$ ./export.sh Usage: ./export.sh origin project lng output_dir
If project==all
, then all the projects of the given origin will be
exported. It the environments variable QUIET is defined, then it
will be less verbose (will not output much progress/debug info).
The exported files are saved under the directory output_dir
.
Their path under the output_dir
is the same as the path of the
imported files. This is useful for making diffs with the original
files of the project.
This script is usually called from the web (through the REST API) to export all the PO files of a project, in .tgz format.
$ ./export_tgz.sh Usage: ./export_tgz.sh origin project lng [output_dir]
If project==all, then all the projects of the given origin will be
exported. If the output_dir
is not given, then the /tmp
directory will be used.
It outputs the path of the created archive.
A snapshot is an export from the DB of the current PO files of a project-language. This export (which is a .tgz archive) is stored in the DB. A project has a snapshot for each language. Snapshots are useful for generating the diffs.
A diff is the difference between the snapshot and the previous snapshot. The diffs are stored in the DB as well. They are sequentially numbered and keep the history of changes.
There are two types of diffs that are generated and stored. One is
the unified diff (diff -u
) and the other the embedded diff
(generated by pology
http://websvn.kde.org/trunk/l10n-support/pology/)
Diffs ensure that translators get only the latest feedback (since the last snapshot), without having to review again the suggestions made previously. So, they make easier the work of the translators. However the previous diffs are saved in the DB as well, in order to have a full history of the suggested translations over the time.
The script db_diff.php
is used to add, list or get the diffs
from the DB. It is just an interface to the DB.
$ ./db_diff.php Usage: ./db_diff.php add origin project lng file.diff file.ediff [comment [user_id]] ./db_diff.php list origin project lng ./db_diff.php get origin project lng number (diff|ediff) [file] origin -- the origin of the project (ubuntu, GNOME, KDE, etc.) project -- the name of the project to be exported lng -- language of translation (de, fr, sq, en_GB, etc.) file.diff -- file in `diff -u` format file.ediff -- file in ediff (embedded diff) format comment -- optional comment about the ediff file that is being added user_id -- optional (drupal) uid of the user that is adding the ediff number -- the number of ediff that is being retrieved Examples: ./db_diff.php add LibreOffice sw fr LibreOffice-sw-fr.diff LibreOffice-sw-fr.ediff ./db_diff.php list LibreOffice sw fr ./db_diff.php get LibreOffice sw fr 5 diff > LibO/fr/sw_5.diff ./db_diff.php get LibreOffice sw fr 5 ediff > LibO/fr/sw_5.ediff
This script is usually called from other scripts (not directly from the command line).
The script db_snapshot.php
is used as a DB interface for the snapshots.
$ ./db_snapshot.php Usage: ./db_snapshot.php (init|update|get) origin project lng file.tgz origin -- the origin of the project (ubuntu, GNOME, KDE, etc.) project -- the name of the project to be exported lng -- language of translation (de, fr, sq, en_GB, etc.) file.tgz -- tgz archive of the snapshot of the project The operation 'init' is used to insert into the DB the snapshot for the first time. The operation 'update' to update it, and 'get' to retrive it from the DB. Examples: ./db_snapshot.php init LibreOffice sw fr LibreOffice-sw-fr.tgz ./db_snapshot.php update LibreOffice sw fr LibreOffice-sw-fr.tgz ./db_snapshot.php get LibreOffice sw fr LibreOffice-sw-fr.tgz
The operation init
will first delete a snapshot, if it already
exists in the DB. This script is usually called from other scripts
(not directly from the command line).
This script compares the current translation files of an {origin,
project, lng}
with the last snapshot.
$ ./make_diff.sh Usage: ./make_diff.sh origin project lng Export the current state of translation files of a project-language and make a diff with the last snapshot.
It does these:
{origin, project, lng}
(by calling export.sh
)
{origin, project, lng}
diff -rubB
and with pology
When it is done, it leaves in its own directory the files
origin-project-lng.tgz
(which contains the exported files),
origin-project-lng.diff
and origin-project-lng.ediff
.
It outputs some debug information as well, but if the QUIET
environment variable is define, this output is suppressed.
$ ./make_snapshot.sh Usage: ./make_snapshot.sh origin project lng [diff_comment] Make the diff with the last snapshot and store it in DB. Save in DB the current snapshot.
This script just calls make_diff.sh
and stores in DB the files
origin-project-lng.diff
and origin-project-lng.ediff
, if they
are not empty. It also updates the snapshot of {origin, project,
lng}
with the file origin-project-lng.tgz
. Finally it cleans all
the three files generated by make_diff.sh
.
make_diff.sh
is separated from make_snapshot.sh
because it
needs to be used also by the REST API
translations/project/diff/origin/project/lng/-
to generate the
changes (diffs) since the last snapshot.
When a project is imported, an initial snapshot is created and stored in the DB as well. This initial snapshot contains the original files that were used for the import. It is done like this:
### store the tgz file into the DB as a snapshot ../export/db_snapshot.php init $origin $project $lng $snapshot_tgz
Immediately after the initial snapshot, another snapshot is done, by exporting files in the original mode.
### make a second snapshot, which will generate a diff ### with the initial snapshot, and will save it into the DB export PO_EXPORT_MODE='original' ## set the export mode for po_export.php diff_comment="Import diff. Contains formating changes, any skipped entries, etc." ../export/make_snapshot.sh $origin $project $lng "$diff_comment"
This snapshot will also generate a diff, which contains the differences that come as a result of formatting changes between the original format and the exported format. It also contains the entries that are skipped during the import.
Whenever a translator checks the latest diff, he should also make a snapshot, which will also generate the diff with the previous snapshot (and store it on the DB). As a result, the translations that have been already suggested to him will not be suggested again.
When the time comes to re-import a project, a last snapshot is made automatically before the import, in order to store as a diff any latest (unchecked) suggestions.
### make a last snapshot before the import (useful in the case of re-import) export PO_EXPORT_MODE='most_voted' ## set the export mode for po_export.php diff_comment="Contains the latest suggestions before import." ../export/make_snapshot.sh $origin $project $lng "$diff_comment"
Then an initial snapshot is made again with the original files,
using db_snapshot.php init ...
(which will not generate any
diff). After it, a snapshot using the original
mode of export is
made again, which will generate again any formatting changes and
save them as a diff.
However, in the case of re-import, another snapshot is needed,
using the most_voted
mode of export, which will generate a diff
that contains all the feedback and suggestions made before the
re-import.
### make another snapshot, which will contain all the previous suggestions ### (before the import), in a single diff export PO_EXPORT_MODE='most_voted' ## set the export mode for po_export.php diff_comment="Initial diff after import. Contains all the previous suggestions (before the last import)." ../export/make_snapshot.sh $origin $project $lng "$diff_comment"
Usually this diff contains the suggestions that the translator has already rejected, and making this snapshot ensures that they are not suggested again to him.
This logic of the initial snapshots and diffs is applied by calling
the functions make-last-snapshot()
and make-snapshot()
, which
are defined on the file import/make-snapshot.sh
. They are
included and called automatically by the import scripts, before and
after each import.
This script can be used by the translators to get the diffs of the projects from the server, through the REST API.
$ ./wget-diffs.sh Usage: ./wget-diffs.sh origin project lng [nr] Get the diffs of a project using wget and the REST API. If 'nr' is missing, then the list of diffs will be retrieved instead. If 'nr' is '-', then the latest diffs (since the last snapshot) will be computed and returned (it will take longer to execute, since the diffs are calculated on the fly). Examples: ./wget-diffs.sh KDE kdelibs sq ./wget-diffs.sh KDE kdelibs sq 1 ./wget-diffs.sh KDE kdelibs sq 2 ./wget-diffs.sh KDE kdelibs sq -
The files *.db.php
contain DB classes that encapsulate the
interaction of import/export scripts with the database of the
application. All of them extend db/class.DB.php
, which creates a
connection to the database. The parameters of the DB connection are
included from db/settings.php
, which is generated automatically
during installation.
gettext/POParser.php
is a parser used to extract the data from a
PO/POT file, in order to import them into the DB . It is taken from:
http://code.google.com/p/php-po-parser/issues/detail?id=2 It makes
no validity checks, but this is OK, since the PO files that are
imported are supposed to be valid. (Anyway, if needed, PO files can
be checked with msgfmt before being imported).
gettext/POWriter.php
is used during export to generate a PO file
from the projects, locations, strings and translations that are
stored in the DB.


R
Class for accessing R via libR.
Static Member Summary
| Static Public Members | ||
| public static get |
Acquire global environment in R. |
|
| public static get |
Initialized libR object for accessing R. |
Static Method Summary
| Static Public Methods | ||
| public static |
Check whether R class is globally initialized or not. |
|
| public static |
Python like range function. |
Constructor Summary
| Public Constructor | ||
| public |
Constructor function for class R |
Member Summary
| Public Members | ||
| public |
[e]: * |
Method Summary
| Public Methods | ||
| public |
Execute R code. |
|
| public |
evalWithTry(code: string, silent: boolean): * Execute R code with R try. |
|
| public |
eval_direct(code: string): SEXPWrap Execute R code without error handling. |
|
| public |
Execute R code. |
|
| public |
Acquire bridging function to access R function. |
|
| public |
Acquire bridging function to access R function. |
|
| public |
Acquire value of R variable |
|
| public |
getVarNames(varname: string): string Acquire names attribute of R variable |
|
| public |
overrideBusy(onBusy: function) Set callback on R's computation. |
|
| public |
overrideReadConsole(onReadConsole: function) Use your own console input/output instead of R's default one. |
|
| public |
overrideShowMessage(onMessage: function) Use your own console input/output instead of R's default one. |
|
| public |
overrideWriteConsole(onWriteConsole: function) Use your own console input/output instead of R's default one. |
|
| public |
release() Finish using R. |
|
| public |
Set value to R variable |
|
| public |
setVarNames(varname: string, value: object) Set names attribute to R variable |
| Private Methods | ||
| private |
__RFuncBridge(func: function): * Bridging function for R function. |
|
| private |
__RFuncBridge_raw(_func: function): SEXPWrap Bridging function for R function. |
|
| private |
__eval_langsxp(langsxp: *, silent: boolean): * Execute R code with LANGSXP |
|
| private |
__func_sexp(name: string): SEXPWrap Find functions in R environment. |
|
| private |
Load some R functions. |
Static Public Members
Static Public Methods
Public Constructors
Public Members
public [e]: * source
Public Methods
public eval(code: string, silent: boolean): * source
Execute R code.
Return:
| * | JavaScript compatible object of returned value. |
Throw:
When execution fails. |
Example:
let value = R.eval("sum(c(1, 2, 3))") // value will be 6
public evalWithTry(code: string, silent: boolean): * source
Execute R code with R try. This is more safe than R#eval.
Return:
| * | Returned value. Returns undefined on error. |
public eval_direct(code: string): SEXPWrap source
Execute R code without error handling. App crashes when execution/parse failure. Please use this function with care.
Params:
| Name | Type | Attribute | Description |
| code | string | R code |
See:
public eval_raw(code: string, silent: boolean): SEXPWrap source
Execute R code.
Throw:
When execution fails. |
See:
- eval, R_ParseEvalString
public func(name: string): function source
Acquire bridging function to access R function. Functions receive JavaScript value, and returns JavaScript compatible objects.
Params:
| Name | Type | Attribute | Description |
| name | string | name of R function |
Example:
const sum = R.func("sum")
console.log(sum([1, 2, 3])) // prints 6
public func_raw(name: string): function source
Acquire bridging function to access R function. This function doesn't convert to/from SEXP. Receives SEXPWrap, and returns SEXPWrap. Please use carefully.
Params:
| Name | Type | Attribute | Description |
| name | string | name of R function |
See:
public getVar(varname: string): * source
Acquire value of R variable
Params:
| Name | Type | Attribute | Description |
| varname | string | Name of variable |
Return:
| * | Value in the R variable. |
public getVarNames(varname: string): string source
Acquire names attribute of R variable
Params:
| Name | Type | Attribute | Description |
| varname | string | Name of variable |
Return:
| string | Associated name attribute for the specified R variable. If no name, undefined will be returned. |
public overrideBusy(onBusy: function) source
Set callback on R's computation.
Params:
| Name | Type | Attribute | Description |
| onBusy | function | Function called on busy/job finish |
public overrideReadConsole(onReadConsole: function) source
Use your own console input/output instead of R's default one.
Params:
| Name | Type | Attribute | Description |
| onReadConsole | function | Function on console read |
public overrideShowMessage(onMessage: function) source
Use your own console input/output instead of R's default one.
Params:
| Name | Type | Attribute | Description |
| onMessage | function | Function on showing message |
public overrideWriteConsole(onWriteConsole: function) source
Use your own console input/output instead of R's default one.
Params:
| Name | Type | Attribute | Description |
| onWriteConsole | function | Function on console write |
Private Methods
private __RFuncBridge(func: function): * source
Bridging function for R function. Please do not call this function manually.
Params:
| Name | Type | Attribute | Description |
| func | function | SEXPWrap object of R function |
Return:
| * | JavaScript compatible returned value |
private __RFuncBridge_raw(_func: function): SEXPWrap source
Bridging function for R function. This bridging function doesn't handle SEXP. Please do not call this function manually.
Params:
| Name | Type | Attribute | Description |
| _func | function | SEXPWrap object of R function |
private __eval_langsxp(langsxp: *, silent: boolean): * source
Execute R code with LANGSXP
Params:
| Name | Type | Attribute | Description |
| langsxp | * | ||
| silent | boolean |
|
Return:
| * |


Freeside Technology Spaces, a 501(c)3 non-profit organization, strives to provide a space that inspires collaboration, creativity, teaching, and open projects for the Atlanta community.
Freeside is a collaborative space to grow, learn, teach, and create.
We offer classes in both traditional and novel fabrication techniques, you can even teach if you have the chops!
You can finally get your projects off of the dining room table.
675 Metropolitan Pkwy, Atlanta GA
http://meetup.com/freeside-atlanta
http://wiki.freesideatlanta.org
hello@freesideatlanta.org


The Sixth Sense (1999) Reviewed by Eugene Novikov http://www.ultimate-movie.com Member: Online Film Critics Society
*** out of four
"I see dead people. Walking around like regular people."
Starring Bruce Willis, Haley Joel Osment, Toni Collette, Olivia Williams. Rated PG-13.
*Please note: I have found it exceedingly difficult to discuss this movie without going into plot details. While I have tried to be as vague as possible, if you plan to see this movie and want to stay completely clueless about its twists and turns, hold off reading what follows until you are a Sixth Sense virgin no more.
The ghost story is alive and well in Hollywood, it seems, with at least three high-profile films that fit the bill being released this year. In the infamous month of August, a notorious dumping ground for studios who want wash their hands of films with little potential, Spyglass Entertainment brings us The Sixth Sense, a somber, deceptively tricky supernatural thriller that, unlike guilty pleasure films like The Mummy, is a keeper for all the right reasons.
Bruce Willis is given his first role in a looooong time that requires him to actually -- gasp! -- act. He plays Malcolm Crowe, a child psychologist who becomes insecure after his failure with a patient and a subsequent incident with him.  But there is more to him than meets the eye.  Their invariably gory fatal wounds are still intact. They want the boy to perform tasks that they themselves cannot.
Malcolm, the M.D. that he is, at first does not believe Cole and The Sixth Sense risks turning into another "Nobody believes me" story. Fortunately it makes a hairpin turn off that perilous path as the good doctor finds proof (dubious as it may be) of the phenomenon. Cole pleads with Malcolm to "please make them go away." How he is to accomplish that is a far more difficult matter.
The Sixth Sense is a triumph of calm, confident storytelling rather than the feverishly kinetic plotting and filming we've come to expect from Bruce Willis films. This movie is not slow, it's steady and constant. It's a hypnotically engaging horror mystery; scary, intriguing and mesmerizing. Here's a movie that is far more frightening yet far less lauded than The Blair Witch Project, a film that simply isn't nearly as horrifying as so many claim. The Sixth Sense on the other hand has more merit as a horror movie than many have given it.
I've despised Bruce Willis for his choice of projects (as opposed to lack of talent) but here he proves that he can handle a serious role. His is a nice, quiet, skilled performance, with barely a hint of his infamous trademark smirk. But, at the risk of repeating other critics, the real star of The Sixth Sense is little Haley Joel Osment, a frighteningly talented young actor who is more then up to his unconventionally challenging role. He not only holds his own in talky, complex sequences with Willis, but he outshines his older, more experienced co-star every chance he gets. The movie itself isn't an award contender but Osment's performance should not -- and I expect that it will not -- be forgotten come Oscar time.
My biggest problem with The Sixth Sense is the film's ending. It is a lot of things: shocking, creative, "cool" and a terrific way for director/screenwriter M. Night Shyamalan to show off his plotting prowess. What it's not, sadly, is a satisfactory denoument to all that preceded it. It represents a gear shift rather than a resolution. A more traditional conclusion may not have been as blindsiding or as showy but it would have worked better with respect to the storyline. Still, the ending that we are given will inspire many to go for a second viewing, or at least to rewind scenes in their had to search for the suddenly obvious clues to what was destined to happen.
The Sixth Sense is a psychological thriller for the patient, discerning viewer. It makes no attempt to appeal to those with short attention spans nor does it aim for the lowest common denominator. It's an intelligent, complex film (although mostly in retrospect) that flaunts strong performances, impressive direction and a denoument that will make your jaw drop, even if it does not resolve as much of the conflict as it should have. Here is a summer movie that isn't a "summer movie" at all. ©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