% rebase('index/views/base.html', title='Getting Started') {% block style %} {% endblock %} {% block script %} {% endblock %} {% block content %}
Kokoropy is a python web framework. Therefore you need to have python (recommended python 2.7) installed in your computer.
Linux & MacOS user does not need to worry anything since those OS have python pre-installed by default.
Windows user should download and install python. Personally, I suggest you to use Enthought Canopy Distribution
since it already has some libraries such as numpy & matplotlib.
If you are using debian-based linux (such as ubuntu)
Kokoropy built with scientific purpose on mind. Some examples are depended on already famous libraries, such as numpy, scikit-learn, and matplotlib. To install those libraries, you can do:
pip install numpy pip install matplotlib pip install sklearn
If you are using python 3, you will need to install `python3-beaker` package
pip install beaker
Download kokoropy from github repository here, or clone it by using git
git clone git@github.com:goFrendiAsgard/kokoropy.git
After All prerequisites met, you can just start kokoropy by using this command:
cd path/to/kokoropy python rossian.py start
Now, open up your browser, and type
http://localhost:8080
in the address bar
Don't worry This is just informational, you don't have to do anything
Just like every MVC framework, kokoropy has a typical directory structure. At the development stage, you only need to pay attention to /applications directory (this is where your applications laid)
kokoropy |--- /applications THIS IS WHERE YOUR APPLICATIONS LAID | |--- __init__.py * application's bootstrap | | | |--- /example * example application | | |--- __init__.py * application's __init__.py | | |--- /assets * application's static files | | |--- /models * application's models | | |--- /controllers * application's controllers | | |--- /views * application's views | | |--- routes.py * application's routes | | | |--- /index * index application | | |--- __init__.py * application's __init__.py | | |--- /assets * application's static files | | |--- /models * application's models | | |--- /controllers * application's controllers | | |--- /views * application's views | | |--- routes.py * application's routes | | | |--- /[your_application] * your application | | |--- __init__.py * application's __init__.py | | |--- /assets * application's static files | | |--- /models * application's models | | |--- /controllers * application's controllers | | |--- /views * application's views | | |--- routes.py * application's routes | |--- /kokoropy THIS IS WHERE KOKOROPY'S CORE LAID | |--- __init__.py * __init__.py | |--- /beaker * beaker package | |--- /sqlalchemy * sqlalchemy package | |--- /alembic * alembic package | |--- bottle.py * bottle module | |--- kokoro.py * kokoropy's main program | |--- /db DATABASE EXAMPLE | |--- README.md DOCUMENTATION & TUTORIAL | | DEVELOPMENT & DEBUGGING |--- rossian.py * script to manage kokoropy | | HEROKU DEPLOYMENT FILES |--- heroku.sh * heroku command example |--- heroku_app.py * bootstrapper for heroku |--- Procfile * heroku specific file |--- runtime.txt * heroku specific file |--- requirements.txt * heroku specific file
In kokoropy, every application should contains __init__.py file.
The same rule is also applied to application's models and controllers directory. You should also put an __init__.py inside each of them.
Building everything from scratch is such a pain. Therefore, some frameworks provide generator scripts.
FuelPHP has oil
, Laravel has artisan
, Django has manage.py
,
Ruby on Rails has rails
.
In kokoropy, we have rossian.py
, a smart, cute, little script that help you do most of things better and faster.
You can do:
python rossian.py
to see how it works.
Currently, here is a list of commands that might be useful
VERSION: 0.0.1 USAGE: * Help python rossian.py help * Run Server python rossian.py start [--host=localhost --port=8080 --server=kokoro --baseurl=/ --runtimepath=.runtime --debug --reload] * Scaffold Application python rossian.py scaffold-application APPLICATION-NAME * Scaffold Migration python rossian.py scaffold-migration APPLICATION-NAME MIGRATION-NAME [table-name] [column-name:type] ... * Scaffold Model python rossian.py scaffold-model APPLICATION-NAME [table-name] [column-name:type] ... * Scaffold CRUD python rossian.py scaffold-crud APPLICATION-NAME [table-name] [column-name:type] ... * Scaffold View (to make custom CRUD view) python rossian.py scaffold-view APPLICATION-NAME [table-name] [view] * Scaffold CMS python rossian.py scaffold-cms * Migration upgrade (to the newest version) python rossian.py migration-upgrade [APPLICATION-NAME] * Migration downgrade (to the previous version) python rossian.py migration-downgrade APPLICATION-NAME * List of migration applied python rossian.py migration-log
Trivia: rossian.py
was named after my smart and cute ex-girlfriend, Rossian Vinatha.
She was always encourage and help me to do many new things (including ride a motorbike) better.
We were in relationship since 2013-12-09, and we've just broke up at 2014-08-04. That was unfortunate.
I still hope her to get back, but more of it, I hope her to find her happiness.
Okay, let's try your first hello world program
First, do:
python rossian.py scaffolding-application demo
This will make demo
directory inside your applications
kokoropy |--- /applications | |--- __init__.py | | | |--- /demo * (1. Make demo directory) | | |--- __init__.py * (2. Make __init__.py) | | |--- routes.py * (3. Make routes.py) (...) (...)
Now, edit your routes.py and put this:
We hope the code is already self-explanatory, but if you still need some explanation, here is:
Important : The tupple should be named urls. This tupple is used to wrap bottle route decorator. To get more comprehensive documentation about route decorator, please visit Bottle's documentation about request routing
You might need something more complex than just a typical "hello world" program.
It's not good to put everything in routes.py, since it will be to complicated to be maintained.
Here is where MVC rocks. MVC stands for Model, View, Controller.
Let's make your first MVC in kokoropy. At the end of this section, you will be able to access these url:
kokoropy |--- /applications | |--- __init__.py | | | |--- /demo * ( 1. Make demo directory) | | |--- __init__.py * ( 2. Make __init__.py) | | |--- routes.py * ( 3. Make routes.py) | | |--- /models * ( 4. Make models directory) | | | |--- __init__.py * ( 5. Make __init__.py) | | | |--- my_model.py * ( 6. Make my_model.py) | | |--- /controllers * ( 7. Make controllers directory) | | | |--- __init__.py * ( 8. Make __init__.py) | | | |--- my_controller.py * ( 9. Make my_controller.py) | | |--- /views * (10. Make views directory) | | | |--- my_view.tpl * (11. Make my_view.py) | | |--- /assets * (10. Make assets directory) | | | |--- uploads * (11. Make uploads directory) (...) (...)
Put this in my_model.py:
Since we are using SQLALchemy's ORM and a custom Model code, there are many things you don't need to write by yourself.
If you don't like (or not ready to use) ORM, you can also use classical SQL approach. SQL Alchemy supporting both ORM & classical SQL approach. Please check SQL Alchemy documentation for more information.
Now, here is some explanation of the code:
connection_string
from configuration.
Base
and Mixin
.
It has 2 properties mapped to column, name and image.
Put this in my_controller.py:
Here is the explanation
Every function in autorouted controller with action_, prefix will be published, and accessible with this url format:
BASE_URL/application_name/controller_name/function_without_prefix
You can also use post_, get_, put_, and delete_ prefix. These prefixes are work with REST request.
Beware : Autoroute controller might looks to be fun, and it is recommended when you are on development stage. Also, it will feels familiar, if you came from CodeIgniter. However, for real-world usage, we suggest to use manual routing via routes.py. Manual routing allow you to change the url freely without touching your controller logic (and code) at all.
Put this in my_view.tpl:
Here we get our pokemon_list from the controller, and present it to our visitor in table. In kokoropy, Simple Template Engine is used to render the view.
% name = "Bob" # a line of python code
Some plain text in between
 <% # A block of python code name = name.title().strip() %>
More plain text

rebase
function to set index/views/base as parent template
Aside from simple template engine behavior, kokoropy also provide block by using {% block block_name %}
and {% endblock %}
(similar to jinja2).
The blocks also support inheritance, so that you can use {% parent %}
inside your child block.
Since the database is empty, you won't be able to see anything. when running this demo.
In this case, open up db/demo.db, add some data, put some images on applications/demo/assets/uploads.
As we say, put autoroute controller is great for development, however sometime you need more "expressive" routing. Here is where you need manual routing. To enable manual routing, first open up your previously created controller, and remove this part:
class My_Controller(Autoroute_Controller):
with this:
class My_Controller(obj):
and put this in your routes.py
Sometime people want to define their own hook and error message. Do this is very easy, as easy as define manual routing.
This is how to deploy kokoropy on apache web server (assuming you use ubuntu or debian):
sudo apt-get install libapache2-mod-wsgi
.
sudo a2enmod wsgi
.
/path/to/kokoropy/kokoro.wsgi
.
/etc/apache2/sites-available/kokoro.apache_conf
(For other OS, please append this file contents to httpd.conf
)<VirtualHost *> # replace this with your absolute path to kokoropy DocumentRoot /absolute/path/to/kokoropy # server name, usually localhost, but you can also use another alias if DNS set correctly ServerName localhost WSGIDaemonProcess kokoropy user=www-data group=www-data processes=1 threads=5 # replace this with your absolute path to kokoropy + kokoro.wsgi location WSGIScriptAlias / /absolute/path/to/kokoropy/kokoro.wsgi # absolute path to kokoropy <Directory /absolute/path/to/kokoropy> WSGIProcessGroup kokoropy WSGIApplicationGroup %{GLOBAL} Options ExecCGI Order deny,allow Allow from all </Directory> </VirtualHost>Adjust some values as follows:
/absolute/path/to/kokoropy
with your kokoropy directory location.
/etc/hosts
(e.g: <IP_ADDRESS>
arcaneSanctum will add arcaneSanctum as valid ServerName).
<VirtualHost *:80>
into <VirtualHost localhost:80>
sudo a2ensite kokoro.apache_conf
.
sudo service apache2 reload
. If it does not work, restart your apache by using sudo service apache2 restart
.
This is how to deploy kokoropy on heroku (assuming you use ubuntu):
wget -qO- https://toolbelt.heroku.com/install-ubuntu.sh | sh
. For other OS, please visit the heroku website for more information.
git init
python-2.7.4
argparse==1.2.1 distribute==0.6.24 gunicorn==17.5 wsgiref==0.1.2 numpy==1.7.0 matplotlib==1.1.0 scipy==0.11.0
web: python heroku_app.py
heroku login
heroku create --buildpack https://github.com/dbrgn/heroku-buildpack-python-sklearn/
heroku create
heroku create
but change your mind later, and think that you need matplotlib, do this: heroku config:set BUILDPACK_URL=https://github.com/dbrgn/heroku-buildpack-python-sklearn/
heroku_app.py
executable by using this command chmod a+x heroku_app.py
git add .


My Houses List (in HTML)
Add New House
Clear All Houses
{{house.nickName}}
{{house.address}},
{{house.city}}, {{house.state}}
{{house.forSale}}
${{house.salePrice}}
Zestimate®: {{house.estimatedPrice}}
Discount: ${{house.discount}}%
Estimated Mortgage: {{house.estimatedMortgage}}


