Vim documentation: motion
main help file*motion.txt* For Vim version 7.2. Last change: 2008 Aug 03 VIM REFERENCE MANUAL by Bram Moolenaar Cursor motions *cursor-motions* *navigation* These commands move the cursor position. If the new position is off of the screen, the screen is scrolled to show the cursor (see also 'scrolljump' and 'scrolloff' options). 1. Motions and operators |operator| 2. Left-right motions |left-right-motions| 3. Up-down motions |up-down-motions| 4. Word motions |word-motions| 5. Text object motions |object-motions| 6. Text object selection |object-select| 7. Marks |mark-motions| 8. Jumps |jump-motions| 9. Various motions |various-motions| General remarks: If you want to know where you are in the file use the "CTRL-G" command |CTRL-G| or the "g CTRL-G" command |g_CTRL-G|. If you set the 'ruler' option, the cursor position is continuously shown in the status line (which slows down Vim a little). Experienced users prefer the hjkl keys because they are always right under their fingers. Beginners often prefer the arrow keys, because they do not know what the hjkl keys do. The mnemonic value of hjkl is clear from looking at the keyboard. Think of j as an arrow pointing downwards. The 'virtualedit' option can be set to make it possible to move the cursor to positions where there is no character or halfway a character.
1. Motions and operators *operator* The motion commands can be used after an operator command, to have the command operate on the text that was moved over. That is the text between the cursor position before and after the motion. Operators are generally used to delete or change text. The following operators are available: |c| c change |d| d delete |y| y yank into register (does not change the text) |~| ~ swap case (only if 'tildeop' is set) |g~| g~ swap case |gu| gu make lowercase |gU| gU make uppercase |!| ! filter through an external program |=| = filter through 'equalprg' or C-indenting if empty |gq| gq text formatting |g?| g? ROT13 encoding |>| > shift right |<| < shift left |zf| zf define a fold |g@| g@ call function set with the 'operatorfunc' option If the motion includes a count and the operator also had a count before it, the two counts are multiplied. For example: "2d3w" deletes six words. After applying the operator the cursor is mostly left at the start of the text that was operated upon. For example, "yfe" doesn't move the cursor, but "yFe" moves the cursor leftwards to the "e" where the yank started. *linewise* *characterwise* The operator either affects whole lines, or the characters between the start and end position. Generally, motions that move between lines affect lines (are linewise), and motions that move within a line affect characters (are characterwise). However, there are some exceptions. *exclusive* *inclusive* A character motion is either inclusive or exclusive. When inclusive, the start and end position of the motion are included in the operation. When exclusive, the last character towards the end of the buffer is not included. Linewise motions always include the start and end position. Which motions are linewise, inclusive or exclusive is mentioned with the command. There are however, two general exceptions: 1. If the motion is exclusive and the end of the motion is in column 1, the end of the motion is moved to the end of the previous line and the motion becomes inclusive. Example: "}" moves to the first line after a paragraph, but "d}" will not include that line. *exclusive-linewise* 2. If the motion is exclusive, the end of the motion is in column 1 and the start of the motion was at or before the first non-blank in the line, the motion becomes linewise. Example: If a paragraph begins with some blanks and you do "d}" while standing on the first non-blank, all the lines of the paragraph are deleted, including the blanks. If you do a put now, the deleted lines will be inserted below the cursor position. Note that when the operator is pending (the operator command is typed, but the motion isn't yet), a special set of mappings can be used. See |:omap|. Instead of first giving the operator and then a motion you can use Visual mode: mark the start of the text with "v", move the cursor to the end of the text that is to be affected and then hit the operator. The text between the start and the cursor position is highlighted, so you can see what text will be operated upon. This allows much more freedom, but requires more key strokes and has limited redo functionality. See the chapter on Visual mode |Visual-mode|. You can use a ":" command for a motion. For example "d:call FindEnd()". But this can't be redone with "." if the command is more than one line. This can be repeated: d:call search("f")<CR> This cannot be repeated: d:if 1<CR> call search("f")<CR> endif<CR> FORCING A MOTION TO BE LINEWISE, CHARACTERWISE OR BLOCKWISE When a motion is not of the type you would like to use, you can force another type by using "v", "V" or CTRL-V just after the operator. Example: dj deletes two lines dvj deletes from the cursor position until the character below the cursor d<C-V>j deletes the character under the cursor and the character below the cursor. Be careful with forcing a linewise movement to be used characterwise or blockwise, the column may not always be defined. *o_v* v When used after an operator, before the motion command: Force the operator to work characterwise, also when the motion is linewise. If the motion was linewise, it will become |exclusive|. If the motion already was characterwise, toggle inclusive/exclusive. This can be used to make an exclusive motion inclusive and an inclusive motion exclusive. *o_V* V When used after an operator, before the motion command: Force the operator to work linewise, also when the motion is characterwise. *o_CTRL-V* CTRL-V When used after an operator, before the motion command: Force the operator to work blockwise. This works like Visual block mode selection, with the corners defined by the cursor position before and after the motion.
2. Left-right motions *left-right-motions* h or *h* <Left> or *<Left>* CTRL-H or *CTRL-H* *<BS>* <BS> [count] characters to the left. |exclusive| motion. Note: If you prefer <BS> to delete a character, use the mapping: :map CTRL-V<BS> X (to enter "CTRL-V<BS>" type the CTRL-V key, followed by the <BS> key) See |:fixdel| if the <BS> key does not do what you want. l or *l* <Right> or *<Right>* *<Space>* <Space> [count] characters to the right. |exclusive| motion. *0* 0 To the first character of the line. |exclusive| motion. *<Home>* *<kHome>* <Home> To the first character of the line. |exclusive| motion. When moving up or down next, stay in same TEXT column (if possible). Most other commands stay in the same SCREEN column. <Home> works like "1|", which differs from "0" when the line starts with a <Tab>. {not in Vi} *^* ^ To the first non-blank character of the line. |exclusive| motion. *$* *<End>* *<kEnd>* $ or <End> To the end of the line. When a count is given also go [count - 1] lines downward |inclusive|. In Visual mode the cursor goes to just after the last character in the line. When 'virtualedit' is active, "$" may move the cursor back from past the end of the line to the last character in the line. *g_* g_ To the last non-blank character of the line and [count - 1] lines downward |inclusive|. {not in Vi} *g0* *g<Home>* g0 or g<Home> When lines wrap ('wrap' on): To the first character of the screen line. |exclusive| motion. Differs from "0" when a line is wider than the screen. When lines don't wrap ('wrap' off): To the leftmost character of the current line that is on the screen. Differs from "0" when the first character of the line is not on the screen. {not in Vi} *g^* g^ When lines wrap ('wrap' on): To the first non-blank character of the screen line. |exclusive| motion. Differs from "^" when a line is wider than the screen. When lines don't wrap ('wrap' off): To the leftmost non-blank character of the current line that is on the screen. Differs from "^" when the first non-blank character of the line is not on the screen. {not in Vi} *gm* gm Like "g0", but half a screenwidth to the right (or as much as possible). {not in Vi} *g$* *g<End>* g$ or g<End> When lines wrap ('wrap' on): To the last character of the screen line and [count - 1] screen lines downward |inclusive|. Differs from "$" when a line is wider than the screen. When lines don't wrap ('wrap' off): To the rightmost character of the current line that is visible on the screen. Differs from "$" when the last character of the line is not on the screen or when a count is used. Additionally, vertical movements keep the column, instead of going to the end of the line. {not in Vi} *bar* | To screen column [count] in the current line. |exclusive| motion. *f* f{char} To [count]'th occurrence of {char} to the right. The cursor is placed on {char} |inclusive|. {char} can be entered as a digraph |digraph-arg|. When 'encoding' is set to Unicode, composing characters may be used, see |utf-8-char-arg|. |:lmap| mappings apply to {char}. The CTRL-^ command in Insert mode can be used to switch this on/off |i_CTRL-^|. *F* F{char} To the [count]'th occurrence of {char} to the left. The cursor is placed on {char} |exclusive|. {char} can be entered like with the |f| command. *t* t{char} Till before [count]'th occurrence of {char} to the right. The cursor is placed on the character left of {char} |inclusive|. {char} can be entered like with the |f| command. *T* T{char} Till after [count]'th occurrence of {char} to the left. The cursor is placed on the character right of {char} |exclusive|. {char} can be entered like with the |f| command. *;* ; Repeat latest f, t, F or T [count] times. *,* , Repeat latest f, t, F or T in opposite direction [count] times. These commands move the cursor to the specified column in the current line. They stop at the first column and at the end of the line, except "$", which may move to one of the next lines. See 'whichwrap' option to make some of the commands move across line boundaries.
3. Up-down motions *up-down-motions* k or *k* <Up> or *<Up>* *CTRL-P* CTRL-P [count] lines upward |linewise|. j or *j* <Down> or *<Down>* CTRL-J or *CTRL-J* <NL> or *<NL>* *CTRL-N* CTRL-N [count] lines downward |linewise|. gk or *gk* *g<Up>* g<Up> [count] display lines upward. |exclusive| motion. Differs from 'k' when lines wrap, and when used with an operator, because it's not linewise. {not in Vi} gj or *gj* *g<Down>* g<Down> [count] display lines downward. |exclusive| motion. Differs from 'j' when lines wrap, and when used with an operator, because it's not linewise. {not in Vi} *-* - <minus> [count] lines upward, on the first non-blank character |linewise|. + or *+* CTRL-M or *CTRL-M* *<CR>* <CR> [count] lines downward, on the first non-blank character |linewise|. *_* _ <underscore> [count] - 1 lines downward, on the first non-blank character |linewise|. *G* G Goto line [count], default last line, on the first non-blank character |linewise|. If 'startofline' not set, keep the same column. *<C-End>* <C-End> Goto line [count], default last line, on the last character |inclusive|. {not in Vi} <C-Home> or *gg* *<C-Home>* gg Goto line [count], default first line, on the first non-blank character |linewise|. If 'startofline' not set, keep the same column. :[range] Set the cursor on the specified line number. If there are several numbers, the last one is used. *N%* {count}% Go to {count} percentage in the file, on the first non-blank in the line |linewise|. To compute the new line number this formula is used: ({count} * number-of-lines + 99) / 100 See also 'startofline' option. {not in Vi} :[range]go[to] [count] *:go* *:goto* *go* [count]go Go to {count} byte in the buffer. Default [count] is one, start of the file. When giving [range], the last number in it used as the byte count. End-of-line characters are counted depending on the current 'fileformat' setting. {not in Vi} {not available when compiled without the |+byte_offset| feature} These commands move to the specified line. They stop when reaching the first or the last line. The first two commands put the cursor in the same column (if possible) as it was after the last command that changed the column, except after the "$" command, then the cursor will be put on the last character of the line. If "k", "-" or CTRL-P is used with a [count] and there are less than [count] lines above the cursor and the 'cpo' option includes the "-" flag it is an error. |cpo--|.
4. Word motions *word-motions* <S-Right> or *<S-Right>* *w* w [count] words forward. |exclusive| motion. <C-Right> or *<C-Right>* *W* W [count] WORDS forward. |exclusive| motion. *e* e Forward to the end of word [count] |inclusive|. Does not stop in an empty line. *E* E Forward to the end of WORD [count] |inclusive|. Does not stop in an empty line. <S-Left> or *<S-Left>* *b* b [count] words backward. |exclusive| motion. <C-Left> or *<C-Left>* *B* B [count] WORDS backward. |exclusive| motion. *ge* ge Backward to the end of word [count] |inclusive|. *gE* gE Backward to the end of WORD [count] |inclusive|. These commands move over words or WORDS. *word* A word consists of a sequence of letters, digits and underscores, or a sequence of other non-blank characters, separated with white space (spaces, tabs, <EOL>). This can be changed with the 'iskeyword' option. An empty line is also considered to be a word. *WORD* A WORD consists of a sequence of non-blank characters, separated with white space. An empty line is also considered to be a WORD. A sequence of folded lines is counted for one word of a single character. "w" and "W", "e" and "E" move to the start/end of the first word or WORD after a range of folded lines. "b" and "B" move to the start of the first word or WORD before the fold. Special case: "cw" and "cW" are treated like "ce" and "cE" if the cursor is on a non-blank. This is because "cw" is interpreted as change-word, and a word does not include the following white space. {Vi: "cw" when on a blank followed by other blanks changes only the first blank; this is probably a bug, because "dw" deletes all the blanks} Another special case: When using the "w" motion in combination with an operator and the last word moved over is at the end of a line, the end of that word becomes the end of the operated text, not the first word in the next line. The original Vi implementation of "e" is buggy. For example, the "e" command will stop on the first character of a line if the previous line was empty. But when you use "2e" this does not happen. In Vim "ee" and "2e" are the same, which is more logical. However, this causes a small incompatibility between Vi and Vim.
5. Text object motions *object-motions* *(* ( [count] sentences backward. |exclusive| motion. *)* ) [count] sentences forward. |exclusive| motion. *{* { [count] paragraphs backward. |exclusive| motion. *}* } [count] paragraphs forward. |exclusive| motion. *]]* ]] [count] sections forward or to the next '{' in the first column. When used after an operator, then also stops below a '}' in the first column. |exclusive| Note that |exclusive-linewise| often applies. *][* ][ [count] sections forward or to the next '}' in the first column. |exclusive| Note that |exclusive-linewise| often applies. *[[* [[ [count] sections backward or to the previous '{' in the first column. |exclusive| Note that |exclusive-linewise| often applies. *[]* [] [count] sections backward or to the previous '}' in the first column. |exclusive| Note that |exclusive-linewise| often applies. These commands move over three kinds of text objects. *sentence* A sentence is defined as ending at a '.', '!' or '?' followed by either the end of a line, or by a space or tab. Any number of closing ')', ']', '"'' and ''' characters may appear after the '.', '!' or '?' before the spaces, tabs or end of line. A paragraph and section boundary is also a sentence boundary. If the 'J' flag is present in 'cpoptions', at least two spaces have to follow the punctuation mark; <Tab>s are not recognized as white space. The definition of a sentence cannot be changed. *paragraph* A paragraph begins after each empty line, and also at each of a set of paragraph macros, specified by the pairs of characters in the 'paragraphs' option. The default is "IPLPPPQPP TPHPLIPpLpItpplpipbp", which corresponds to the macros ".IP", ".LP", etc. (These are nroff macros, so the dot must be in the first column). A section boundary is also a paragraph boundary. Note that a blank line (only containing white space) is NOT a paragraph boundary. Also note that this does not include a '{' or '}' in the first column. When the '{' flag is in 'cpoptions' then '{' in the first column is used as a paragraph boundary |posix|. *section* A section begins after a form-feed (<C-L>) in the first column and at each of a set of section macros, specified by the pairs of characters in the 'sections' option. The default is "SHNHH HUnhsh", which defines a section to start at the nroff macros ".SH", ".NH", ".H", ".HU", ".nh" and ".sh". The "]" and "[" commands stop at the '{' or '}' in the first column. This is useful to find the start or end of a function in a C program. Note that the first character of the command determines the search direction and the second character the type of brace found. If your '{' or '}' are not in the first column, and you would like to use "[[" and "]]" anyway, try these mappings: :map [[ ?{<CR>w99[{ :map ][ /}<CR>b99]} :map ]] j0[[%/{<CR> :map [] k$][%?}<CR> [type these literally, see |<>|]
6. Text object selection *object-select* *text-objects* *v_a* *v_i* This is a series of commands that can only be used while in Visual mode or after an operator. The commands that start with "a" select "a"n object including white space, the commands starting with "i" select an "inner" object without white space, or just the white space. Thus the "inner" commands always select less text than the "a" commands. These commands are {not in Vi}. These commands are not available when the |+textobjects| feature has been disabled at compile time. *v_aw* *aw* aw "a word", select [count] words (see |word|). Leading or trailing white space is included, but not counted. When used in Visual linewise mode "aw" switches to Visual characterwise mode. *v_iw* *iw* iw "inner word", select [count] words (see |word|). White space between words is counted too. When used in Visual linewise mode "iw" switches to Visual characterwise mode. *v_aW* *aW* aW "a WORD", select [count] WORDs (see |WORD|). Leading or trailing white space is included, but not counted. When used in Visual linewise mode "aW" switches to Visual characterwise mode. *v_iW* *iW* iW "inner WORD", select [count] WORDs (see |WORD|). White space between words is counted too. When used in Visual linewise mode "iW" switches to Visual characterwise mode. *v_as* *as* as "a sentence", select [count] sentences (see |sentence|). When used in Visual mode it is made characterwise. *v_is* *is* is "inner sentence", select [count] sentences (see |sentence|). When used in Visual mode it is made characterwise. *v_ap* *ap* ap "a paragraph", select [count] paragraphs (see |paragraph|). Exception: a blank line (only containing white space) is also a paragraph boundary. When used in Visual mode it is made linewise. *v_ip* *ip* ip "inner paragraph", select [count] paragraphs (see |paragraph|). Exception: a blank line (only containing white space) is also a paragraph boundary. When used in Visual mode it is made linewise. a] *v_a]* *v_a[* *a]* *a[* a[ "a [] block", select [count] '[' ']' blocks. This goes backwards to the [count] unclosed '[', and finds the matching ']'. The enclosed text is selected, including the '[' and ']'. When used in Visual mode it is made characterwise. i] *v_i]* *v_i[* *i]* *i[* i[ "inner [] block", select [count] '[' ']' blocks. This goes backwards to the [count] unclosed '[', and finds the matching ']'. The enclosed text is selected, excluding the '[' and ']'. When used in Visual mode it is made characterwise. a) *v_a)* *a)* *a(* a( *v_ab* *v_a(* *ab* ab "a block", select [count] blocks, from "[count] [(" to the matching ')', including the '(' and ')' (see |[(|). Does not include white space outside of the parenthesis. When used in Visual mode it is made characterwise. i) *v_i)* *i)* *i(* i( *v_ib* *v_i(* *ib* ib "inner block", select [count] blocks, from "[count] [(" to the matching ')', excluding the '(' and ')' (see |[(|). When used in Visual mode it is made characterwise. a> *v_a>* *v_a<* *a>* *a<* a< "a <> block", select [count] <> blocks, from the [count]'th unmatched '<' backwards to the matching '>', including the '<' and '>'. When used in Visual mode it is made characterwise. i> *v_i>* *v_i<* *i>* *i<* i< "inner <> block", select [count] <> blocks, from the [count]'th unmatched '<' backwards to the matching '>', excluding the '<' and '>'. When used in Visual mode it is made characterwise. *v_at* *at* at "a tag block", select [count] tag blocks, from the [count]'th unmatched "<aaa>" backwards to the matching "</aaa>", including the "<aaa>" and "</aaa>". See |tag-blocks| about the details. When used in Visual mode it is made characterwise. *v_it* *it* it "inner tag block", select [count] tag blocks, from the [count]'th unmatched "<aaa>" backwards to the matching "</aaa>", excluding the "<aaa>" and "</aaa>". See |tag-blocks| about the details. When used in Visual mode it is made characterwise. a} *v_a}* *a}* *a{* a{ *v_aB* *v_a{* *aB* aB "a Block", select [count] Blocks, from "[count] [{" to the matching '}', including the '{' and '}' (see |[{|). When used in Visual mode it is made characterwise. i} *v_i}* *i}* *i{* i{ *v_iB* *v_i{* *iB* iB "inner Block", select [count] Blocks, from "[count] [{" to the matching '}', excluding the '{' and '}' (see |[{|). When used in Visual mode it is made characterwise. a" *v_aquote* *aquote* a' *v_a'* *a'* a` *v_a`* *a`* "a quoted string". Selects the text from the previous quote until the next quote. The 'quoteescape' option is used to skip escaped quotes. Only works within one line. When the cursor starts on a quote, Vim will figure out which quote pairs form a string by searching from the start of the line. Any trailing or leading white space is included. When used in Visual mode it is made characterwise. Repeating this object in Visual mode another string is included. A count is currently not used. i" *v_iquote* *iquote* i' *v_i'* *i'* i` *v_i`* *i`* Like a", a' and a`, but exclude the quotes and repeating won't extend the Visual selection. Special case: With a count of 2 the quotes are included, but no extra white space as with a"/a'/a`. When used after an operator: For non-block objects: For the "a" commands: The operator applies to the object and the white space after the object. If there is no white space after the object or when the cursor was in the white space before the object, the white space before the object is included. For the "inner" commands: If the cursor was on the object, the operator applies to the object. If the cursor was on white space, the operator applies to the white space. For a block object: The operator applies to the block where the cursor is in, or the block on which the cursor is on one of the braces. For the "inner" commands the surrounding braces are excluded. For the "a" commands, the braces are included. When used in Visual mode: When start and end of the Visual area are the same (just after typing "v"): One object is selected, the same as for using an operator. When start and end of the Visual area are not the same: For non-block objects the area is extended by one object or the white space up to the next object, or both for the "a" objects. The direction in which this happens depends on which side of the Visual area the cursor is. For the block objects the block is extended one level outwards. For illustration, here is a list of delete commands, grouped from small to big objects. Note that for a single character and a whole line the existing vi movement commands are used. "dl" delete character (alias: "x") |dl| "diw" delete inner word *diw* "daw" delete a word *daw* "diW" delete inner WORD (see |WORD|) *diW* "daW" delete a WORD (see |WORD|) *daW* "dd" delete one line |dd| "dis" delete inner sentence *dis* "das" delete a sentence *das* "dib" delete inner '(' ')' block *dib* "dab" delete a '(' ')' block *dab* "dip" delete inner paragraph *dip* "dap" delete a paragraph *dap* "diB" delete inner '{' '}' block *diB* "daB" delete a '{' '}' block *daB* Note the difference between using a movement command and an object. The movement command operates from here (cursor position) to where the movement takes us. When using an object the whole object is operated upon, no matter where on the object the cursor is. For example, compare "dw" and "daw": "dw" deletes from the cursor position to the start of the next word, "daw" deletes the word under the cursor and the space after or before it. Tag blocks *tag-blocks* For the "it" and "at" text objects an attempt is done to select blocks between matching tags for HTML and XML. But since these are not completely compatible there are a few restrictions. The normal method is to select a <tag> until the matching </tag>. For "at" the tags are included, for "it" they are excluded. But when "it" is repeated the tags will be included (otherwise nothing would change). Also, "it" used on a tag block with no contents will select the leading tag. "<aaa/>" items are skipped. Case is ignored, also for XML where case does matter. In HTML it is possible to have a tag like <br> or <meta ...> without a matching end tag. These are ignored. The text objects are tolerant about mistakes. Stray end tags are ignored.
7. Marks *mark-motions* *E20* *E78* Jumping to a mark can be done in two ways: 1. With ` (backtick): The cursor is positioned at the specified location and the motion is |exclusive|. 2. With '' (single quote): The cursor is positioned on the first non-blank character in the line of the specified location and the motion is linewise. *m* *mark* *Mark* m{a-zA-Z} Set mark {a-zA-Z} at cursor position (does not move the cursor, this is not a motion command). *m'* *m`* m' or m` Set the previous context mark. This can be jumped to with the "''"' or "``" command (does not move the cursor, this is not a motion command). *m[* *m]* m[ or m] Set the |'[| or |']| mark. Useful when an operator is to be simulated by multiple commands. (does not move the cursor, this is not a motion command). *:ma* *:mark* *E191* :[range]ma[rk] {a-zA-Z'} Set mark {a-zA-Z'} at last line number in [range], column 0. Default is cursor line. *:k* :[range]k{a-zA-Z'} Same as :mark, but the space before the mark name can be omitted. *'* *'a* *`* *`a* '{a-z} `{a-z} Jump to the mark {a-z} in the current buffer. *'A* *'0* *`A* *`0* '{A-Z0-9} `{A-Z0-9} To the mark {A-Z0-9} in the file where it was set (not a motion command when in another file). {not in Vi} *g'* *g'a* *g`* *g`a* g'{mark} g`{mark} Jump to the {mark}, but don't change the jumplist when jumping within the current buffer. Example: g`" jumps to the last known position in a file. See $VIMRUNTIME/vimrc_example.vim. Also see |:keepjumps|. {not in Vi} *:marks* :marks List all the current marks (not a motion command). The |'(|, |')|, |'{| and |'}| marks are not listed. The first column has number zero. {not in Vi} *E283* :marks {arg} List the marks that are mentioned in {arg} (not a motion command). For example: :marks aB to list marks 'a' and 'B'. {not in Vi} *:delm* *:delmarks* :delm[arks] {marks} Delete the specified marks. Marks that can be deleted include A-Z and 0-9. You cannot delete the '' mark. They can be specified by giving the list of mark names, or with a range, separated with a dash. Spaces are ignored.  Delete all marks for the current buffer, but not marks A-Z or 0-9. {not in Vi} A mark is not visible in any way. It is just a position in the file that is remembered. Do not confuse marks with named registers, they are totally unrelated. 'a - 'z lowercase marks, valid within one file 'A - 'Z uppercase marks, also called file marks, valid between files '0 - '9 numbered marks, set from .viminfo file Lowercase marks 'a to 'z are remembered as long as the file remains in the buffer list. If you remove the file from the buffer list, all its marks are lost. If you delete a line that contains a mark, that mark is erased. Lowercase marks can be used in combination with operators. For example: "d't" deletes the lines from the cursor position to mark 't'. Hint: Use mark 't' for Top, 'b' for Bottom, etc.. Lowercase marks are restored when using undo and redo. Uppercase marks 'A to 'Z include the file name. {Vi: no uppercase marks} You can use them to jump from file to file. You can only use an uppercase mark with an operator if the mark is in the current file. The line number of the mark remains correct, even if you insert/delete lines or edit another file for a moment. When the 'viminfo' option is not empty, uppercase marks are kept in the .viminfo file. See |viminfo-file-marks|. Numbered marks '0 to '9 are quite different. They can not be set directly. They are only present when using a viminfo file |viminfo-file|. Basically '0 is the location of the cursor when you last exited Vim, '1 the last but one time, etc. Use the "r" flag in 'viminfo' to specify files for which no Numbered mark should be stored. See |viminfo-file-marks|. *'[* *`[* '[ `[ To the first character of the previously changed or yanked text. {not in Vi} *']* *`]* '] `] To the last character of the previously changed or yanked text. {not in Vi} After executing an operator the Cursor is put at the beginning of the text that was operated upon. After a put command ("p" or "P") the cursor is sometimes placed at the first inserted line and sometimes on the last inserted character. The four commands above put the cursor at either end. Example: After yanking 10 lines you want to go to the last one of them: "10Y']". After inserting several lines with the "p" command you want to jump to the lowest inserted line: "p']". This also works for text that has been inserted. Note: After deleting text, the start and end positions are the same, except when using blockwise Visual mode. These commands do not work when no change was made yet in the current file. *'<* *`<* '< `< To the first line or character of the last selected Visual area in the current buffer. For block mode it may also be the last character in the first line (to be able to define the block). {not in Vi}. *'>* *`>* '> `> To the last line or character of the last selected Visual area in the current buffer. For block mode it may also be the first character of the last line (to be able to define the block). Note that 'selection' applies, the position may be just after the Visual area. {not in Vi}. *''* *``* '' `` To the position before the latest jump, or where the last "m'"' or "m`" command was given. Not set when the |:keepjumps| command modifier was used. Also see |restore-position|. *'quote* *`quote* '"' `" To the cursor position when last exiting the current buffer. Defaults to the first character of the first line. See |last-position-jump| for how to use this for each opened file. Only one position is remembered per buffer, not one for each window. As long as the buffer is visible in a window the position won't be changed. {not in Vi}. *'^* *`^* '^ `^ To the position where the cursor was the last time when Insert mode was stopped. This is used by the |gi| command. Not set when the |:keepjumps| command modifier was used. {not in Vi} *'.* *`.* '. `. To the position where the last change was made. The position is at or near where the change started. Sometimes a command is executed as several changes, then the position can be near the end of what the command changed. For example when inserting a word, the position will be on the last character. {not in Vi} *'(* *`(* '( `( To the start of the current sentence, like the |(| command. {not in Vi} *')* *`)* ') `) To the end of the current sentence, like the |)| command. {not in Vi} *'{* *`{* '{ `{ To the start of the current paragraph, like the |{| command. {not in Vi} *'}* *`}* '} `} To the end of the current paragraph, like the |}| command. {not in Vi} These commands are not marks themselves, but jump to a mark: *]'* ]' [count] times to next line with a lowercase mark below the cursor, on the first non-blank character in the line. {not in Vi} *]`* ]` [count] times to lowercase mark after the cursor. {not in Vi} *['* [' [count] times to previous line with a lowercase mark before the cursor, on the first non-blank character in the line. {not in Vi} *[`* [` [count] times to lowercase mark before the cursor. {not in Vi} :loc[kmarks] {command} *:loc* *:lockmarks* Execute {command} without adjusting marks. This is useful when changing text in a way that the line count will be the same when the change has completed. WARNING: When the line count does change, marks below the change will keep their line number, thus move to another text line. These items will not be adjusted for deleted/inserted lines: - lower case letter marks 'a - 'z - upper case letter marks 'A - 'Z - numbered marks '0 - '9 - last insert position '^ - last change position '. - the Visual area '< and '> - line numbers in placed signs - line numbers in quickfix positions - positions in the |jumplist| - positions in the |tagstack| These items will still be adjusted: - previous context mark '' - the cursor position - the view of a window on a buffer - folds - diffs :kee[pmarks] {command} *:kee* *:keepmarks* Currently only has effect for the filter command YXXY:range!|: - When the number of lines after filtering is equal to or larger than before, all marks are kept at the same line number. - When the number of lines decreases, the marks in the lines that disappeared are deleted. In any case the marks below the filtered text have their line numbers adjusted, thus stick to the text, as usual. When the 'R' flag is missing from 'cpoptions' this has the same effect as using ":keepmarks". *:keepj* *:keepjumps* :keepj[umps] {command} Moving around in {command} does not change the |''|, |'.| and |'^| marks, the |jumplist| or the |changelist|. Useful when making a change or inserting text automatically and the user doesn't want to go to this position. E.g., when updating a "Last change" timestamp in the first line: :let lnum = line(".") :keepjumps normal gg :call SetLastChange() :keepjumps exe "normal " . lnum . "G" Note that ":keepjumps" must be used for every command. When invoking a function the commands in that function can still change the jumplist. Also, for ":keepjumps exe 'command '"' the "command" won't keep jumps. Instead use: ":exe 'keepjumps command'"'
8. Jumps *jump-motions* A "jump" is one of the following commands: "'"', "`", "G", "/", "?", "n", "N", "%", "(", ")", "[[", "]]", "{", "}", ":s", ":tag", "L", "M", "H" and the commands that start editing a new file. If you make the cursor "jump" with one of these commands, the position of the cursor before the jump is remembered. You can return to that position with the "''"' and "``" command, unless the line containing that position was changed or deleted. *CTRL-O* CTRL-O Go to [count] Older cursor position in jump list (not a motion command). {not in Vi} {not available without the +jumplist feature} <Tab> or *CTRL-I* *<Tab>* CTRL-I Go to [count] newer cursor position in jump list (not a motion command). In a |quickfix-window| it takes you to the position of the error under the cursor. {not in Vi} {not available without the +jumplist feature} *:ju* *:jumps* :ju[mps] Print the jump list (not a motion command). {not in Vi} {not available without the +jumplist feature} *jumplist* Jumps are remembered in a jump list. With the CTRL-O and CTRL-I command you can go to cursor positions before older jumps, and back again. Thus you can move up and down the list. There is a separate jump list for each window. The maximum number of entries is fixed at 100. {not available without the +jumplist feature} For example, after three jump commands you have this jump list: jump line col file/line 3 1 0 some text 2 70 0 another line 1 1154 23 end. > The "file/line" column shows the file name, or the text at the jump if it is in the current file (an indent is removed and a long line is truncated to fit in the window). You are currently in line 1167. If you then use the CTRL-O command, the cursor is put in line 1154. This results in: jump line col file/line 2 1 0 some text 1 70 0 another line > 0 1154 23 end. 1 1167 0 foo bar The pointer will be set at the last used jump position. The next CTRL-O command will use the entry above it, the next CTRL-I command will use the entry below it. If the pointer is below the last entry, this indicates that you did not use a CTRL-I or CTRL-O before. In this case the CTRL-O command will cause the cursor position to be added to the jump list, so you can get back to the position before the CTRL-O. In this case this is line 1167. With more CTRL-O commands you will go to lines 70 and 1. If you use CTRL-I you can go back to 1154 and 1167 again. Note that the number in the "jump" column indicates the count for the CTRL-O or CTRL-I command that takes you to this position. If you use a jump command, the current line number is inserted at the end of the jump list. If the same line was already in the jump list, it is removed. The result is that when repeating CTRL-O you will get back to old positions only once. When the |:keepjumps| command modifier is used, jumps are not stored in the jumplist. Jumps are also not stored in other cases, e.g., in a |:global| command. You can explicitly add a jump by setting the '' mark. After the CTRL-O command that got you into line 1154 you could give another jump command (e.g., "G"). The jump list would then become: jump line col file/line 4 1 0 some text 3 70 0 another line 2 1167 0 foo bar 1 1154 23 end. > The line numbers will be adjusted for deleted and inserted lines. This fails if you stop editing a file without writing, like with ":n!". When you split a window, the jumplist will be copied to the new window. If you have included the '' item in the 'viminfo' option the jumplist will be stored in the viminfo file and restored when starting Vim. CHANGE LIST JUMPS *changelist* *change-list-jumps* *E664* When making a change the cursor position is remembered. One position is remembered for every change that can be undone, unless it is close to a previous change. Two commands can be used to jump to positions of changes, also those that have been undone: *g;* *E662* g; Go to [count] older position in change list. If [count] is larger than the number of older change positions go to the oldest change. If there is no older change an error message is given. (not a motion command) {not in Vi} {not available without the +jumplist feature} *g,* *E663* g, Go to [count] newer cursor position in change list. Just like |g;| but in the opposite direction. (not a motion command) {not in Vi} {not available without the +jumplist feature} When using a count you jump as far back or forward as possible. Thus you can use "999g;" to go to the first change for which the position is still remembered. The number of entries in the change list is fixed and is the same as for the |jumplist|. When two undo-able changes are in the same line and at a column position less than 'textwidth' apart only the last one is remembered. This avoids that a sequence of small changes in a line, for example "xxxxx", adds many positions to the change list. When 'textwidth' is zero 'wrapmargin' is used. When that also isn't set a fixed number of 79 is used. Detail: For the computations bytes are used, not characters, to avoid a speed penalty (this only matters for multi-byte encodings). Note that when text has been inserted or deleted the cursor position might be a bit different from the position of the change. Especially when lines have been deleted. When the |:keepjumps| command modifier is used the position of a change is not remembered. *:changes* :changes Print the change list. A ">" character indicates the current position. Just after a change it is below the newest entry, indicating that "g;" takes you to the newest entry position. The first column indicates the count needed to take you to this position. Example: change line col text 3 9 8 bla bla bla 2 11 57 foo is a bar 1 14 54 the latest changed line > The "3g;" command takes you to line 9. Then the output of ":changes is: change line col text > 0 9 8 bla bla bla 1 11 57 foo is a bar 2 14 54 the latest changed line Now you can use "g," to go to line 11 and "2g," to go to line 14.
9. Various motions *various-motions* *%* % Find the next item in this line after or under the cursor and jump to its match. |inclusive| motion. Items can be: ([{}]) parenthesis or (curly/square) brackets (this can be changed with the 'matchpairs' option) /* */ start or end of C-style comment #if, #ifdef, #else, #elif, #endif C preprocessor conditionals (when the cursor is on the # or no ([{ following) For other items the matchit plugin can be used, see |matchit-install|. This plugin also helps to skip matches in comments. When 'cpoptions' contains "M" |cpo-M| backslashes before parens and braces are ignored. Without "M" the number of backslashes matters: an even number doesn't match with an odd number. Thus in "( \) )" and "\( ( \)" the first and last parenthesis match. When the '%' character is not present in 'cpoptions' |cpo-%|, parens and braces inside double quotes are ignored, unless the number of parens/braces in a line is uneven and this line and the previous one does not end in a backslash. '(', '{', '[', ']', '}' and ')' are also ignored (parens and braces inside single quotes). Note that this works fine for C, but not for Perl, where single quotes are used for strings. Nothing special is done for matches in comments. You can either use the matchit plugin |matchit-install| or put quotes around matches. No count is allowed, {count}% jumps to a line {count} percentage down the file |N%|. Using '%' on #if/#else/#endif makes the movement linewise. *[(* [( go to [count] previous unmatched '('. |exclusive| motion. {not in Vi} *[{* [{ go to [count] previous unmatched '{'. |exclusive| motion. {not in Vi} *])* ]) go to [count] next unmatched ')'. |exclusive| motion. {not in Vi} *]}* ]} go to [count] next unmatched '}'. |exclusive| motion. {not in Vi} The above four commands can be used to go to the start or end of the current code block. It is like doing "%" on the '(', ')', '{' or '}' at the other end of the code block, but you can do this from anywhere in the code block. Very useful for C programs. Example: When standing on "case x:", "[{" will bring you back to the switch statement. *]m* ]m Go to [count] next start of a method (for Java or similar structured language). When not before the start of a method, jump to the start or end of the class. When no '{' is found after the cursor, this is an error. |exclusive| motion. {not in Vi} *]M* ]M Go to [count] next end of a method (for Java or similar structured language). When not before the end of a method, jump to the start or end of the class. When no '}' is found after the cursor, this is an error. |exclusive| motion. {not in Vi} *[m* [m Go to [count] previous start of a method (for Java or similar structured language). When not after the start of a method, jump to the start or end of the class. When no '{' is found before the cursor this is an error. |exclusive| motion. {not in Vi} *[M* [M Go to [count] previous end of a method (for Java or similar structured language). When not after the end of a method, jump to the start or end of the class. When no '}' is found before the cursor this is an error. |exclusive| motion. {not in Vi} The above two commands assume that the file contains a class with methods. The class definition is surrounded in '{' and '}'. Each method in the class is also surrounded with '{' and '}'. This applies to the Java language. The file looks like this: // comment class foo { int method_one() { body_one(); } int method_two() { body_two(); } } Starting with the cursor on "body_two()", using "[m" will jump to the '{' at the start of "method_two()" (obviously this is much more useful when the method is long!). Using "2[m" will jump to the start of "method_one()". Using "3[m" will jump to the start of the class. *[#* [# go to [count] previous unmatched "#if" or "#else". |exclusive| motion. {not in Vi} *]#* ]# go to [count] next unmatched "#else" or "#endif". |exclusive| motion. {not in Vi} These two commands work in C programs that contain #if/#else/#endif constructs. It brings you to the start or end of the #if/#else/#endif where the current line is included. You can then use "%" to go to the matching line. *[star* *[/* [* or [/ go to [count] previous start of a C comment "/*". |exclusive| motion. {not in Vi} *]star* *]/* ]* or ]/ go to [count] next end of a C comment "*/". |exclusive| motion. {not in Vi} *H* H To line [count] from top (Home) of window (default: first line on the window) on the first non-blank character |linewise|. See also 'startofline' option. Cursor is adjusted for 'scrolloff' option. *M* M To Middle line of window, on the first non-blank character |linewise|. See also 'startofline' option. *L* L To line [count] from bottom of window (default: Last line on the window) on the first non-blank character |linewise|. See also 'startofline' option. Cursor is adjusted for 'scrolloff' option. <LeftMouse> Moves to the position on the screen where the mouse click is |exclusive|. See also |<LeftMouse>|. If the position is in a status line, that window is made the active window and the cursor is not moved. {not in Vi} top - main help file


This page can only find netdata URLs you have already visited and are linked to your account on this netdata registry.


public interface CachedBatchSerializer
extends scala.Serializable
| Modifier and Type | Method and Description |
|---|---|
scala.Function2<Object,scala.collection.Iterator<CachedBatch>,scala.collection.Iterator<CachedBatch>> |
buildFilter(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> predicates,
scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> cachedAttributes)
Builds a function that can be used to filter batches prior to being decompressed.
|
RDD<ColumnarBatch> |
convertCachedBatchToColumnarBatch(RDD<CachedBatch> input,
scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> cacheAttributes,
scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> selectedAttributes,
org.apache.spark.sql.internal.SQLConf conf)
Convert the cached data into a ColumnarBatch.
|
RDD<org.apache.spark.sql.catalyst.InternalRow> |
convertCachedBatchToInternalRow(RDD<CachedBatch> input,
scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> cacheAttributes,
scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> selectedAttributes,
org.apache.spark.sql.internal.SQLConf conf)
Convert the cached batch into
InternalRow s. |
RDD<CachedBatch> |
convertColumnarBatchToCachedBatch(RDD<ColumnarBatch> input,
scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> schema,
StorageLevel storageLevel,
org.apache.spark.sql.internal.SQLConf conf)
Convert an
RDD[ColumnarBatch] into an RDD[CachedBatch] in preparation for caching the data. |
RDD<CachedBatch> |
convertInternalRowToCachedBatch(RDD<org.apache.spark.sql.catalyst.InternalRow> input,
scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> schema,
StorageLevel storageLevel,
org.apache.spark.sql.internal.SQLConf conf)
Convert an
RDD[InternalRow] into an RDD[CachedBatch] in preparation for caching the data. |
boolean |
supportsColumnarInput(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> schema)
Can
convertColumnarBatchToCachedBatch() be called instead of
convertInternalRowToCachedBatch() for this given schema? True if it can and false if it
cannot. |
boolean |
supportsColumnarOutput(StructType schema)
Can
convertCachedBatchToColumnarBatch() be called instead of
convertCachedBatchToInternalRow() for this given schema? True if it can and false if it
cannot. |
scala.Option<scala.collection.Seq<String>> |
vectorTypes(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> attributes,
org.apache.spark.sql.internal.SQLConf conf)
The exact java types of the columns that are output in columnar processing mode.
|
scala.Function2<Object,scala.collection.Iterator<CachedBatch>,scala.collection.Iterator<CachedBatch>> buildFilter(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> predicates, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> cachedAttributes)
SimpleMetricsCachedBatchSerializer
will provide the filter logic
necessary. You will need to provide metrics for this to work. SimpleMetricsCachedBatch
provides the APIs to hold those metrics and explains the metrics used, really just min and max.
Note that this is intended to skip batches that are not needed, and the actual filtering of
individual rows is handled later.predicates
- the set of expressions to use for filtering.cachedAttributes
- the schema/attributes of the data that is cached. This can be helpful
if you don't store it with the data.RDD<ColumnarBatch> convertCachedBatchToColumnarBatch(RDD<CachedBatch> input, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> cacheAttributes, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> selectedAttributes, org.apache.spark.sql.internal.SQLConf conf)
supportsColumnarOutput()
returns true for the associated schema, but there are other checks
that can force row based output. One of the main advantages of doing columnar output over row
based output is that the code generation is more standard and can be combined with code
generation for downstream operations.input
- the cached batches that should be converted.cacheAttributes
- the attributes of the data in the batch.selectedAttributes
- the fields that should be loaded from the data and the order they
should appear in the output batch.conf
- the configuration for the job.RDD<org.apache.spark.sql.catalyst.InternalRow> convertCachedBatchToInternalRow(RDD<CachedBatch> input, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> cacheAttributes, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> selectedAttributes, org.apache.spark.sql.internal.SQLConf conf)
InternalRow
s. If you want this to be performant, code
generation is advised.input
- the cached batches that should be converted.cacheAttributes
- the attributes of the data in the batch.selectedAttributes
- the field that should be loaded from the data and the order they
should appear in the output rows.conf
- the configuration for the job.RDD<CachedBatch> convertColumnarBatchToCachedBatch(RDD<ColumnarBatch> input, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> schema, StorageLevel storageLevel, org.apache.spark.sql.internal.SQLConf conf)
RDD[ColumnarBatch]
into an RDD[CachedBatch]
in preparation for caching the data.
This will only be called if supportsColumnarInput()
returned true for the given schema and
the plan up to this point would could produce columnar output without modifying it.input
- the input RDD
to be converted.schema
- the schema of the data being stored.storageLevel
- where the data will be stored.conf
- the config for the query.RDD<CachedBatch> convertInternalRowToCachedBatch(RDD<org.apache.spark.sql.catalyst.InternalRow> input, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> schema, StorageLevel storageLevel, org.apache.spark.sql.internal.SQLConf conf)
RDD[InternalRow]
into an RDD[CachedBatch]
in preparation for caching the data.input
- the input RDD
to be converted.schema
- the schema of the data being stored.storageLevel
- where the data will be stored.conf
- the config for the query.boolean supportsColumnarInput(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> schema)
convertColumnarBatchToCachedBatch()
be called instead of
convertInternalRowToCachedBatch()
for this given schema? True if it can and false if it
cannot. Columnar input is only supported if the plan could produce columnar output. Currently
this is mostly supported by input formats like parquet and orc, but more operations are likely
to be supported soon.schema
- the schema of the data being stored.boolean supportsColumnarOutput(StructType schema)
convertCachedBatchToColumnarBatch()
be called instead of
convertCachedBatchToInternalRow()
for this given schema? True if it can and false if it
cannot. Columnar output is typically preferred because it is more efficient. Note that
convertCachedBatchToInternalRow()
must always be supported as there are other checks that
can force row based output.schema
- the schema of the data being checked.scala.Option<scala.collection.Seq<String>> vectorTypes(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> attributes, org.apache.spark.sql.internal.SQLConf conf)
attributes
- the attributes to be output.conf
- the config for the query that will read the data.


At work I've been developing a static publishing CMS. This has worked well, but it's made me think differently about application development. Previously I'd deal with any issues inside the specific programming environment I was using, separate from Apache. These environments (Webware, Zope, PHP) are controllable and relatively well partitioned, and I generally have a lot of control. But these environments don't interact that well when they come together to make one site. One piece is in Zope, another as a Perl CGI script, another as PHP, and now the addition of static content from the CMS.
One solution is a homogeneous environment, e.g., use Zope for absolutely everything. But that's really not realistic, there's a lot of useful tools that aren't in Zope (or PHP, or Perl, or...) and converting every application isn't worth it. The one thing they all have in common is Apache, and I'm hoping to use that.
The first thing I've been experimenting with is authentication. Apache doesn't do authentication very well. It mostly expects HTTP authentication.  A lot. You can't provide any UI -- the login popup can't have messages or links, and expecting the user to cancel and then notice links on the error page is optimistic. There's no logout. A page either has to require login, or else no login is allowed -- you can't get user information unless you reject anonymous users. You can't do cross-site logins, even if you try really really hard (it's not easy with cookies, but at least it's possible).  And since it is orthogonal to everything else, there's absolutely no way to fix it, it's all up to the browsers and the browsers aren't even bothering to try.
My first experiment has been to use mod_python to allow cookie authentication. Mostly this has meant trying lots of things that don't work in order to find one that does. I'll write more about that later, but in the end I was able to get it to work. Rather than centralizing authentication, I think it will be easier to simply use a signed cookie to indicate that authentication has occurred. This way Apache doesn't have to know about every authentication backend I might want to use.
The second feature I'm looking forward to is Apache 2's filters. Particularly for templating, probably using mod_include (server-side includes). Any resource (static files, CGI scripts, etc.) can output SSI tags and they will be interpreted. This should make a site look much easier to implement, and will remove one of the biggest barriers to a heterogeneous site. It also makes it possible to compose a page from heterogeneous sources, as SSIs can in turn include any local URL.
Hi, Ian!
I built a CMS using mod_python a couple of years ago. It's currently hosting two sites: phoenixchildrenshospital.com and turntableband.com.
I ended up taking the lazy road and using Basic Auth, but I have pretty much the same opinion as you.  It's horribly limited, and implementing "logout" is arguably impossible (Zope seems to pull it off, sorta, kinda).
So, you've got some setup to do before mod_python is ready for a CMS, mainly session managemet, authentication, templating, and database interfaces, but once you get past that, mod_python is a total joy to program in. So simple! It does exactly what it's supposed to do; no more, no less.
I especially love the "publisher" module, since it lets me completely close the gap between URLs and function calls.
I haven't tried Webware, but I've heard great things about it. I was initially very impressed with Zope, but my main beef with it is that it tries to appease content editors and programmers through the same interface, and as a result, feels very crippled. Am I supposed to write my code in Zope, or on the file system? If I write inside of Zope, I have to expose system functionality through external methods or products, and it's so constrained and filtered that I barely feel like I'm using Python anymore. mod_python let me just write Python, with the added convenience that I can make a page just as easily as I can make a function.
Good luck with your project.
Dave
We are working on static publishing CMS too, and it's successfully used for many projects, here is a short list of them I've participated in. Are you interested in expiriense exchange?


Rest API 2.0?

Which HTTP verb will you use for create request over web sockets? XD
When you need a little more or a little less.
Standard for application-level query language invented by Facebook.
Schema notation:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: |
|
Directives:
Ability to retrieve an information about your schema by using GraphQL itself.
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: |
|
(Excelent for tooling)
F# implementation of GraphQL standard for client and server.
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: |
|
Good |
Bad |
|---|---|
What approaches did we use to address problems we've met?
Uniform API to work with both sync/async computations:
1: 2: 3: 4: 5: 6: 7: |
|
Fast, low overhead in synchronous cases:
Know what's going to be executed before executing it.
Know what's going to be accessed before accessing it.
Execution plan infers usage of objects and fields defined GraphQL schema
Property tracker infers usage of .NET objects and properties directly from the code before it executes
(Keep track of improvements on github)
References:


WITNESS LIST Education Committee March 28, 2001 - 9:00A SB 19 FOR: Barnett, Dr. Stephen Pediatrician (Texas Medical Association), Austin, TX Condrasky, Terry Wellness Education Teacher (Children of Texas), Round Rock, TX Cribb, Peter Catch Project Director (Houston Health Science Center), Austin, TX Crider, Christi Health Promotion (American Cancer Society), Austin, TX Pierce, Diane Texas PTA President (Texas PTA), Austin, TX Rohack, Jim Cardiologist (Texas Medical Association), Temple, TX Sanchez, Eduardo Family Practice Physician (American Heart Association), Austin, TX Sanchez, Rosa Principal (Self), Victoria, TX Tighe, Frank Physical/Wellness Educator (Children of Texas), Round Rock, TX ON: Floyd, Robert Executive Director (Texas Music Educators Association), Austin, TX Registering, but not testifying: For: Borden, Sandi Executive Director (Texas Elementary Principals and Supervisors Association), Austin, TX Fickel, Ann Director of Legislation (Texas Classroom Teachers Association), Austin, TX Phipps, Candie Lobbyist (Texas Pediatric Society), Austin, TX Shore, Grace Chair State Board of Education (Self), Austin, TX Smith, Lauren (Association of Texas Professional Educators), Austin, TX Young, Jenny Policy Analyst (Texas Medical Association), Austin, TX On: Huang, Phil (Texas Department of Health), Austin, TX Stounter, Marion Director of Child Wellness Division (Texas Department of Health), Austin, TX SB 26 AGAINST: Borden, Sandi Executive Director (Texas Elementary Principals and Supervisors Association), Austin, TX ON: Lara, Rene Legislative Liaison (Texas Federation of Teachers), Austin, TX Registering, but not testifying: For: Campbell, Jack Governmental Affairs (Texas Association of Business and Chambers of Commerce), Austin, TX On: Currah, Tom Policy Analyst (Comptroller), Austin, TX Ressel, Betty Manager, School Performance Review (Texas Comptroller's Office), Austin, TX SB 460 FOR: Tiffen, David Assistant Superintendent (Richardson I.S.D.), Richardson, TX Registering, but not testifying: For: Backus, David Attorney (Texas Association of School Administrators), Austin, TX Carpenter, Bill Asst. Supt. for Gov. Relations (Houston I.S.D.), Houston, TX De Leon, Marty Lobbyist (Texas Association of School Boards), Austin, TX SB 526 AGAINST: Borden, Sandi Excutive Director (Texas Elementary Principals and Supervisors Association), Austin, TX Registering, but not testifying: Against: Tounget, Craig Director of Governmental Relations (Texas PTA), Austin, TX SB 743 ON: Schroder, Dr. Gene Associate Dean for Outreach Programs (University of Texas School of Public Health - Houston), Houston, TX SB 975 FOR: Lang, Gaydelle Education (Houston I.S.D.), Houston, TX Lara, Rene Legislative Liaison (Texas Federation of Teachers), Austin, TX Soto, Manny (Ysleta I.S.D.), Ysleta, TX Williams, Ellen Attorney (Texas School Alliance), Austin, TX ON: Nelson, Jim (Texas Education Agency), Austin, TX Smisko, Ann Educational Administration (Texas Education Agency), Austin, TX Registering, but not testifying: For: Batson, Amanda Executive Director (Texas Association for the Gifted/Talented), Austin, TX Bricker, Laurie Houston I.S.D. Board Member (Houston I.S.D.), Houston, TX Campbell, Jack Governmental Affairs (Texas Association of Business and Chambers of Commerce), Austin, TX Carpenter, Bill Asst. Supt. for Governmental Relations (Houston I.S.D./Texas School Alliance), Houston, TX De Leon, Marty Lobbyist (Texas Association of School Boards), Austin, TX Eckhart, Harley Associate Executive Director (Texas Elementary Principals and Supervisors Association), Austin, TX Fickel, Ann Director of Legislation (Texas Classroom Teachers Association), Austin, TX Jackson, Diane Public School Administrator (Spring Branch I.S.D.), Houston, TX King, Mary Director of High School Services (Texas Association of Secondary School Principals), Austin, TX Smith, Lauren (Association of Texas Professional Educators), Austin, TX SB 1196 FOR: Armstrong, Bonnie Child Advocate (Children), Fort Worth, TX Bright, Mike Executive Director (The Arc of Texas), Austin, TX Derr, Patti Parent (Texas Federation of Families), Austin, TX Gundlins, Kathy Children (Self), Houston, TX Norton, Colleen (Texas Advocates Supporting Kids with Disabilities), Austin, TX Schleiss, Ronnie Parent (Austin I.S.D.), Austin, TX Sharp, Amy Student (Self), College Station, TX Webb-Johnson, Dr. Gwendolyn Assistant Professor of Special Education (Self), Austin, TX ON: Davis, Mike State Fire Marshal (Texas Department of Insurance), Austin, TX La Vello, Richard Attorney (Advocacy, Inc.), Austin, TX Seay, Penny Director (Center for Disability Studies, UT Austin), Austin, TX Registering, but not testifying: For: Backus, David Attorney (Texas Association of School Administrators), Austin, TX Borden, Sandi Excutive Director (Texas Elementary Principals and Supervisors Association), Austin, TX Bright, Mike Executive Director (The Arc of Texas), Austin, TX De Leon, Marty Lobbyist (Texas Association of School Boards), Austin, TX Gantt, Melanie Public Policy Advocate (Mental Health Association in Texas), Austin, TX Halligan, Mike Executive Director (Texas Mental Health Consumers), Austin, TX Kern, Diana Public Policy Analyst (NAMI TX), Austin, TX Lambert, Kay (Advocacy, Inc.), Austin, TX Mewkowsky, John Advocate (TACIL), Austin, TX Paynter, Suzi Citizenship Education (Texas Baptist Christian Life Commission), Austin, TX Rogers, Kenny Student (Self), Dallas, TX Smoot, Samantha Executive Director (Texas Freedom Network), Austin, TX Tounget, Craig Director of Governmental Relations (Texas PTA), Austin, TX Zoern, Stacy (Coalition of Texans with Disabilities), Austin, TX On: Crawford, Pamela Executive Director (Texas Council of Administrators of Special Education), Austin, TX Murphy, Marsha Director of Special Education (Perryton I.S.D., Spearman I.S.D., Booker I.S.D., Follett I.S.D.), Perryton, TX Price, Dennis Special Education Director (Amarillo I.S.D.), Amarillo, TX Wilder, Ann Director of Special Education (Amarillo I.S.D.), Amarillo, TX Providing written testimony: For: Smith, Lauren (Association of Texas Professional Educators), Austin, TX SB 1205 FOR: Duncan, Gregory Manager (Pryor Resources, Inc.), Overland Park, KS Registering, but not testifying: On: De Long, Michael Program Coordinator (Texas Workforce Commission), Austin, TX SB 1327 FOR: Kester, Steve (American Electronics Association), Austin, TX Lara, Rene Legislative Liaison (Texas Federation of Teachers), Austin, TX Warshauer, Max Teacher Southwest Texas State Univ. (Self), San Marcos, TX ON: Nelson, Jim Commissioner (Texas Education Agency), Austin, TX Smisko, Ann Educational Administration (Texas Education Agency), Austin, TX Registering, but not testifying: For: Borden, Sandi Executive Director (Texas Elementary Principals and Supervisors Association), Austin, TX Campbell, Jack Governmental Affairs (Texas Association of Business and Chambers of Commerce), Austin, TX De Leon, Marty Lobbyist (Texas Association of School Boards), Austin, TX King, Mary Director of High School Services (Texas Association of Secondary School Principals), Austin, TX Shore, Gene Chair (State Board of Education), Austin, TX Smith, Lauren (Association of Texas Professional Educators), Austin, TX Wurzel, Geoff Governmental Affiars Manager (National Semiconductor), Austin, TX SB 1465 Registering, but not testifying: On: Burck, Dan Chancellor (UT System), Austin, TX Martinez, Arthur Business Manager (UT System), Austin, TX Meyer, Richard Attorney (TIBH Industries, Inc.), Austin, TX Morris, Brett Associate Director of Human Resources (UT System), Austin, TX Self, Floyd Purchasing Director (UT Austin), Austin, TX SB 1498 Registering, but not testifying: For: Borden, Sandi Executive Director (Texas Elementary Principals and Supervisors Association), Austin, TX Smith, Sharon Kay Student Body President (University of Texas at Arlington), Arlington, TX On: Gardner, Dr. Kent Dean of Students (University of Texas at Arlington), Arlington, TX SB 1766 FOR: Grusendorf, Bill Executive Director (Texas Association of Rural Schools), San Saba, TX Pierce, Wayne Executive Director (Equity Center), Austin, TX Rawlinson, Ed School Superintendent (Fast Growth School Coalition and Northside I.S.D.), San Antonio, TX ON: O'Hanlon, Kevin Attorney (South Texas Association of Schools), Austin, TX Registering, but not testifying: For: Backus, David Attorney (Texas Association of School Administrators), Austin, TX Backus, David Attorney (Texas Association of School Administrators), Austin, TX Carpenter, Bill Houston I.S.D. (Texas School Alliance), Houston, TX Dunn, David Lobbyist (Texas Association of School Boards), Austin, TX


HorseCenter: Making 2019 Eclipse Awards predictions
by Matt Shifman/Brian ZipseThis week on HorseCenter, co-hosts Brian Zipse and Matt Shifman predict the winners for the 2019 Eclipse Awards.
The guys agree on most of the would-be champions, but there's a lively debate to be had about both the 3-year-old male and female divisions, along with the Older Dirt Male category.
Matt leans to the sprinters like Covfefe and Mitole, but Brian prefers the distance horses Guarana and Vino Rosso.
Members of the NTRA, Daily Racing Form and National Turf Writers and Broadcasters -- of which Horse Racing Nation has a few -- will vote on the Eclipse Awards at year's end, with the winners announced in January.
Next week, HorseCenter will preview the Thanksgiving weekend stakes racing. And always, thanks for watching the show.


Nakalembe wins Nigeria Ladies Open
by Michael NsubugaThe Entebbe Club golfer travelled to Nigeria with four other Ugandans.
Uganda’s Irene Nakalembe is aiming for a double after winning the Nigeria Ladies Open at the IBB International Golf and Country Club in Abuja on Friday.
Nakalembe returned 236 gross over 54 holes to beat over 60 golfers including defending champion Eva Magala to the 22nd edition of the annual championship title.
Her focus is now on the Ikoy Ladies Open in Lagos, for which she is defending champion. Last year she won the championship, with Magala taking the Nigeria Ladies Open.
The national team player, who was sponsored by RwandAir to this year’s championship, beat Nigeria’s Rachael Danjuma who finished second by 12 strokes while Amina Wilfred was 16 strokes off, in third.
Defending champion Eva Magala paid dearly for her poor start, finishing fourth, 18 strokes away while Gloria Mbaguta, Evelyn Asiimwe and Peace Kabasweka finished 7th, 9th and 10th respectively.
The Entebbe Club golfer travelled to Nigeria with other Ugandans that also included Anne Abeja, Safari Zawadi, Carol Kamusiime and Wendy Angudeyo, who also competed in the championship.
“It feels great to win this championship. I didn’t expect it but I knew I had a good chance. I had a good start and just maintained it,” Nakalembe who started with four-over 76 before a uniform eight-over 80 in each of the last two rounds, stated.
“I expect to give the Ikoy championship another shot as defending champion,”
Last year, in the 44th edition of the championship, Nakalembe’s won the event with an aggregate score of 243 over 54-holes, beating Eva Magala by a stroke to wrap up a fantastic outing for the two top female golfers.
Magala won last year’s championship with 251 gross over 54 holes in the tournament that attracted 116 players.


THE X-FILES (1998)
Starring: David Duchovny (Fox Mulder), Gillian Anderson (Dana Scully), William B. Davis (The Cigarette-Smoking Man), Martin Landau (Dr. Alvin Kurtzweil), Jeffrey DeMunn (Dr. Ben Bronschweig), John Neville (The Well-Manicured Man), Mitch Pileggi (Walter Skinner)
Directed by: Rob Bowman, Written by: Chris Carter from a story by Chris Carter and Frank Spotnitz
Rated PG-13 by the MPAA for violence, gore, and profanity
Reviewed by Doug Skiles
The truth is out there.
So, um, what's the truth? Well, if you mean you want the truth about what the new X-FILES movie is titled, I can't really help you. The movie titles only said THE X-FILES. The advertisements all seem to say THE X-FILES: FIGHT THE FUTURE. Well, take it either way. I think it's just THE X-FILES, but, well, I don't really know.
Oh, did you want the truth about the movie? As in, is it any good? Well, I'm not the biggest expert in this area. You see, I've only seen maybe 4 episodes of the television series, give or take one or two. So I'm not a big X-Phile. So it's safe to say that it's quite reassuring that I can say - Yes. It's good. It's very good. It's great, in fact. The first true RIDE of the summer is here, and you'll be kicking yourself if you don't strap in to this one while it's in theaters - some of the images just won't translate as well onto a TV screen. If you haven't seen the film yet, get up and go NOW.
Wait, not now. You might want to read this review first. Of course, that's really up to you, but still, you might want to. Don't worry, I won't spoil anything. I make a point to only talk about maybe five minutes of the film and then leave the lesser-known details to you.
Okay, citizens. THE X-FILES opens up with us seeing a freaky beast attack ancient humans in the B.C. caveman ages. The beast remains in shadows so that we're not quite sure what it is. Cut to the present day. We see a mysterious black ooze (I think fans of the tv series will recognize this, or so I'm told) inhabit a little boy who goes to the same spot where the cavemen were attacked so long ago. Is there a connection? Does Bea Arthur look hideous naked? And from there, we cut to our heroes, FBI Agents Mulder and Scully. Previously, they worked on the mysterious X-Files, files found in the darker rooms of the FBI's hallways, files which detail cases too strange to be explained by rational thought and logical explanation. Cases that seem to deal with the supernatural, or the extraterrestrial... or both. But that's ridiculous. Well, Scully thinks it's ridiculous. Mulder believes all of it. Anyway, the files have since been shut down after Mulder pushed his beliefs a little too far and annoyed the wrong people. Now he and Scully are still a team, but they're a team of ordinary FBI agents, dealing with less interesting things, like terrorist threats. Yeah, that's a big yawn, huh Mulder?
Of course, when something goes wrong in their new line of duty, the FBI looks for someone to blame for the foul-up, and even though it wasn't their fault, Mulder and Scully were there, and they're first in line to have the whole thing put on their heads. Now they're going to try to clear their names, and along the way, they're going to learn a lot more about the mysterious conspiracy that's being run behind the scenes worldwide, to hide the real truth about just the kinds of things that Mulder and Scully used to investigate in the X-Files division. Of course, they can't learn everything - there's plenty more episodes of the series to be had, and future movies to be made.
The performances are all acted by people who've handled these roles for years on the tv show (with the exception of Martin Landau playing a new character - and he's never bad, so of course that's just another good point). And since they've had to time to develop the roles, they make us feel like we're watching developed, layered characters even if we don't watch the show much, or at all. We really care about Mulder and Scully - they actually have deep personalities, which is truly something to be appreciated, especially in today's film world. The action scenes are infrequent, but tense, and solid. Really though, this story is driven by plot and dialogue. It's a winding plot that you have to pay attention to, especially if you're not a series afficianado, but trust me, it's worth it. Some of the scenes are awe-inspiring, and the scope of some visuals, particularly towards the end, make you truly appreciate that this was made into a movie as opposed to just another episode of the show. The plot winds around and around but always holds your interest, thanks in part to great performances and in part to great writing that takes the time to give us characterizations of the people we're watching instead of just putting them through the paces. The effects, when they show up, are also great. Seems like this movie works even for those who don't watch the show, and I also find it very hard to believe that those who do watch would be let down by this.
If there's a flaw to this, it's that the villians aren't quite clearly explained enough. We understand their motives, but how did they come to reach these motives? There had to be some kind of communication that we didn't learn about. I know, I know, I'm keeping this pretty vague. But I can assure you, I'm not digging too deep here, this is actually a question you need to ask yourself, and in the end, it's never quite answered. Maybe series fans know more on this subject. Though really, in such an otherwise great movie, why should I gripe about this?
I can't elaborate too much on things that were great because I wouldn't dare reveal the plot. You have to go and see it for yourself. And you'd better. The summer has had some letdowns, and some fun, but so far, this is the best ride out there, and it's a damn good ride that could hold its own in any summer... or any season of any year, for that matter. One wonders if Chris Carter, the show's creator, can continue to make X-FILES films that can stand alone as their own series and still make them interesting and relevant to the viewers at home. But there's no need to worry about this now.
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


"PELATIAH "deliverance of the Lord. (1.) A son of Hananiah and grandson of Zerubbabel (1 Chronicles 3:21). (2.) A captain of “the sons of Simeon” (4:42). (3.) Nehemiah 10:22. (4.) One of the twenty-five princes of the people against whom Ezekiel prophesied on account of their wicked counsel (Ezekiel 11:1-13).
"PELATIAH "deliverance of the Lord. (1.) A son of Hananiah and grandson of Zerubbabel (1 Chronicles 3:21).
(2.) A captain of “the sons of Simeon” (4:42).
(3.) Nehemiah 10:22.
(4.) One of the twenty-five princes of the people against whom Ezekiel prophesied on account of their wicked counsel (Ezekiel 11:1-13).


NamedNodeMap
s are used to
represent collections of nodes that can be accessed by name
| @Comparisons
| |||||||||
Constructors and assignment operator
| |||||||||
Destructor.
| |||||||||
Functions introduced in DOM Level 2.
| |||||||||
Functions to change the node collection.
| |||||||||
Get functions.
| |||||||||
Set functions.
|
NamedNodeMap
s are used to represent collections of nodes that can be accessed by name. Note thatNamedNodeMap
does not inherit fromNodeList
;NamedNodeMap
s are not maintained in any particular order. Nodes contained in aNamedNodeMap
may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents, and does not imply that the DOM specifies an order to these Nodes.
DOM_NamedNodeMap
reference object
that refers to the same underlying NamedNodeMap as the original.
Like most other DOM types in this implementation, memory management of named node maps is automatic. Instances of DOM_NamedNodeMap function as references to an underlying heap based implementation object, and should never be explicitly new-ed or deleted in application code, but should appear only as local variables or function parameters.
nodeName
attribute.
nodeName
attribute is used to derive the name
which the node must be stored under, multiple nodes of certain types
(those that have a "special" string value) cannot be stored as the names
would clash. This is seen as preferable to allowing nodes to be aliased.
arg
was created from a
different document than the one that created the
NamedNodeMap
.
NamedNodeMap
is readonly.
arg
is an
Attr
that is already an attribute of another
Element
object. The DOM user must explicitly clone
Attr
nodes to re-use them in other elements.Node
replaces an existing node the
replaced Node
is returned,
otherwise null
is returned.
nodeName
attribute of
the node. If a node with that name is already present in the map, it
is replaced by the new one.
index
th item in the map.
If index
is greater than or equal to the number of nodes in the map, this returns
null
.
index
th position in the
NamedNodeMap
, or null
if that is not a valid
index.
DOM_Node
(of any type) with the specified nodeName
, or
null
if it does not identify any node in
the map.
nodeName
of a node to retrieve.
length-1
inclusive.
Attr
with a default value it is immediately replaced.
name
in
the map.
NamedNodeMap
is readonly.null
if no node
with such a name exists.
nodeName
of a node to remove.
"Experimental - subject to change"
DOM_Node
(of any type) with the specified
local name and namespace URI, or null
if they do not
identify any node in the map.
"Experimental - subject to change"
"Experimental - subject to change"namespaceURI
and localName
.
arg
was created from a
different document than the one that created the
DOM_NamedNodeMap
.
NO_MODIFICATION_ALLOWED_ERR: Raised if this
vNamedNodeMap
is readonly.
INUSE_ATTRIBUTE_ERR: Raised if arg
is an
DOM_Attr
that is already an attribute of another
DOM_Element
object. The DOM user must explicitly clone
DOM_Attr
nodes to re-use them in other elements.DOM_Node
replaces an existing node the
replaced DOM_Node
is returned,
otherwise null
is returned.
namespaceURI
and
localName
attribute of the node. If a node with those
namespace URI and local name is already present in the map, it is
replaced by the new one.
name
in
the map.
NO_MODIFICATION_ALLOWED_ERR: Raised if this DOM_NamedNodeMap
is readonly.
localName - The local name of the
node to remove. When this DOM_NamedNodeMap
contains the
attributes attached to an element, as returned by the attributes
attribute of the DOM_Node
interface, if the removed
attribute is known to have a default value, an attribute
immediately appears containing the default value
as well as the corresponding namespace URI, local name, and prefix.
alphabetic index hierarchy of classes
|
Xerces-C XML Parser for C++ Version 1.1 |
|
|
generated by doc++


The current options of ngBusy is : {{optionsForShow}} The code of the template is:
{{optionsForShow}}


$0276/630: Index: End of filename in command buffer ROM-Reference: CPX $0276 : $C51D $C6A0 STX $0276 : $C6C8 Previous Page / Next Page


The following is a list of projects I have done with links online. Some of this projects contain little information just since it was used for test purposes.
In my entire life I have gone under different learning institutions Moringa School being one of them. Am in Moringa School for my coding lessons and sharpen my coding skills. I have always wanted to be good in coding so as to tackle more problems facing the society. Before Moringa School, I attended Jomo Kenyatta University Of Agriculture and Technology for my degree in Bachelor of Business and Information Technology. I joined jkuat in the year 2015 and in the year 2018. I am yet to submit my projects so as to graduate. From the year 2010 to 2014 I attended kisii School for my high school and thats where my interest in programming started growing stronger. I never did Computer studies in school but it always puzzled me and intrested me to be a programmer and design programs that people could use in their daily lives.
My job experince is not that much since ive spent alot of time in school. though I have worked on a number of companies in a span of two years for my attachment and experince. All this happened during the strike of of lecturers. Firstly, I worked at Sanergy as a fellow for two and a half months as a sofware developer. Since I wasn't skilled enough, I worked under supervision from my mentors. We worked on a plaform called Sales force. As developers, we added company modueles to salesforce for a needs as a company using a language called apex together with SoQL. I also worked for a comapny called Chokom Investment Limited as a system and network administrator. All I did was manage the company's network and maintain systems to be upto date.
I took programming for a number of reasons, like
My current interests are not alot but most of my friends call me a nerd because of what I like. They Include


100% width; irrespective of device width in css pixel
50% width; scales to 100% for small device
50% width; scales to 100% for small device
33.33 width; scales to 100% for medium and small device
33.33 width; scales to 100% for medium and small device
33.33 width; scales to 100% for medium and small device
33.33 width; scales to 100% for medium and small device
66.66 width; scales to 100% for medium and small device


menu
Identify
Home
Home
Logout
Login
Sign up
Plant name
Plant type
Fertilizing Period in days
Watering Period in days
Last watering
Last Fertilizing
File
0%
Create
Cancel


Please complete the following details so we can suggest resources to help your child.
{{checkboxLabels.iep.explanation}}
{{checkboxLabels.disability.explanation}}
{{checkboxLabels.subjects.explanation}}
{{checkboxLabels.actingUp.explanation}}
Next