HSP : Hot Soup Processor ver3.6 / onion software 1997-2021(c)
HSP can hold types such as numeric type and string type as the contents of variables. In this document, I will explain how string types are handled by HSP. The details of each instruction and its application are explained.
By understanding the handling of strings, you should be able to operate strings in more detail. Also, there are parts related to memory management and file handling, so it may be useful to know it. Will come.
First, let's review the basics of handling strings in HSP. A character string is a collection of characters enclosed in "(half-width double quotation marks). HSP uses character strings in all situations such as displaying messages and file names.
For example, mes "TEST MESSAGE"
In the command, the character string "TEST MESSAGE" enclosed in "" "is displayed on the screen.
You can also store a character string in a variable.
For example, if you write a = "TEST MESSAGE"
, the variable a will contain the string "TEST MESSAGE".
It will be remembered. That way, instead of specifying a string like mes a
You can specify the variable name and use the character string stored in the variable as a parameter.
The above is basic, but as an application of this, it is possible to add expressions to strings.
For example, in the command a = "TEST" + "MESSAGE"
, the string "TEST" and
The character string "MESSAGE" is added with "+".
If it is a numerical calculation, it will be added, but if you add the character strings, the character strings will be concatenated.
In other words, the two strings are connected to form the string "TEST MESSAGE".
The only expression that can be used in a character string is addition, but you can connect multiple expressions like a = "ABC" + "DEF" + "GHI"
.
You can, or you can put a variable in between, like a = "ABC" + b + "DEF" + c
. So
a="TEST" b=" AND " c="MESSAGE" print a+b+c
If you do, the contents of the three variables will be concatenated and the string "TEST AND MESSAGE" will appear on the screen. It shows. If this is not a string type variable, but a numeric type variable that stores a numerical value is in the middle What happens if you add them together?
HSP has the following promises.
In other words, it automatically matches the type that is the first term in the formula. So
a="TEST " b=12345 c=" MESSAGE" print a+b+c
Even if there is a numeric type variable like, the display will be "TEST 12345 MESSAGE", which is It is treated as a character string to the last.
How does HSP manage strings? As I said before, a string is a collection of characters of indefinite length. String variables can store an unlimited number of characters as long as memory allows. Here, if you know the relationship between "character string" and "buffer", the handling of character strings will be handled. It will be more refreshing.
HSP manages each character of the character string by handling it as a numerical value called "code". This is because any computer is internally managed numerically. Take a look at the table below.
| Code (decimal) | Code (hexary) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | a | b | c | d | e | f |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 32 | $20 | ! | " | # | $ | % | & | ' | ( | ) | * | + | , | - | . | / | |
| 48 | $30 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | : | ; | < | = | > | ? |
| 64 | $40 | @ | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
| 80 | $50 | P | Q | R | S | T | U | V | W | X | Y | Z | [ | \ | ] | ^ | _ |
| 96 | $60 | ` | a | b | c | d | e | f | g | h | i | j | k | l | m | n | o |
| 112 | $70 | p | q | r | s | t | u | v | w | x | y | z | { | | | } | ~ |
This is called the ASCII code table . Every character has a corresponding number (code). Among them, it is used as standard, ASCII code with only half-width alphabets and symbols extracted ( ASCII : American Standard Code for Information Interchange ) It's called. This is enough in English, but in Japanese there are many other double-byte characters, Each also has a code.
This is not a difficult concept, simply the letter "A" is code 65 (decimal) and "$" is It's just that you can convert it to a number like 36 (decimal number).
The way to read this table is, for example, if it is "@", it will be "64" according to the numerical value in the "code" on the left. After that, it will increase by 1 each time it shifts to the right. In other words, "A" is 65, "B" is 66, and so on. Decimal numbers and hexadecimal numbers are written in the "code" section, but in the computer world, they are hexadecimal numbers. Decimal numbers are fine for HSP, and of course hexadecimal numbers are OK because the delimiters are good. (In HSP, hexadecimal numbers are written with $ at the beginning, such as "$ 48") So "N" is 78 in decimal and $ 6e in hexadecimal. I'm in trouble if I get confused, so here Unless otherwise stated, the code will be treated as a decimal number.
By the way, the space that comes out when you press the space key is code 32. There are other spaces, but they are not normally used.
Now, a string can be thought of as a collection of this code. The code can be a number from 0 to 255. In other words, it can represent 256 types of characters. That's why. However, if you include Japanese kanji, the amount will be enormous, and 256 types are not enough. So, in HSP, Japanese uses two codes, 256 types x 256 types = 65536 types (although not so much). I'm going to use the code.
Japanese characters are called full-width characters, and English characters are called half-width characters. This is because the English characters (ASCII code) are half the size of the Japanese characters. There are various ways to represent Japanese codes, but the one used by HSP is It is called Shift JIS (SJIS). This document also provides explanations based on Shift JIS.
First of all, it is said that "a character string is a line of several codes that represent characters". Remember here. You'll soon see what this helps.
It turns out that the characters can be codes that are represented by numbers from 0 to 255. This number of 256 types is a unit of 1 byte (byte) that often appears in the computer world. Become. A byte is a basic unit for storing a numerical value in the memory of a computer. A number from 0 to 255 can be stored in 1 byte. 1 megabyte of memory When converted to bytes, it is roughly 1,000,000 bytes, which is a very small unit.
The reason why I talked about this kind of hardware is not because I want to make it difficult. This 1 byte, numerical value from 0 to 255, refers to HSP's poke instruction and peek function. I wanted you to remember it.
The poke instruction and peek function are instructions for reading and writing the memory buffer, and what is a character string? I feel unrelated. However, the location where the contents of the variable are also stored It's one of the memory buffers .
This is an important concept that is useful to know. A character string stored in a character string type variable The contents of, numeric variables, and even arrays can be read and written by the peek function and poke instruction. about it. Similarly, all instructions that target the memory buffer (bload instruction and bsave instruction) Can be used for regular variables.
To try here,
a="*" b=peek(a,0) mes "b="+b
Try running the script. The character string "*" assigned to the variable a is stored. One byte is taken out from the buffer and displayed, but the numerical value 42, which is the character code of "*" Has been taken out. In this way, by using the poke command and peek function, the stored character string can be displayed. On the other hand, you will be able to access more finely.
Now let's talk about the details of the detailed access.
There are certain rules for buffers that store strings. First of all, remember this important rule first.
Once you understand these two rules, it doesn't matter how you play with the buffer according to them. There is none. First, suppose you have the following script as a simple example.
a="ABCDE"
When this is done, the buffer that stores the contents of variable a looks like this:
| string | A | B | C | D | E | Exit code |
|---|---|---|---|---|---|---|
| Buffer contents | 65 | 66 | 67 | 68 | 69 | 0 |
The character string "ABCDE" is changed to the numbers "65", "66", "67", "68", "69", and "0" in the buffer. Will be remembered.
The peek function is 1 byte from any place in the buffer, This is an instruction that can retrieve data. According to the help
read 1 byte from peek (p1, p2) buffer p1 = variable: variable name to which the buffer is allocated p2 = 0 ~: Buffer index (in Byte)
So that's why
a="ABCDE" b=peek(a,2)
Then, the code of the character in the third character of the variable a can be read. The reason why it is the third character is that the second parameter of the peek instruction starts from 0 and is 1 byte. Since it is specified for each, if 2 is specified, the code corresponding to the third character is taken out in the order of 0, 1, and 2. Because it is.
On the contrary, the poke instruction is an instruction to write data to the buffer. According to the help
poke p1, p2, p3 Write 1 byte to the buffer p1 = variable: variable name to which the buffer is allocated p2 = 0 ~: Buffer index (in Byte) p3 = 0 to 255: Value to be written to the buffer or character string (in Byte)
So, for example,
a="" poke a,0,65 poke a,1,66 poke a,2,67 poke a,3,0 mes a
If so, the data is sent directly to the buffer even though no string is assigned to the variable a. Because I wrote it, the string "ABC" is remembered.
Don't forget to put 0 at the end as the end code. HSP interprets the contents of the buffer as a string until 0 appears. If you forget 0 Add extra data to the string, or in the worst case, keep memory until you get a general protection error I will continue to read.
You can also take the code that marks this end and do the following:
a="ABCDEF" poke a,3,0 mes a
In this script, the string "ABCDEF" is assigned to the variable a, but after that, the poke command The exit code is written in the middle. As a result, there is an exit code after "ABC" Therefore, the string is judged to be finished there, and only the string "ABC" is displayed.
By understanding how strings work in this way, you can access each character in a string. It will be easier.
There are some points to be aware of when reading or writing in the buffer. You can assign an unlimited number of strings to the variable buffer, but start with a large buffer I can't prepare it. Therefore, reserve a small area at first, and if necessary The area is expanding.
When declaring a character string with the sdim instruction, you can specify the area size to be allocated first. The expansion of the area is done automatically, but if you know that you will use a large string from the beginning, or If you want to use an array with two or more dimensions, it is a good idea to specify it.
However, even if you reserve a 256-byte buffer, you can only use up to 255 characters. This is because we need a place to put the exit code 0 at the end. "Sdim a, 256" is 255 characters + exit code Up to means to secure an area.
The peek function and poke instruction can only be used within the currently reserved area. For example, if you have reserved a 256-byte buffer like "sdim a, 256", Please note that only the range 0-255 is available.
It is not possible to take out a part of the character string as a character code, or conversely make the character code a character string It is convenient to have it at some time. Here are two templates that I often use.
// Example 1: (Retrieve character code) b = peek (a, 0); Assign the first character code of variable a to variable b
// Example 2: (Character code is a string) a="_" b=65 poke a, 0, b; Put the character code of the variable b in the string type variable a
In Example 2, the numerical value assigned to the variable b is written as a character code with the poke instruction. This overwrites the first letter of variable a. Variable a is initially assigned only one character, "_" However, this "_" disappears and it is replaced with a new character code. The ending code (0) at the end of the string is already set with the first "a =" _ "", so You don't have to write it again. With this procedure, the character code is a one-character string type variable. Can be converted to.
For those who use Microsoft N-BASIC, these examples are functions such as ASC and CHR $. Speaking of similar work, it may be easy to understand. Handling character codes is It's usually rare, but it's a good idea to remember it as a quick turn in the event of an emergency.
Let me give you another useful example. If you use the peek function, you can fetch one character anywhere in the string as a code. I can do it. However, it is only the code (numerical value) that is taken out, and the ASCII code table It's a hassle to match up.
"'(Half-width single quotation mark)" is convenient to use in such a case. It is a notation by. It is used by enclosing one character in "'", such as "'A'". This way "'A'" has the same meaning as "65". In other words, it will convert the characters enclosed in "'" into a code. It is. So
a="***TEST" b=peek(a,0) if b ='*': mes "* was there"
Then, you can easily check whether the first character of the variable a is the code of "*". "'" Is similar to "" (double quotes), which deals with strings, but it actually indicates a number. So please do not make a mistake.
Finally, let me review the contents explained here.
It means that. You just need to know this concept and the existence of character codes.
It is a text file that is opened and saved with Notepad or a text editor, HSP can also read and create this text file.
What is a text file? In fact, a text file is a string It's just a file of the contents. As explained so far, the character string stored in the variable is called a code in the buffer in the memory. It is remembered in the form. If you save this content as it is to a file with the bsave instruction, You will have a text file. Conversely, the content of the text file is just a string It is nothing but.
For example
a="TEXT FILE." bsave "test.txt",a
You can also create a text file with the content "TEXT FILE." With a script like. However, with this alone, the file size becomes the same as the buffer size, which is wasteful. I can do it. If you save only the part used as a character string in the file it is perfect. Therefore,
a="TEXT FILE." size=strlen(a) bsave "test.txt",a,size
As shown above, use the strlen function to check the length of the string, and then save only that size. This will result in a text file of the appropriate length.
In the same way, you can also read a text file with the bload command. For example
sdim a,32000 bload "test.txt",a mes a
The script looks like this. The first sdim instruction is a text file to read Since it may be large, we have secured a buffer for about 32000 characters. This is 32000 bytes It is possible to read up to the file. Read the text file with the bload command and Finally, the contents are displayed with the mes command.
Since the buffer is initialized as a character string type variable with the sdim instruction, the buffer is used with the mes instruction. Simply display the content as a string. The text file read into the buffer is also Since it is the same as a character string, it will be displayed properly as it is.
I've said that a text file is a file of a buffer of string variables, Actually, there is only one difference. It doesn't contain code 0 at the end of the string That is the point. This means that the size saved in the file is the size of the string So you don't need the code to mark the end. (However, the exit code is also included in the text file for clarity in some text editors. There is something that will put you in. But this is a code called [EOF], not 0, It will be 26. )
If you can read a text file with HSP, you need to put 0 at the end, but it is as it is It is usable. There is a deep reason for this.
The reason is that, like the sdim instruction, the contents are all immediately after the variable buffer is allocated. It is cleared at 0. A text file that does not contain an exit code in this buffer Even if it is read, the end code 0 is always included in the continuation of the read data.
It wasn't that deep. Therefore, in the buffer where the text file has been read once, When I read another text file again, it was smaller than the previous text file In that case, the previous data will remain. To prevent this, be sure to use the sdim instruction to buffer the text file before reading it. You need to secure it and clear it with 0.
In fact, there is a simpler way to read a text file. If you use a mechanism called "memory notepad instruction", you don't have to worry about the size or the end code. It can handle text files. We'll see how to do this later.
Character strings handled by HSP are roughly divided into simple character strings with only one line and character strings containing multiple lines. can do. There is no particular difference in processing between the two. Simply script It's just something that the creator should be aware of.
A multi-line string is a string that contains line breaks. A line break is the next line after that. It's like a sign to take. as a trial,
a="ABC\nDEF" mes a
When I run the script,
ABC DEF
The message is displayed across the two lines. This is because the variable a contains a newline sign "\\ n".
Until now, characters have codes and are stored in the buffer in the form of numbers. As I said, what about line breaks? In the script given in the above example, the contents of variable a are in the buffer,
| string | A | B | C | \n | D | E | F | Exit code | |
|---|---|---|---|---|---|---|---|---|---|
| Buffer contents | 65 | 66 | 67 | 13 | 10 | 68 | 69 | 70 | 0 |
Contains the data. "\\ N" indicates a line break, but that part is "13" and "10". There are two codes. And this is exactly the "line feed code". Line feed code cannot be entered from the keyboard, so in HSP, use the character "\\ n" instead. I try to represent it, but in reality, there are two codes "13" and "10" in the character string. It is placed.
The trouble is that there are several dialects for line feed codes. "13" "10" on MS-DOS and Windows However, it is only "13" on MacOS of Macintosh. Also, in UNIX, it is set to "10". It has become. In HSP, as a line feed code, in addition to MS-DOS and Windows "13" and "10", It also supports MacOS "13" only, but does not support UNIX line feed codes. In the first place, the Japanese code is different in many UNIX, so you can use a converter to DOS format etc. It's a good idea to convert the entire text in advance.
The inclusion of a line feed code makes the string very convenient, but adds complexity. The text file will of course have a lot of lines with line breaks and You can also insert line breaks in the input box with the HSP mesbox instruction. In addition, the line feed code is also included in the character string used in the dirlist instruction, listbox instruction, and combox instruction. is. By inserting a line feed code, you can organize a lot of information, but on the other hand, Handling as a character string becomes more and more difficult.
Therefore, in HSP, a line feed code is set by a series of instruction sets called memory notepad instructions. It makes it relatively easy to handle the included character string. Text with multiple lines The problem when dealing with it is when you want to check something line by line, or when you want to check the character string line by line. If you want to operate it. In this line-by-line work, if you divide it into two processes Work is refreshing. In other words
In this way, from the character string data of multiple lines, a character string that does not include the line feed code of only one line can be obtained. If the procedure is to take it out, work on it, and then return the result again, the line feed code It eliminates the need for troublesome checks and improves efficiency.
The instruction set for that is the memory notepad instruction. It consists of the following instructions:
| Instructions | Main Functions | Remarks |
|---|---|---|
| notesel | Specify variables to be treated as memory notepads | |
| notemax | Get the total number of lines | Use as a system variable |
| notesize | Get the entire size | Use as a system variable |
| noteload | Read text file | |
| notesave | Export text file | |
| noteadd | Add content to specified line | Insert / overwrite mode available |
| noteget | Read the contents of the specified line | |
| notedel | Delete specified line | |
| notefind | String search |
There are many instructions, but it's not difficult to use. Basically, first specify the variable name to be the target of the character string operation with the notesel instruction. Then, if you want to read one line, use the noteget command, and if you want to change or add the contents of the line, use the noteget command. Use the noteadd instruction.
For example, a variable a that contains a string with multiple lines, on the first line If you want to retrieve the string,
a="ABC\nDEF" notesel a noteget b,0 mes b
It looks like. At this time, what you have to be careful about is specified by the note get instruction. The row index starts at 0, which means that the first row is specified as 0. And, in detail, the noteget instruction always sets the variable to be read to the string type. In the above example, even if the variable b is a numeric type, after executing the noteget instruction, It means that it will be a character string type.
Efficient processing for all lines by using notemax and repeat ~ loop instructions Can be described. For example
a="ABC\nDEF\nGHI" notesel a repeat notemax noteget b,cnt mes "["+b+"]" loop
In this script, the contents of all lines of variable a are displayed in parentheses. notemax can be used as a system variable to find out how many rows there are and return it to a variable. Loop with the repeat ~ loop instruction as many times as you check here. During this loop Since the system variable cnt increases in order from 0, read it with the note get instruction. If you use the system variable cnt to specify the row index, you can retrieve each row in turn.
It is also possible to handle text files with the memory notepad instructions. The noteload command is used when reading a text file. The notesave instruction is used to save a text file. For example
a="ABC\nDEF\nGHI" notesel a notesave "a.txt"
In this script, the content assigned to the variable a is used as a text file named "a.txt". you save. It's easy.
Conversely, when reading a text file into a variable, use it as follows.
notesel a noteload "a.txt" mes a
The noteload instruction loads the specified file into the variable specified by the notesel instruction. The exit code of the end of the string and the buffer area of the variable are also automatically taken into consideration.
HSP has some instructions and functions to handle strings conveniently. Here, we will introduce the instr function for searching and the strmid function for extracting a part of the character string. If you read this document, you can see that the same process can be achieved with the peek function and poke instruction. As you can see, it's decided that the function should be supported from the beginning, isn't it?
First, the strmid function looks like this:
strmid (p1, p2, p3) Extract a part of the string p1 = variable name: variable name that stores the character string to be retrieved p2 = 0 to (0): Index at the beginning of retrieval p3 = 0 ~ (0): Number of characters to extract
If you have used Microsoft N-BASIC, you can retrieve the character string. You may remember that there were three functions, LEFT $, RIGHT $, and MID $. These are "n characters from the left", "n characters from the right", and "n2 characters from the n1st character" of the character string, respectively. Was to take out and return its contents, but the strmid function has three functions. It is a combined command.
Specify the variable name that stores the original character string to be retrieved in p1
Character index to start fetching with p2 (starting from 0), number of characters to fetch with p3
It is to specify. It should be noted that the p3 character index is
The first character is 0, the second character is 1 ..., and so on.
Now, for example, if you want to retrieve a part of variable a
When extracting "n characters from the left", it becomes strmid (a, 0, n)
.
In the case of "n characters from the right", it becomes strmid (a, -1, n)
.
"N1 to n2 characters" becomes strmid (a, n1-1, n2)
.
The other is to check if the specified string is included in the string. The instr function. This is in help
instr (p1, p2, "string") Search for strings p1 = variable name: Character string type variable name that stores the character string to be searched p2 = 0 to (0): Index to start searching "string": Search string
It is like that. Check if there is a character string specified by "string" in the character string type variable specified by p1. Returns the character index. Note that the result is a number. In the character index The first character at the beginning of the character string is set to 0, and the number increases in order of 1, 2, 3 ... (Similar to the index specified by the strmid function). If not found, -1 is substituted.
You can also specify the character index to start looking at on p2 (skip the specification). If you do, it will start from (0) at the beginning). In this case, the search results will be indexed from where you started looking. be careful. It is no longer the index from the beginning of the string.
In addition to this, the following functions are provided as standard. For details, refer to the instruction help for each.
| Keywords | Functions |
|---|---|
| getstr | Read string from buffer |
| getpath | Get part of the path |
| strf | Convert to formatted string |
| strtrim | Remove only specified characters |
| split | Substitute the element split from the string |
| strrep | Replace a specific string |
| cnvwtos | Convert unicode to regular string |
| cnvstow | Convert normal strings to unicode |
What I have explained so far is a half-width character string for the time being. It's about the characters in the ASCII code table. All the commands related to character string operations prepared by HSP are in half-width characters. There is no problem if the character string to be handled is only English characters.
However, it gets a little tricky if it contains Japanese double-byte characters. As I said before, Japanese cannot be expressed in 1 byte (256 types), so It is expressed using 2 bytes. In other words, two English characters are equivalent to one Japanese character. But these can be mixed Therefore, there are some complicated rules. The rules are as follows.
In other words, only when the numerical value of the code is within a certain range, we have created a special rule that makes one for two characters. This is a valid rule on Windows and MS-DOS, with text brought from other operating systems and the internet. It may not work.
Such Japanese character codes are usually called "Shift JIS codes". Japanese is, Since 2 bytes are 1 character, if you want to retrieve the Japanese character code, either perform the peek function twice or You need to use the wpeek function. However, the wpeek function is "$ 81" and "$ 24" (each in hexadecimal). If there is a 2-byte code, reverse the 2-byte code, such as "$ 2481" (hexabyte). Please note that it will be a single number.
As such, handling Japanese codes is a bit more difficult than English characters. However, if you put restrictions such as not mixing English characters and Japanese, it will always be 1 character in 2 bytes. It will be a rule and will be easier when extracting characters and checking the length.
Recently, Japanese character strings are increasingly handled in unicode format. HSP can handle unicode (UTF-8) format by HSPUTF runtime. However, many text files that have been handled in Windows for a long time are still in Shift JIS. Since it is not compatible with unicode, it is desirable to use it properly depending on the situation. (In environments such as android, iOS, Linux, html5, unicode (UTF-8) format is used as standard.)
In this document, you can work with strings more finely and efficiently by understanding how strings work. I've explained how to do it.
Approach to strings without line feed code and add memory notepad instructions to it By doing so, I think that even a character string that spans multiple lines can be processed efficiently. I hope this document will make that task a little easier.


Internationalization¶
New in version 1.1.
Complementary to translations provided for Sphinx-generated messages such as navigation bars, Sphinx provides mechanisms facilitating document translations in itself. See the Options for internationalization for details on configuration.
Sphinx internationalization details¶
gettext [1] is an established standard for internationalization and localization. It naively maps messages in a program to a translated string. Sphinx uses these facilities to translate whole documents.
Initially project maintainers have to collect all translatable strings (also
referred to as messages) to make them known to translators. Sphinx extracts
these through invocation of sphinx-build -b gettext
.
Every single element in the doctree will end up in a single message which results in lists being equally split into different chunks while large paragraphs will remain as coarsely-grained as they were in the original document. This grants seamless document updates while still providing a little bit of context for translators in free-text passages. It is the maintainer’s task to split up paragraphs which are too large as there is no sane automated way to do that.
After Sphinx successfully ran the
MessageCatalogBuilder
you will find a
collection of .pot
files in your output directory. These are catalog
templates and contain messages in your original language only.
They can be delivered to translators which will transform them to .po
files
— so called message catalogs — containing a mapping from the original
messages to foreign-language strings.
Gettext compiles them into a binary format known as binary catalogs through msgfmt for efficiency reasons. If you make these files discoverable with :confval:`locale_dirs` for your :confval:`language`, Sphinx will pick them up automatically.
An example: you have a document usage.rst
in your Sphinx project. The
gettext builder will put its messages into usage.pot
. Imagine you have
Spanish translations [2] on your hands in usage.po
— for your builds to
be translated you need to follow these instructions:
Compile your message catalog to a locale directory, say
locale
, so it ends up in./locale/es/LC_MESSAGES/usage.mo
in your source directory (wherees
is the language code for Spanish.)msgfmt "usage.po" -o "locale/es/LC_MESSAGES/usage.mo"
Set :confval:`locale_dirs` to
["locale/"]
.Set :confval:`language` to
es
(also possible via-D
).Run your desired build.
Translating with sphinx-intl¶
Quick guide¶
sphinx-intl is a useful tool to work with Sphinx translation flow. This section describe an easy way to translate with sphinx-intl.
Install sphinx-intl by pip install sphinx-intl or easy_install sphinx-intl.
Add configurations to your conf.py:
locale_dirs = ['locale/'] # path is example but recommended. gettext_compact = False # optional.
This case-study assumes that :confval:`locale_dirs` is set to ‘locale/’ and :confval:`gettext_compact` is set to False (the Sphinx document is already configured as such).
Extract document’s translatable messages into pot files:
$ make gettext
As a result, many pot files are generated under
_build/gettext
directory.Setup/Update your locale_dir:
$ sphinx-intl update -p _build/gettext -l de -l ja
Done. You got these directories that contain po files:
- ./locale/de/LC_MESSAGES/
- ./locale/ja/LC_MESSAGES/
Translate your po files under ./locale/<lang>/LC_MESSAGES/.
make translated document.
You need a :confval:`language` parameter in
conf.py
or you may also specify the parameter on the command line:$ make -e SPHINXOPTS="-D language='de'" html
Congratulations! You got the translated documentation in the _build/html
directory.
New in version 1.3: sphinx-build that is invoked by make command will build po files into mo files.
If you are using 1.2.x or earlier, please invoke sphinx-intl build
command
before make command.
Translating¶
Translate po file under ./locale/de/LC_MESSAGES
directory.
The case of builders.po file for sphinx document:
# a5600c3d2e3d48fc8c261ea0284db79b
#: ../../builders.rst:4
msgid "Available builders"
msgstr "<FILL HERE BY TARGET LANGUAGE>"
Another case, msgid is multi-line text and contains reStructuredText syntax:
# 302558364e1d41c69b3277277e34b184
#: ../../builders.rst:9
msgid ""
"These are the built-in Sphinx builders. More builders can be added by "
":ref:`extensions <extensions>`."
msgstr ""
"FILL HERE BY TARGET LANGUAGE FILL HERE BY TARGET LANGUAGE FILL HERE "
"BY TARGET LANGUAGE :ref:`EXTENSIONS <extensions>` FILL HERE."
Please be careful not to break reST notation. Most po-editors will help you with that.
Update your po files by new pot files¶
If a document is updated, it is necessary to generate updated pot files and to apply differences to translated po files. In order to apply the updating difference of a pot file to po file, use the sphinx-intl update command.
$ sphinx-intl update -p _build/locale
Using Transifex service for team translation¶
Transifex is one of several services that allow collaborative translation via a web interface. It has a nifty Python-based command line client that makes it easy to fetch and push translations.
Install transifex-client
You need tx command to upload resources (pot files).
$ pip install transifex-client
Create your transifex account and create new project for your document
Currently, transifex does not allow for a translation project to have more than one version of the document, so you’d better include a version number in your project name.
For example:
Project ID: sphinx-document-test_1_0
Project URL: https://www.transifex.com/projects/p/sphinx-document-test_1_0/
Create config files for tx command
This process will create
.tx/config
in the current directory, as well as a~/.transifexrc
file that includes auth information.$ tx init Creating .tx folder... Transifex instance [https://www.transifex.com]: ... Please enter your transifex username: <transifex-username> Password: <transifex-password> ... Done.
Upload pot files to transifex service
Register pot files to
.tx/config
file:$ cd /your/document/root $ sphinx-intl update-txconfig-resources --pot-dir _build/locale \ --transifex-project-name sphinx-document-test_1_0
and upload pot files:
$ tx push -s Pushing translations for resource sphinx-document-test_1_0.builders: Pushing source file (locale/pot/builders.pot) Resource does not exist. Creating... ... Done.
Forward the translation on transifex
Pull translated po files and make translated html
Get translated catalogs and build mo files (ex. for ‘de’):
$ cd /your/document/root $ tx pull -l de Pulling translations for resource sphinx-document-test_1_0.builders (...) -> de: locale/de/LC_MESSAGES/builders.po ... Done.
Invoke make html:
$ make -e SPHINXOPTS="-D language='de'" html
That’s all!
Tip
Translating locally and on Transifex
If you want to push all language’s po files, you can be done by using tx push -t command. Watch out! This operation overwrites translations in transifex.
In other words, if you have updated each in the service and local po files, it would take much time and effort to integrate them.
Contributing to Sphinx reference translation¶
The recommended way for new contributors to translate Sphinx reference is to join the translation team on Transifex.
There is sphinx translation page for Sphinx-1.3 documentation.
- Login to transifex service.
- Go to sphinx translation page.
- Click
Request language
and fill form. - Wait acceptance by transifex sphinx translation maintainers.
- (after acceptance) translate on transifex.
Footnotes
| [1] | See the GNU gettext utilities for details on that software suite. |
| [2] | Because nobody expects the Spanish Inquisition! |


With our exhibition Art and Appetite, we invite you to feast your eyes on the rich tradition of food and drink in American art with over 100 paintings, sculptures, and decorative arts from the 18th century to the 20th century. Continue the celebration of delectable edibles in your kitchen with our online cookbook featuring vintage American recipes featured in the exhibition as well as some scrumptious new offerings from Chicago's top culinary talent.


Watch for the Plot
The idea for a competition platform similar to fantasy football but for the movie and TV show genre started in the HelloWorld 2018 Hackathon at Purdue University. We decided that there was a market of individuals just itching for the ability to compete among themselves for which of their theories were best. After all, when there is a record of your victory, it is that much sweeter to Watch for the Plot for next time.
Submit predictions in a format of competition of leagues. Even be an administrator of a league, where you decide the movie or TV show! From there, submit futures at your will, but always remember, the other members in your league will be reviewing your submissions for plausibility, so always think your futures out in detail! Then, we'll have you choose which futures you want from your favorite to your most hated, and we'll have a draft night to assign your predictions. Make your trades, submit more predictions, and motion for draft nights before the dead zone, because we will assign points based on whether your predictions were true!


{{firstName}}
{{firstName}} {{lastname}}
Pass Names
{{firstName}} {{middleName}} {{lastName}}
Push
Pull
Value of X is {{x}} and Value of Y is {{y}}


Slider
You can see three sliders.
Clicking and dragging on the circle changes the value of the slider.
Horizontal Slider
You can see seven horizontal sliders.
The sliders look and work correctly.
You can define standalone sliders, which work more like widgets (i.e. they don't use d3 data binding). This is done by not setting the 'key' property
You can set the 'exponent' property on the slider, which makes it a non linear scale, following d3.scale.pow().


_Dinosaur_ (PG) *** (out of ****)
_Dinosaur_ marks another advancement for Walt Disney Pictures' animation division. It is the first computer-animated feature from the Mouse to be produced entirely in-house, as opposed to their hit collaborations with the Pixar animation studio. The film also convincingly blends CGI characters with live action backdrops. With such innovation on display, it's unfortunate that the makers of _Dinosaur_ couldn't find a more interesting story to tell.
_Dinosaur_'s story is typical of Disney's traditionally animated features, where a young protagonist comes of age. Here it is the young iguanodon Aladar (voiced by D.B. Sweeney), who is raised by a loving family of lemurs after his egg is displaced (in a truly spectacular wordless opening sequence). Aladar's pleasant life with foster caregivers Yar (Ossie Davis) and Plio (Alfre Woodard) is violently interrupted when a meteorite destroys their island home, and they and young lemurs Zini (Max Casella) and Suri (Hayden Panettiere) find themselves with a herd of dinos braving battering heat and a lack of water to make it to their lush nesting ground.
That's the entire film--the dinosaurs making their long trek to the nesting ground, with Aladar coming into his own while bonding with budding love interest Neera (Julianna Margulies) as well as old dinos Eema (Della Reese) and Baylene (Joan Plowright), and butting heads with the group's leader Kron (Samuel E. Wright), who sees no fault with letting the weak in the pack get lost and/or die. There are some good, thrilling set pieces, namely those involving the ravenous carnotaurs who stalk the pack. But they are just pieces in the larger puzzle that is Aladar's coming of age, a tale that Disney has told in more entertaining and emotionally satisfying ways in films past.
However, Disney hasn't told the tale in such a visually striking way. The seamless compositing of the CGI creatures with the live action settings has a lot to do with the nearly photo-real quality of the computer effects. The textures, from Aladar's scaly skin to the fur of the lemurs, are remarkably lifelike and meticulously detailed. The creatures also move convincingly like dinosaurs; the dinosaurs' ability to speak aside, the film feels like an authentic recreation of life during the cretaceous.
Perhaps that's why that opening sequence, in which Aladar's egg is removed from its nest and dropped onto the lemur island, is _Dinosaur_'s big highlight. Told without a single spoken word, it is so compelling because it feels so real. When the speech and the familiar story kick in, the film feels less so--and, hence, less fresh. _Dinosaur_ is indeed a sight to behold--and one well worth paying the full movie ticket price to see--but it could've been a more nourishing feast for the mind.
Michael Dequina<EMAIL_ADDRESS>|<EMAIL_ADDRESS>|<EMAIL_ADDRESS>|<EMAIL_ADDRESS>Mr. Brown's Movie Site: http://welcome.to/mrbrown CinemaReview Magazine: http://www.CinemaReview.com on ICQ: #25289934 | on AOL Instant Messenger: MrBrown23
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


No technical experience required! Make your free website with our easy drag & drop functionality. Everything you need is at your fingertips.
Get under the hood. Advanced users can easily edit images online, as well as add HTML, Javascript, and sitewide CSS.
Choose from hundreds of professionally designed and fully customizable styles. Make it your own by adding photos, videos, maps, forms and much more.
Start with a free website, and select the premium features you need as your business grows. With Our website
SExpand your reach by publishing your website to mobile phones, Facebook, and the web. Edit in one place, and publish everywhere.


StudyBuddy
A suite of tools for increasing study productivity
Upload
(.png, .jpg, .pdf, .docx, .txt, .wav, .mp3)
Select a file to upload to either translate, perform tone analysis, use text to speech, or create a text summary.
Or enter text here.
Record Speech
Submit
Output here:
Translate
Tone Analysis
Text2Speech
Text Summary


jsonurl-factory
package provides an extensible
JSON→URL
parser core and an implementation based on Java SE datatypes.
The Parser interface defines a generic JSON→URL object model parser and JsonUrlParser provides an implementation based Java SE data types (e.g. Map, List, etc). There are additional modules, distributed as separate artifacts, which implement JSON→URL parsers based on other APIs (json.org API, JSR-374 API).
Here's a simple example of parsing JSON→URL text into a Java Map.
import java.util.Map; import org.jsonurl.j2se.JsonUrlParser; JsonUrlParser p = new JsonUrlParser(); Map myObject = p.parseObject( "(Hello:World)" ); System.out.println(obj.get("Hello")) // World
The parser is designed to parse untrusted input. It supports limits on the number of parsed values and depth of nested arrays or objects. When the limit is exceeded a LimitException is thrown. Reasonable limit values are set by default.


int n = 5.seconds; // n is 5000 because 5 seconds are 5000 milliseconds
StopWatch sw; sw.wait(5.seconds);
int n = 5.minutes; // n is 300_000 because 5 minutes are 300 seconds are 300_000 milliseconds
StopWatch sw; sw.wait(5.minutes);


Tope Way School
[60, 20]
|
the Ha Monument
[61, 20]
|
Club Scanlon
[62, 20]
|
Gleed Walk
[63, 20]
|
Langrishe Street
[64, 20]
|
Roft Park
[65, 20]
|
a factory
[66, 20]
|
Veryard Crescent
[67, 20]
|
the Vicari Building
[68, 20]
|
wasteland
[69, 20]
|
the Bogie Building
[60, 21]
|
Belgrave Library
[61, 21]
|
the Passley Building
[62, 21]
|
a warehouse
[63, 21]
|
Tett Road
[64, 21]
|
a junkyard
[65, 21]
|
Morriss Way
[66, 21]
|
a junkyard
[67, 21]
|
Keen Park
[68, 21]
|
James Street School
[69, 21]
|
Peppe Street
[60, 22]
|
Solomon Lane Police Dept
[61, 22]
|
Notley Walk Fire Station
[62, 22]
|
St Wolfeius's Church
[63, 22]
|
the Hanna Monument
[64, 22]
|
a junkyard
[65, 22]
|
Haggett Place
[66, 22]
|
Adolphy Row Railway Station
[67, 22]
|
a warehouse
[68, 22]
|
Greenaway Way School
[69, 22]
|
Riddick Plaza
[60, 23]
|
the Plowright Building
[61, 23]
|
the Hippisley Museum
[62, 23]
|
the Hanson Museum
[63, 23]
|
the Eadie Building
[64, 23]
|
Benjamin Alley
[65, 23]
|
the Muttlebury Arms
[66, 23]
|
the Scaife Building
[67, 23]
|
Tompsett Walk
[68, 23]
|
wasteland
[69, 23]
|
the Sellar Building
[60, 24]
|
the Ingham Hotel
[61, 24]
|
Club Aisthorpe
[62, 24]
|
Monks Avenue
[63, 24]
|
Pask Crescent School
[64, 24]
|
the Amos Building
[65, 24]
|
wasteland
[66, 24]
|
Club Gapper
[67, 24]
|
St Marcus's Church
[68, 24]
|
Wolters Square
[69, 24]
|
the Horner Monument
[60, 25]
|
Club Robson
[61, 25]
|
the Swears Museum
[62, 25]
|
Hutchins Lane
[63, 25]
|
Labarte Library
[64, 25]
|
Heward Square
[65, 25]
|
a factory
[66, 25]
|
Barnete Street
[67, 25]
|
a cemetery
[68, 25]
|
Wallace Grove
[69, 25]
|
Daubeny Road
[60, 26]
|
the Henry Building
[61, 26]
|
St Birinus's Church
[62, 26]
|
the Tompkins Building
[63, 26]
|
Humphreys Library
[64, 26]
|
Rollinson Lane
[65, 26]
|
Parry Drive Fire Station
[66, 26]
|
Bohin Avenue
[67, 26]
|
Club Lambe
[68, 26]
|
wasteland
[69, 26]
|
the Organ Museum
[60, 27]
|
Bourne Avenue
[61, 27]
|
Springford Avenue Railway Station
[62, 27]
|
Fir Street
[63, 27]
|
Michell Avenue
[64, 27]
|
Schandua Bank
[65, 27]
|
Highton Place
[66, 27]
|
Woodward Lane
[67, 27]
|
the Carder Building
[68, 27]
|
Gyllet Drive
[69, 27]
|
Stretchbury Cinema
[60, 28]
|
Baxter Boulevard School
[61, 28]
|
a carpark
[62, 28]
|
Robbins Place
[63, 28]
|
Geddes Plaza
[64, 28]
|
the Spare Motel
[65, 28]
|
Eford Way
[66, 28]
|
the Howlett Building
[67, 28]
|
Essell Plaza Railway Station
[68, 28]
|
St Joachim's Church
[69, 28]
|
Club Dodds
[60, 29]
|
the Roode Building
[61, 29]
|
Kirby Boulevard Police Dept
[62, 29]
|
Thurlow Drive Railway Station
[63, 29]
|
Hammond Library
[64, 29]
|
St Elisabeth's Church
[65, 29]
|
the Horder Motel
[66, 29]
|
the Maitland Building
[67, 29]
|
Club Bucke
[68, 29]
|
the Chetwind Arms
[69, 29]
|
|
Menu
City Map
Find Location
Route Finder
World View
Map Mirror
|


Firmware:
32-bit
64-bit
detect
Jailbreak
Downgrade
Can i
jailbreak
?
Jailbreak
available for that firmware:


Mandor Mountains [aw29], mountain, in Mandoria, peasants: 203
Last updated Turn #140
Mandor Mountains [aw29], mountain, in Mandoria, peasants: 203
------------------------------------------------------------------------
3: General Kraken [k3k], Imperial Empire, duke, priest of the Church of
3: Halon [157], with two winged horses, 44 nazgul, arrived from the west,
3: accompanied by:
3: Phantom III [d6x], Imperial Empire, priest of the Church of
3: Dol [153], with 14 nazgul
3: Veejay [v8j], Imperial Empire, Bishop of the Church of Ham [155],
3: with five angels
3: Goon III [b9v], Imperial Empire, Bishop of the Church of Dol [153],
3: with five angels, 54 hvy. xbowmen, 17 nazgul
3: Lord Rodrigo Bane [c8b], Imperial Empire, priest of the Church of
3: Dol [153], with ten workers, 50 hvy. xbowmen, 16 nazgul
3: Licia [i1l], Imperial Empire, Bishop of the Church of Ham [155],
3: with five angels, 50 hvy. xbowmen
3: Odin [y5z], Imperial Empire, with 35 peasants, 15 soldiers, 55 hvy.
3: xbowmen
3: Thorg [j8u], Imperial Empire, with one warmount
3: Jupiter [m8j], Imperial Empire, duke, the High Priest of the Church
3: of Halon [157], with 35 peasants, 13 soldiers, ten angels,
3: two skirmishers, 52 hvy. xbowmen
3: Dryeth [q4e], Imperial Empire, priest of the Church of Dol [153],
3: with 15 nazgul
3: Firefly [f3f], Imperial Empire, priest of the Church of
3: Halon [157], with 50 hvy. xbowmen
3: Sunwalker [a8x], Imperial Empire, duke, Bishop of the Church of
3: Halon [157], with five angels, 52 nazgul
3: Thomas [o5y], Imperial Empire, priest of the Church of Dol [153],
3: with 52 hvy. xbowmen, five nazgul
3: Alexei Galantor [j7l], Imperial Empire, duke, priest of the Church
3: of Halon [157], with 35 peasants, 84 nazgul
3: Sir Peter [u9p], Imperial Empire, with 30 peasants, 20 workers,
3: ten hvy. xbowmen
3: George [p7f], Imperial Empire, duke, priest of the Church of
3: Dol [153], with eight nazgul
3: Lucca [h0t], Imperial Empire, priest of the Church of Halon [157],
3: with one skirmisher, 50 nazgul
3: Johny [w2d], Imperial Empire, priest of the Church of Halon [157],
3: with 41 nazgul
3: Stefano [t8e], Imperial Empire, Bishop of the Church of
3: Halon [157], with 30 peasants, five angels, 48 nazgul
3: Sir Charles [j5r], Imperial Empire, priest of the Church of
3: Halon [157], with 30 peasants, 49 nazgul
3: Majikthise [n4g], Imperial Empire
3: City boy [c5x], Mandor Confederacy, prisoner
3: swift [e6w], Mandor Confederacy, prisoner
3: Green Yobos [a6g], Mandor Confederacy, prisoner
3: Aurora [g5z], Mandor Confederacy, prisoner
3: Everblack [n3r], Mandor Confederacy, prisoner
4: General Kraken [k3k], Imperial Empire, duke, priest of the Church of
4: Halon [157], with two winged horses, 44 nazgul, went east,
4: accompanied by:
4: Phantom III [d6x], Imperial Empire, priest of the Church of
4: Dol [153], with 14 nazgul
4: Veejay [v8j], Imperial Empire, Bishop of the Church of Ham [155],
4: with five angels
4: Goon III [b9v], Imperial Empire, Bishop of the Church of Dol [153],
4: with five angels, 54 hvy. xbowmen, 17 nazgul
4: Lord Rodrigo Bane [c8b], Imperial Empire, priest of the Church of
4: Dol [153], with ten workers, 50 hvy. xbowmen, 16 nazgul
4: Licia [i1l], Imperial Empire, Bishop of the Church of Ham [155],
4: with five angels, 50 hvy. xbowmen
4: Odin [y5z], Imperial Empire, with 35 peasants, 15 soldiers, 55 hvy.
4: xbowmen
4: Thorg [j8u], Imperial Empire, with one warmount
4: Jupiter [m8j], Imperial Empire, duke, the High Priest of the Church
4: of Halon [157], with 35 peasants, 14 soldiers, ten angels,
4: one skirmisher, 52 hvy. xbowmen
4: Dryeth [q4e], Imperial Empire, priest of the Church of Dol [153],
4: with 15 nazgul
4: Firefly [f3f], Imperial Empire, priest of the Church of
4: Halon [157], with 50 hvy. xbowmen
4: Sunwalker [a8x], Imperial Empire, duke, Bishop of the Church of
4: Halon [157], with five angels, 52 nazgul
4: Thomas [o5y], Imperial Empire, priest of the Church of Dol [153],
4: with 52 hvy. xbowmen, five nazgul
4: Alexei Galantor [j7l], Imperial Empire, duke, priest of the Church
4: of Halon [157], with 35 peasants, 84 nazgul
4: Sir Peter [u9p], Imperial Empire, with 30 peasants, 20 workers,
4: ten hvy. xbowmen
4: George [p7f], Imperial Empire, duke, priest of the Church of
4: Dol [153], with eight nazgul
4: Lucca [h0t], Imperial Empire, priest of the Church of Halon [157],
4: with one skirmisher, 50 nazgul
4: Johny [w2d], Imperial Empire, priest of the Church of Halon [157],
4: with 41 nazgul
4: Stefano [t8e], Imperial Empire, Bishop of the Church of
4: Halon [157], with 30 peasants, five angels, 48 nazgul
4: Sir Charles [j5r], Imperial Empire, priest of the Church of
4: Halon [157], with 30 peasants, 49 nazgul
4: Majikthise [n4g], Imperial Empire
4: City boy [c5x], Mandor Confederacy, prisoner
4: swift [e6w], Mandor Confederacy, prisoner
4: Green Yobos [a6g], Mandor Confederacy, prisoner
4: Aurora [g5z], Mandor Confederacy, prisoner
4: Everblack [n3r], Mandor Confederacy, prisoner
9: Band of thieves [ei4b], bandits, number: 40, went east.
14: Lisa [m7c], refugee, arrived from the north.
18: Lisa [m7c], refugee, went west.
21: Stack of savages [gk7k], savages, number: 27, went east.
22: Stack of savages [af9b], savages, number: 10, arrived from the west.
24: Stack of savages [af9b], savages, number: 10, went east.
27: New noble [w1d], refugee, arrived from the east.
30: The population grows by one peasant.
Routes leaving Mandor Mountains:
North, mountain, to Mandor Mountains [av29], 10 days
East, plain, to Plain of Tears [aw30], 7 days
South, to Ocean [ax29], The Inner Sea, impassable
West, mountain, to Mandor Mountains [aw28], 10 days
Inner locations:
An Orc Stronghold [q36], orc-stronghold, defense 25, owner:
Stack of orcs [bg1f], orcs, number: 494
Seen here:
New noble [w1d], refugee


NIIT University,Neemrana Rajasthan
B.Tech in Computer Science Engineering (2018-2022)
Marketing | Operations
Experienced leader, executive and project manager with demonstrated ability to successfully lead groups , effectively manage projects, drive projects, develop associates, improve quality, enhance productivity and meet service level agreements.
B.Tech in Computer Science Engineering (2018-2022)
Python, Web Development – HTML CSS & JavaScript, Office Suite , Email Marketting , Github , Linux
Public Speaking ,Leadership , Conflict management , Organization , Decision-making , People management , Data entry skills , Reporting skills ,Deadline-oriented
A front-end website to show a personal portfolio, built using HTML, CSS and Javascript
An Android application that can be used to guide new comers in NIIT University. The app shall be developed using flutter.
An android application that notifies you of the location of various potholes around the city. The same app can be used to report a pothole for the well-being of all the citizens.
A Research on Nano Circuits. My Role Being a Projects and Operations Manager , I have organized and collaborated our group with Company Executives to reach our research targets .
Have managed SINUSOID : A Tech Fest being an Operations Manager and Security Team Head . This event helped me to understand working with people having various mindsets .
I would love to hear from you, connect with me!!


Overview
Package
Class
Use
Tree
Deprecated
Index
Help
kool-parent 0.1.27 Reference
Prev
Next
Frames
No Frames
All Classes
Package org.davidmoten.kool.internal.operators.maybe
Class Summary
Class
MaybeDefer
MaybeDoOnEmpty
MaybeDoOnError
MaybeDoOnValue
MaybeError
MaybeFilter
MaybeFlatMap
MaybeFlatMapMaybe
MaybeFromCallable
MaybeIsPresent
MaybeIterator
MaybeMap
MaybeOrElse
MaybeSwitchOnError
MaybeToStream
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
kool-parent 0.1.27 Reference
Prev
Next
Frames
No Frames
All Classes


Wear of Truck parts
Wear of the engine accessory as <0;1>
Wear of the transmission accessory as <0;1>
Wear of the cabin accessory as <0;1>
Wear of the chassis accessory as <0;1>
Average wear across the wheel accessory as <0;1>


Notation Used in This Book
C code is set in Arial font, like this: for(I = 0;I<10;I++)p[I] = q;
J code is set in Courier New font, like this: p =. 10 $ q
When J and C use different words for the same idea, the J word is used. The first few times, the C word may be given in parentheses, in Arial font: verb (function). When a word is given a formal definition, it is set in bold italics: verb.
To describe the elements of programming, J uses a vocabulary that will be familiar, though possibly frightening: the vocabulary of English grammar. We will speak of nouns, verbs, and the like. Don't worry, you're not going to have to write a book report!
Use of this terminology is not as strange as it may seem. Take 'verb', for example, an idea that corresponds to the C 'function' or 'operator'. Why not just say 'operator'? Well, that word is also used in mathematics and physics, with a meaning quite different from C's. Even a C 'function' is not a true mathematical function--it can return different values after invocations with the same arguments.
J avoids imprecise usage by choosing a familiar set of words and giving them entirely new meanings. Since J is a language, the vocabulary chosen is that of English grammar. It is hoped that the familiarity of the words will provide some mnemonic value, but as long as you learn the J meanings you are free to forget the grammatical ones. The following table may help:
|
J word |
C word |
|
verb |
function or operator |
|
noun |
object |
|
copula |
assignment |
|
punctuation |
separator |
|
adverb |
(#define macro) |
|
conjunction |
(#define macro) |
In keeping with the grammatical flavor of the vocabulary, we say that every word (token) in a J program has a part of speech (name type) which is one of the following: noun, verb, adverb, adjective, copula, or punctuation.
The primary parts of speech are noun, verb, adverb, and conjunction. Every name we can create, and every word defined by J except for the copulas (=. and =:) and punctuation, will be a definite one of the primary parts of speech. In this book, the term entity is used to mean something that can be any of the primary parts of speech. An entity can be assigned to a name, but most entities are anonymous, appearing and disappearing during the execution of a single sentence (just like intermediate results in the evaluation of C expressions).
A noun holds data; a verb operates on one or two nouns to produce a result which is a noun; an adverb operates on one noun or verb to produce a derived entity; a conjunction operates on two nouns or verbs to produce a derived entity. Adverbs and conjunctions are called modifiers. The closest thing C has to a modifier is a preprocessor macro which can accept function names as data and produce code sequences including the name. J modifiers perform their actions during execution rather than compilation, providing opportunities unknown to C.
A word on punctuation under J's definition: it consists of the characters ( ) ' and end-of-line (written LF but representing either a single LF character or the CRLF combination), along with the comment delimiter NB. and a few other special words like if. and case. . There are a lot of other characters that you think of as punctuation, namely [ ] , . " ; { }, that J uses to do work. You will be especially surprised to find that [ ] and { } are independent rather than matched pairs, but you'll get used to it.
Sentences (statements)
The executable unit in J is called the sentence, corresponding to the C statement. The sentence delimiters in J (corresponding to the semicolon in C) are the linefeed LF and the control words like if. that we will learn about later. A sentence comprises all the characters between sentence delimiters; since LF is a sentence delimiter, it follows that a J sentence must all fit on one line. There is nothing corresponding to \<CR> in C that allows you to split a sentence across lines.
All comments start with NB. and run to the next LF . The comment is ignored when the sentence is executed. NB. is equivalent to // in C.
Word Formation (tokenizing rules)
J's names (identifiers) are formed much as in C. Names must begin with an alphabetic, underscore is allowed, and upper- and lowercase letters are distinguished. Names that end with an underscore or contain two consecutive underscores are special, and you should avoid them until you know what a locale is.
The ASCII graphic characters ('+', for example) are called primitives (operators) in J. You will learn their meanings as we go on.
Any name or primitive (identifier or operator) can be made into a new primitive by adding '.' or ':' at the end. Since all primitives are system-defined (i. e. they are reserved words), you may not put '.' or ':' in your names. No space is required after a primitive. The part of speech for each primitive is fixed. Example primitives are:
+ +. +: { {: {:: i. i: for. select. case. end.
The first step in processing a sentence is to split it into words. The words correspond roughly to C tokens, after making allowance for the special status of the '.' and ':' characters. The space and TAB characters are treated as whitespace.
We will be careful to distinguish periods used for English punctuation from the dot that may be at the end of a primitive. When a J word comes at the end of an English sentence, we will be sure to leave a space before the period. For example, the verb for Boolean Or is +., while the verb for addition is + .
You do not need to trouble yourself with the distinction between integers, floats, and complex numbers. If it's a number, J will handle it properly. There are a great many ways to specify numbers. We will discuss complex numbers and exponential forms in the chapters on mathematics; the more usual forms are:
2
_2 (underscore, not -, is the negative sign)
0.5 (since '.' is special, it must not be the first character of a number)
1e3 (the same as 1000)
16b1f (equivalent to 0x1f; the 16b indicates a base-16 number)
_ (infinity, which is a perfectly valid number in J)
__ (negative infinity, represented by two underscores)
_. (indeterminate, the result you get from something like _-_ . Don't get the idea that it would be clever to use _. to indicate a special data value: _. is hard to test for and gives wildly unpredictable results. Treat _. as an indication that you have a bug you'd better fix)
A noun whose value is one of the numbers 0 and 1 is said to be Boolean. Many verbs in J are designed to use or produce Boolean values, with 0 meaning false and 1 meaning true, but there is no Boolean data type: any noun can be used as a Boolean if its values are 0 or 1.
A word is in order in defense of the underscore as the negative sign. -x means 'take the negative of the number x'; likewise -5 means 'take the negative of the number 5'. In J, the number 'negative 5' is no cloistered companion, accessible only by reference to the number 5: it is a number in its own right and it deserves its own symbol: _5.
Adjacent Numbers Form a Single Word
Numbers separated by whitespace are treated as a single word whose value is the list of the numbers (we will learn all about lists soon--they're like arrays). Remember, word formation is the first step in processing a sentence, so the numbers are welded into a list before anything else can be done with them. This may cause you a problem if you have adjacent numbers that should not be made into a list. In that case, put parentheses around any number you want to keep separate.
You will quickly learn that lists of numbers are so common in J that creating them automatically from adjacent numbers saves you a lot of typing.
Adjacent Named Nouns Do NOT Form a Single Word
Because the adjacent numbers 4 5 are turned into a list, you might think that a b, when a and b have the values 4 and 5, would also be turned into a list. Not so. 4 5 becomes a list before any of the names are examined; at that point the interpreter does not even know the part of speech of the names. a and b remain as separate words, to be operated on as execution proceeds.
An ASCII string enclosed in single quotes is a constant of character type (examples: 'a', 'abc'). There is no notation to make the distinction between C's single-quoted character constants and double-quoted character strings.
There are no special escape sequences such as '\n'. If you need a quote character inside a string, double the quote: 'cannot can be shortened to can''t'. Character constants do not include a trailing NUL (\0) character, and NUL is a legal character within a string.
Valence of Verbs (Binary and Unary Operators)
C operators can be unary or binary depending on whether they have one or two operands; for example, the unary * operator means pointer dereferencing (*p), while the binary * operator means multiplication (x*y). J verbs also come in unary and binary versions, with the addition that this applies to all verbs, both primitive and user-defined verbs.
When a J verb (function or operator) is executed with only one operand (i. e. without a noun or phrase that evaluates to a noun on its left) we say its invocation is monadic (unary); if there is a noun or noun-phrase on its left, that noun becomes a second operand to the verb and we say that the invocation is dyadic (binary).
There is no ambiguity over which kind of invocation is
used in any particular case. If dyadic invocation
is possible, dyadic is used. So, in 5 - 2,
the dyadic form of -
is used; in 5 + - 2,
the monadic form of -
is used.
Each verb-name really stands for two verbs, one that handles monadic invocations and one that handles dyadic. The versions handling the two cases are defined independently. We use the term valence to describe the number of operands expected by a verb-definition: a verb-definition has monadic valence if it can be applied only monadically, dyadic valence if it can be applied only dyadically, and dual valence if it can be applied either way. Since the definitions of the monadic and dyadic forms of a verb can be wildly different, when we name a verb we will be careful to indicate which version we are talking about: 'monad $', 'dyad i.'.
Note that it is impossible to invoke a verb with no operands. In C we can write func(), but in J we always must give an operand.
Note also that the syntax of J limits verbs (functions) to at most two operands. When you need a verb with more than two operands, you will represent it as a monad or dyad in which one of the verb's syntactic operands is an aggregate of the actual operands the verb will use during its execution. The first thing the verb will do is to split its operand into the individual pieces. J has primitives to make this process easy.
The value produced by any entity when it is applied to its operand(s) is called its result (returned value).
How Names (Identifiers) Get Assigned
Assignment in J is performed by expressions of the form
name =. entity NB. private
and
name =: entity NB. public
Names assigned by public assignment are visible outside the entity in which they are defined; names assigned by private assignment usually are not; we will learn the details when we discuss modular code. The difference between the two forms of assignment is in the character following the = . Just as in C, the assignment expression is considered to produce as its result the value that was assigned, so expressions like
a =. 1 + b =. 5
are legal. J calls =. and =: copulas. Just as in C, the entity that is assigned to the name can be the result of evaluating an expression.
There are a number of additional capabilities of J assignment that you can read about in the Dictionary. One that has no counterpart in C is that the name being assigned can itself be a variable, i. e. you can calculate the name that you want to assign the value to.
The value assigned can be a noun (object), verb (function), adverb, or conjunction; the name then becomes whatever part of speech was assigned to it (even if it was previously defined as a different part of speech!). For example,
n =: 5
creates a noun, and
v =: verb define
x + y
)
creates a verb (more below).
Note: the J Dictionary uses the terms 'local' and 'global' instead of 'private' and 'public'. I think 'private' and 'public' are more accurate terms, because there is another dimension to name scope in J, using the J notions locale and path, that causes public variables to be visible only in certain entities. It will be a long time before we learn about locales; until then, public names will be global.
Note: private and public names exist in different namespaces. Referencing a variable checks for the private name first, followed by the public one. Assignment to a public name when the same name is defined in the private namespace is almost always a blunder, so it is flagged as an error.
Forget the table of operator precedence! All J verbs (functions and operators) have the same priority and associate right-to-left. For example, a * b + c is equivalent to a * (b + c), not (a * b) + c. Use care when copying mathematical formulas. Note that the negative sign _ is a part of the number, not a verb. _5 + _4 is _9, while -5 + -4 is _1.
The executable bits of a sentence (statement) are called fragments (subexpressions). A verb with its operand(s) is a fragment, as is a copula with its name and value. We will meet other types of fragment later. Execution of a sentence consists of the right-to-left execution of its fragments, with the result of each fragment's execution replacing the fragment and being passed as an operand into the next fragment. The result of the last execution becomes the result of the sentence. This result is usually a noun but it can be any of the primary parts of speech. As an example, execution of the sentence
a =. 3 + b =. 4 * 1 + 4
consists of execution of the following fragments: 1 + 4 with result 5; 4 * 5 with result 20; b =. 20 with result 20; 3 + 20 with result 23; a =. 23 with result 23 . The names a and b are assigned when the assignment fragments are executed.
If a verb has a noun on its left, it is executed as a dyadic verb with a left and right operand. If the verb does not have a noun on its left, it is executed as monadic with just a right operand. You must know the part of speech of the names in a sentence to understand the execution order. In the sentence
result =. name1 verb2 5
you must know name1 is a verb, in which case verb2 is executed monadically and the result is name1(verb2(5)), or name1 is a noun, in which case verb2 is dyadic and the result is (name1 verb2 5) .
When a sentence contains names, the sentence is executed as if each name were enclosed in parentheses and then replaced by its value. If a has the value 4 and b has the value 5,
a + b
is equivalent to
(4) + (5)
Enclosing the value in parentheses is a necessary step to get the order of evaluation right, just as in ordinary arithmetic, where if a is x+2 and b is y, ab is not x+2y, but (x+2)y.
If you read the Dictionary you will soon encounter the example
mean=: +/ % #
mean 2 3 4 5 6
4
and you will probably follow in the footsteps of countless J neophytes, typing into your J session
+/ % # 2 3 4 5 6
0.2
and be baffled by the result. Why 0.2 instead of 4? Because you left out the parentheses:
(+/ % #) 2 3 4 5 6
4
In this book, the discussion of what (+/ % #) means will be deferred until we discuss modifiers. Later, when we discuss Tacit Programming, it will be revealed that our notion of replacing a name with its parenthesized value is a simplification of the actual process of execution. Forget that for now--you are highly unlikely to encounter a situation where the simplification leads you into error.
Using the parenthesized-substitution rule, we can justify the difference between
4 5
and
a b
when a is 4 and b is 5 . 4 5 is two adjacent numbers, which are always treated as a single word. a b is equivalent to (4) (5), which is not two adjacent numbers but rather a syntax error.
What a verb (function) looks like
As we saw, a J verb (function) is defined by lines that look like:
name =: verb define
J sentences here
)
The result of the verb define is a verb, and normally you will assign the result to a name so you can execute the verb by name when you need it. Subsequent lines, starting with the one after verb define and ending before the next line containing only the word ')', are read and saved as the text of the verb (heaven help you if you leave out the )!). The verb is not 'compiled'--after the most rudimentary syntax checking, the text is saved and will be interpreted when the verb is executed.
Each line of the verb is a sentence (statement). The result of the last sentence executed becomes the result of the whole verb (this is not precisely true but it's close enough for now--details will be revealed in 'Control Structures').
Since a J verb has only one or two operands, there is no need for you to provide a list of parameter names as you do in a function definition in C; instead, J names them for you. At the start of a verb's execution, the private name y is initialized with the value of the right operand of the verb. If the verb is dyadic, the private name x is initialized with the value of the left operand. Many programmers like to start their verbs by assigning these values to more descriptive names.
Note on special names
J uses the names x, y, u, v, m, and n to represent arguments to verbs and other entities. You should avoid using these names for other purposes.
If your verb is going to define only a monadic or dyadic form, you should use monad define or dyad define instead of verb define . If you are going to define both valences, the way to do so is:
name =: verb define
monadic case here
:
dyadic case here
)
where a line with the single word : separates the two cases. If you use verb define and don't have the :, the verb will be monadic.
If your verb is only one line long (not at all unusual in J!) you can define it all in one line by using the appropriate one of the forms
name =: monad : 'text of verb'
name =: dyad : 'text of verb'
In early versions of J, the operands of a verb were named x. and y. rather than x and y . Some old verbs use these forms. If you want to use it you must execute 9!:49 (1) to enable recognition of the old forms.
No compiling. No linking. No makefiles. No debugger required. You simply type J sentences and the interpreter executes them and displays any result. At the very simplest, you can use it as a desk calculator:
22 + 55
77
J prints 3 spaces as a prompt, so when you scroll through the log of a session, your input will be indented 3 spaces while J's typeout will be unindented. The result of a sentence typed on the keyboard is displayed, except that to avoid excessive typeout nothing is displayed if the last fragment executed in the sentence is an assignment. If you are at the keyboard while you are reading this book, you can type the examples and see the responses, or experiment on your own.
Here is a simple program to add twice the left argument to three times the right argument:
add2x3y =: dyad : '(2 * x) + 3 * y'
We can run this program by giving it operands:
1 2 3 add2x3y 4 5 6
14 19 24
Instead of simply displaying the result, we can assign it to a noun:
a =: 1 2 3 add2x3y 4 5 6
We can inspect the value assigned to the noun by typing the name of the noun:
a
14 19 24
We can use the noun in an expression:
2 * a
28 38 48
We can create a new verb that operates on the noun:
twicea =: monad : '2 * a'
twicea ''
28 38 48
Notice the '' after the invocation of twicea. Remember, to invoke a verb you must give it an operand, even if the verb doesn't use an operand. '' is just an empty string; 0 or any other value would work too. If you leave out the operand, J will show you the value of the name; since twicea is a verb, its value is the definition of the verb:
twicea
3 : '2*a'
Of course, in any practical application you will need to have most of your programs in a library so you can quickly make them all available to J. J calls these libraries scripts (filename extension '.ijs') and runs them with the load verb, for example:
load 'system\packages\misc\jforc.ijs'
load reads lines from the script and executes them. These lines will normally be all the verb and noun definitions your application needs, possibly including load commands for other scripts. A script may end with a line executing one of the verbs it defined, thereby launching the application; or, it may end after defining names, leaving you in control at the keyboard to type sentences for J to execute.
Note: Names defined by private assignment (using =.) when a script is loaded are not available outside the script. If you want to define names for use elsewhere, make sure you use =: for your assignments within a script.
If you are used to debugging with Visual C++(tm) or the like, you will find the environment less glitzy and more friendly. If you want to change a verb (function), you simply edit the script, using the editor of your choice (I use the built-in editor provided with J), and rerun it. The verb will be updated, but all defined nouns (objects) will be unchanged. Even if you are running a large application--yea, even if the application is in the middle of reading from an asynchronous socket--you can change the program, without recompiling, relinking, or reinitializing. If you'd like to add some debugging code while the system is running, go right ahead. This easy interaction with an executing program is one of the great benefits of programming in J.
If a J verb is taking too long to run, signal it to stop by running the Jbreak program that is supplied as part of the J installation. Control will return to the keyboard.
When a sentence contains an error, J stops and displays the sentence along with a terse error message. Refer to the chapter on Error Messages for explanation of the error.
The Execution Window; Script Windows
When J starts it displays its execution window. The title of the execution window ends with the characters '.ijx'. The only way to have a sentence executed is to have the sentence sent to the execution window. The simplest way to do that is by typing the sentence into the execution window, as we have been doing in the examples so far.
The execution window is an edit window and a session log as well as a place to type sentences for execution. If you put the cursor on some line other than the last and press ENTER, the line you were on will be copied to the bottom of the session log as if you had typed it for execution. You can then edit the line before pressing ENTER again to execute it.
For convenience in editing, you may create other windows which will be script windows. Usually these windows will contain J scripts that you are working on, and the editor that manages the script windows is familiar with the syntax of J. You create a script window by clicking File on the Menu Bar and then selecting New ijs, Open, or Recent.
Sentences that you type into a script window are not automatically executed by J; you must copy them into the execution window to have them executed. You can use the script-window editor to send lines from a script to the execution window: click Run on the Menu Bar and then File, Selection, or Window as appropriate.
To run a selection of lines from a script window, be sure to use Run|Selection rather than cut-and-paste. If you paste a number of lines into the execution window, nothing will be executed until you press ENTER, and then only the line containing the cursor will be executed.
It is important to remember that the script windows exist only for your convenience in editing and are not used during execution. If you make a change to a script window, you need to Run that window to cause the lines in the script to be executed.
If you are debugging a script and you remove a definition from the script and Run it, the definition will not be removed from the J session. Running the script is like entering the sentences one by one from the keyboard, and not-defining the name does nothing to expunge an established definition. To remove the old definition, use 4!:55 <'expiredname' or start a fresh session of J.
When J starts, a number of useful names are defined. Rather than discuss them all, I will show you how they come to be defined so you can study them when you need to.
When J starts, it executes the script J-directory\system\extras\config\profile.ijs which then executes the script J-directory\system\extras\util\boot.ijs . boot.ijs in turn executes a series of scripts in J-directory\system\main which define the starting environment. Look at these scripts to see what they define.
For more information, including how to add your own initial definitions, see the section on Startup under "Odds and Ends".
The Labs are interactive demos describing various topics in J. To run the lab for printf, start a J session, on the menu bar select Studio|Labs..., then select the lab you are interested in, then press 'Run'. The lab provides explanatory text interspersed with examples executed in your J session which you are free to experiment with as you step through the lab.
I recommend that every now and again you tarry a while among the labs, running whichever ones seem interesting. Much of the description of the J system can be found only there.
The J documentation is available online. Pressing F1 brings up the Vocabulary page, from which you can quickly go to the Dictionary's description of each J primitive. At the top of each page of documentation are links to the manuals distributed with J: these are:
The Index to all documentation;
The User Manual which describes components of J that are not in the language itself, including system libraries and external interfaces;
The J Primer, an introduction to J;
J for C Programmers (this book);
Learning J, by Roger Stokes, a book comparable in scope to this book;
J Phrases, a collection of useful fragments of J (you will need to finish this book before trying to use J Phrases);
The J Dictionary, the official definition of the language;
Release Notes for all releases of J;
A description of foreign conjunctions (!:);
A description of the operands to the wd verb (Windows interface).
A Reference Card with a terse description of most of the primitives of J can be found in the J Wiki at http://code.jsoftware.com/wiki/HenryRich . It looks best when printed in color.
Your first step in learning J should be to sign up for the J Forum at www.jsoftware.com. A great many experienced J users monitor messages sent to the Forum and are willing to answer your questions on J, from the trivial to the profound.


| No. of copies | Record date | Added on | Actions |
|---|---|---|---|
| 2 | July 31, 2017 | August 1, 2017 | |
| 4 | July 31, 2017 | August 2, 2017 | |
| 6 | July 31, 2017 | August 3, 2017 | |
| 8 | July 31, 2017 | August 4, 2017 | |
| 10 | July 31, 2017 | August 5, 2017 | |
| 12 | July 31, 2017 | August 6, 2017 | |
| 14 | July 31, 2017 | August 7, 2017 | |
| 16 | July 31, 2017 | August 8, 2017 | |
| 18 | July 31, 2017 | August 9, 2017 | |
| 20 | July 31, 2017 | August 10, 2017 |


MiliBank
Read Before:
- MVC (The design pattern, not the framework ASPNET MVC)
- ADO .NET
Part A
You will now build a simple bank system based on the MVC pattern, with the windows console as the UI.
Your models will be the following:
- Account - Based on the same logic from exercise 2 (Write new models, both for Simple and VIP account)
- User - Will contain the following information:
Every account can belong to more than a single user.
Every user can have more than a single account.
The application will provide the following actions to the user:
- List all users
- List all accounts for a given user with their current balance
- Deposit/Withdraw from a given account
- Create a new user
- Create a new account for a user
- Delete users and accounts
* Only databases supported by the ADO namespace, DO NOT USE OleDB
NOTES:
- When you delete a user, you also need to delete his accounts, how do we accomplish this properly?
- Use the DataReader class in order to read data from the DB
- Implement converter classes to convert from DataReader data to your models
- Dispose of transactions properly and timely
- Ummm... maybe there's a design pattern for something like that
Part B
You will now refactor your DB access code and replace it with an ORM (Please save the previous version of your code...).
The ORM you will be using is NHibernate with FluentNHibernate for the mapping.
- Map the class Account manually (create a class that inherits from ClassMap)
- Map the class User Automatically (Convention based mapping)


Empresa
Usuário
Elements
Basic Elements
Text Elements
Extended Elements
Tabs
Layouts
Real-World-Examples
Profile
Information
Nice to Know
Colors & Styles
Credits & License
Login


“You may not control all the events that happen to you, but you can decide not to be reduced by them.“ Maya AngelouAfrican/American04/04/1928-05/28/2014
“You may not control all the events that happen to you, but you can decide not to be reduced by them.“
Maya AngelouAfrican/American04/04/1928-05/28/2014


The decimal value of this prime was computed with calc and the English name was computed with number.
four hundred forty six cen-quattuor-dec-illion, eighty seven cen-tre-dec-illiard, five hundred fifty seven cen-tre-dec-illion, one hundred eighty three cen-do-dec-illiard, seven hundred fifty eight cen-do-dec-illion, four hundred twenty nine cen-un-dec-illiard, five hundred seventy one cen-un-dec-illion, one hundred fifty one cen-dec-illiard, seven hundred six cen-dec-illion, four hundred two cen-novem-tilliard, one hundred one cen-novem-tillion, eight hundred nine cen-octo-tilliard, eight hundred eighty six cen-octo-tillion, two hundred eight cen-septen-tilliard, six hundred thirty two cen-septen-tillion, four hundred twelve cen-sex-tilliard, eight hundred fifty nine cen-sex-tillion, nine hundred one cen-quin-tilliard, one hundred eleven cen-quin-tillion, nine hundred ninety one cen-quattuor-tilliard, two hundred nineteen cen-quattuor-tillion, nine hundred sixty three cen-tre-tilliard, four hundred four cen-tre-tillion, six hundred eighty five cen-do-tilliard, seven hundred ninety two cen-do-tillion, eight hundred twenty cen-un-tilliard, four hundred seventy three cen-un-tillion, three hundred sixty nine cen-tilliard, one hundred twelve cen-tillion, five hundred forty five novem-nonagin-tilliard, two hundred sixty nine novem-nonagin-tillion, three octo-nonagin-tilliard, nine hundred eighty nine octo-nonagin-tillion, twenty six septen-nonagin-tilliard, one hundred fifty three septen-nonagin-tillion, two hundred forty five sex-nonagin-tilliard, nine hundred thirty one sex-nonagin-tillion, one hundred twenty four quin-nonagin-tilliard, three hundred sixteen quin-nonagin-tillion, seven hundred two quattuor-nonagin-tilliard, three hundred ninety five quattuor-nonagin-tillion, seven hundred fifty eight tre-nonagin-tilliard, seven hundred five tre-nonagin-tillion, six hundred ninety three do-nonagin-tilliard, six hundred seventy nine do-nonagin-tillion, three hundred sixty four un-nonagin-tilliard, seven hundred ninety un-nonagin-tillion, nine hundred three nonagin-tilliard, four hundred ninety seven nonagin-tillion, four hundred sixty one novem-octogin-tilliard, one hundred forty seven novem-octogin-tillion, seventy one octo-octogin-tilliard, sixty five octo-octogin-tillion, two hundred fifty four septen-octogin-tilliard, one hundred ninety three septen-octogin-tillion, three hundred fifty three sex-octogin-tilliard, nine hundred thirty eight sex-octogin-tillion, one hundred twenty four quin-octogin-tilliard, nine hundred seventy eight quin-octogin-tillion, two hundred twenty six quattuor-octogin-tilliard, three hundred seven quattuor-octogin-tillion, nine hundred forty seven tre-octogin-tilliard, three hundred twelve tre-octogin-tillion, four hundred ten do-octogin-tilliard, seven hundred ninety eight do-octogin-tillion, eight hundred seventy four un-octogin-tilliard, eight hundred sixty nine un-octogin-tillion, forty octogin-tilliard, seventy octogin-tillion, two hundred seventy nine novem-septuagin-tilliard, three hundred twenty eight novem-septuagin-tillion, four hundred twenty eight octo-septuagin-tilliard, eight hundred ten octo-septuagin-tillion, three hundred eleven septen-septuagin-tilliard, seven hundred fifty four septen-septuagin-tillion, eight hundred forty four sex-septuagin-tilliard, one hundred eight sex-septuagin-tillion, ninety four quin-septuagin-tilliard, eight hundred seventy eight quin-septuagin-tillion, two hundred fifty two quattuor-septuagin-tilliard, four hundred ninety four quattuor-septuagin-tillion, eight hundred sixty six tre-septuagin-tilliard, seven hundred sixty tre-septuagin-tillion, nine hundred sixty nine do-septuagin-tilliard, five hundred eighty six do-septuagin-tillion, nine hundred ninety eight un-septuagin-tilliard, one hundred twenty eight un-septuagin-tillion, nine hundred eighty two septuagin-tilliard, six hundred forty five septuagin-tillion, eight hundred seventy seven novem-sexagin-tilliard, five hundred ninety six novem-sexagin-tillion, twenty eight octo-sexagin-tilliard, nine hundred seventy nine octo-sexagin-tillion, one hundred seventy one septen-sexagin-tilliard, five hundred thirty six septen-sexagin-tillion, nine hundred sixty two sex-sexagin-tilliard, five hundred three sex-sexagin-tillion, sixty eight quin-sexagin-tilliard, four hundred twenty nine quin-sexagin-tillion, six hundred seventeen quattuor-sexagin-tilliard, three hundred thirty one quattuor-sexagin-tillion, seven hundred two tre-sexagin-tilliard, one hundred eighty four tre-sexagin-tillion, seven hundred fifty do-sexagin-tilliard, three hundred twenty four do-sexagin-tillion, five hundred eighty three un-sexagin-tilliard, nine un-sexagin-tillion, one hundred seventy one sexagin-tilliard, eight hundred thirty two sexagin-tillion, one hundred four novem-quinquagin-tilliard, nine hundred sixteen novem-quinquagin-tillion, fifty octo-quinquagin-tilliard, one hundred fifty seven octo-quinquagin-tillion, six hundred twenty eight septen-quinquagin-tilliard, eight hundred eighty six septen-quinquagin-tillion, six hundred six sex-quinquagin-tilliard, three hundred seventy two sex-quinquagin-tillion, one hundred forty five quin-quinquagin-tilliard, five hundred one quin-quinquagin-tillion, seven hundred two quattuor-quinquagin-tilliard, two hundred twenty five quattuor-quinquagin-tillion, nine hundred twenty five tre-quinquagin-tilliard, one hundred twenty five tre-quinquagin-tillion, two hundred twenty four do-quinquagin-tilliard, seventy six do-quinquagin-tillion, eight hundred twenty nine un-quinquagin-tilliard, six hundred five un-quinquagin-tillion, four hundred twenty seven quinquagin-tilliard, one hundred seventy three quinquagin-tillion, five hundred seventy three novem-quadragin-tilliard, nine hundred sixty four novem-quadragin-tillion, eight hundred twelve octo-quadragin-tilliard, nine hundred ninety five octo-quadragin-tillion, two hundred fifty septen-quadragin-tilliard, five hundred sixty nine septen-quadragin-tillion, four hundred twelve sex-quadragin-tilliard, four hundred eighty sex-quadragin-tillion, seven hundred twenty quin-quadragin-tilliard, seven hundred thirty eight quin-quadragin-tillion, four hundred seventy six quattuor-quadragin-tilliard, eight hundred fifty five quattuor-quadragin-tillion, two hundred ninety three tre-quadragin-tilliard, six hundred eighty one tre-quadragin-tillion, six hundred sixty six do-quadragin-tilliard, seven hundred twelve do-quadragin-tillion, eight hundred forty four un-quadragin-tilliard, eight hundred thirty one un-quadragin-tillion, one hundred ninety quadragin-tilliard, eight hundred seventy seven quadragin-tillion, six hundred twenty novem-trigin-tilliard, six hundred six novem-trigin-tillion, seven hundred eighty six octo-trigin-tilliard, six hundred sixty three octo-trigin-tillion, eight hundred sixty two septen-trigin-tilliard, one hundred ninety septen-trigin-tillion, two hundred forty sex-trigin-tilliard, one hundred eighteen sex-trigin-tillion, five hundred seventy quin-trigin-tilliard, seven hundred thirty six quin-trigin-tillion, eight hundred thirty one quattuor-trigin-tilliard, nine hundred one quattuor-trigin-tillion, eight hundred eighty six tre-trigin-tilliard, four hundred seventy nine tre-trigin-tillion, two hundred twenty five do-trigin-tilliard, eight hundred ten do-trigin-tillion, four hundred fourteen un-trigin-tilliard, seven hundred fourteen un-trigin-tillion, seventy eight trigin-tilliard, nine hundred thirty five trigin-tillion, three hundred eighty six novem-vigin-tilliard, five hundred sixty two novem-vigin-tillion, four hundred ninety seven octo-vigin-tilliard, nine hundred sixty eight octo-vigin-tillion, one hundred seventy eight septen-vigin-tilliard, seven hundred twenty nine septen-vigin-tillion, one hundred twenty seven sex-vigin-tilliard, six hundred twenty nine sex-vigin-tillion, five hundred ninety four quin-vigin-tilliard, nine hundred twenty four quin-vigin-tillion, four hundred eleven quattuor-vigin-tilliard, nine hundred sixty quattuor-vigin-tillion, nine hundred sixty one tre-vigin-tilliard, three hundred eighty six tre-vigin-tillion, seven hundred thirteen do-vigin-tilliard, nine hundred forty six do-vigin-tillion, two hundred seventy nine un-vigin-tilliard, eight hundred ninety nine un-vigin-tillion, two hundred seventy five vigin-tilliard, six vigin-tillion, nine hundred fifty four novem-dec-illiard, nine hundred seventeen novem-dec-illion, one hundred thirty nine octo-dec-illiard, seven hundred fifty eight octo-dec-illion, seven hundred ninety six septen-dec-illiard, sixty one septen-dec-illion, two hundred twenty three sex-dec-illiard, eight hundred three sex-dec-illion, three hundred ninety three quin-dec-illiard, five hundred thirty seven quin-dec-illion, three hundred eighty one quattuor-dec-illiard, thirty four quattuor-dec-illion, six hundred sixty six tre-dec-illiard, four hundred ninety four tre-dec-illion, four hundred two do-dec-illiard, nine hundred fifty one do-dec-illion, fifty two un-dec-illiard, fifty nine un-dec-illion, forty seven dec-illiard, nine hundred sixty eight dec-illion, six hundred ninety three noni-lliard, two hundred fifty five noni-llion, three hundred eighty eight octi-lliard, six hundred forty seven octi-llion, nine hundred thirty septi-lliard, four hundred forty septi-llion, nine hundred twenty five sexti-lliard, one hundred four sexti-llion, one hundred eighty six quinti-lliard, eight hundred seventeen quinti-llion, nine quadri-lliard, six hundred forty quadri-llion, one hundred seventy one tri-lliard, seven hundred sixty four tri-llion, one hundred thirty three bi-lliard, one hundred seventy two bi-llion, four hundred eighteen mi-lliard, one hundred thirty two mi-llion, eight hundred thirty six thousand, three hundred fifty one


I am a Software Developer residing in Bangalore, India. I enjoy creating efficient and elegant code from scratch, whether it be Android, Java, Python or CSS. Being enthusiastic about technology in general, I'm always looking for new stuff to learn.
When I'm not coding or looking up new frameworks online, you'll find me at the checkout counter of a bookshop with my arms full of books, or in a random spot re-reading one of the Harry Potter novels for the umpteenth time.
What I DoAndroid Studio is the new rodeo!
Unity3D makes all greedy!
Tinkering around the web armed with Bootstrap, HTML and CSS!
Business Process Management!
Drop me an owl, would love to hear from you!


Jang Hyuk & Jin Seo Yeon join Sooyoung in upcoming crime drama 'Tell Me What You Saw'
by beansssOCN's upcoming Sat-Sun crime/suspense drama 'Tell Me What You Saw' has confirmed its main cast, made up of Jang Hyuk, Jin Seo Yeon, and Sooyoung!
In 'Tell Me What You Saw', Jang Hyuk will play the role of a genius profiler, unmatched in his abilities to put together clear evidence with hidden clues to solve mysteries. Sooyoung takes on the role of a female detective with the unique ability of a photographic memory, while actress Jin Seo Yeon will head a special crime investigation unit as a police chief. These three main cast members will team up against a dangerous serial killer, who was believed to be dead.
Directed by Lee Joon Hyung with creative aid from Hong Sun of 'Voice', 'The Guest', and more, OCN's 'Tell Me What You Saw' is set to air some time in early 2020. Does the storyline sound interesting so far?


My web apps were all built as explorations — of Rails, CSS animations, JavaScript, and more.
-
Grown is a Rails app for garden planning. Users can create gardens with multiple plots containing various plants, with maintenance instructions for each. Users can contribute plots to one another's gardens for a "community garden" functionality, requiring complex relationships within a Postgres database using ActiveRecord. Currently in development. View source code.
-
What's Next is the first iteration of a later group project, a platform-agnostic mobile app for reflection and self-care called Unstuck. What's Next was built in 36 hours and explores API calls and CSS animations. View source code.
-
I served as project manager on a team of four people to build Game Knight, a clone of BoardGameGeek.com. Our "quest" was to create a more user-friendly version of the site in Rails, while using an Agile workflow. View source code.
-
This Rails blog was one of my first Rails projects and explores restricting login to admins. View source code.
-
Concerts, Concerts, Concerts dives into using AJAX calls in Rails, as well as mobile-responsive design. View source code.