20 Nov 2016 | Microservice, Seneca, Docker
Microservices are the new trend in composing applications with small and reusable pieces of logic accessible from any clients.But if services should be light and tiny as possible, what about their execution environment ? Can I expect to run hundreds of microservices each with their own and heavy application server ? If so, application server would demand much more resources than our little service, the ratio would be catastrophic. Is there a solution to run microservices on micro application servers and why not on micro os ? Yes, the solution is Seneca plus Docker.
Think of it, why would you use microservices ? Here a few common reasons :
One of them is the most underestimated and the most technical : scalability. But how do you currently implement your microservice ? Did you really take scalability into consideration ? Or more probably you stuck to your good old technologies so often successful in the past.
Let me present to you what may be your next try to address scalability in your development.
Seneca is a microservices toolkit for Node.js. It helps you write clean, organized code that you can scale and deploy at any time.
I took this presentation literally from their site, it’s a perfect fit. Maybe I’d add service discovery as a major feature worth being mentioned.
Now, how would I code my first and simple microservice ? First, install Node.js if necessary and create your project in a directory of your choice by :
Then install Seneca by :
To test our first service, get some fake users from https://www.mockaroo.com/ and save them in json format in your project directory.
Now comes our first microservice with seneca that serves users data. Copy the code in index.js
What happens here ? First we create our seneca instance. It’s versatile and can serve to implement server and client as well. We’ll use it as a server to pass user data from our file of users.
Seneca uses pattern matching to identify a service. And we litteraly add a service with … add function. First parameter is the pattern identifier of this service. This pattern matching is wonderful to classify our microservices and permits some form of overloading with a common part in identifiers and a distinguible one to route correctly to the target.
Then the service logic is provided as a function. This function accepts a message argument with all arguments passed to the call of this web service. Respond is our “classical” callback with its first parameter to signal error and the second one to send data back to the client.
Finally, we launch our service with “listen”. Seneca is able to listen with different transports protocols and ports. The default transport plugin provides HTTP and TCP protocols. But for all the examples, we’ll keep HTTP. By default, seneca server listens on port 10101 with HTTP protocol.
What if you want to change the listening port number ? Simple, just pass the option to listen function
And if I want to listen from a specific network address ? Same way. Here a dummy example with localhost.
Ok, how can I call it ? Two ways are offered, you can use Seneca client or any HTTP client.
Don’t forget the act path in your URL, it’s the marker of any client calls even from Seneca ones.
To demonstrate Seneca client, just execute the following codes respectively inside and outside index.js.
As seen above, you specify the pattern identifier of the service you want to call along with the data to transmit. An other way to write this part would be in JSON format.
Even if we’re not going to use it in our examples, note that you can export your service as an Express middleware to use it in your existing Express application.
Seneca provides a plugin for service discovery called ‘mesh’. And there shines the concept of pattern. Remember a service is identified by the pattern it takes in charge. Mesh permits to services to address each other thanks to this pattern regardless of current location of the endpoint.
First, install the plugin in your project.
Then our service discovery needs a node to be the entry point to join the network, it’s called the base. Notice that it will be used only once by a client joining the network. In any subsequent need for information about service location any node can answer the request. That means that if the base goes down, our cluster will still work with its actual members !
I chose to implement a base within an actual service.Of course, you can decide to externalize a devoted instance for that matter. If necessary you can simply create a base with a single line of code
This is the code for the intermixed variation.
New things happen here. We use the plugin ‘mesh’ and make our service a base for our network of services with isbase:true option. We notify the (future) members that we publish a service identified by “role:users,cmd:get”. Pay attention to the fact, we don’t listen to a port. So our service is only discoverable by others members of the network but not directly addressable. If we aim to be able to address it in a direct call we should have built a base outside and make a listen call as follow
Why do I double the pin option ? It’ll become clear in a moment.
Now, the client service
The service identified by “role:users,cmd:check” will make a call to an other service identified by “role”:”users”,”cmd”:”get”. Note that no address is given here, only the identifier. We indicate our pattern to identify the service as on option to the mesh plugin. To make it callable, we listen on port 5000.
Launch the two services with node and issue a call by
The answer
Of course the response will differ according to you generated test data.
How do we know what services are exposed in a network ? Fairly simple, call this on any service of the network.
the answer contains all the services
Here appears the reason to double the pin of services : to make it appear in the network service as well as in the direct callable port. For example, you obtain “pin”:”role:users,cmd:check”,”port”:5000 for the “callable” part and “role:users,cmd:check”,”port”:59982 for the “hidden” but known service in our network. If you delete any one the pin option, you only receive a not very expressive “pin”:”null:true”. And you’ve got the same information twice because two nodes are in our network and each one provides its information.
I won’t waste to present Docker. What I try here is to show you an introduction to how a docker microservices network could be built.
The first service will serve as a base and be attributed to its own container. This is its Dockerfile.
I choose ubuntu 14.04 only because it’s my current system. For the base to be able to communicate with exterior, I expose the default port 39999. To use the latest version of node, I had to provide it myself as a directory in the project directory and copy it into /opt/node. I also created a special directory for my service /logi/getuserservice and copy all necessary artefacts : package.json index.js and MOCK_DATA.json
The version of code I used for the service in index.js is
My package.json is dedicated to seneca
Let’s build it. My project for this sole service resides in the directory ws1. So from its parent, I issue
And then run it with
Notice that I use the most direct network configuration, this is certainly not your choice for production.
The Dockerfile
It’s almost the same. The only noticeable difference is that I expose the port 5000 to call directly my service.
The code for index.js
Use the same package.json from above. Now, let’s build it and run it. The ws2 directory is my working space for this service.
Now test it by
You should get the answer.
Seneca plus Docker is a winning pair. They’re both light and powerful. I only scratched the surface of this vast subject whether about Docker or Seneca. I was pretty impressed by the quantity of plugins for Seneca. It seems to be a rational and viable choice that I discovered only lately. But microservices embrace a lot more domains I didn’t address here. To name a few : security, load balancing, transaction, etc. I hope it gave you a taste of microservices and a first (naïve) architecture to illustrate the possibility offered. Your way is only beginning here. The story is not over …
A few references obviously or not useful.


August spent a lot of his post college time rock climbing, building videogame prototypes, and spending time with friends while also oversharing about aforementioned prototypes. After putting several months into one particular game idea Sweepyheads: the Game, he decided that he wanted to work with a game studio that would appreciate his enthusiasm and encourage development of unique prototypes.
In December, 2016, he left his San Francisco software position and moved to Cleveland, OH to execute a solo VR project. It has been a wild 3 years of developing and learning, but in January 2020 the project will be complete and the next part of his journey will begin.
List of accomplishments and highlights in Auggo Doggo Games solo development*
These accomplishments apply to both Plunker, and Sweepyheads and most of August’s other experimental prototypes.
*August has other skills, tools, and languages that were obtained through school, work and non game related personal projects. Any other skills can usually be found listed in his Resume.
Inquiries, business or otherwise, can be sent to AuggoDoggoGames@gmail.com.


