'Platoon'
A retrospective movie review by Walter Frith
Oliver Stone's semi-autobiographical account of his own experiences in the Vietnam War is presented in 1986's 'Platoon'. When I first saw this film with a packed audience I was not only entertained, not only informed but I was astonished at how many people disliked this film all for the wrong reasons.  A lot of people don't want to face the many aspects of combat tradgedies associated with war but Oliver Stone did his part by making a film to which a testament of thoughtful insight was made to try and prevent history from repeating itself.
To depict 'Platoon' as simple war film would be superficial. It's probably the best film in at least the last 30 years or more that correctly formulated the three aspects of quality story telling: man vs. man, man vs. nature, man vs. himself. Filmed on an initial 6 million dollar budget and with the Philippines substituting for Vietnam in location shooting, Stone had a tight schedule to work with and the results were nothing short of brilliant.
Charlie Sheen is the film's protagonist, a young man who narrates his experiences in Vietnam in letters he sends home to his grandmother and we gain an insight into the men within his platoon. Tom Berenger plays a no nonsense, unorthodox and somewhat evil sergeant undoubtedly made a victim of it all by the insanity of war who tries to shape and mold the men in his company into fighting without rules, without morals and without comapssion for anyone, even women and children in a suspicious village they stumble upon where weapons for the enemy are being stored. Willem Dafoe plays another sergeant within the same platoon whose personality is just the opposite of Berenger's and he butts heads with Berenger's war crime activities and the two men become at odds with each other with tragic results.
'Platoon' is a smart film that is told with little or no plot but rather a style uniquely inventive of caring about the characters involved and paying tribute to the men who fought and died in the Vietnam War and Stone dedicates the film to them in the movie's closing credits. Filled with explosive scenes of combat including a vicious climax which may force some to cover their eyes and with a cast of ordinary characters of all different personalities and habits, Oliver Stone's 'Platoon' is a lacerating indictment of a confict fought and which makes people debate the real purpose of the Vietnam War. One of the greatest films in the history of cinema and a war film like no other.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Welcome!
Procedure:
The experiment consists of four sub-tasks.
The tasks 2 and 3 will be repeated for all 30 games.
This study aims to assess the game characteristics that make a game more sensitive to delay in Cloud Gaming. Cloud Gaming means games are running in a cloud server, and the video of the game is streaming to the clients via a network. Additionally, the user’s inputs such as mouse and keyboards are sent back to the cloud server, so unlike the online gaming where part of the game was running in your local device here everything is in the server and if there would be any delay all of your actions are delayed.
Delay reduces players performance and it strongly annoys them. But games have different tolerance to delay. In some games having even a little amount of delay is not acceptable while in some games, playing with delay won’t cause serious problem. For example, high delay in a shooting game would lead to missing a shot and giving the opportunity to the enemy to shoot at you, while in a turn-based game like Chess having even a higher level of delay won’t make a problem as you can perform the same action again without losing any score.
We identified some characteristics that influence the delay sensitivity and now we are asking you to rate each of these characteristics in different game scenarios. Below there is a short description of each of these characteristics.
1- Temporal Accuracy
Temporal Accuracy describes the available time interval for a player to perform a desired interaction. The time interval is strongly dependent on the mechanics and pace of a game scenario. In other words, this game characteristic describes the available reaction time of a player.
In a jump and run game scenario for example, there is a point A, which marks the earliest point a player could perform a successful jump, and a point B, which marks the latest point a player could perform a successful jump. Depending on the distance between these two points and the speed of the character, there is an available time interval to perform the jump successfully. This example is illustrated in Fig. 1A and Fig. 1B. If the time interval is short, we consider the game to require a high temporal accuracy to be played.
The characteristic should be quantified by using the 5-point category scale shown below. Here, an example for a game with an unlimited time interval to perform an interaction is chess. An example for a game with an extremely short available time interval, a shooting game can be considered, as often the player who reacts first (immediate) wins.
How do you judge the available time interval for players to perform the desired interaction in this game scenario?
Figure 1A: Slow pace, you have a long interval to jump Figure 1B: Fast pace, you have a short interval to jump
2- Spatial Accuracy
The spatial accuracy is the degree of precision required to complete an interaction successfully.
Typically, game scenarios in which the player has to select (or point at) on object precisely, or in which precise movements are necessary, require a high spatial accuracy. However, this characteristic often strongly depends on the size of the controlled object (e.g., a character or curser) and the size of objects to interact with (e.g., a target or platform). In a shooting game scenario for example, the position of the cursor controlling a sniper riffle has to be much more precise than compared to a flame thrower, due to their different impact radius. For the latter scenario, a lower spatial accuracy is needed, as the radius is much larger. This example is illustrated in Fig. 2.
The characteristic should be quantified by using the 4-point category scale shown below. Here, an example for a game scenario not requiring any precision is a Flipper game, as here only the timing of the paddle movement is important. Using a sniper weapon in a shooting game scenario, would be an example for a game scenario which requires a high spatial accuracy.
How much spatial accuracy to successfully perform an interaction is required in this game scenario?
Figure 2: Different size of objects would lead to different spatial accuracy
3- Predictability
Predictability describes if a player is able to estimate the upcoming events in the game. This can for example relate to positions of objects (spatial) or time points of events (temporal).
In a simple point and click game scenario as illustrated in Fig 3, where a player has to click on the moving squares, the movement path of an object could be linear (see Figure 3A), or random (see Figure 3B). In the linear mode, a player can easily predict where the object will be a second later. In this case, a player can adapt and select the predicted/anticipated position to counter-balance a delay, which is not possible for a random movement.
The characteristic should be quantified by using the 4-point category scale shown below. Here, an example for a game where no events requiring an interaction can be predicted is chess, whereas a game scenario with purely random movements as shown in Fig. 3B would be not predictable.
How much are the events of this game scenario predictable for a player?
Figure 3A: Linear movement of objects Figure 3B: Random movement of objects
4- Number of input directions
The number of possible input directions in a game scenario is known as Degree of Freedom (DoF). DoF consists of translations (back and forward, left and right, up and down) as well as rotations (vertical axis and height) for one or multiple input devices/elements.
The characteristic should be quantified by using the 5-point category scale shown below. An example of a game scenario with DoF of 1, a jumping game where a player must simply jump (up) can be considered. In a jumping game where in addition to jumping a player can also go forward and backward, the DoF is 3. In a shooting game where a player can go in 4 different directions with a keyboard and 4 different directions with a mouse, the DoF is 8.
How many different input directions (DoF) are available in this game scenario?
How strong a delayed interaction influences a user’s experience, often depends on the negative consequences. Such consequences could be the loss of progress, points, and rewards.
The characteristic should be quantified by using the 3-point category scale shown below. In a scenario without negative consequences of an incorrect interaction or in which the game status is only worse but it is still realistic to win (e.g. chess or racing game), the consequences are low. If an incorrect interaction would result in a situation in which the game is difficult to win afterwards, the consequences are medium. Lastly, if an incorrect interaction immediately results in losing the game (e.g. jump and run in which a collision with an object directly lead to losing), the negative consequences are high.
How strong are the negative consequences of an incorrect interaction in this game scenario?
Figure 4: A single misplay would lead to game over
There are games in which every input of the user can significantly change the outcome of the game. In many jump and run game scenarios for example, it is critical that a player performs a jump correctly, otherwise this would results in losing the game. However, in a racing game or strategy game, many inputs do not directly lead to a strong change of the game state, for example when selecting units or looking at a map.
The characteristic should be quantified by using the 3-point category scale shown below. Exploring a game world or looking at a map would be a scenario with a low importance of actions. Selecting units in a strategy game or shooting with a weapon which has a high shooting rate (e.g., a minigun), can be considered as moderately important actions. A jump and run game scenario or shooting at a target with a weapon which has a low shooting rate (e.g., a sniper) would mainly consist of highly important actions.
How much each input of this game scenario can change its outcome?
The number of required actions and with that also the number of inputs a player performs in a certain time frame may influence the perception of a network delay. The characteristic could also be described as the minimum actions per minute (APM) to player the game scenario. It is assumed that a higher number of required action will lead to more user inputs and thus, more situation in which a player can perceive a delay. The number of objects to react to or the pace of the game can influence also the number of required actions.
The characteristic should be quantified by using the 3-point category scale shown below. A game scenario with a low number of required actions would be puzzle games, in which every few seconds an action is performed. A game scenario which requires an interaction every 1-2 seconds should be considered as moderate in terms of number of required actions. Lastly, a scenarios in which more than one interaction is required every second, should be rated as a scenarios with a high number of required actions.
How do you judge the number of required actions in this scenario?
Figure 5: (a) Low number of required actions (b) higher number of required actions
Feedback frequency means how often the game gives visual, auditive, or haptic feedback to the player. A player’s input frequency may influence the degree to which he perceives a possible delay. For example, if player keeps moving a delayed mouse cursor he will always perceive the delayed movement but if he only sometimes presses a key to jump, then the feedback will only be delayed in this moment. Here, the jump of the character is a visual feedback provided by the game.
The characteristic should be quantified by using the 3-point category scale shown below.
How often does the game scenario provide feedback to the player?
Type of the input that a game have give to the game can be different. In some games, players are continuously giving input, for example in a shooting game where players are always moving their mouse. Some games have discrete inputs meaning that players interact using pressing a button, for example a jumping game where players must jump using pressing a key. In games with Quasi-Continuous inputs players interact with the game using holding a key or constantly pressing a key, for example in Tekken where the player is constantly executing the same technique.
The characteristic should be quantified by using the 5-point category scale shown below.
How do you assess the type of user actions in this game ?


Development started in 2002 by Gary Sherman
## QGIS, today
QGIS is at:
* Stable: QGIS 3.8.2 'Zanzibar' (16.08.2019)
* LTR: QGIS 3.4.11 'Madeira'
* GNU/Linux - OS X - MS Windows - Android (QField)
* GRASS, Saga, OTB modules accessible from the QGIS GUI
QGIS is a project within OSGEO
The Open Geospatial Foundation (OSGeo) is a non-profit non-governmental organization whose mission is to support and promote the collaborative development of open geospatial technologies and data.
QGIS Features useful to planetary scientist
- OGC Web-Services: WMS, WFS(-T), CSW, WCS
- (Planetary) geologic mapping capabilities
- Stream digitizing
- Geologic symbology available
- Printproof: legends, grids, scales
- opens Planetary Data System v4 images/maps
OWS support in QGIS
USGS WMS basemaps
Crater mapping/statistics
PDS4 support in QGIS
CaSSIS data from PSA and in QGIS
Step one: Select data from PSA (or PDS)
PDS4 support in QGIS
CaSSIS data from PSA and in QGIS
Step two: Download data from PSA (or PDS)
PDS4 support in QGIS
CaSSIS data from PSA and in QGIS
Step three: Visualize PDS4 image data in QGIS
Acknowledgements
A special thanks goes to the all the QGIS/FOSS4G developers, contributors and sponsors, and planetary data users testing these tools!
that's it!
... and that's only the beginning!
Audience: demo of paricular aspect? Questions?