Now that you understand what an anonymous verb/adverb/conjunction is, you are ready to follow parsing and execution word by word. We will finally abandon all shortcuts and process sentences exactly as the interpreter does.
In any compiled language, a program is broken into words (tokens) and then parsed, and code is generated from the parsed result. Not so in J: a sentence is broken into words, but the sentence is not fully parsed; rather, parsing and execution proceed simultaneously, scanning the text from right to left. Parsing finds patterns in the sentence that are then executed. Execution includes the usual supplying of noun operands to verbs to obtain a result from the verb, but also other actions: supplying verb and noun operands to conjunctions and adverbs to produce derived entities, and recognition of other sequences that we will learn soon.
Execution of a bit of a sentence, which we will call a fragment, consists of replacing the fragment with an appropriate single word, namely the result of executing the fragment. In the simple case, where the fragment is the invocation of a verb (i. e. the fragment looks like verb noun or noun verb noun), the word that replaces it is the noun that is the result of the verb. If the fragment is the invocation of a modifier, the result of executing it will be a noun or a derived verb/adverb/conjunction. A noun is nothing but its value, but the derived verb/adverb/conjunction will itself eventually be executed: it is called an anonymous verb/adverb/conjunction and is saved by the interpreter in a private form, and the single word used to replace the fragment is a reference to this anonymous verb/adverb/conjunction (for the case of an anonymous verb, you may think of the single word as a pointer to a function that performs according to the definition of the anonymous verb).
In all cases the word replacing the fragment has a definite part of speech, and if it is a verb, a definite rank.
I want to repeat that 'execution' as used here is not synonymous with 'execution on noun operands'. Yes, verbs are executed that way. But the execution of a modifier produces an anonymous entity, and it may consume no nouns at all (as in the example of +&.>). Execution of a modifier is a step along the path to execution of the derived verb.
Execution of a sentence begins by breaking the sentence into words. The words (with a beginning-of-line marker, shown here as $, prepended) become the initial contents of the unprocessed word list. A push-down stack will also be used during execution; it is initially empty. Execution of the sentence is performed by repetition of the parsing step which comprises: (1) examining the top 4 elements of the stack to see if they match one of the 9 executable patterns; (2) if a match was found, executing the executable portion of the stack (what we called the executable fragment in the last chapter), resulting in a single word which replaces the fragment on the stack; (3) if no match was found, moving the rightmost word of the unprocessed word list into the leftmost position of the stack, pushing the rest of the stack to the right. Execution finishes when there are no unprocessed words and the stack does not contain an executable pattern. Note that execution of a fragment may leave the stack matching one of the executable patterns, so several sequential parsing steps may perform an execution without moving anything onto the stack. After all words have been processed, the stack should contain a beginning-of-line marker followed by a single word which becomes the result of the sentence.
To follow the parsing we need to know what patterns at the top of the stack contain an executable fragment. The parsing table below gives the complete list. More than one symbol in a box means that any one of them matches the box. name means any valid variable name, and C, A, V, and N stand for conjunction, adverb, verb, and noun respectively.
|
leftmost
stack word |
other
stack words |
action |
||
|
$ =. =: ( |
V |
N |
anything |
0 Monad |
|
$ =. =: ( A V N |
V |
V |
N |
1 Monad |
|
$ =. =: ( A V N |
N |
V |
N |
2 Dyad |
|
$ =. =: ( A V N |
V N |
A |
anything |
3 Adverb |
|
$ =. =: ( A V N |
V N |
C |
V N |
4 Conj |
|
$ =. =: ( A V N |
V N |
V |
V |
5 Fork |
|
$ =. =: ( |
C A V N |
C A V N |
anything |
6 Hook/Adverb |
|
name N |
=. =: |
C A V N |
anything |
7 Is |
|
( |
C A V N |
) |
anything |
8 Paren |
The lines in the parsing table are processed in order. If the leftmost 4 words on the stack match a line in the table, the fragment (those words on the stack which are in boldface in the parsing table) is executed and replaced on the stack by the single word returned. Because the fragment is always either two or three words long, it is officially known as a bident or trident. The last column of the parsing table gives a description of what execution of the fragment entails.
You will have an easier time following the parsing if you note that the leftmost word in the executable pattern is usually one of $ =. =: ( A V N . This means that you can scan from the right until you hit a word that matches one of those before you even start checking for an executable pattern. If you find one of $ =. =: ( A V N and it doesn't match an executable pattern, keep looking for the next occurrence.
Note that the leftmost stack word in the parsing table is never a conjunction. This is the ultimate source of our long-noted rule that conjunctions associate left-to-right: a conjunction can be executed only when it appears in the third stack position, but if another conjunction is in the leftmost position then, the stack will always be pushed down to examine that conjunction's left argument.
Line 6, defining hooks, is matched for any combination of CAVN CAVN except N A and V A which are matched in line 3. Only the combinations A A, C N, C V, N C, V C, and V V are valid; the rest result in syntax errors.
Examples Of Parsing And Execution
We will now follow a few sentences through parsing. We will represent anonymous entities by names in italics, with an indication of how the anonymous entity was created. Up till now in this book we have scarcely noticed that the term 'verb' was used both for an entity that can be applied to a noun to produce a noun result, and also for the name of that entity. This ambiguity will continue--being precise would be too cumbersome--but you should be aware of it. When we say 'the result is av, defined as +/', that means that an anonymous verb was created whose function is described as +/, and the nickname we are giving it--the word, that is, that goes on the execution stack to betoken this verb--is av.
Sentence: +/2*a where a is 1 2 3
|
unprocessed word list |
stack |
line |
|
$ + / 2 * a |
|
|
|
$ + / 2 * |
1 2 3 (not executable) |
|
|
$ + / 2 |
* 1 2 3 (not executable) |
|
|
$ + / |
2 * 1 2 3 (not executable) |
|
|
$ + |
/ 2 * 1 2 3 (result 2 4 6) |
2 |
|
|
$ + / 2 4 6 (result av, defined as +/) |
3 |
|
|
$ av 2 4 6 (result 12) |
0 |
|
|
$ 12 |
|
The column labeled 'line' indicates which line of the parsing table was matched by the stack. The fragment is marked in boldface and underlined. Note that when the noun a moved onto the stack, its value was moved; when a named verb, adverb, or conjunction is moved onto the stack, only the name is moved. Note also that the noun's value (1 2 3 here) is a single word.
From now on we will omit the lines that do not contain an executable fragment.
Sentence: mean =: +/ % #
|
unprocessed word list |
stack |
line |
|
$ mean =: + / % # |
|
|
|
$ mean |
=: + / % # (result av1, defined as +/) |
3 |
|
$ mean |
=: av1 % # (result av2, defined as av1 % #) |
5 |
|
|
$ mean =: av2 (result av2; mean is assigned av2) |
7 |
|
|
$ av2 |
|
I want to emphasize that what is assigned to mean is the result of parsing +/ % # . It is not the sequence +/ % #, but rather a single verb which performs the function described by the fork. Now you see why putting parentheses around the definition doesn't matter: av2 would be parsed the same either way.
|
unprocessed word list |
stack |
line |
|
$ mean 4 5 6 |
|
|
|
|
$ mean 4 5 6 (result 5) |
0 |
|
|
$ 5 |
|
Sentence: mean 4 5 6
Since mean is the result from parsing +/ % #, it is executed without further ado. As you can see, a single 'execution' step can trigger a cascade of processing as each verb referred to by an executing verb is executed in turn. Here, execution of mean does the entire processing of the fork, returning the result 5 . The verb to be executed can be quite complex, and can have a mixture of named and anonymous components, as in the next example.
Sentence: (mean - (+/ % #)&.(^."1)) 4 5 6 (find the difference between arithmetic and geometric mean)
|
unprocessed word list |
stack |
line |
|
$ ( mean - ( + / % # ) &. ( ^. " 1 ) ) 4 5 6 |
|
|
|
$ ( mean - ( + / % # ) &. |
( ^. " 1 ) ) 4 5 6 (result av1, defined as ^. " 1) |
4 |
|
$ ( mean - ( + / % # ) &. |
( av1 ) ) 4 5 6 (result av1) |
8 |
|
$ ( mean - |
( + / % # ) &. av1 ) 4 5 6 (result av2, defined as +/ |
3 |
|
$ ( mean - |
( av2 % # ) &. av1 ) 4 5 6 (result av3, defined as av2 % #) |
5 |
|
$ ( mean - |
( av3 ) &. av1 ) 4 5 6 (result av3) |
8 |
|
$ ( mean |
- av3 &. av1 ) 4 5 6 (result av4, defined as av3 &. av1) |
4 |
|
$ |
( mean - av4 ) 4 5 6 (result av5, defined as mean - av4) |
5 |
|
$ |
( av5 ) 4 5 6 (result av5) |
8 |
|
|
$ av5 4 5 6 (result 0.0675759) |
0 |
|
|
$ 0.0675759 |
|
Again, there was only one execution of a verb. It happened at the very end: after av5 was created, it was executed, and its execution included the execution of everything else. av5 executed to produce mean - av4; to do that it executed av4, then mean, then -, and so on up the line. Each executed entity produced a result in accordance with its definition.
Sentence: inc =: ({.a)&+ where a is 4 5 6
|
unprocessed word list |
stack |
line |
|
$ inc =: ( {. a ) & + |
|
|
|
$ inc =: |
( {. 4 5 6 ) & + (result 4) |
0 |
|
$ inc =: |
( 4 ) & + (result 4) |
8 |
|
$ inc |
=: 4 & + (result av, defined as 4&+) |
4 |
|
$ |
inc =: av (result av; inc is assigned av) |
7 |
|
|
$ av |
|
This illustrates an important point. Even in the middle of a complex definition, verbs are applied to nouns wherever possible. And, the value of a noun in a definition is the value at the time the definition was parsed. If a parsed definition refers to a verb, it does so by name, so the value of a verb is its value when it is executed.
The remaining examples are curiosities to show you that it's worth your trouble to learn the intricacies of parsing.
Sentence: a + a =. 5
|
unprocessed word list |
stack |
line |
|
$ a + a =. 5 |
|
|
|
$ a + |
a =. 5 (result is 5; a is assigned 5) |
0 |
|
|
$ 5 + 5 (result is 10) |
2 |
|
|
$ 10 |
|
a is assigned a value just before that value is pushed onto the stack.
Sentence: 2 +: (2 : '&') -: * 5
|
unprocessed word list |
stack |
line |
|
$ 2 +: ( 2 : '&' ) -: * 5 |
|
|
|
$ 2 +: |
( 2 : '&' ) -: * 5 (result is ac1, defined as 2 : '&') |
4 |
|
$ 2 +: |
( ac1 ) -: * 5 (result is ac1) |
8 |
|
$ |
2 +: ac1 -: * 5 (result is ac2, defined as &) |
4 |
|
|
$ 2 ac2 * 5 (result is av, defined as 2&*) |
4 |
|
|
$ av 5 (result is 10) |
0 |
|
|
$ 10 |
|
Look at what happens when we omit the parentheses:
Sentence: 2 +: 2 : '&' -: * 5
|
unprocessed word list |
stack |
line |
|
$ 2 +: 2 : '&' -: * 5 |
|
|
|
$ 2 +: 2 : |
'&' -: * 5 (result is 1) |
1 |
|
$ 2 |
+: 2 : '&' -: 1 (result is ac1, defined as 2 : '&') |
4 |
|
$ |
2 +: ac1 -: 1 (result is ac2, defined as &) |
4 |
|
|
$ 2 ac2 1 (domain error: 2&1 is illegal) |
4 |
The omission produces a subtle but fatal change in the parsing order. As the Dictionary says, "it may be necessary to parenthesize an adverbial or conjunctival phrase that produces anything other than a noun or verb". Now you see why.
If you try to execute a nonexistent verb, you get an error:
z 5
|value error: z
| z 5
However, that error occurs during execution of the name, not during its parsing. During parsing, an undefined name is assumed to be a verb of infinite rank. This allows you to write verbs that refer to each other, and relieves you from having to be scrupulous about the order in which you define verbs. For example:
a =: z
This produces a verb a which, when executed, will execute z.
z =: +
a 5
5
With z defined, a executes correctly. Of course, it's OK to assign z to another verb too:
b =: z
b 5
5
Now, can you tell me what +/@b 1 2 3 will do? Take a minute to figure it out (Hint: note that I used @ rather than @:).
+/@b 1 2 3
1 2 3
Because b has rank 0, +/@b also has rank zero, so the 'summing' is applied to atoms individually and we get a list result. Do you think +/@a 1 2 3 will have the same result?
+/@a 1 2 3
6
Even though a has the same value as b, its rank is different. a's rank was assigned when it was parsed, and at that time z was assumed to have infinite rank. b's rank was assigned when it was parsed too, but by that time z had been defined with rank 0. You can win a lot of bar bets with this one if you hang out with the right crowd.
Note
Avoid using the parameter names x, y, u, v, m, and n for your own public variables. Those names are reassigned whenever an explicitly-defined entity starts. Also, when an explicit definition is running, those names are always evaluated before they are put onto the stack (in other words, they are passed by value rather than by name, even if they are verbs). Therefore, they produce value error if they are undefined when used.


Toggle navigation
Home
Dashboard
About Us
Features
Gallery
Blog
Contact
404, Page not found
The Page you are looking for doesn't exist or an other error occurred.
GO BACK TO THE HOMEPAGE


General
Password
Name:
Edit
Lastname:
Edit
Email:
Edit
Enter a valid email.
pic:
Save
Old Password:
New Password:
Retype new password:
Enter a valid email.
Save


What type of Triangle?
Enter your first side here:
Side two:
Side three:
Make that triangle!
Your triangle type is:


Ontrack
{{ user.account.fullName }}
{{ message.content }}
×
{{notificationContent()}}
Ontrack is loading its components and will be available shortly...
Ontrack application could not be loaded.
{{appLoadingError}}


When is this medication taken?
Take with food?
Default units taken per dose
For how long?
How often?
How many days between dosings?
Which days?
How many times a day do you take this medicine?


{{define "body"}} {{if ne .User.ID 0}}
Welcome {{.User.FirstName}}.
{{.ErrorMessage}}
{{end}} {{if .Shouts}} {{range $shout := .Shouts}}Shoutr is a new kind of web 3.0 social media platform.
With Shoutr, you can shout your opinions on the Internet!
Sign up for an account today to access the content in our walled garden.
Sign Up | Login {{end}} {{end}}


Thai Boxing, sometimes referred to as "Muay Thai", is a combat sport that uses stand-up striking along with various clinching techniques. This discipline is known as the "art of eight limbs" as it is characterized by the combined use of fists, elbows, knees and shins. Thai Boxing is more than just a practical system for self-defense. It is a fun and effective way to get in shape and promote personal health and well being.
Zack Fox is a 3x Thai Boxing champion in the 159-165 weight class. He and has 8+ years of experience in Thai Boxing with 16 fights, four of which were won by knockout. He has traveled to many locations both within and outside of the United States to train and compete.


"We shape our tools and thereafter our tools shape us.”
What I Do
I build products to help people be happier, more productive, and accomplish their goals.
Recently I've been working on building Web Applications as well as publishing native iOS apps.
Teaching
CS61A : Structure & Interpretation of Computer Programs — Fall 2014
Questions? Send me an email or reach out on twitter


ls | List files in the directory |
cd | Change directory |
rm | Remove file or directory(-r) |
cp | Copy file or directory(-r) |
mv | Move file or directory |
wc | Count words in file |
man | Read the manual |
cat | Reads content of files sequentially |
mkdir | Make new directory |
date | Show system date |
grep | Searches text for matches of a regular expression |
tail | Displays the tail end of a file or data |
ls > foo | Send output from ls into file foo |
wc < foo | Receive input from file foo into wc |
ls | wc | Connect output of ls into input of wc |
-a | All, Append | -n | Number |
-b | Buffer, Batch | -o | Output |
-c | Command, Check | -p | Port |
-d | Debug, Delete, Directory | -q | Quiet, Quit |
-e | Execute, Edit | -r | Recurse |
-f | File, Force | -s | Silent |
-g | Group | -t | Tag |
-h | Headers, Help | -u | User |
-i | Interactive | -v | Verbose, Version |
-j | -w | Width | |
-k | Keep | -x | Extract |
-l | List | -y | Yes |
-m | Message | -z |


|
| Value |
Description |
Notes |
|
| 01 |
Supplier’s sales classification |
A rating applied by a supplier (typically a wholesaler) to indicate its assessment of the expected or actual sales performance
of a product.
|
| 02 |
Supplier’s bonus eligibility |
A supplier’s coding of the eligibility of a product for a bonus scheme on overall sales. |
| 03 |
Publisher’s sales classification |
A rating applied by the publisher to indicate a sales category (eg backlist/frontlist, core stock etc). Use only when the
publisher is not the ‘supplier’.
|
| 04 |
Supplier’s pricing restriction classification |
A classification applied by a supplier to a product sold on Agency terms, to indicate that retail price restrictions are applicable. |
|


Would you like to play on a
Single PC
or
Online
How many players?
{{n}}
Enter your Steam Name/ID
Loading
You should play
{{ game.name }}
Play Game
Not what you want? Find another game.
Start over
{{ error }}
Try again


<dependency>
<groupId>com.tinkerpop.blueprints</groupId>
<artifactId>blueprints-neo4j-graph</artifactId>
<version>??</version>
</dependency>
Graph graph = new Neo4jGraph("/tmp/neo4j");
Neo Technology are the developers of the Neo4j graph database. Neo4j natively supports the property graph data model. Note that Neo4j requires that the value objects in the property map of an element be Java primitives, java.lang.String
values, or arrays of primitives and java.lang.String
values. Neo4jElement
will also accept a Collection
of like primitives or java.lang.String
values and will convert those to the appropriate array type for storage in Neo4j.
supportsDuplicateEdges: true
supportsSelfLoops: true
supportsSerializableObjectProperty: false
supportsBooleanProperty: true
supportsDoubleProperty: true
supportsFloatProperty: true
supportsIntegerProperty: true
supportsPrimitiveArrayProperty: true
supportsUniformListProperty: true
supportsMixedListProperty: false
supportsLongProperty: true
supportsMapProperty: false
supportsStringProperty: true
ignoresSuppliedIds: true
isPersistent: true
isRDFModel: false
isWrapper: false
supportsIndices: true
supportsVertexIndex: true
supportsEdgeIndex: true
supportsKeyIndices: true
supportsVertexKeyIndex: true
supportsEdgeKeyIndex: true
supportsEdgeIteration: true
supportsVertexIteration: true
supportsTransactions: true
supportsThreadedTransactions: false
It is possible to parameterize the indices created through Blueprints. Learn more about the types of indices supported by Neo4j at this location.
Index<Vertex> index = graph.createIndex("myIdx", Vertex.class, new Parameter("analyzer", LowerCaseKeywordAnalyzer.class.getName()));
Vertex a = graph.addVertex(null);
a.setProperty("name", "marko");
index.put("name", "marko", a);
Iterator itty = graph.getIndex("myIdx", Vertex.class).query("name", "MaRkO").iterator();
assertEquals(itty.next(), a);


ROUTEL
Section: Linux (8)Updated: 3 Jan, 2008
Index Return to Main Contents
NAME
routel - list routes with pretty output format
routef - flush routes
SYNTAX
routel [tablenr [raw ip args...]]
routef
DESCRIPTION
These programs are a set of helper scripts you can use instead of raw iproute2 commands.
The routel script will list routes in a format that some might consider easier to interpret then the ip route list equivalent.
The routef script does not take any arguments and will simply flush the routing table down the drain. Beware! This means deleting all routes which will make your network unusable!
FILES
/usr/bin/routef
/usr/bin/routel
AUTHORS
The routel script was written by Stephen R. van den Berg<EMAIL_ADDRESS>1999/04/18 and donated to the public domain.
This manual page was written by Andreas Henriksson<EMAIL_ADDRESS>for the Debian GNU/Linux system.
SEE ALSO
ip(8)
Index
This document was created by man2html, using the manual pages.
Time: 05:34:29 GMT, December 24, 2015


- getBilling(double, double, double) - Static method in class tax_return_calculator.TaxReturn
-
Calculates and returns the bill of the user.
- getBye() - Static method in class tax_return_calculator.TaxReturn
-
Prints a goodbye statement.
- getConsultTime() - Static method in class tax_return_calculator.TaxReturn
-
Ask the user for their amount of consulting time they used and return their answer.
- getIncome() - Static method in class tax_return_calculator.TaxReturn
-
Ask the user for their yearly income and return their answer.
- getOption() - Static method in class tax_return_calculator.TaxReturn
-
Ask the user for their continuation status and return their answer.
- getOutput(double, double, double, double) - Static method in class tax_return_calculator.TaxReturn
-
Prints the final calculated bill and data of the user.
- getRate() - Static method in class tax_return_calculator.TaxReturn
-
Ask the user for their hourly rate of income and return their answer.


/* User manual and reference guide */
CodeMirror is a code-editor component that can be embedded in Web pages. It provides only the editor component, no accompanying buttons (see CodeMirror UI for a drop-in button bar), auto-completion, or other IDE functionality. It does provide a rich API on top of which such functionality can be straightforwardly implemented.
CodeMirror works with language-specific modes. Modes are JavaScript
programs that help color (and optionally indent) text written in a
given language. The distribution comes with a few modes (see the
mode/
directory), and it isn't hard to write new
ones for other languages.
The easiest way to use CodeMirror is to simply load the script and
style sheet found under
lib/
in the distribution, plus the script and style sheet for the mode(s)
you want to use. (See also the
compresion helper.) For example:
<script src="lib/codemirror.js"></script> <link rel="stylesheet" href="lib/codemirror.css"> <script src="mode/javascript/javascript.js"></script> <link rel="stylesheet" href="mode/javascript/javascript.css">
Having done this, an editor instance can be created like this:
var myCodeMirror = CodeMirror(document.body);
The editor will be appended to the document body, will start empty,
and will use the mode that we loaded. To have more control over the
new editor, a configuration object can be passed to
CodeMirror
as a second argument:
var myCodeMirror = CodeMirror(document.body, { value: "function myScript(){return 100;}\n", mode: "javascript" });
This will initialize the editor with a piece of code already in it, and explicitly tell it to use the JavaScript mode (which is useful when multiple modes are loaded). See below for a full discussion of the configuration options that CodeMirror accepts.
In cases where you don't want to append the editor to an element,
and need more control over the way it is inserted, the first
argument to the
CodeMirror
function can also be a function that, when given a DOM element,
inserts it into the document somewhere. This could be used to, for
example, replace a textarea with a real editor:
var myCodeMirror = CodeMirror(function(elt) { myTextArea.parentNode.replaceChild(elt, myTextArea); }, {value: myTextArea.value});
However, for this use case, which is a common way to use CodeMirror, the library provides a much more powerful shortcut:
var myCodeMirror = CodeMirror.fromTextArea(myTextArea);
This will, among other things, ensure that the textarea's value is updated when the form (if it is part of a form) is submitted. See the API reference for a full description of this method.
Both the
CodeMirror
function and its
fromTextArea
method take as second (optional) argument an object containing
configuration options. Any option not supplied like this will be
taken from
CodeMirror.defaults
, an object containing the default options. You can update this
object to change the defaults on your page.
Options are not checked in any way, so setting bogus option values is bound to lead to odd errors.
Note: CodeMirror 2 does not support line-wrapping. I would have very much liked to support it, but it combines extremely poorly with the way the editor is implemented.
These are the supported options:
value (string)
mode (string or object)
name
property that names the mode (for example
{name: "javascript", json: true}
). The demo pages for each mode contain information about what
configuration parameters the mode supports. You can ask CodeMirror
which modes and MIME types are loaded with the
CodeMirror.listModes
and
CodeMirror.listMIMEs
functions.
indentUnit (integer)
indentWithTabs (boolean)
tabMode (string)
"classic" (the default)
"shift"
mode. (When shift is held, this behaves like the
"indent"
mode.)
"shift"
indentUnit
.
If shift was held while pressing tab, un-indent all selected
lines one unit.
"indent"
"default"
enterMode (string)
"indent" (the default)
"keep"
"flat"
electricChars (boolean)
lineNumbers (boolean)
firstLineNumber (integer)
gutter (boolean)
readOnly (boolean)
"nocursor"
as a value for this option, instead of
true
.
onChange (function)
onCursorActivity (function)
onChange
, but will also be called when the cursor moves without any changes
being made.
onGutterClick (function)
onFocus, onBlur (function)
onScroll (function)
onHighlightComplete (function)
matchBrackets (boolean)
workTime, workDelay (number)
workTime
milliseconds, and then use timeout to sleep for
workDelay
milliseconds. The defaults are 200 and 300, you can change these
options to make the highlighting more or less aggressive.
undoDepth (integer)
tabindex (integer)
document (DOM document)
document
object.
onKeyEvent (function)
keydown
,
keyup
, and
keypress
event that CodeMirror captures. It will be passed two arguments,
the editor instance and the key event. This key event is pretty
much the raw key event, except that a
stop()
method is always added to it. You could feed it to, for example,
jQuery.Event
to further normalize it.keydown
does not stop the
keypress
from firing, whereas on others it does. If you respond to an event,
you should probably inspect its
type
property and only do something when it is
keydown
(or
keypress
for actions that need character data).
Up to a certain extent, CodeMirror's look can be changed by
modifying style sheet files. The style sheets supplied by modes
simply provide the colors for that mode, and can be adapted in a
very straightforward way. To style the editor itself, it is possible
to alter or override the styles defined in codemirror.css
.
Some care must be taken there, since a lot of the rules in this file are necessary to have CodeMirror function properly. Adjusting colors should be safe, of course, and with some care a lot of other things can be changed as well. The CSS classes defined in this file serve the following roles:
CodeMirror
overflow: auto
+ fixed height). Can also be used to set styles that should hold
for everything inside the editor, or to set a background.
CodeMirror-focused
CodeMirror-gutter
CodeMirror-gutter-text
for that. By default, the gutter is 'fluid', meaning it will adjust
its width to the maximum line number or line marker width. You can
also set a fixed width if you want.
CodeMirror-gutter-text
CodeMirror-lines
class.
CodeMirror-lines
CodeMirror-gutter
should have the same padding.
CodeMirror-cursor
CodeMirror-selected
span
elements with this class.
CodeMirror-matchingbracket
,
CodeMirror-nonmatchingbracket
The actual lines, as well as the cursor, are represented by
pre
elements. By default no text styling (such as bold) that might
change line height is applied. If you do want such effects, you'll
have to give
CodeMirror pre
a fixed height. Also, you must still take care that character width
is constant.
If your page's style sheets do funky things to all
div
or
pre
elements (you probably shouldn't do that), you'll have to define
rules to cancel these effects out again for elements under the
CodeMirror
class.
A lot of CodeMirror features are only available through its API. This has the disadvantage that you need to do work to enable them, and the advantage that CodeMirror will fit seamlessly into your application.
Whenever points in the document are represented, the API uses
objects with
line
and
ch
properties. Both are zero-based. CodeMirror makes sure to 'clip' any
positions passed by client code so that they fit inside the
document, so you shouldn't worry too much about sanitizing your
coordinates. If you give
ch
a value of
null
, or don't specify it, it will be replaced with the length of the
specified line.
getValue() → string
setValue(string)
getSelection() → string
replaceSelection(string)
focus()
setOption(option, value)
option
should the name of an option, and
value
should be a valid value for that option.
getOption(option) → value
cursorCoords(start) → object
{x, y, yBot}
object containing the coordinates of the cursor relative to the
top-left corner of the page.
yBot
is the coordinate of the bottom of the cursor.
start
is a boolean indicating whether you want the start or the end of
the selection.
charCoords(pos) → object
cursorCoords
, but returns the position of an arbitrary characters.
pos
should be a
{line, ch}
object.
coordsChar(object) → pos
{x, y}
object (in page coordinates), returns the
{line, ch}
position that corresponds to it.
undo()
redo()
historySize() → object
{undo, redo}
properties, both of which hold integers, indicating the amount of
stored undo and redo operations.
indentLine(line)
getSearchCursor(query, start, caseFold) → cursor
query
can be a regular expression or a string (only strings will match
across lines—if they contain newlines).
start
provides the starting position of the search. It can be a
{line, ch}
object, or can be left off to default to the start of the document.
caseFold
is only relevant when matching a string. It will cause the search
to be case-insensitive. A search cursor has the following methods:
findNext(), findPrevious() → boolean
match
method, in case you want to extract matched groups.
from(), to() → object
findNext
or
findPrevious
did not return false. They will return
{line, ch}
objects pointing at the start and end of the match.
getTokenAt(pos) → object
{line, ch}
object). The returned object has the following properties:
start
end
string
className
markText(from, to, className) → function
from
and
to
should be
{line, ch}
objects. The method will return a function that can be called to
remove the marking.
setMarker(line, text, className) → lineHandle
text
and
className
are optional. Setting
text
to a Unicode character like ● tends to give a nice effect. To put a
picture in the gutter, set
text
to a space and
className
to something that sets a background image. If you specify
text
, the given text (which may contain HTML) will, by default, replace
the line number for that line. If this is not what you want, you
can include the string
%N%
in the text, which will be replaced by the line number.
clearMarker(line)
setMarker
.
line
can be either a number or a handle returned by
setMarker
(since a number may now refer to a different line if something was
added or deleted).
setLineClass(line, className) → lineHandle
line
can be a number or a line handle (as returned by
setMarker
or this function). Pass
null
to clear the class for a line.
lineInfo(line) → object
setMarker
. The returned object has the structure
{line, text, markerText, markerClass}
.
addWidget(pos, node, scrollIntoView)
node
, which should be an absolutely positioned DOM node, into the
editor, positioned right below the given
{line, ch}
position. When
scrollIntoView
is true, the editor will ensure that the entire node is visible (if
possible). To remove the widget again, simply use DOM methods (move
it somewhere else, or call
removeChild
on its parent).
matchBrackets()
lineCount() → number
getCursor(start) → object
start
is a boolean indicating whether the start or the end of the
selection must be retrieved. If it is not given, the current cursor
pos, i.e. the side of the selection that would move if you pressed
an arrow key, is chosen. A
{line, ch}
object will be returned.
somethingSelected() → boolean
setCursor(pos)
{line, ch}
object, or the line and the character as two separate parameters.
setSelection(start, end)
start
and
end
should be
{line, ch}
objects.
getLine(n) → string
n
.
setLine(n, text)
n
.
removeLine(n)
getRange(from, to) → string
{line, ch}
objects.
replaceRange(string, from, to)
from
and
to
with the given string.
from
and
to
must be
{line, ch}
objects.
to
can be left off to simply insert the string at position
from
.
The following are more low-level methods:
operation(func) → result
refresh()
getInputField() → textarea
getWrapperElement() → node
Finally, the
CodeMirror
object itself has a method
fromTextArea
. This takes a textarea DOM node as first argument and an optional
configuration object as second. It will replace the textarea with a
CodeMirror instance, and wire up the form of that textarea (if any)
to make sure the editor contents are put into the textarea when the
form is submitted. A CodeMirror instance created this way has two
additional methods:
save()
toTextArea()
Modes typically consist of a JavaScript file and a CSS file. The CSS
file (see, for example javascript.css
)
defines the classes that will be used to style the syntactic
elements of the code, and the script contains the logic to actually
assign these classes to the right pieces of text.
You'll usually want to use some kind of prefix for your CSS classes, so that they are unlikely to clash with other classes, both those used by other modes and those defined by the page in which CodeMirror is embedded.
The mode script should call
CodeMirror.defineMode
to register itself with CodeMirror. This function takes two
arguments. The first should be the name of the mode, for which you
should use a lowercase string, preferably one that is also the name
of the files that define the mode (i.e.
"xml"
is defined
xml.js
). The second argument should be a function that, given a CodeMirror
configuration object (the thing passed to the
CodeMirror
function) and a mode configuration object (as in the mode
option), returns a mode
object.
Typically, you should use this second argument to
defineMode
as your module scope function (modes should not leak anything into
the global scope!), i.e. write your whole mode inside this function.
The main responsibility of a mode script is parsing the content of the editor. Depending on the language and the amount of functionality desired, this can be done in really easy or extremely complicated ways. Some parsers can be stateless, meaning that they look at one element (token) of the code at a time, with no memory of what came before. Most, however, will need to remember something. This is done by using a state object, which is an object that can be mutated every time a new token is read.
Modes that use a state must define a
startState
method on their mode object. This is a function of no arguments that
produces a state object to be used at the start of a document.
The most important part of a mode object is its
token(stream, state)
method. All modes must define this method. It should read one token
from the stream it is given as an argument, optionally update its
state, and return a CSS class string, or
null
for tokens that do not have to be styled.
By default, blank lines are simply skipped when tokenizing a
document. For languages that have significant blank lines, you can
define a
blankLine(state)
method on your mode that will get called whenever a blank line is
passed over, so that it can update the parser state.
The stream object encapsulates a line of code (tokens may never span lines) and our current position in that line. It has the following API:
eol() → boolean
sol() → boolean
peek() → character
undefined
at the end of the line.
next() → character
undefined
when no more characters are available.
eat(match) → character
match
can be a character, a regular expression, or a function that takes
a character and returns a boolean. If the next character in the
stream 'matches' the given argument, it is consumed and returned.
Otherwise,
undefined
is returned.
eatWhile(match) → boolean
eat
with the given argument, until it fails. Returns true if any
characters were eaten.
eatSpace() → boolean
eatWhile
when matching white-space.
skipToEnd()
skipTo(ch) → boolean
match(pattern, consume, caseFold) → boolean
eat
—if
consume
is true or not given—or a look-ahead that doesn't update the stream
position—if it is false.
pattern
can be either a string or a regular expression starting with
^
. When it is a string,
caseFold
can be set to true to make the match case-insensitive. When
successfully matching a regular expression, the returned value will
be the array returned by
match
, in case you need to extract matched groups.
backUp(n)
n
characters. Backing it up further than the start of the current
token will cause things to break, so be careful.
column() → integer
indentation() → integer
current() → string
Because state object are mutated, and CodeMirror needs to keep valid
versions of a state around so that it can restart a parse at any
line, copies must be made of state objects. The default algorithm
used is that a new state object is created, which gets all the
properties of the old object. Any properties which hold arrays get a
copy of these arrays (since arrays tend to be used as mutable
stacks). When this is not correct, for example because a mode
mutates non-array properties of its state object, a mode object
should define a
copyState
method, which is given a state and should return a safe copy of that
state.
If you want your mode to provide smart indentation (see entermode
and tabMode
when they have a
value of
"indent"
), you must define an
indent(state, textAfter)
method on your mode object.
The indentation method should inspect the given state object, and
optionally the
textAfter
string, which contains the text on the line that is being indented,
and return an integer, the amount of spaces to indent. It should
usually take the indentUnit
option into account.
Finally, a mode may define an
electricChars
property, which should hold a string containing all the characters
that should trigger the behaviour described for the electricChars
option.
So, to summarize, a mode must provide a
token
method, and it may provide
startState
,
copyState
, and
indent
methods. For an example of a trivial mode, see the diff mode, for a more involved
example, see the JavaScript
mode.
Sometimes, it is useful for modes to nest—to have one mode
delegate work to another mode. An example of this kind of mode is
the mixed-mode HTML mode.
To implement such nesting, it is usually necessary to create mode
objects and copy states yourself. To create a mode object, there are
CodeMirror.getMode(options, parserConfig)
, where the first argument is a configuration object as passed to
the mode constructor function, and the second argument is a mode
specification as in the mode
option. To copy a state object, call
CodeMirror.copyState(mode, state)
, where
mode
is the mode that created the given state.
To make indentation work properly in a nested parser, it is
advisable to give the
startState
method of modes that are intended to be nested an optional argument
that provides the base indentation for the block of code. The
JavaScript and CSS parser do this, for example, to allow JavaScript
and CSS code inside the mixed-mode HTML mode to be properly
indented.
Finally, it is possible to associate your mode, or a certain
configuration of your mode, with a MIME type. For
example, the JavaScript mode associates itself with
text/javascript
, and its JSON variant with
application/json
. To do this, call
CodeMirror.defineMIME(mime, modeSpec)
, where
modeSpec
can be a string or object specifying a mode, as in the mode
option.


-
Kyle and Stan Malvertising Network Nine Times Bigger Than First Reported
threatpost.com
The Kyle and Stan malvertising network has compromised more than nine times as many domains as originally reported two weeks ago.
-
Major Bash Vulnerability Affects Linux, UNIX, Mac OS X
threatpost.com
A critical remote code execution vulnerability in Bash, present in almost all Linux, UNIX and Mac OS X deployments, has been discovered. Experts ...
-
POS Service Confirms Goodwill Breach Lasted 18 Months
threatpost.com
Third-party payment vendor C&K Systems released details regarding a breach that affected its systems for 18 months and went on to affect customers ...
-
Series of Vulnerabilities Found in Schneider Electric SCADA Products
threatpost.com
UPDATE--There are several unpatched, remotely exploitable vulnerabilities in a number of Schneider Electric's SCADA products, one of which could be ...
-
Citadel Variant Used in Attacks Against Middle Eastern Petrochemical ...
threatpost.com
IBM reports a variant of the Citadel banking Trojan was spotted in APT-style targeted attacks against petrochemical companies in the Middle East.
-
Honeypot Snares Two Bots Exploiting Bash Vulnerability
threatpost.com
Two malware samples trying to exploit the Bash vulnerability, both DDoS bots, were snared in a honeypot belonging to AlienVault Labs.
-
Patching Bash Vulnerability a Challenge for ICS, SCADA
threatpost.com
Experts are concerned that many Linux-based industrial control systems and embedded systems could be too steep a patching challenge and remain in the ...
-
As Bug Bounties Become the Norm, Challenges Remain
threatpost.com
While bounties have now become commonplace, simply offering one doesn't guarantee any level of success for a vendor.
-
Researchers Work to Predict Malicious Domains
threatpost.com
Some researchers are trying to stay a step ahead of the game by predicting which domains will be used for malicious purposes.
-
More Trouble For jQuery As Second Compromise Reported
threatpost.com
The website for JavaScript library jQuery is under attack for the second time in a week.
-
High-Volume, High-Rate DDoS Attacks Persist
threatpost.com
A new report illustrates the continued proliferation of both high-volume and high-rate distributed denial of service attacks, like the ones executed ...
-
JQuery Website Redirecting to RIG Exploit Kit
threatpost.com
jQuery.com, website for the popular jQuery JavaScript library, is redirecting visitors to a site hosting the RIG exploit kit, security company RiskIQ ...
-
Charney on Trustworthy Computing: 'I Was the Architect of These Changes'
threatpost.com
Scott Charney, the head of Microsoft's Trustworthy Computing efforts, said that he was the one who decided it was time to move the TwC group in a new ...
-
Era Ends With Break Up of Trustworthy Computing Group at Microsoft
threatpost.com
In a move that has surprised many in the security community, Microsoft has disbanded its Trustworthy Computing unit, the group that was responsible ...
-
56 Million Payment Cards At Risk in Home Depot Data Breach
threatpost.com
The Home Depot data breach put 56 million payment cards at risk, the company said today, adding that the attackers used custom malware in the breach.
-
Apple Launches iOS 8, Fixes Dozens of Security Flaws
threatpost.com
Apple has released iOS 8, a massive update to its mobile operating system, that includes fixes for more than 40 security vulnerabilities. Apple is ...
-
Where have all those malware epidemics gone?
business.kaspersky.com
It's been years since we've last heard of any large worm epidemics. Does it really mean that malware epidemics have gone away for good?
-
White House: Internet Not Borderless, But Lacking Interior
threatpost.com
White House special assistant to the President and Cybersecurity Coordinator Micheal Daniel explains that a series of simple, known issues add up to ...
-
Apple Extends Two-Factor Authentication to iCloud
threatpost.com
Apple finally has enabled two-factor authentication for its iCloud storage service, more than a year and a half after the company first turned the ...
-
Apple CEO Defends iMessage Security
threatpost.com
Despite research published last year that demonstrated that Apple has the ability to decrypt users iMessages if it so chooses, Apple CEO Tim Cook ...
-
With MAMA, U.S. Air Force Aiming to Raise Cyber Awareness on Networks
threatpost.com
The United States Air Force is attempting to enhance its cyber situational awareness in order to contend with “increasingly sophisticated” threats to ...
-
SNMP DDoS Scans Spoof Google Public DNS Server
threatpost.com
SNMP-based DDoS attacks spoofing Google's public recursive DNS server have been spotted by the SANS Internet Storm Center.
-
Shellshock DHCP RCE Proof of Concept -
www.trustedsec.com
DHCP bash shellshock POC: 1) Just about any DHCP string value should work for the exploit. Value 114 is URL, which is a string and should be reliable ...
-
New Initiative Simply Secure Aims to Make Security Tools Easier to Use
threatpost.com
The dramatic revelations of large-scale government surveillance and deep penetration of the Internet by intelligence services and other adversaries ...
-
Security Experts Expect Bash Software Bug to Be Significant
www.nytimes.com
The newly discovered bug could allow hackers to write code that could surreptitiously take over a machine, or run their own programs in the ...
-
Mozilla Patches RSA Signature Forgery in Firefox, Thunderbird, NSS
threatpost.com
Users of Mozilla products should update Firefox, NSS, SeaMonkey and Thunderbird in order to obtain fixes for a bug that could let an attacker forge ...
-
Bash Exploit Reported, First Round of Patches Incomplete
threatpost.com
Reports of the first in-the-wild exploits targeting the Bash vulnerability have surfaced, as have complaints the first patches for the bug are ...
-
"Bash" (CVE-2014-6271) vulnerability – Q&A
securelist.com
The “bash” vulnerability is an extremely powerful vulnerability due to its high impact and the ease with which it can be exploited.
-
Home Hacking Made Simple
threatpost.com
David Jacoby looked at all of the Web-enabled devices in his house--TV, game console, network storage device--and found a handful of exploitable bugs ...
-
Small Signs of Progress on DNSSEC
threatpost.com
The Internet hasn't been quick to adopt DNSSEC, for a variety of reasons, but experts say that there are some reasons to be optimistic about the ...


When styling a page, all HTML elements are considered boxes, which consists of the HTML content, padding, border, and margin. This is called the Box Model. The content is in the center and is surrounded by a border. Padding allows us to control the space between the element and the border, while margin allows us to place space between elements (outside of the border). Top, right, left, and bottom border, margin and padding can be styled separately. Border has a width property which refers to the weight of the line and a style (solid, dotted, dashed, etc) must be declared.
Shorthand border: 5px solid red; will produce
background-color: lightblue; border: 5px solid red; padding: 50px 100px; will produce:
and p { background-color: lightblue; border: 5px solid red; padding: 50px 100px; } p.ex { margin: 100px 50px; }
The first paragraph has no margin and the second does have margins.
| T-1 | T-2 | T-3 | T-4 | T-5 | T-6 | T-7 | T-8 |
| C-1 | C-3 | C-4 | C-5 | C-6 | C-7 | C-8 | C-9 |


JPV Motorcycle Shop
See more snippets like this online store item at JPV - http://jpvmotorcycleshop.com.
This is a short description. Lorem ipsum dolor sit amet, consectetur adipiscing elit.


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.apache.xalan.xsltc.dom.NodeSortRecord
public abstract class NodeSortRecord
Base class for sort records containing application specific sort keys
| Field Summary | |
|---|---|
protected java.text.Collator |
_collator
Deprecated. This field continues to exist for binary compatibility. New code should not refer to it. |
protected CollatorFactory |
_collatorFactory
|
protected java.text.Collator[] |
_collators
|
private DOM |
_dom
|
private int |
_last
|
protected java.util.Locale |
_locale
Deprecated. This field continues to exist for binary compatibility. New code should not refer to it. |
private int |
_node
|
private int |
_scanned
|
protected SortSettings |
_settings
|
private java.lang.Object[] |
_values
|
static int |
COMPARE_ASCENDING
|
static int |
COMPARE_DESCENDING
|
static int |
COMPARE_NUMERIC
|
static int |
COMPARE_STRING
|
private static java.text.Collator |
DEFAULT_COLLATOR
Deprecated. This field continues to exist for binary compatibility. New code should not refer to it. |
| Constructor Summary | |
|---|---|
NodeSortRecord()
|
|
NodeSortRecord(int node)
This constructor is run by a call to ClassLoader in the makeNodeSortRecord method in the NodeSortRecordFactory class. |
| Method Summary | |
|---|---|
int |
compareDocOrder(NodeSortRecord other)
|
int |
compareTo(NodeSortRecord other)
Compare this sort element to another. |
abstract java.lang.String |
extractValueFromDOM(DOM dom,
int current,
int level,
AbstractTranslet translet,
int last)
Extract the sort value for a level of this key. |
java.text.Collator[] |
getCollator()
Returns the array of Collators used for text comparisons in this object. |
int |
getNode()
Returns the node for this sort object |
void |
initialize(int node,
int last,
DOM dom,
SortSettings settings)
This method allows the caller to set the values that could not be passed to the default constructor. |
private java.lang.Double |
numericValue(int level)
|
private java.lang.Comparable |
stringValue(int level)
Get the string or numeric value of a specific level key for this sort element. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
public static final int COMPARE_STRING
public static final int COMPARE_NUMERIC
public static final int COMPARE_ASCENDING
public static final int COMPARE_DESCENDING
private static final java.text.Collator DEFAULT_COLLATOR
protected java.text.Collator _collator
protected java.text.Collator[] _collators
protected java.util.Locale _locale
protected CollatorFactory _collatorFactory
protected SortSettings _settings
private DOM _dom
private int _node
private int _last
private int _scanned
private java.lang.Object[] _values
| Constructor Detail |
|---|
public NodeSortRecord(int node)
public NodeSortRecord()
| Method Detail |
|---|
public final void initialize(int node, int last, DOM dom, SortSettings settings) throws TransletException
TransletException
public final int getNode()
public final int compareDocOrder(NodeSortRecord other)
private final java.lang.Comparable stringValue(int level)
private final java.lang.Double numericValue(int level)
public int compareTo(NodeSortRecord other)
public java.text.Collator[] getCollator()
public abstract java.lang.String extractValueFromDOM(DOM dom, int current, int level, AbstractTranslet translet, int last)
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


How To Migrate 32 Bit Thunderbird To 64 Bit On Windows Ghacks Tech News
Mozilla Thunderbirdを64ビット版に移行する手順解説 Enjoypclife Net
Thunderbird Make Email Easier Thunderbird
Thunderbird 64bit Version
Mozilla Thunderbird 78 10 0 64 Bit Free Download Software Reviews Downloads News Free Trials Freeware And Full Commercial Software Downloadcrew
Thunderbird 64 Bit Download 2021 Latest For Windows 10 8 7
Download Mozilla Thunderbird For Windows Xp 32 64 Bit In English
Mozilla Thunderbird Portable 78 10 0 Free Download Software Reviews Downloads News Free Trials Freeware And Full Commercial Software Downloadcrew
Thunderbird 78 0 Release Imminent Ghacks Tech News
Mozilla Thunderbird 78 Officially Released With Major Changes Here S What S New 9to5linux
Thunderbird 64bit版 のバージョン 78 に移行してみる
Thunderbird 78 10 0 64 Bit For Windows Download
Thunderbird 68 X Update Loop Due To Phantom Updates Born S Tech And Windows World
Mozilla Earlybird 82 0a1 64 Bit Free Download Software Reviews Downloads News Free Trials Freeware And Full Commercial Software Downloadcrew
Thunderbird 78 0 Major Update Is Now Available For Download
Mozilla Thunderbird 52 9 0 Offline Installer Free Download
Thunderbird 68 0 Revamps App Menu And Options Dialog Unveils 64 Bit Windows Release Betanews
Add Windows 64 Bit Version Download Link To Https Www Thunderbird Net Thunderbird Beta All Issue 49 Thundernest Thunderbird Website Github
Upgrade To Thunderbird 64 Bit And Go Supersonic Scottie S Tech Info
Https Encrypted Tbn0 Gstatic Com Images Q Tbn And9gcryxjcak8h6f9a7bcx2quihqsuwcjmegs05x9fqeqaf2qjjt4pe Usqp Cau
Thunderbird 60 9 0 Is Released Solved Windows 10 Forums
Download Mozilla Thunderbird 64 32 Bit For Windows 10 Pc Free
Mozilla Thunderbird 60 6 1 Free Download Pc Wonderland
Thunderbird 60 Released
Imperialwicket X86 64 64 Bit Thunderbird And Firefox From Mozilla
Thunderbird 68 8 0 Neowin


{% block head %}{% endblock %}
Home
Shop
Products
App 1
App 2
Product 1722324
Account
{% block content %}{% endblock %}


Mentor Name
mentor[at]gmail[dot]com
+919898989898
He is one of the fastest
growing entrepreneurs
in India. He is the founder and CEO of Imagesbazaaar.com, the
largest collection of Indian
Stock images, which eliminates the need for brands to conduct their own photo shoot ultimately
saving their time and
money and the same time.


| Table 1 |
Summary of estimated flood losses over the past few years in ... |
| Table 2 |
Overview of water-related pathogens (both waterborne and vec ... |
| Table 3 |
Potentially strong relationships between exposure situations ... |
| Table 4 |
Potential impact of major climatic elements on agriculture a ... |
| Table 5 |
Dengue fever cases reported in Pakistan. |


Given a matrix of dimension mxn M -yields-> R or C ,where R (C) is a row (column) vector of dimension 1xn (nx1).
All operations on a matrix fitting this pattern can be found in this package!


public class AcceptFlags
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
static int |
CREATE_CURRENT_PATCH
This flag is used in conjunction with the
PATCH_CHANGESETS_WITH_GAPS
flag. |
static int |
CREATE_CURRENT_PATCH_WITH_AUTO_RESOLVE
This flag is used in conjunction with the
PATCH_CHANGESETS_WITH_GAPS
flag. |
static int |
CURRENT_PATCH_HANDLING_MASK
Mask used to extract the current port handling directive from the accept flags
|
static int |
DEFAULT
Perform the operation without any special options.
|
static int |
DO_NOT_REORDER
Perform the operation without re-ordering.
|
static int |
INITIATE_AUTO_PATCH
This flag is used in conjunction with the
PATCH_CHANGESETS_WITH_GAPS
flag. |
static int |
PATCH_CHANGESETS_WITH_GAPS
If there is a gap introduced by the accept, let the accept proceed and
have any gapped change sets be queued as pending ports.
|
static int |
PREFLIGHT
Perform the operation in preflight/read-only mode, i.e. let the client
know what the operation would have done if it was allowed to write to the
workspace.
|
static int |
REDUCE_N_WAY_DUE_TO_REORDER
This flag is used to indicate that the accept should reduce any n-way conflicts
that are caused by history reordering by creating a change set that contains
the required merges.
|
static int |
REPORT_DELETE_CONFLICTS
This flag is used to indicate that delete/delete conflicts should be reported
as conflicts.
|
| Constructor and Description |
|---|
AcceptFlags() |
| Modifier and Type | Method and Description |
|---|---|
static int |
getCurrentPatchHandlingDirective(int flags) |
static boolean |
isValid(int flags) |
public static final int DEFAULT
public static final int DO_NOT_REORDER
public static final int PREFLIGHT
public static final int PATCH_CHANGESETS_WITH_GAPS
public static final int CURRENT_PATCH_HANDLING_MASK
public static final int CREATE_CURRENT_PATCH
PATCH_CHANGESETS_WITH_GAPS
flag. When both the PORT_CHANGESETS_WITH_GAPS flag and this flag are set, the server
will make the first pending port the current port but will not auto-resolve any changes.public static final int CREATE_CURRENT_PATCH_WITH_AUTO_RESOLVE
PATCH_CHANGESETS_WITH_GAPS
flag. When both the PORT_CHANGESETS_WITH_GAPS flag and this flag are set, the server
will make the first pending port the current port and auto-resolve as many changes
in the current port as possible.public static final int INITIATE_AUTO_PATCH
PATCH_CHANGESETS_WITH_GAPS
flag. When both the PORT_CHANGESETS_WITH_GAPS flag and this flag are set, the server
will make an attempt to auto-port as many of the gapped change sets as possible. The
first change set that cannot be auto-ported will become the current port while the
remaining will be left on the pending port list.public static final int REDUCE_N_WAY_DUE_TO_REORDER
public static final int REPORT_DELETE_CONFLICTS


This day and age, predictability and reliability are two of the most important words when it comes deployments. In this series, I am going to talk about how to add both predictability and reliability to your ASP.NET Core Continuous Integration pipeline using TeamCity and Octopus Deploy.
In the last post of this series, we went over some reasoning as to why it is bad to not have a continuous build server in your pipeline and how we can set one up using TeamCity in conjunction with a git repository hosted at GitHub. In this post, we will add another step to the process that will allow us to automate configuration and deployments to x-number of deployment targets. With .NET Core being cross platform, I will show you how to set up targets for both a Linux and Windows based machine.
If we have TeamCity producing builds for us, why can't we just use those assets for our deployments?
TeamCity (in most cases) is used to do one thing and do it well, produce validated builds. When we push changes to our repository TeamCity grabs the source, builds it, runs tests against the build and publishes a validated artifact to any external system registered to receive them. But what happens when we need to configure those builds to conform to a deployment's needs? Often the person in charge of the deployment would handle these steps manually. Of which might consist of...
If you recall our desires to build predictability and reliability through automation, you will quickly be able to identify the red flag in this process. Relying on a human to be able to open up configuration files and manually update them is one step away from crazy. The more deployments you add to the mix, the crazier the situation becomes. The goal instead should be to have one single source of truth for configuration values and to automate the configure process so no human hand ever touches it.
If we have a build that is configured through automation, what are we to make of the actual deployment step. Typically, the person responsible for the deployment would...
This process, much like the one above, has proven time and time to be unpredictable and by way of unreliable. Like in the past, we should move away from having someone manually deploy to targets and instead look to utilize automation.
Luckily, when installed and configure appropriately, Octopus Deploy will handle all this for us!
Let's start this process by installing the Octopus Deploy Server. You can either head over to the Octopus Deploy Server official download page or use Chocolatey by running the following command.
choco install octopusdeploy
Select the free trial and fill out the necessary information. After 45 days is up, you will be able to continue with the Community Edition of Octopus Deploy. This will get you up to 5 projects and 5 users to use for free.
Select where you want Octopus to store its assets.
Select what account you want to run the Octopus service under. In most cases, your "Local System Account" will suffice.
Create a new database in your SQL Server instance and connect to it with appropriate credentials.
Octopus has its own internal web server, of which defaults to port 80. Based on your TeamCity setup and other variables specific to your environment, you most likely will need to change this port to avoid port conflicts. In my setup, I change it to port 8080.
Set up an account to login with.
Default options will suffice.
Once you click "Install", a bunch of scripts will kick off and you will end up at the follow screen after a minute or two.
One of the first steps you are going to want to take is creating what is called an Environment. Environments are high-level buckets we can use to organize our various targets. For example, a typical deployment pipeline might consist of a dev, test, stage and production steps. Each of these steps in an application deployment life-cycle would map nicely to an Environment inside of Octopus.
Head to the environment page in your portal and click "Add Environment". Go ahead and add a name and description as you see fit and click "Save". In my case, I created a "Test (Windows)" and "Production (Linux)" Environment.
Targets are the servers where your applications will be deployed. Octopus Deploy
To start, let's create a new Account that Octopus will use to access our Windows target. Head to the "Accounts" page located at environment > accounts. For my Windows target, I will create an Account of the type "Usernames/Passwords" and assign it to my "Test" Environment.
After you have an Account setup with the proper access, head back to the environment page and under your Environment of choice, select "Add Target". You will be prompted with a number of target types to choose from. For my Windows target, which exists inside the same network as my TeamCity instance, I am able to use the type "Listening Tentacle". If your TeamCity install does not have access to an open port on the Octopus instance, you will have to poll for changes instead of listening for them.
You will also be notified that you need to ensure a Tentacle is installed on your target machine. We will take care of this in the next step.
A Tentacle is a secure, lightweight agent service that Octopus uses to deploy software. Octopus Deploy
On your target machine, either head to the official Octopus Deploy Tentacle download site or do it like a modern developer and use Chocolatey.
choco install octopusdeploy.tentacle
Once installed, open up your Tentacle Manager and follow the prompts to configure it. Start by identifying where you want your Tentacle to store its data.
Next, choose your Communication Style.
Next, you need to set the port in which the Tentacle with handle its communications on. You will also need to add the "Octopus Thumbprint" that is supplied when adding your Target. This validates the connection between the two nodes.
Finally, click the "Install" button and after a minute or so you will end up a screen that looks like the following.
Once you have your Tentacle installed, head back to the "Add Target" screen in your Octopus Deploy portal and select "Discover". If everything went okay, you will be prompted to name your new Target and supply it a role to operate under. Click "Save" to commit your changes and your new Target should show up under your Environment on the environment page of your portal.
Once you have your Target created, Octopus offers up a great diagnostics tool called "Check health". When activated, this will initiate a series of diagnostic request made from your Octopus Deploy server to your Target(s).
If there are issues, you will be provided feedback on that particular issue or Octopus will attempt to fix itself. For example, I was notified that Calamari was not installed on my Windows Target and offered an option to do a click-once automated install.
Our account this time around with be of the type "SSH Key Pair". This will allow the Target to ssh into our Linux box and validate using the SSK Key. Head to the environment > account page and add the new Account. The main difference being you will now need a private pass key and passpharse if applicable.
For more information about my deployment process prior to setting up my CI environment, take a look at the following posts.
As of current, my production ASP.NET Core application deployment lives at DigitalOcean on an Ubuntu distribution. Since Octopus Deploy 3.0 was released the sub-system components used by Octopus, mainly Calamari, can run on most Linux distribution so long as some basic requirements are met. The combination of Calamari running bash scripts and communicating via SSH, for the most part creates a Tentacle parity rich experience. Long story short, it works and works good.
Octopus did a pretty good job documenting the requirements to make this work at SSH Targets. At this link you will see a list of distributions guaranteed to work and a detailed list of features you need to ensure are enabled or installed on your target.
Had back to your environments page and click "Add Target" under your desired Environment. This time we are going to select the "SSH Connection" type, supply an appropriate Hostname and port, and hit "Discovery". Most of what is needed will be pre-populated after the discovery operation completes, except the Account to tie to this target. Add the SSH Key Pair Account we just created and then hit save.
Head back to the environments page and run a "Check Health" operation on this Target. During its first pass, I first was informed I was missing Mono. To solve this, I SSH'ed into my machine, and ran the following.
sudo apt-get install mono-complete
If you don't have the proper key Signing Key and Repository available, you might have to run the following.
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF echo "deb http://download.mono-project.com/repo/debian wheezy main" | sudo tee /etc/apt/sources.list.d/mono-xamarin.list sudo apt-get update sudo apt-get install mono-complete
After I went on the server and installed Mono manually, I went back to Octopus and ran the "Check health" step again. At this all checks passed.
We now have Octopus Deploy installed in our pipe-line, configured with an Environment, Accounts, and Targets. With that out of the way, we can start work on creating a Project inside of Octopus Deploy that we will use to define our configuration and deployment process. Until then, feel free to leave any comments or suggestions below.
Deploying An ASP.NET Core Site, You're Still Doing It Wrong : Part 4 - Octopus Deploy: Configuration And Deployments


POSTS
"Official" blog posts
A New Adventure
Sep 10
Building a Small PWA with Preact and Firebase
Jul 23
Turning the Page
Jul 2
Stumbling Through Learning About Event Listeners
Sep 15
I'm Learning How to Solve Problems with JavaScript
Aug 8
Reducing HTML Email Code
Jul 16
Rethinking My eMMail Workflow
Jun 30
Pursuing a Nanodegree (1 of ?)
Jun 26
TIL Executing Local Ruby
Nov 20
The Email Design Conference 2015
Aug 29
Front-End Conf Lives!
Oct 23
Give Back
Oct 7
Experiment - Personal JSON-based API
Aug 30
Thank You
Aug 28
No Sleep til Portland
Jul 21
Front-End Design Conference Finales
Jun 9
Why Grok is Special
Apr 7
Fun With Responsive Email Banners
Mar 27
A Shift in Focus
Mar 3
I Forgot About Dre
Jan 27
An API Event?
Jan 23
Front-End Conf Update
Jan 19
Photoshop's Timeline Rocks
Jan 8
Upcoming Events in '13
Aug 17
Front-End Conf '13
Jul 18
The Trouble with "The Trouble with Code School"
Apr 30
Mixture and Firebase and Public APIs
Apr 7
Playing With Data URIs
Mar 21
Going Live With Number Five
Mar 20
Ricardo Rally Time
Feb 27
Sass Color Variable Pop Quiz
Jan 21
Future of Front-End Conf
Oct 5
I'm Down With SVG
Sep 30
Circles Conf 2012
Sep 22
re:build Conference 2012
Sep 22
See Nick Preprocess
Aug 15
Playing With CSS Hat
Jul 21
Mondays Rock
Jul 16
Production vs. Shipping
Jul 16
Growing with Envy
Jul 2
HTML but with an A and Less Code
Jun 26
A Sass Noob using Math for Flexible Widths
Jun 18
Sass and Compass Pairing with Michael Parenteau
Jun 17
Rebuilding
Jun 16
Fluid
Mar 12


Question from a Telegram User:
45,000 TPS means you can handle 45,000 transactions per second.
transaction means one smartcontract.
However, Komodo's block generation cycle is one minute.
Does that mean that 45,000 X 60 = 2,700,000 tx/min is possible every minute?
Or is it possible to contract every second?


Chicken Little
Design Document
Revision History
| Aug 16, 2000 |
|
initial revision |
| Aug 30, 2000 |
|
Expanded music/sound requirements |
| Aug 31, 2000 |
|
Schedule format. |
Audio requirements
Level, story sequence music
One song for each level in story mode, associated with the back drop. can have ambient sounds in music appropriate to the back drop. in head-to-head back drop selection brings the music with it. (looping)
Dynamic music for in-game songs by jumping to extra patterns for defeat/victory conditions during play. At minimal, the music should pick up pace when your playing area is getting full. Also, the story sequence music could differ slightly from in-game music, even if some patterns and all samples are shared.
Detail: With 2 players on the same machine, the music will pick up the pace when either playing area is getting full, and always play the victory theme no matter who wins.
Week 1 - Sept 1-3, 2000
Week 2 - Sept 4-10, 2000
Week 3 - Sept 11-17, 2000
- Finish in-game music for Turkey Lurkey setting, with extra dynamic patterns (at least pick up pace).
- [Sound] Rotate piece
- [Sound] Piece touches down (eggs, stone)
- [Sound] Eggs hatch and disappear
- [Sound] Uncontrolled piece dumped on you (eggs, stone)
- [Sound] Multiple pieces dumped on you (eggs, stones)
- [Sound] Sound/voices for achieving combos/dual matches
- [Sound] Those sounds you get when you enter your high score, or when choosing menu options.
Week 4 - Sept 18-24, 2000
- [Music] Menu music - during title screen and while selecting menu options
- [Music] 1 or 2 in game tracks
Week 5 - Sept 25-29, 2000
Post-alpha 1
- [Music] Remaining in-game music
- [Music] Prologue theme, Epilogue - intro/ending cutscenes
- [Music] Highscore table theme - horray!
- [Music] Elavator theme - paused, in-game menu... could be the theme song instead.
- [Music] Credits theme - all of 10 seconds long :)
- [Music] Victory theme - when player wins (very short)
- [Music] Defeat theme - continue? 10, 9, 8...
- [Sound] Sound for each special event (quake, icestorm, fireball)
- [Voice] Possibly spoken words for cutscenes (narrator)
Front | Previous | Next


Lyophillic colloids are stable due to
charge on the particles.
large size of the particles.
small size of the particles.
layer of dispersion of medium on the particles.


2 Getting Access to Excel
This section contains detailed descriptions on how to get access to Microsoft Excel. You can skip this section if you already have access to Microsoft Excel or if you already know how to access it.
2.1 Installing Microsoft Excel
Video guide
Below is a video guide (without sound) on installing Microsoft Excel. You can skip this video if you prefer following the step-by-step guide below.
Note: You can skip the section from 1:30 to 5:40 where Office is installed.Step 1: Go to office.com
Go to www.office.com using a browser like Google Chrome, Safari, or Microsoft Edge.
Step 2: Sign in
Click on “Sign in”.
Step 3: Use your university e-mail to log in
Use your University of Bristol e-mail to sign in.
Step 4: Enter your password
You should now see the University of Bristol logo. Use your University of Bristol password to complete the sign-in.
Step 5: Respond to saving details
You will be asked whether you want the browser to remember your username and password. It is highly recommended that you select No if you are using a shared computer.
Step 6: Logged-in
You are now logged in to your University of Bristol office account.
Step 7: Installing Microsoft Ofice
Click “Install Office”
Step 3: Installing Microsoft Ofice
Select Office 365
Step 4: Installing Microsoft Ofice
And follow the instructions to install Microsoft Office (including Excel, Word, and PowerPoint).
2.2 Windows Virtual Desktop
The University of Bristol offers you to access a university computer remotely. Follow the steps below to log on.

Step 2: Locate the student remote desktop
Scroll to the bottom of the page and find the two (identical) links to the student remote desktop. Click on one of these links (or the link here).
Step 3: Enter your university e-mail address and follow the steps to log in (this process is similar to the process for installing Office, explained above).
Step 4: “Remote Access Solutions for Students and Teaching”
You should now be at the website called “Remote Access Solutions for Students and Teaching” Click on “Windows Virtual Desktop”
Step 5: Access a virtual remote desktop via the wew
Click on the link to log on to the virtual remote desktop. As you’ve already logged in to your UoB account above, you don’t need to do it again here.
Step 6: Open the virtual desktop
Now click on the “Open Access” Icon.
The browser will now open a remote desktop. While it is loading it should look as follows
Step 7: Enter your user name and password
Now enter your user name and password. Note depending on how you’ve logged on to the system, you might not be asked about this,
Step 8: You are logged in
You should now see Windows desktop within your bwowserStep 9: You can now use the remote computer
Click on the Windows icon in the lower left corner to open the menu. You can now use the software installed on the UoB desktop.
Saving files remotely
Note that since you are working on a UoB computer, you cannot save and create files everywhere. For example, you cannot save files to the desktop. However, you can save files to your University of Bristol “OneDrive” account:
You can also use Internet Explorer or Microsoft Edge within the Windows Virtual Desktop to browse the internet within the browser. If you want to work on a dataset from Eurostat within the Windows Virtual Desktop the easiest way is to access the Eurostat website within the Windows Virtual Desktop and download the data to the virtual drive.
2.3 Microsoft Excel in the cloud
Video guide
Below is a video guide (without sound) on accessing Microsoft Excel in the cloud. You can skip this video if you prefer following the step-by-step guide below.

Step 2: Sign in
Click on “Sign in”.
Step 3: Use your university e-mail to log in
Use your University of Bristol e-mail to sign in.
Step 4: Enter your password
You should now see the University of Bristol logo. Use your University of Bristol password to complete the sign-in.
Step 5: Respond to saving details
You will be asked whether you want the browser to remember your username and password. It is highly recommended that you select No if you are using a shared computer.
Step 6: Logged-in
You are now logged in to your University of Bristol office account.
Step 7: Open Excel
Click on the Microsoft Excel icon to start Microsoft Excel in the cloud.
Step 8: Select document
You can now either open a new blank document, open a template, or open an existing document.
Step 9: Open a new workbook
Select “New blank workbook” to create a new empty Excel document.
Step 10: You have arrived!
Congratulations. You have now opened Microsoft Excel in the cloud and you can start working.
Step 11: Uploading a document.
You might have downloaded a document that you want to open in Microsoft Excel. Because you are working in the cloud, you first have to upload the document to the cloud. Click “File”
Step 12: Uploading a document continued
Once you’ve opened the “File” menu, select “Open”.
Step 13: Uploading a document continued
Look for “More on OneDrive for Business” at the bottom of the list (you might have to scroll down).
Step 14: Uploading a document continued
You should now be viewing your University of Bristol OneDrive folder. This is a good place to store files that you want to work on. You can access these files from anywhere and share them with fellow students.
Step 15: Uploading a document continued
Select “Upload” to upload a document from your local computer. After you’ve uploaded the document you should see it in your OneDriver folder. You can then open it by clicking on it.
Step 16: Returning to our Excel document
Note that we can return to our Microsoft Excel document by clicking on the tab.