---
title: Course
layout: default
description: Course material
header-img: "image/rawa-sun-falling.jpg"
python_slides:
{
ch1_slides: "https://drive.google.com/open?id=1OrBzhXwrhItDqIoKJLjis01Mkd4vq9jA2S_VBz3-Obc",
ch2_slides: "https://drive.google.com/open?id=188nQUWvvVuvD6OfQVzXRVxC0YJeA8NIXwzONZJzIDTU",
ch3_and_4_slides: "https://drive.google.com/open?id=1sK-XGxPSt8AHq9ziaix4x54R07tVyXsRAfHf9ITB44w",
ch5_slides: "https://drive.google.com/open?id=1HWmBYYAMOmn83BUyQFSCB_1rvf22gzCBrXXHKMAe0BM",
ch6_slides: "https://docs.google.com/presentation/d/1MAt7yBKzZLXa13XNmbqzpsoWCBjTz_KiXfAmayVPyAg/edit?usp=sharing",
ch6_code: "https://drive.google.com/open?id=1kYb-CMOP7P1cFhHLwjcoQNmJrsKxU1AP",
ch7_slides: "https://drive.google.com/open?id=1AbjRkvLvA-AzKgI1nLhmykOIEN3Gvnt-JR2_6zrP6ic",
ch8_slides: "https://drive.google.com/open?id=1saORlRLAIQ5HPB4dTzRt4OLvXw5yV-fIcYHTNFR6FvU",
}
cplusplus_slides:
{
ch1_slides: "https://drive.google.com/open?id=1Oj_2YVifYq_tvkOCpfjPqfeCPcz8MFY8",
ch2_slides: "https://drive.google.com/open?id=1J79LuSh6YmBRL8TzGhIK4MQ7VmQEWekc",
ch3_slides: "https://drive.google.com/open?id=1CAewDcOdNqrv1bFT1QivjyiZGvXxgWtZ",
ch4_slides: "https://drive.google.com/open?id=12-YwIrCP5eqGgaqAmCSKSKUqk12_Y7T2",
ch5_slides: "https://drive.google.com/open?id=1BJovViQgAqvSj5ttIp-Lg1TXa2SkKJfl",
ch6_slides: "https://drive.google.com/open?id=1B9sZa8O4gh_akKZeam_3xZ-XrMdLEJGj",
ch7_slides: "https://drive.google.com/open?id=16qzz6bWno3oLSUFLso2Is3LVdStIJ85d"
}
---
{% if page.title %}{{ page.title }}{% else %}{{ site.title }}{% endif %}
{{ page.description }}
There are a lot of resources for self-learning programming. For me, when I start to learn a new program language, I like to quick go through the basic language syntax. So the site w3schools.com is one of my favorite. It will introduce basic syntax and sample code. You can copy and test sample code. It is suitable to master basic knowldge of a langaueg, i.e. syntax, operation, function, ...
After you know the basic knowledge and code about a language, the best resource to master a language is official website of the language. It has all language syntax, sample code, library available, and usage of the library API, e.g. function parameters, function description, function output or return.
For Python, you can refer to Python 3 tutorial . Just ignore Python 2 because Python-2 will not be supported by end of the year.
For C++, you can refer to C++ tutorial
If program has BUG, copy error or warning information to Google. Most of time, refer to answers in https://stackoverflow.com/


Created by Henri Yandell at SourceLabs, Inc..
Released under the Apache License 2.0 and Copyright 2007 SourceLabs, Inc.
This project uses the excellent famfamfam.com Silk icons.
A portlet for the JIRA dashboard that provides a concise way to list a set of projects.
Its expected use case is for saving real estate on big JIRA installations - specifically public ones such as the Apache JIRA and the Codehaus JIRA.
It provides the following functionality:
Version 1.0.2 was released on the 26th of June 2007. It sorted categories and took care of errors when there were no proejct or category descriptions.
Version 1.0.1 was released on the 13th of April 2007. It made sure tooltips were properly escaped and didn't break the rendering.
Version 1.0 was released on the 5th of April 2007.
Install the plugin by downloading the plugin jar, place it in your $JIRA/WEB-INF/lib/
and giving your JIRA a restart.
Once it's installed you can add it to your dashboard by selecting the Selected Filter List
portlet. Please follow the instructions from Atlassian for configuring your personal dashboard or the default dashboard.
The source is available for perusing by downloading the source zip and unpacking.
Please report such things to the project's JIRA, mail these to me at henri-at-sourcelabs.com, or add them as comments to the JIRA plugin page.
Initially, the portlet will look something like this when a user hits a page:
By clicking on the [show >>]
link, they can open up the tabular view and get something that looks like this:
On a private JIRA - ie) one which does not allow anonymous users to see projects, the portlet will currently look as follows:


Actions originate from the parser, a central part of the standard library. The detailed inner workings of the parser are beyond the scope of this manual (but interested readers are encouraged to look at the source code of the standard library). What story authors should know, though, is that the parser makes queries to understand-predicates, which are defined by the standard library and the story author together. These predicates can make queries to the parser in turn. To see how this back-and-forth is supposed to work, we must first introduce a new data structure:
During parsing, the standard library works with an intermediate representation of actions, called complex actions. Like regular actions, complex actions are lists of dictionary words and objects, but the following subexpressions are also allowed in them:
[+ #object1 #object2 ...]
The player referred to multiple objects here.
[a #object]
The player referred to a non-specific object that should be printed with “a” rather than “the”. [a ...] subexpressions may be nested inside [+ ...] subexpressions.
[]
The input contained one or more words that couldn't be parsed. When the complex action is printed, this part will appear as “something”.
[1]
The input contained one or more words that couldn't be parsed, and an animate object was expected. When the complex action is printed, this part will appear as “someone”.
[,]
The input contained multiple objects in an illegal place.
[all]
The input contained an ALL-expression in an illegal place.
Thus, a complex action might be:
| [give [+ [a #apple] #peeler] to [1]] |
and its printed representation makes an appearance in the following message:
The following chart illustrates the overall parsing process, starting with the player input as a list of words, and ending with a set of actions. The list of words is first split into a sequence of sublists by the word THEN or the full stop. If such a sublist cannot be parsed, it is in turn split by the first AND or comma. This allows the player to type multiple commands on one line, such as: N, U THEN DROP ALL, D.
When the library needs to parse an action, it makes a multi-query to the predicate:
| (understand $Words as $ComplexAction) |
A multi-query is made in order to collect every possible interpretation of the player's input, which could be ambiguous.
The first parameter is the input: a list of dictionary words. The second parameter is the output: a complex action.
Story authors can easily add rule definitions to this predicate, in order to add support for new verbs or set phrases:
| (understand [take a break] as [wait]) |
Note that the multi-query to (understand $ as $) may backtrack over several possible interpretations, e.g. [wait] and [take #break] if an object called “break” is in scope.
Understand-rules may of course have rule bodies:
| (understand [who am i] as [examine $Player]) | |
| (current player $Player) |
| (understand [yodel] as [yodel]) |
Here the story author has introduced a new action, [yodel]. When the name of the action is identical to the matched input, as in this particular case, a short form can be used instead:
| (understand [yodel]) |
So far, there is no code to handle the [yodel] action. The fallback implementations of the five action-handling predicates will cause the action to succeed without printing anything at all. This is a no-no in parser games, so the story author should at least add a perform-rule:
| (perform [yodel]) | |
| Your voice soars over the mountain tops, bringing tears to many eyes. |
The standard library might have to print the name of an action, perhaps as part of a disambiguation question, or during debugging if the ACTIONS ON command has been issued. This is done with a query to the predicate (describe action $). The parameter is a complex action, so it may contain [+ ...] and other special subexpressions. Usually, there is no need to add an explicit rule for describing every new action; the default implementation of (describe action $) simply visits each element of the action (which is a list) in turn, printing dictionary words verbatim, and calling (the full $) for anything else.
Commands are system-level actions, such as SAVE or TRANSCRIPT OFF, that do not consume any time in the game world. The predicate (command $) decides whether an action is a command or not. Thus, to define a new command called HINT, we could write:
| (understand [hint]) | |
| (command [hint]) | |
| (perform [hint]) | |
| Try yodeling a lot. |
There is also a short form that combines the first two rule definitions into one:
| (understand command [hint]) | |
| (perform [hint]) | |
| Try yodeling a lot. |
Many actions involve objects. The rule for understanding such an action will typically query a library-provided predicate for parsing a list of words as an object. There are several to choose from, but the most basic one is (understand $Words as non-all object $Object), which can be used like this:
| (understand [transmogrify | $Words] as [transmogrify $Object]) | |
| *(understand $Words as non-all object $Object) |
Note that a multi-query must be used, because the words may be ambiguous. Suppose a red box and a blue box are in scope. TRANSMOGRIFY BOX will cause the above rule header to match, binding $Words to the single-element list [box]. Since there are two boxes, (understand [box] as non-all object $Object) will return twice, binding $Object to #redbox the first time, and to #bluebox the second time. Consequently, the rule for understanding the action will return twice, binding its output parameter to [transmogrify #redbox] the first time, and [transmogrify #bluebox] the second time.
Some actions involve two (or even more) objects, usually separated by a keyword such as a preposition. Dialog provides a handy built-in predicate for searching a list for a set of keywords, and splitting the list at the position where a match was found. Consider the following example, where a new “read something to somebody” action is created:
| #book | |
| (proper *) | |
| (name *) | To Kill A Mockingbird |
| #bird | |
| (animate *) | |
| (name *) | mockingbird |
| (understand [read | $Words] as [read $Object to $Person]) | |
| *(split $Words by [to] into $Left and $Right) | |
| *(understand $Left as non-all object $Object) | |
| *(understand $Right as non-all object $Person) |
Again, the consistent use of multi-queries helps with disambiguation.  The split-predicate first separates it into [] and [kill a mockingbird to mockingbird]. The empty list is not a valid object name, so the subsequent query to (understand $Left ...) fails, and the split-predicate proceeds with the next occurrence of the keyword: Now it separates $Words into [to kill a mockingbird] and [mockingbird], which makes the rest of the rule body succeed.
Still, the name of the second object (MOCKINGBIRD) is ambiguous, so the final invocation of *(understand $Right ...) returns twice. The parser will end up asking the player whether they wanted to read the book to the bird, or the book to the book. One way to address this problem is to indicate that the second noun is supposed to be animate:
| (understand [read | $Words] as [read $Object to $Person]) | |
| *(split $Words by [to] into $Left and $Right) | |
| *(understand $Left as non-all object $Object) | |
| *(understand $Right as single object $Person preferably animate) |
Only a few standard traits can be used for conditional object parsing in this way. The full set of object-parsing predicates is:
• A predicate that accepts multiple objects, but not the word ALL:
(understand $Words as non-all object $Output)
• Predicates that accept multiple objects, including ALL:
(understand $Words as object $Output preferably held)
(understand $Words as object $Output preferably held excluding $ExcludeObj)
(understand $Words as object $Output preferably worn)
(understand $Words as object $Output preferably takable)
(understand $Words as object $Output preferably child of $Parent)
• Predicates that only accept a single object (possibly implied by ALL):
(understand $Words as single object $Output)
(understand $Words as single object $Output preferably held)
(understand $Words as single object $Output preferably animate)
(understand $Words as single object $Output preferably supporter)
(understand $Words as single object $Output preferably container)
Some of the variants above are primarily there to provide context for the word ALL. For instance, TAKE ALL should only select takable objects (items not already held), while DROP ALL should operate on held objects. But the preferably specifier is also used to carry out some initial disambiguation, so that e.g. FEED BIRD might be understood as an intention to feed the bird (animate), but not the bird cage.
The output of these predicates is either an object or a list that represents a complex object (e.g. [+ $Obj1 $Obj2 $Obj3], or [a $Obj1], or []) For the as single object rules, the output is guaranteed to be either an object or one of the values that indicate a parse error.
Some actions involve a named direction, such as SOUTHWEST, OUT, or UP. To parse a direction, use the predicate:
| (understand $Words as direction $Dir) |
As when parsing objects, $Dir is potentially a complex expression: When the player types PUSH CART SOUTHWEST, OUT AND UP, the words [southwest , out and up] will be understood as the complex direction [+ #southwest #out #up].
To parse a number, typed using decimal digits or spelled out as a word, use:
| (understand $Words as number $N) |
The output parameter $N is a number, and thus limited to the range 0–16383.
To go the other way, printing a numeric value with words, use:
| (spell out $N) |
Some actions, e.g. [ask $ about $] and [tell $ about $], involve topics of conversation. As we saw in the Standard actions chapter, topics can be regular objects, but sometimes it makes more sense to use dictionary words to represent abstract concepts. To parse a topic, use the predicate:
| (understand $Words as topic $Topic) |
It is possible to add rules to that predicate in order to add new topics to a game:
| (understand [my childhood] as topic @childhood) | |
| (understand [growing up on planet zyx] as topic @childhood) |
However, that would result in a parser that is very picky about the exact wording of ask/tell commands, so it is not generally recommended. A better (but potentially slower) approach is to look for keywords or key phrases like this:
| (understand $Words as topic @childhood) | |
| ($Words contains sublist [growing up]) | |
| (or) ($Words contains one of [childhood planet zyx]) |
The default implementation of (understand $ as topic $) tries to strike a balance between performance and flexibility by using a system of simple keywords. Keywords are defined with (topic keyword $ implies $):
| (topic keyword @childhood implies @childhood) | |
| (topic keyword @zyx implies @childhood) |
A short form is available when the keyword equals the topic value:
| (topic keyword @childhood) |
All of these variants can of course be combined. For instance, the keyword approach could be employed as a fall-back that often works well enough, and specific understand-rules could use the (just) keyword to overrule the keyword system when it would otherwise misfire:
| (understand [your childhood] as topic #doctor) | |
| (just) | |
| (topic keyword @childhood) | |
| (topic keyword @yourself implies #doctor) |
The (just) keyword can also be used to selectively disable the behaviour where objects in scope are understood as topics. For instance, in an aquarium, the word FISH might be accepted as a synonym for every individual fish in the room. But suppose we want the last word of ASK CLERK ABOUT FISH to be understood unambiguously as being in reference to the general subject of fish. That is, suppose we don't want the game to ask the player if they meant to ask about fish in general, the zebrafish, or the neon tetra. To obtain the desired behaviour, we just have to:
| (understand [fish] as topic @fish) | |
| (current room #aquarium) | |
| (just) |
Topics are supposed to have a printed representation, accessible via the (describe topic $) predicate. The default implementation of this predicate delegates to (the full $) when the topic is an object; otherwise it just prints the word “something”. Story authors are strongly recommended to override this predicate for non-object topics:
| (describe topic @childhood) | |
| your childhood |
When you add new actions that involve topics, remember to add corresponding (describe action $) rules as well. That's because the default implementation of (describe action $) is rather crude: It looks at each element of the action list, printing full descriptions of any objects, and printing dictionary words as they appear. But if the dictionary word happens to be a topic, the proper thing to do is to query (describe topic $) to print it. Thus:
| (understand [complain about | $Words] as [complain about $Topic]) | |
| *(understand $Words as topic $Topic) | |
| (describe action [complain about $Topic]) | |
| complain about (describe topic $Topic) |
When the player's input can be understood in multiple ways, it is up to the library to weigh the different interpretetions against each other, and select the one most probably intended by the player. This is achieved by looking at the actions from a semantical point of view, and discarding the unlikely ones, as determined by the predicate (unlikely $):
| (unlikely [open $Object]) | |
| ~(openable $Object) | |
| (unlikely [open $Object]) | |
| ($Object is open) |
If that's not enough, and several equally likely (or unlikely) interpretations remain, the library will ask the player a disambiguating question.
Thus, if the player is located in a room with a wooden door (open), and holds a wooden box (closed), and attempts to OPEN WOODEN, that will be understood as a request to [open #woodenbox]. The alternative, [open #woodendoor], gets discarded due to the second rule above. But if both the door and the box are open, both actions are deemed equally unlikely, and the game resorts to asking the player what they meant.
Story authors may override (unlikely $) to influence this proceduce. For instance, if a room contains a red lever and a red indicator light, it's up to the author to specify:
| (unlikely [pull #redlight]) |
which makes PULL RED do the expected thing.
Sometimes it is necessary to override (unlikely $) with a negated rule, when a more general rule would identify it as unlikely by default. For instance, suppose a location contains a wall-mounted ladder, and the story author wants the game to understand CLIMB LADDER as going up. The functionality itself is implemented by redirecting [climb #ladder] to [go #up]:
| (instead of [climb #ladder]) | |
| (current room #ladderroom) | |
| (try [go #up]) |
But [climb #ladder] is still considered unlikely by the parser, because (we assume) the ladder is not an actor supporter, i.e. it is not possible to be located #on the ladder. Now, if the player were to attempt to CLIMB LADDER while also holding the ladder instruction manual, the game would ask which one of the objects to climb. To prevent that slightly surreal question, a negated rule can be defined:
| ~(unlikely [climb #ladder]) %% Climbing the ladder is not unlikely after all. |
In Dialog, the current room and its neighbours are in scope by default. But rooms are often named by some conspicuous object contained inside them, so that e.g. an engine might be located in the engine room. To avoid a lot of disambiguating questions, any action that expilitly mentions a room is considered unlikely by default. This is implemented in the library using a catch-all rule for (unlikely $Action) that delegates to (unlikely due to room $Action). The latter checks that this isn't one of the few actions that are likely to involve rooms ([enter $Room], [leave $Room], and [go to $Room]). If it isn't, and if the action contains a room object, the predicate succeeds and the action is considered unlikely.
When the player's input can be understood as several actions, but all of those actions are deemed unlikely, there's still a chance to avoid a disambiguating question: In these situations, the library invokes (unlikely due to room $) a second time, and discards any actions that were deemed unlikely due to rooms; they are considered extra unlikely.
For this reason, if you ever add a new action that involves a room object directly, make sure to override (unlikely due to room $) instead of just (unlikely $).
Before the player's input is handed to the action-parsing predicate (understand $ as $), it undergoes rewriting: The predicate (rewrite $Input into $Output) is queried once (i.e. neither iteratively nor with a multi-query), and may transform the list of words in any way it sees fit before parsing. This can be used to define multi-word synonyms for verbs:
| (rewrite [pick up | $Words] into [take | $Words]) | |
| (rewrite [let go of | $Words] into [drop | $Words]) |
Word-for-word replacements should preferably be handled directly in the heads of the understand-rules, using slash expressions:
| (understand [drink/sip/quaff | $Words] as [drink $Obj]) | |
| *(understand $Words as non-all object $Obj) |
Some actions are designed to require objects, but it makes grammatical sense to use the verb alone (intransitively), or with fewer objects than the author had in mind. For instance, an understand-rule could be added to recognize PLAY VIOLIN WITH BOW as the action [play #violin with #bow]:
| (understand [play | $Words] as [play $Obj1 with $Obj2]) | |
| *(split $Words by [with using] into $Left and $Right) | |
| *(understand $Left as single object $Obj1) | |
| *(understand $Right as single object $Obj2 preferably held) |
But now, players who enter PLAY VIOLIN (or just PLAY) will be met by an unhelpful message about not understanding what they wanted to do. In this case, it's a good idea to add partial actions that nudge the player towards the full sentence. These actions can ask the player for clarification, and set up an implicit action using one of the predicates (asking for object in $) and (asking for direction in $). The parameter is a simple action, with an empty list [] marking the position of a blank slot. If the player now types in the name of an object (or, optionally, USE followed by the name of an object), this will be understood as the implicit action, with that object in the slot. Thus:
| (understand [play | $Words] as [play $Obj]) | |
| *(understand $Words as single object $Obj) | |
| (perform [play $Obj]) | |
| With what? | |
| (asking for object in [play $Obj with []]) | |
| (understand [play]) | |
| (perform [play]) | |
| Play what? | |
| (asking for object in [play []]) |
Note that (asking for object in $) and (asking for direction in $) will automatically invoke (stop) to prevent any subsequent actions: We've asked the player a question, so we have to give them an opportunity to respond.
Of course, it is also possible to override your own action-handling rules for this kind of intermediate actions, in specific situations where no additional object is required:
| (perform [play #piano]) | |
| You plink away at the Maple Leaf Rag, only to get stuck in the trio. |
Just remember that rules are tried in program order, so the rule for playing the piano must appear before the generic perform-rule that asks for a second object. One approach is to organize the story file as a large bulk of object-specific rule definitions, followed by a smaller section at the end where new actions are defined.
The order of understand-rules has another, more subtle implication. The library usually parses actions in a strict mode, where every word of the player's input must be accounted for. If that fails, the library sets a global flag that makes the understand ... as object rules more lenient, and tries to parse the input a second time. Now, unparseable input is represented by special markers ([], [1], [,], or [all]) in the resulting complex action, and a description of that incomplete action is printed. Thus, PLAY SPICCATO WITH BOW might result in the response “I only understood you as far as wanting to play something with the bow”. But here's the subtlety: Only the first incomplete action will be described in that message. So if the rules were defined in this order:
| (understand [play | $Words] as [play $Obj]) | |
| *(understand $Words as single object $Obj) | |
| (understand [play | $Words] as [play $Obj1 with $Obj2]) | |
| *(split $Words by [with using] into $Left and $Right) | |
| *(understand $Left as single object $Obj1) | |
| *(understand $Right as single object $Obj2 preferably held) |
then the entire subexpression SPICCATO WITH BOW would be interpreted as a badly formed object reference, and the error message would just be: “I only understood you as far as wanting to play something.”
Thus, in the interest of providing as informative error messages as possible to the player, authors are encouraged to always put the longest understand-rule first, i.e. the one that involves the most objects.
Story-specific actions are typically defined towards the end of the source code file. This allows object-specific rules, defined earlier in the file, to override them.
In this example, we first split the player's input by either of the keywords WITH and USING. Then we parse the right-hand side first, obtaining a tool object. We then exclude the tool when parsing the left-hand side: If the player types PEEL ALL WITH PEELER, the ALL will expand to every held object except the peeler. Note that this may still not be what the player intended (because in addition to fruit, they might be holding a brass key and a lamp), but at this stage we are primarily interested in grammar, not semantics.
Remember, put the longest understand-rule first:
| (understand [peel | $Words] as [peel $Object with $Tool]) | |
| *(split $Words by [with using] into $Left and $Right) | |
| *(understand $Right as single object $Tool preferably held) | |
| *(understand $Left as object $Object preferably held excluding $Tool) | |
| (understand [peel | $Words] as [peel $Object]) | |
| *(understand $Words as object $Object preferably held) | |
| (perform [peel $Obj]) | |
| With what? | |
| (asking for object in [peel $Obj with []]) |
Either variant is deemed unlikely for non-edible objects:
| (unlikely [peel $Obj | $]) %% Match both variants. | |
| ~(edible $Obj) |
The likelihood of an action helps resolve ambiguities, but it won't prevent the action from being attempted: If the player unambiguously tries to peel the kitchen floor, that request is going to go through, unlikely or not. Thus we also need:
| (prevent [peel $Obj | $]) | |
| ~(edible $Obj) | |
| That's not something you can peel. |
Likewise, because we specified preferably held, the library will try to satisfy the parser rules using objects that are held by the player, so that e.g. PEEL FRUIT will prioritize held fruit over non-held fruit. But an unambiguous PEEL BANANA will be understood even when the banana isn't held.
Thus, we need a rule to prevent the peeling of a non-held object. The standard library provides a number of handy when-predicates that check for common conditions, and print appropriate responses when the conditions are met.
| (prevent [peel $Obj | $]) | |
| (when $Obj isn't directly held) | |
| (prevent [peel $ with $Obj]) | |
| (when $Obj isn't directly held) |
But, out of the kindness of our hearts, we might decide to pick up the mentioned objects automatically before attempting the peel action:
| (before [peel $Obj | $]) | |
| %% This will invoke (first try [take $Obj]) if necessary: | |
| (ensure $Obj is held) | |
| (before [peel $ with $Obj]) | |
| (ensure $Obj is held) |
Finally, there needs to be a default response for the [peel $ with $] action (we already have one for the [peel $] action):
| (perform [peel $Obj with $Tool]) | |
| After an extended period of fumbling, you conclude that you don't know | |
| how to peel (the $Obj) with (the $Tool). | |
| (tick) (stop) |
Of course, the story should also contain a couple of objects that would make the peel action succeed. The following object-specific rules must be defined before the generic rules described above, otherwise they will never match:
| (edible #apple) | |
| (edible #peeled-apple) | |
| (perform [peel #apple with #peeler]) | |
| You peel the apple without cutting yourself even once. | |
| (#apple is $Rel $Loc) | |
| (now) (#apple is nowhere) | |
| (now) (#peeled-apple is $Rel $Loc) |
Finally, we could smoothen gameplay by implicitly assuming that if the player is holding the peeler, that's probably their tool of choice for peeling:
| (instead of [peel $Obj]) | |
| (current player $Player) | |
| (#peeler is #heldby $Player) | |
| \( with the peeler \) (line) %% Tell the player what's going on. | |
| (try [peel $Obj with #peeler]) |


Every digital ad you want, designed with insights,
delivered days.
Product Stories is a all in one solution that converts your Shopify product pages in AMP
format and at the same time in Google Story format.
Monitor your creative health scores internally and against peer benchmarks.
Monitor your creative health scores internally and against peer benchmarks.
Monitor your creative health scores internally and against peer benchmarks.
CREATIVE INSIGHT
When do I feature my logo? Which spokesperson is my target audience responding to? How do I optimize my call to action? Get real-time answers to improve your creative mid-flight. And see what’s worked in the past to get intel for your next campaign.
DiscoverCampaigns call for more assets than ever before, and it’s impossible to keep pace without a platform designed for the new era of marketing. VidMob’s operating system for creativity makes it possible to meet the needs of a modern CMO.
DiscoverHead of Marketing, InBev company


Console preferences
Use the Console preference panel to customize the appearance of messages that appear in the Console view.
| Option | Description |
|---|---|
| Always clear console before building | Select this option to clear the contents of the Console view every time you perform a build. |
| Open console when building | Select this option to open the Console view when you perform a build. |
| Bring console to top when building (if present) | Select this option to make the Console view the active window when you perform a build. |
| Limit console output (#lines) | Specify the maximum number of lines that can display in the Console view. |
| Display tab width | Specify the number of spaces for a tab. |
| Output text color | Customize the color of text in the Console view. |
| Information message text color | Customize the color of information text messages in the Console view. |
| Error message text color | Customize the color of error messages in the Console view. |
| Background color | Customize the background color in the Console view. |
| Background color for build problems | Customize the background color of build problems in the Console view. |
| Highlighting color for build problems | Customize the highlighting color of build problems in the Console view. |
Defining Project Build settings
Building projects


You will be given a random number at the start of the game.
There are four crystals below. By clicking on a crystal you will add a specific amount of points to your total score.
You win the game by matching your total score to the random number. You lose the game if your total score is greater than the random number.
The value of each crystal is hidden from you until you click on it.
Each time you start a new game, new values will be set for the 4 crystals and the random score to match.


{% extends "reviewers/base.html" %} {% block content %}
{{ log.to_string('reviewer') }}
Review was flagged prior to deletion.


[gecode-users] Set constraints working for sequential data, but not non-sequential data. Ideas?
Holger Winnemoeller
holger.winnemoeller at gmail.com
Wed Dec 16 21:05:57 CET 2009
Mikael,
thank you for your answer! Your second mail was spot-on!
I've added "branch(*this, specialSelected, SET_VAL_MIN_INC);" as the last
line in CreateAndRequestCategory
and the code runs like a charm!
I should really try to get Gist working, as I have a feeling that it will
demystify what to me is currently branching Voodoo.
FYI, my system is Dell Intel Core Duo E8400 @ 3GHz with 4GB of RAM on
WindowsXP professional, running Gecode 3.2.0 (x86). It's interesting, though
maybe not surprising, that Gecode seems to run so much faster on your
system. Do you think it's related more to the version of Gecode, the
machine, or the OS? In any case, the correct answer is obviously not to
upgrade the hardware, but to insert the branching statement :-)
Cheers,
Holger.
On Wed, Dec 16, 2009 at 1:39 AM, Mikael Zayenz Lagerkvist
<zayenz at gmail.com>wrote:
> Hi,
>
> I thought a bit more about your model, and my suggestion would be for
> you to branch on the set of specialSelected set variables first,
> before branching on the resultSet. This will be much more efficient,
> since that will decide the values that should be included in resultSet
> directly.
>
> Cheers,
> Mikael
>
> On Wed, Dec 16, 2009 at 8:51 AM, Mikael Zayenz Lagerkvist
> <zayenz at gmail.com> wrote:
> > Hi,
> > I just tried your problem, and on my computer (Athlon 64 3500+, Ubuntu
> > Linux, gcc 4.2, debug-build of Gecode 3.2.2) both versions of your
> program
> > produce a lot of solutions in a short time. What kind of system do you
> use?
> > The one with shuffled values is not as fast in the beginning, but that is
> > probably due to weak propagation in combination with a branching
> heuristic
> > that tries values not in either set.
> > Cheers,
> > Mikael
> > PS. I would recommend that you use the Driver infrastructure for your
> > experiments so that you can easily add various limits (max number of
> > solutions/failures/time) and run the program in Gist. Using Gist is very
> > good for understanding the behaviour of a Gecode model. Printing the
> search
> > statistics for a completed search is also good when comparing model
> > varieties.
> >
> > 2009/12/16 Holger Winnemoeller <holger.winnemoeller at gmail.com>
> >>
> >> QUESTION: How can I solve the following problem for anything but toy
> >> examples?
> >>
> >> Say, I have the following sets:
> >>
> >> All : {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}
> >> subA: {0,1,2,3,4}
> >> subB: {5,6,7,8,9}
> >>
> >> If I ask for a subset of "All" which contains 4 elements, of which 2
> >> elements are from "subA" and 2 elements are from "subB", I get a variety
> of
> >> results, such as
> >> {0,1,5,6}
> >> {0,1,5,7}
> >> ...
> >> {3,4,8,9}
> >> ...
> >>
> >> etc.
> >>
> >> This works perfectly fine.
> >>
> >> Now, for cases where subA, and subB are not strictly sequential (i.e.
> >> sorted but non-consecutive numbers)
> >>
> >> subA: {4,8,14,16,17}
> >> subB: {0,3,5,10,12}
> >>
> >> The system quickly runs out of steam (maybe not for the toy example
> here,
> >> but for |All| = 100, |subA| = |subB| = 20, asking for 10 items -- see
> >> attached code). Gecode just keeps computing and never seems to find a
> >> solution.
> >>
> >> Given that the sub-sets are disjoint a solution should really be trivial
> >> in any case (take 50% of one subset and 50% of the other). However, I
> don't
> >> want to make the assumption that they are disjoint.
> >>
> >> I have attached some demo code for what I am talking about, so you can
> >> experiment with it.
> >>
> >> Thanks for your help!
> >>
> >> Holger.
> >>
> >> _______________________________________________
> >> Gecode users mailing list
> >> users at gecode.org
> >> https://www.gecode.org/mailman/listinfo/gecode-users
> >>
> >
> >
> >
> > --
> > Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/<http://www.ict.kth.se/%7Ezayenz/>
> >
>
>
>
> --
> Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/<http://www.ict.kth.se/%7Ezayenz/>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.gecode.org/pipermail/users/attachments/20091216/755d371e/attachment.htm>
More information about the users
mailing list


COWBOY BOOTS
Stand out from the crowd in a pair of classic cowboy boots. Available for Ladies and Gents from only £49.99
MILITARY BOOTS
Hard-wearing Men's military boots, guaranteed to withstand all weathers. From only £69.99
ROMAN SANDALS
Get ready for summer with some stylish roman sandals. From only £39.99
OFFICE SHOES
You don't have to wear boring shoes to the office. Check out our new stock of Ladies and Gents fashionable office shoes from only £44.99


Force Plot to Have Tick at 0 or 100
Error Bands and Confidence Intervals
Vertical and Horizontal Bar Charts
Open Hi Low Close and Candlestick Charts
Candlestick and Open Hi Low Close charts
Data Point Highlighting, Tooltips and Cursor Tracking
Highlighting, Dragging Points, Cursor and Trend Lines.
Animated Dashboard Sample - Filled Line with Log Axis
AJAX and JSON Data Loading via Data Renderers
Zooming with Date and Log Axes
Charts with Fill Between Lines
Cumulative Density Function Chart
Probability Density Function Chart
Rotated Labels and Font Styling


Hemi JavaScript Framework
Hemi.ui.util
Description
The utility class includes Web UI help functions.
static Hemi.ui.util
version 4.0.1
Hemi framework utilities
Index
Method Index
-
public alignControl: Returns a bit indicating whether or not the control is requested for display.
-
public endRequest: Hides the WideSelectInstance control if requested.
-
public getIsRequested: Returns a bit indicating whether or not the control is requested for display.
-
public request: Associates a control with a node, and keeps track of the request status.
Methods
alignControl
Returns a bit indicating whether or not the control is requested for display.
Syntax
b = alignControl(
t, o, c
)
Parameters
-
t as FrameworkObject : Control to be aligned.
-
o as Node : Target node for which the control is being aligned.
-
c as Node : Container node used by the control for display.
Returns
b as boolean: Bit indicating whether the control is currently requested for display.
endRequest
Hides the WideSelectInstance control if requested.
Syntax
void endRequest(
t, c
)
Parameters
-
t as FrameworkObject : Control that is making the request.
-
c as Node : Container node used by the control for display.
getIsRequested
Returns a bit indicating whether or not the control is requested for display.
Syntax
b = getIsRequested(
o
)
Parameters
-
o as object : Object to test whether it has been requested.
Returns
b as boolean: Bit indicating whether the control is currently requested for display.
request
Associates a control with a node, and keeps track of the request status.
Syntax
void request(
t, o, c
)
Parameters
-
t as FrameworkObject : Control that is making the request.
-
o as Node : Target node for which the control is being requested.
-
c as Node : Container node used by the control for display.
[ Hemi JavaScript Framework - Stephen W. Cote, 2002 - 2013. ]


CFREE
Section: Linux Programmer's Manual (3)
Updated: 2007-07-26
Index
Return to Main Contents
NAME
cfree - free allocated memory
SYNOPSIS
#include <stdlib.h>
/* In SunOS 4 */
int cfree(void *ptr);
/* In glibc or FreeBSD libcompat */
void cfree(void *ptr);
/* In SCO OpenServer */
void cfree(char *ptr, unsigned num, unsigned size);
/* In Solaris watchmalloc.so.1 */
void cfree(void *ptr, size_t nelem, size_t elsize);
Feature Test Macro Requirements for glibc (see
feature_test_macros(7)):
cfree():
_BSD_SOURCE || _SVID_SOURCE
DESCRIPTION
This function should never be used.
Use
free(3)
instead.
1-arg cfree
In glibc, the function
cfree()
is a synonym for
free(3),
"added for compatibility with SunOS".
Other systems have other functions with this name.
The declaration is sometimes in
<stdlib.h>
and sometimes in
<malloc.h>.
3-arg cfree
Some SCO and Solaris versions have malloc libraries with a 3-argument
cfree(),
apparently as an analog to
calloc(3).
If you need it while porting something, add
#define cfree(p, n, s) free((p))
to your file.
A frequently asked question is "Can I use
free(3)
to free memory allocated with
calloc(3),
or do I need
cfree()?
Answer: use
free(3).
An SCO manual writes: "The cfree routine is provided for compliance
to the iBCSe2 standard and simply calls free.
The num and size
arguments to cfree are not used."
RETURN VALUE
The SunOS version of
cfree()
(which is a synonym for
free(3))
returns 1 on success and 0 on failure.
In case of error,
errno
is set to
EINVAL:
the value of
ptr
was not a pointer to a block previously allocated by
one of the routines in the
malloc(3)
family.
CONFORMING TO
The 3-argument version of
cfree()
as used by SCO conforms to the iBCSe2 standard:
Intel386 Binary Compatibility Specification, Edition 2.
SEE ALSO
malloc(3)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- 1-arg cfree
-
- 3-arg cfree
-
- RETURN VALUE
-
- CONFORMING TO
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 02:55:16 GMT, September 18, 2014


MBMessageDigest Class Reference
| Inherits from | NSObject |
|---|---|
| Declared in | MBMessageDigest.h |
Overview
Provides a mechanism for computing secure one-way hashes from various data sources.
For convenience, extensions are provided for the NSString
and NSData
classes allowing message digests to be computed on such instances directly.
See NSString(MBMessageDigest)
and NSData(MBMessageDigest)
for details.
Creating MD5 message digests
+ MD5DataForString:
Computes an MD5 hash given an input string.
+ (nonnull NSData *)MD5DataForString:(nonnull NSString *)src
Parameters
src |
the string for which the MD5 will be computed |
|---|
Return Value
the MD5 hash, as binary NSData
Declared In
MBMessageDigest.h
+ MD5ForString:
Computes an MD5 hash given an input string.
+ (nonnull NSString *)MD5ForString:(nonnull NSString *)src
Parameters
src |
the string for which the MD5 will be computed |
|---|
Return Value
the MD5 hash, as a lowercase hexadecimal string
Declared In
MBMessageDigest.h
+ MD5ForData:
Computes an MD5 hash from an NSData
instance.
+ (nonnull NSString *)MD5ForData:(nonnull NSData *)src
Parameters
src |
the data for which the MD5 will be computed |
|---|
Return Value
the MD5 hash, as a lowercase hexadecimal string
Declared In
MBMessageDigest.h
+ MD5ForBytes:length:
Computes an MD5 hash from an array of bytes.
+ (nonnull NSString *)MD5ForBytes:(nonnull const void *)bytes length:(size_t)len
Parameters
bytes |
the byte array for which the MD5 will be computed |
|---|---|
len |
the length of the byte array |
Return Value
the MD5 hash, as a lowercase hexadecimal string
Declared In
MBMessageDigest.h
+ MD5ForFileAtPath:error:
Computes an MD5 hash for the contents of a file.
+ (nullable NSString *)MD5ForFileAtPath:(nonnull NSString *)path error:(NSErrorPtrPtr)errPtr
Parameters
path |
the filesystem path of the file for which the MD5 will be computed |
|---|---|
errPtr |
If an error occurs and this parameter is non- |
Return Value
the MD5 hash, as a lowercase hexadecimal string; if an error
occurs while attempting to read the file, nil
is returned
Declared In
MBMessageDigest.h
+ MD5ForFileAtPath:
Computes an MD5 hash for the contents of a file.
+ (nullable NSString *)MD5ForFileAtPath:(nonnull NSString *)path
Parameters
path |
the filesystem path of the file for which the MD5 will be computed |
|---|
Return Value
the MD5 hash, as a lowercase hexadecimal string; if an error
occurs while attempting to read the file, nil
is returned
Declared In
MBMessageDigest.h
Creating SHA-1 message digests
+ SHA1DataForString:
Computes an SHA-1 hash given an input string.
+ (nonnull NSData *)SHA1DataForString:(nonnull NSString *)src
Parameters
src |
the string for which the SHA-1 will be computed |
|---|
Return Value
the SHA-1 hash, as binary NSData
Declared In
MBMessageDigest.h
+ SHA1ForString:
Computes an SHA-1 hash given an input string.
+ (nonnull NSString *)SHA1ForString:(nonnull NSString *)src
Parameters
src |
the string for which the SHA-1 will be computed |
|---|
Return Value
the SHA-1 hash, as a lowercase hexadecimal string
Declared In
MBMessageDigest.h
+ SHA1ForData:
Computes an SHA-1 hash from an NSData
instance.
+ (nonnull NSString *)SHA1ForData:(nonnull NSData *)src
Parameters
src |
the data for which the SHA-1 will be computed |
|---|
Return Value
the SHA-1 hash, as a lowercase hexadecimal string
Declared In
MBMessageDigest.h
+ SHA1ForBytes:length:
Computes an SHA-1 hash from an array of bytes.
+ (nonnull NSString *)SHA1ForBytes:(nonnull const void *)bytes length:(size_t)len
Parameters
bytes |
the byte array for which the SHA-1 will be computed |
|---|---|
len |
the length of the byte array |
Return Value
the SHA-1 hash, as a lowercase hexadecimal string
Declared In
MBMessageDigest.h
+ SHA1ForFileAtPath:error:
Computes an SHA-1 hash for the contents of a file.
+ (nullable NSString *)SHA1ForFileAtPath:(nonnull NSString *)path error:(NSErrorPtrPtr)errPtr
Parameters
path |
the filesystem path of the file for which the SHA-1 will be computed |
|---|---|
errPtr |
If an error occurs and this parameter is non- |
Return Value
the SHA-1 hash, as a lowercase hexadecimal string; if an error
occurs while attempting to read the file, nil
is returned
Declared In
MBMessageDigest.h
+ SHA1ForFileAtPath:
Computes an SHA-1 hash for the contents of a file.
+ (nullable NSString *)SHA1ForFileAtPath:(nonnull NSString *)path
Parameters
path |
the filesystem path of the file for which the SHA-1 will be computed |
|---|
Return Value
the SHA-1 hash, as a lowercase hexadecimal string; if an error
occurs while attempting to read the file, nil
is returned
Declared In
MBMessageDigest.h


research {border-style px;} #ffffff;} participants COVID- risk clinical need participant Health PIs Research px; {font-family font-size help national Public decision double; guidance information make medical ongoing psychological ratio reported review risk-benefit Center Disease JMIR best border-color border-width factors local pandemic scheduled screening solid; ultimately visits {font-style {font-weight (COVID-) Arkansas Clinical Healthcare Little NIH Rock, States United bold changes coronavirus courier; decision-making disease em; ethical institutional perspectives protocol pt;} public research. researchers staff staffing support


---
layout: post
title: everything is never quite enough - wasis diop
date: '2010-02-26T22:56:00.011+02:00'
author: Ema
tags:
- Ema
- film
- Ema's fav
modified_time: '2011-01-08T01:12:41.300+02:00'
blogger_id: tag:blogger.com,1999:blog-551549162106413340.post-6107725093931394086
blogger_orig_url: http://pentrumuzica.blogspot.com/2010/02/everything-is-never-quite-enough-wasis.html
---
dintr-o alta lume in care parca plutesc in loc sa merg... lumea magica a scenei... am descoperit azi piesa asta ce are din plin magie... multumesc Alex


Win2k3
winpop stat domainname
Vista/7
winstat features
wbadmin get status
wbadmin get items
gpresult /H gpols.htm
bcdedit /export <filename>


Abstract interface of RGB-D renderers, which render RGB, depth and label images using VisualElement.
More...
#include <drake/attic/systems/sensors/rgbd_renderer.h>
Abstract interface of RGB-D renderers, which render RGB, depth and label images using VisualElement.
The coordinate system of RgbdRenderer's viewpoint R
is X-right
, Y-down
and Z-forward
with respect to the rendered images.
Output image format:
- RGB (ImageRgba8U) : the RGB image has four channels in the following order: red, green, blue and alpha. Each channel is represented by a uint8_t.
- Depth (ImageDepth32F) : the depth image has a depth channel represented by a float. For a point in space
P
, the value stored in the depth channel holds the Z-component of the position vector p_RP
. Note that this is different from the range data used by laser range finders (like that provided by DepthSensor) in which the depth value represents the distance from the sensor origin to the object's surface.
- Label (ImageLabel16I) : the label image has single channel represented by a int16_t. The value stored in the channel holds a model ID which corresponds to an object in the scene. For the pixels corresponding to no body, namely the sky and the flat terrain, we assign Label::kNoBody and Label::kFlatTerrain, respectively.
◆ VisualIndex
Represents indices for visual elements.
◆ RgbdRenderer() [1/3]
◆ RgbdRenderer() [2/3]
◆ RgbdRenderer() [3/3]
A constructor for RgbdRenderer.
- Parameters
-
| config | Configurations of the renderer. See RenderingConfig. |
| X_WC | The initial pose of the renderer's unique camera viewpoint C in the world coordinate system. The camera pose C can be updated by calling UpdateViewpoint later on. Default value: Identity. |
◆ ~RgbdRenderer()
◆ AddFlatTerrain()
Adds a flat terrain in the rendering scene.
◆ color_palette()
Returns the color palette of this renderer.
◆ config()
Returns the configuration object of this renderer.
◆ operator=() [1/2]
◆ operator=() [2/2]
◆ RegisterVisual()
Registers a visual element to a rigid body and returns the ID of the visual element.
The element is uniquely identified using body_id
and visual_id
.
- Parameters
-
| visual | A visual element to be registered. See VisualElement for more detail. |
| body_id | The ID of a rigid body that you want a visual to be associated with. Note that you can associate more than one visual with a rigid body. |
- Returns
- visual_id A local visual ID associated with given
body_id
. nullopt
will be returned if visual
contains an unsupported shape. We assume visual_id
will be used together with body_id
when you call UpdateVisualPose() later.
◆ RenderColorImage()
| void RenderColorImage |
( |
ImageRgba8U * |
color_image_out | ) |
const |
Renders and outputs the rendered color image.
- Parameters
-
| color_image_out | The rendered color image. |
◆ RenderDepthImage()
Renders and outputs the rendered depth image.
- Parameters
-
| depth_image_out | The rendered depth image. |
◆ RenderLabelImage()
Renders and outputs the rendered label image.
- Parameters
-
| label_image_out | The rendered label image. |
◆ UpdateViewpoint()
| void UpdateViewpoint |
( |
const Eigen::Isometry3d & |
X_WC | ) |
const |
Updates renderer's camera viewpoint with given pose X_WC.
- Parameters
-
| X_WC | The pose of renderer's camera viewpoint in the world coordinate system. |
◆ UpdateVisualPose()
| void UpdateVisualPose |
( |
const Eigen::Isometry3d & |
X_WV, |
|
|
int |
body_id, |
|
|
VisualIndex |
visual_id |
|
) |
| const |
Updates the pose of a visual with given pose X_WV.
- Parameters
-
| X_WV | The pose of a visual in the world coordinate system. |
| body_id | The ID of a rigid body that the visual you want to update is associated with. |
| visual_id | The local ID of a visual that is associated with a rigid body and you want to update. |
The documentation for this class was generated from the following files:


error codes in libcurl
DESCRIPTION
This man page includes most, if not all, available error
codes in libcurl. Why they occur and possibly what you
can do to fix the problem.
CURLcode
Almost all "easy" interface functions return a CURLcode
error code. No matter what, using CURLOPT_ERRORBUFFER is a
good idea as it will give you a human readable error
string that may offer more details about the error cause
than just the error code does.
This man page is meant to describe libcurl 7.9.6 and
later. Earlier versions might have had quirks not men-
tioned here.
CURLcode is one of the following:
CURLE_OK (0)
All fine. Proceed as usual.
CURLE_UNSUPPORTED_PROTOCOL (1)
The URL you passed to libcurl used a protocol that
this libcurl does not support. The support might be
a compile-time option that you didn't use, it can be
a misspelled protocol string or just a protocol
libcurl has no code for.
CURLE_FAILED_INIT (2)
Very early initialization code failed. This is
likely to be an internal error or problem.
CURLE_URL_MALFORMAT (3)
The URL was not properly formatted.
CURLE_URL_MALFORMAT_USER (4)
URL user malformatted. The user-part of the URL syn-
tax was not correct.
CURLE_COULDNT_RESOLVE_PROXY (5)
Couldn't resolve proxy. The given proxy host could
not be resolved.
CURLE_COULDNT_RESOLVE_HOST (6)
Couldn't resolve host. The given remote host was not
resolved.
CURLE_COULDNT_CONNECT (7)
Failed to connect() to host or proxy.
After connecting to a FTP server, libcurl expects to
get a certain reply back. This error code implies
that it god a strange or bad reply. The given remote
server is probably not an OK FTP server.
CURLE_FTP_ACCESS_DENIED (9)
We were denied access when trying to login to an FTP
server or when trying to change working directory to
the one given in the URL.
CURLE_FTP_USER_PASSWORD_INCORRECT (10)
The username and/or the password were incorrect when
trying to login to an FTP server.
CURLE_FTP_WEIRD_PASS_REPLY (11)
After having sent the FTP password to the server,
libcurl expects a proper reply. This error code
indicates that an unexpected code was returned.
CURLE_FTP_WEIRD_USER_REPLY (12)
After having sent user name to the FTP server,
libcurl expects a proper reply. This error code
indicates that an unexpected code was returned.
CURLE_FTP_WEIRD_PASV_REPLY (13)
libcurl failed to get a sensible result back from
the server as a response to either a PASV or a EPSV
command. The server is flawed.
CURLE_FTP_WEIRD_227_FORMAT (14)
FTP servers return a 227-line as a response to a
PASV command. If libcurl fails to parse that line,
this return code is passed back.
CURLE_FTP_CANT_GET_HOST (15)
An internal failure to lookup the host used for the
new connection.
CURLE_FTP_CANT_RECONNECT (16)
A bad return code on either PASV or EPSV was sent by
the FTP server, preventing libcurl from being able
to continue.
CURLE_FTP_COULDNT_SET_BINARY (17)
Received an error when trying to set the transfer
mode to binary.
CURLE_PARTIAL_FILE (18)
A file transfer was shorter or larger than expected.
This happens when the server first reports an
expected transfer size, and then delivers data that
doesn't match the previously given size.
This was either a weird reply to a 'RETR' command or
a zero byte transfer complete.
CURLE_FTP_WRITE_ERROR (20)
After a completed file transfer, the FTP server did
not respond a proper
CURLE_FTP_QUOTE_ERROR (21)
When sending custom "QUOTE" commands to the remote
server, one of the commands returned an error code
that was 400 or higher.
CURLE_HTTP_NOT_FOUND (22)
This is returned if CURLOPT_FAILONERROR is set TRUE
and the HTTP server returns an error code that is >=
400.
CURLE_WRITE_ERROR (23)
An error occurred when writing received data to a
local file, or an error was returned to libcurl from
a write callback.
CURLE_MALFORMAT_USER (24)
Malformat user. User name badly specified. *Not cur-
rently used*
CURLE_FTP_COULDNT_STOR_FILE (25)
FTP couldn't STOR file. The server denied the STOR
operation. The error buffer usually contains the
server's explanation to this.
CURLE_READ_ERROR (26)
There was a problem reading a local file or an error
returned by the read callback.
CURLE_OUT_OF_MEMORY (27)
Out of memory. A memory allocation request failed.
This is serious badness and things are severly
screwed up if this ever occur.
CURLE_OPERATION_TIMEOUTED (28)
Operation timeout. The specified time-out period was
reached according to the conditions.
CURLE_FTP_COULDNT_SET_ASCII (29)
libcurl failed to set ASCII transfer type (TYPE A).
CURLE_FTP_PORT_FAILED (30)
The FTP PORT command returned error. This mostly
happen when you haven't specified a good enough
address for libcurl to use. See CURLOPT_FTPPORT.
The FTP REST command returned error. This should
never happen if the server is sane.
CURLE_FTP_COULDNT_GET_SIZE (32)
The FTP SIZE command returned errror. SIZE is not a
kosher FTP command, it is an extension and not all
servers support it. This is not a surprising error.
CURLE_HTTP_RANGE_ERROR (33)
The HTTP server does not support or accept range
requests.
CURLE_HTTP_POST_ERROR (34)
This is an odd error that mainly occurs due to
internal confusion.
CURLE_SSL_CONNECT_ERROR (35)
A problem occured somewhere in the SSL/TLS hand-
shake. You really want the error buffer and read the
message there as it pinpoints the problem slightly
more. Could be certificates (file formats, paths,
permissions), passwords, and others.
CURLE_FTP_BAD_DOWNLOAD_RESUME (36)
Attempting FTP resume beyond file size.
CURLE_FILE_COULDNT_READ_FILE (37)
A file given with FILE:// couldn't be opened. Most
likely because the file path doesn't identify an
existing file. Did you check file permissions?
CURLE_LDAP_CANNOT_BIND (38)
LDAP cannot bind. LDAP bind operation failed.
CURLE_LDAP_SEARCH_FAILED (39)
LDAP search failed.
CURLE_LIBRARY_NOT_FOUND (40)
Library not found. The LDAP library was not found.
CURLE_FUNCTION_NOT_FOUND (41)
Function not found. A required LDAP function was not
found.
CURLE_ABORTED_BY_CALLBACK (42)
Aborted by callback. A callback returned "abort" to
libcurl.
CURLE_BAD_FUNCTION_ARGUMENT (43)
Internal error. A function was called with a bad
parameter.
Internal error. A function was called in a bad
order.
CURLE_HTTP_PORT_FAILED (45)
Interface error. A specified outgoing interface
could not be used. Set which interface to use for
outgoing connections' source IP address with CUR-
LOPT_INTERFACE.
CURLE_BAD_PASSWORD_ENTERED (46)
Bad password entered. An error was signaled when the
password was entered. This can also be the result of
a "bad password" returned from a specified password
callback.
CURLE_TOO_MANY_REDIRECTS (47)
Too many redirects. When following redirects,
libcurl hit the maximum amount. Set your limit with
CURLOPT_MAXREDIRS.
CURLE_UNKNOWN_TELNET_OPTION (48)
An option set with CURLOPT_TELNETOPTIONS was not
recognized/known. Refer to the appropriate documen-
tation.
CURLE_TELNET_OPTION_SYNTAX (49)
A telnet option string was Illegally formatted.
CURLE_OBSOLETE (50)
This is not an error. This used to be another error
code in an old libcurl version and is currently
unused.
CURLE_SSL_PEER_CERTIFICATE (51)
The remote server's SSL certificate was deemed not
OK.
CURLE_GOT_NOTHING (52)
Nothing was returned from the server, and under the
circumstances, getting nothing is considered an
error.
CURLE_SSL_ENGINE_NOTFOUND (53)
The specified crypto engine wasn't found.
CURLE_SSL_ENGINE_SETFAILED (54)
Failed setting the selected SSL crypto engine as
default!
CURLE_SEND_ERROR (55)
Failed sending network data.
Failure with receiving network data.
CURL_LAST
This is not an error, but in the curl/curl.h file
this can be used to know how many existing error
codes there are.
CURLMcode
This is the generic return code used by functions in the
libcurl multi interface.
Man(1) output converted with
man2html


hi guys, feel free to play the HK space police
left and right arrow : directions
space : fire
Caution:
press "A" key to activate cheat mode. <"A" : the mark that everyone wants for this project!>


Extract signals from the input connector and transfer them to the output connector.
The extracting scheme is given by the integer vector 'extract'. This vector specifies, which input signals are taken and in which order they are transferred to the output vector. Note, that the dimension of 'extract' has to match the number of outputs. Additionally, the dimensions of the input connector signals and the output connector signals have to be explicitly defined via the parameters 'nin' and 'nout'.
Example:
nin = 7 "Number of inputs"; nout = 4 "Number of outputs"; extract[nout] = {6,3,3,2} "Extracting vector";
extracts four output signals (nout=4) from the seven elements of the input vector (nin=7):
output no. 1 is set equal to input no. 6 output no. 2 is set equal to input no. 3 output no. 3 is set equal to input no. 3 output no. 4 is set equal to input no. 2


Cathay Pacific cuts profit guidance for second time amid Hong Kong protests
HONG KONG: Hong Kong's Cathay Pacific Airways on Wednesday (Nov 13) said the short-term outlook remained "challenging and uncertain" due to anti-government protests in its home market as it lowered its profit guidance for the second time in less than a month.
The airline said passenger numbers fell 7 per cent in October and it now expected second-half profit to be "significantly below" the first half's HK$1.347 billion (US$172.04 million), in a step up from the wording "below" used last month.
READ: Cathay Pacific lowers full-year profit expectations as Hong Kong protests bite
READ: Sacked Hong Kong Cathay staff decry 'Cultural Revolution' purge
Hong Kong anti-government protesters on Wednesday paralyzed parts of the Asian financial hub for a third consecutive day, with some transport links, schools and many businesses closing after an escalation of violence.
"Overall we foresee a challenging remainder of 2019 for our airlines," Cathay Chief Customer and Commercial Officer Ronald Lam said in a statement on Wednesday.
"Looking ahead, our advanced bookings continue to show weakness in both inbound and outbound Hong Kong traffic for the rest of 2019, partly offset by moderately increased transit passengers via Hong Kong."
Cathay reduced passenger flight capacity by 2-4 per cent versus its original schedule between August and October and made further cuts of 6-7 per cent for November and December, Lam said.
The percentage of seats filled dropped by 4 percentage points to 77.6 per cent in October despite the capacity cuts, airfares were under pressure and premium travel demand was sluggish, he said.
READ: Battered and bruised, Hong Kong cleans up for sensitive Chinese anniversary
READ: Our coverage of the Hong Kong protests
The airline is expected to hold an analyst briefing on Thursday, the first under a new management team led by Chief Executive Augustus Tang after the airline's former head, Rupert Hogg, resigned in August after a crackdown by China's aviation regulator.
Some analysts have already forecast the carrier will report a loss in the second half.


Andy Murray tipped to win more Grand Slam titles with metal hip
Andy Murray is expected to return to Grand Slam action in January at the Australian Open - 12 months after he was given an emotional send off Down Under
by Irishmirror.ieAndy Murray can win more Grand Slams with his metal hip, according to his fitness trainer.
“Anything is possible,” claimed Matt Little. “Andy just has this X Factor that normal people just don't have so there is no limit to what he can do.”
The story of Murray's return to tennis is documented in the Amazon Prime film Andy Murray: Resurfacing which is out on Friday.
The next chapter in the Scot's story will be a return Down Under in January a year on from fearing his career was over.
A second hip surgery has been followed by a comeback which saw Murray claim the European Open in Antwerp in his last ATP Tour event after a thrilling final against Stan Wawrinka.
The three-time Grand Slam champion played only one match at the Davis Cup to rest a groin strain but will head out to Miami for a two-week training block with his team next week.
“Can Andy win Grand Slams again, starting with the Australian Open? I think so,” said Little. “There is no reason why not really not if he is feeling good and he is in good shape going into the tournament.
"That final against Stan was three hours after playing four or five other matches that week that were all tough. And in Slams you get a day off as well. And it is Andy. This is the thing. Andy just has this X Factor that normal people just don't have. So there is no limit to what he can do – there has never been a limit to what he can do.
“The pain he can push himself through on the court is more than everyone else.
"That was seven, eight months after surgery. You have seen the surgery now in the documentary – they basically cut his arse off and pulled his bone out through it.
"To have that happen to you and then seven, eight months later to beat Stan Wawrinka, in the final of a decent level tournament, it is ridiculous to expect to do that and that is what he has done.
“The other guys are trying hard against him. They don't want to probably lose to a guy with a metal hip either. But the result in Antwerp makes you optimistic for next year. Anything is possible.”
This upbeat mood is in stark contrast to moments in the film where Murray decided to quit in Miami in December 2018 because he could not longer handle the pain.
Little, who has worked as Murray's strength and conditioning coach since 2007, recalled: “We were in pieces, absolute bits.
"Myself, Jamie (Delgado), and Shane (Annun), there were a lot of tears in that locker room. It was great for our wives to come along to the premiere and see what we have been through in the last few years
Murray has yet to set a schedule for 2020 – and could follow Roger Federer's lead and skip the clay-court season to rest his body.
“We will manage his schedule very carefully, very carefully, and very objectively,” Little added. “There has been no blueprint for this. No one has ever done this before. We have no idea what is around the corner.”
Andy Murray: Resurfacing launches today on Amazon Prime Video.


THE TWO JAKES A film review by Harry K. Zink Copyright 1990 Harry K. Zink
Just got back from watching THE TWO JAKES, the "sequel" to Chinatown directed by Jack Nicholson.
This will not contain any spoilers (so those of you paranoid about getting your movie experienced destroyed by them may breathe easy). This is meant more as a description of my feelings after seeing this movie.
Well, first of all, I am extremely happy to note that Jack Nicholson has resisted the temptation to make a "popular" movie (quick cuts, upbeat soundtrack, lots of action, lots of sex) but instead has opted to make a "good" film. It might not appeal to the 18-25 year old crowd, but who really cares about them....
This movie takes off a few years after CHINATOWN and Nicholson reprises his role as Jake Gittes, Private Investigator. It seems that the years have been good to Jake, as his business has expanded, but that he is still pre-occupied with the past (of Chinatown). So much for plot summary - go see it if you want to know what the story is.
The movie is exceptionally well made and very pleasant to watch if you are a fan of the original CHINATOWN. Nicholson has obviously gone to great trouble to recreate the same atmosphere and ambiance the original gave the audience. The movie just "felt" good, down to the quality of the color and the cinematography (beautifully executed by Vilmos Zsigismond).
Visually the movie is stunning, but fortunately the storyline and continuity (in my opinion) were not disregarded either. The story kept me at the edge of my seat, though slow at times, yet it kept serving up surprises and twists (especially every time I thought I had it all figured out).
Just as it was a joy to watch the handiwork of Nicholson, The Director, it was equally pleasant to watch Nicholson, The Actor in action (then again, name one movie where that was not the case...) (with the possible exception of THE RAVEN and LITTLE SHOP...).
All I can say is that this movie is definitely worth watching if you would like to see a *GOOD* movie for a change, reminiscent of a time when such movies were still made.
Harry Zink INET<EMAIL_ADDRESS>UUCP: ucrmath!alchemy!hzink
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Cloud & Edge computing in Retail Stores
Rajasekaran Rajaramlet sekar = SoftwareEngineer { name : String::from("Rajasekaran Rajaram {he/him/his}"), company : String::from("Publicis Sapient"), title : String::from("Software Development Engineer 3"), email<EMAIL_ADDRESS>}
let passion = String::from("Distributed systems, IoT") let interest = String::from("Implementing AI and Robotics in Agriculture")
1. Store & POS
James Ritty's Incorruptible register
John H. Patterson & National Cash Register's (NCR) first POS
Cloud computing is on-demand availability of computer system resources
especially data storage (cloud storage) & computing power,
without direct active management by the user. - Wikipedia
Edge computing brings computation and storage closer to end user
improves response time and bandwidth
Fog Computing - At any point e.g. routers, switches, access points, IoT Gateways
Mobile/Multi Access Edge Computing - Radio access n/w such as GSM, LTE
CloudLet - Typical cloud services near mobile users (Datacenter in a box)
Others Content Delivery N/W, Smart Camera, Pixel Streaming etc.
2. Problems & Solution
- Packaged solution from Vendor
- Lack of knowledge on peripherals interaction
- Device variations, Vendor variations
- High Development cost and slow deployment cycle
- No monitoring and diagnostics
- Controlled by Vendor's field engineers
- No touch installation
- Deployment across various platforms
(Windows/Linux/Android)
- Centralized Monitoring and measurement
- Support across vendors and connectivity protocols
- Offline mode
- Elevated user experience
- Vertx
- Message Processing using Functional Features
- State machine w/ Java enums
- React with XState for state management
- Deployment using go services
(Plan to convert as K8S Operator)
- Simulator for device specific features
(For Development/Testing Purposes)
3. Device connectivity
Defines specifications
Controls ID assignment
Version 3.2 and 2.0 is wide use
Version 4 specificaation is ready
GUI and CLI
HTTP Data Capture
USB Packet capture
N/W packet capture (TFTP & DHCP)
Why?
No documentation, no vendor support but only a box4. No touch Installation
5. Future Scope
6. Modern Stores
Thank you for joining!!!
Special Thanks to Siva and Preeti!
Use a spacebar or arrow keys to navigate.
Press 'P' to launch speaker console.


Project information
- Category: Coding Exercise
- Institute: MIT xPRO
- Project date: JUN, 2021
- Project Repository: PacMen Exercise on GitHub
PacMen Exercise
This is an exercise developed during MIT xPro Professional Certificate in Coding: Full Stack Development with MERN. It is about creating objects dynamically with javascript when a button is clicked, detect the edges to move PacMens of the screen and changing the images of the Pacman Character.


If you’ve ever written an application that sends out email you may have written the code and executed it numerous times to check that the logic works and that the email appears as you hope. This obviously means you have to hit your SMTP server each time, open your email client and check your emails each time.
Reading through my Twitter timeline I saw @TheCodeJunkie asking about the app that you can use to test sending emails from your application.
Intrigued, I kept an eye on my timeline and found that the application in question was Papercut
In simple terms you put Papercut on a machine (most likely your development machine) and in your code set the SMTP host to be the IP Address of where Papercut is running and fire up your application and watch Papercut notify you from the system tray that it’s recevied a message.
Papertray System Tray Icon
Lets open it up and see what it says!
Raw View
Body View
I’ve tested this with a C# application and a Node.js application. If you don’t believe me, here’s the code:
C#
static void Main(string[] args)
{
MailMessage message = new MailMessage("Jonathan Channon "<EMAIL_ADDRESS>{
Subject = "iPhone",
Body = "I would like a free iPhone for work. My boss won't let me have one. How about it?",
BodyEncoding = Encoding.UTF8
};
message.Bcc.Add("boss@company.com");
SmtpClient client = new SmtpClient("<IP_ADDRESS>");
NetworkCredential info = new<EMAIL_ADDRESS>"reallysecurepassword");
client.DeliveryMethod = SmtpDeliveryMethod.Network;
client.UseDefaultCredentials = false;
client.Credentials = info;
try
{
client.Send(message);
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
}
}
Node.js
var nodemailer = require("nodemailer");
var smtpTransport = nodemailer.createTransport("SMTP");
var mailOptions = {
from: "Jonathan Channon ",
to<EMAIL_ADDRESS>cc<EMAIL_ADDRESS>subject: "iPhone",
text: "I would like a free iPhone for work. My boss won't let me have one. How about it?",
html: "I would like a free iPhone for work. My boss won't let me have one. How about it?"
};
smtpTransport.sendMail(mailOptions, function(error, response){
if(error)
{
console.log(error);
}else
{
console.log("Message sent: " %2B response.message);
}
smtpTransport.close();
});
I think this is a great little app and a real time saver. I highly recommend that you check it out!
They also offer a web based version called DummySMTP which allows you to test an almost live copy of your application but DummySMTP captures the emails sent out to customers, for example.


For a glimpse of the future of water in fast-growing Austin and Central Texas, don’t look to the past of reengineered rivers, multi-dam reservoirs and centralized treatment plants typical of America’s 50,000 city utilities. Rather, the future is a gravelly construction site of perhaps 75 by 30 yards in Central Austin. Near the site of the now-shuttered Highland Mall, now being converted to the newest campus of Austin Community College, is this lot wrapped with chain link and ‘No Trespassing’ signs. It is sandwiched between a newly-built parking garage and a rising glass and steel office building that will soon house 1,000 or so city employees. A new permitting department...
In early November, Austin voters nixed a proposal to rethink the Austin Convention Center and skirmishes at the ballot box are surely brewing for the next election over land use, school closures and the relentless roll-up of affordable places to build lives, families and businesses amid skyrocketing property taxes. Is “direct democracy,” the thumbs up or down by voters on measures put on the ballot by petition or city council action, the answer? That’s a debate in and of itself and in fact Austin, like many other cities, is moving toward tougher requirements to get local measures on the ballot. Which comes after the city reduced the signature requirements from 10 to 5 percent of registered voters just in 2012. Why? A good question...
Let’s call it the infantilization of cities. It’s more than a little ironic: as cities are handed ever more responsibility, and grow ever more assertive in the age of geo-urbanism, their biggest challenge may be the lingering Father-Knows-Best attitudes of so-called “senior” levels of government. When those silly Austin voters, for example, decided in 2016 that Uber and Lyft could take their business elsewhere if they wouldn’t accept the same scrutiny of their drivers as imposed on taxicab companies, the sage state legislature stepped in to wisely correct the city’s unruly ways. More recently, Texas’ governor-as-elder had to lean as Austin naively relaxed ordinances on where the homeless could gather or camp...
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam scelerisque id nunc nec volutpat. Etiam pellentesque tristique arcu, non consequat magna fermentum ac. Cras ut ultricies eros. Maecenas eros justo, ullamcorper a sapien id, viverra ultrices eros. Morbi sem neque, posuere et pretium eget, bibendum sollicitudin lacus. Aliquam eleifend sollicitudin diam, eu mattis nisl maximus sed. Nulla imperdiet semper molestie. Morbi massa odio, condimentum sed ipsum ac, gravida ultrices erat. Nullam eget dignissim mauris, non tristique erat. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae;


Elsie Doesn’t Mind
Laura Mullen
If the men she walks past
Make comments Nice tits
Nice ass shake it baby etc
She laughs and says it’s just
Their way of saying hello
To her as their way of saying
Hello to Bill or Pill were she
With her husband would be
An admiring but respectful
Silence she thinks it’s nice
To be noticed doesn’t see
Why the things they’re
Saying freak me out Don’t
Have a cow she thinks
I must be jealous as we
Walk in a kind of hot
Tunnel of glances and
On-going commentary that’s
Only she explains her due
Just a sign of appreciation
Nice pot-roast sexy rib-eye
Awesome flank steak mama
C’mon my filet mignon


manual mapred
Enter the number of task trackers nodes youwant to set up :
Do you want to use those same data nodes as task trackers :
Yes
No


| Interface | Description |
|---|---|
| AnalysisParams |
Defines the request parameters used by all analysis request handlers.
|
| CollectionParams | |
| CommonAdminParams | |
| CommonParams |
Parameters used across many handlers
|
| ConfigSetParams |
ConfigSets API related parameters and actions.
|
| CursorMarkParams |
Parameters and constants used when dealing with cursor based requests across
large sorted result sets.
|
| DisMaxParams |
A collection of params used in DisMaxRequestHandler,
both for Plugin initialization and for Requests.
|
| EventParams | |
| ExpandParams |
Expand parameters
|
| FacetParams |
Facet parameters
|
| GroupParams |
Group parameters
|
| HighlightParams | |
| MoreLikeThisParams | |
| QueryElevationParams |
Parameters used with the QueryElevationComponent
|
| ShardParams |
Parameters used for distributed search.
|
| SimpleParams |
Parameters used by the SimpleQParser.
|
| SpatialParams | |
| SpellingParams |
Parameters used for spellchecking
|
| StatsParams |
Stats Parameters
|
| TermsParams | |
| TermVectorParams | |
| UpdateParams |
A collection of standard params used by Update handlers
|
| Class | Description |
|---|---|
| AppendedSolrParams |
SolrParams wrapper which acts similar to DefaultSolrParams except that
it "appends" the values of multi-value params from both sub instances, so
that all of the values are returned.
|
| CoreAdminParams | |
| DefaultSolrParams | |
| MapSolrParams | |
| ModifiableSolrParams |
This class is similar to MultiMapSolrParams except you can edit the
parameters after it is initialized.
|
| MultiMapSolrParams | |
| RequiredSolrParams |
This is a simple wrapper to SolrParams that will throw a 400
exception if you ask for a parameter that does not exist.
|
| SolrParams |
SolrParams hold request parameters.
|
| Enum | Description |
|---|---|
| CollectionParams.CollectionAction | |
| CommonParams.EchoParamStyle |
valid values for:
echoParams |
| ConfigSetParams.ConfigSetAction | |
| CoreAdminParams.CoreAdminAction | |
| FacetParams.FacetRangeInclude |
An enumeration of the legal values for
FacetParams.FACET_DATE_INCLUDE and FacetParams.FACET_RANGE_INCLUDE
lower = all gap based ranges include their lower bound upper = all gap based ranges include their upper bound edge = the first and last gap ranges include their edge bounds (ie: lower for the first one, upper for the last one) even if the corresponding upper/lower option is not specified outer = the BEFORE and AFTER ranges should be inclusive of their bounds, even if the first or last ranges already include those boundaries. |
| FacetParams.FacetRangeMethod |
An enumeration of the legal values for
FacetParams.FACET_RANGE_METHOD
filter =
dv =
|
| FacetParams.FacetRangeOther |
An enumeration of the legal values for
FacetParams.FACET_RANGE_OTHER and FacetParams.FACET_DATE_OTHER ... |
| MoreLikeThisParams.TermStyle | |
| TermsParams.TermsRegexpFlag |
Copyright © 2000-2016 Apache Software Foundation. All Rights Reserved.


Execute a function ambidextrously (normalizes the differences between synchronous and asynchronous functions). Useful for treating synchronous functions as asynchronous functions (like supporting both synchronous and asynchronous event definitions automatically).
npm install --save ambi
require('ambi')
npm install --save ambi
require('ambi')
<EMAIL_ADDRESS>ender add ambi
require('ambi')
This package is published with the following editions:
ambi
aliases ambi/index.js
which uses Editions to automatically select the correct edition for the consumers environmentambi/source/index.js
is Source + ESNext + Requireambi/es2015/index.js
is Babel Compiled + ES2015 + RequireOlder environments may need Babel's Polyfill or something similar.
// Import
const ambi = require('ambi')
let result = null
// Sample methods
function syncMethod (x, y) {
return x * y
}
function asyncMethod (x, y, next) {
return setTimeout(function () {
next(null, x * y)
}, 0)
}
// Call the synchronous function asynchronously
// ambi adds support for this asynchronous callback automatically
result = ambi(syncMethod, 5, 2, function(err, result) {
console.log(err, result) // null, 10
})
console.log(result) // 10 - just like normal
// Call the asynchronous function asynchronously
// ambi doesn't do anything special here
result = ambi(asyncMethod, 5, 2, function (err, result) {
console.log(err, result) // null, 10
})
console.log(result) // setTimeout - just like normal
(method, ...args)
method
is the function to execute...args
is the arguments to send to the method
(err, ...results)
err
argumenterr
argument equal to null, and a result
argument equal to the returned result of the synchronous method[methodToFire, methodToIntrospect]
as the method
argumentDiscover the release history by heading on over to the HISTORY.md
file.
Discover how you can contribute by heading on over to the CONTRIBUTING.md
file.
These amazing people are maintaining this project:
No sponsors yet! Will you be the first?
These amazing people have contributed code to this project:
Discover how you can contribute by heading on over to the CONTRIBUTING.md
file.
Unless stated otherwise all works are:
and licensed under: