"
. " ". $starttime." - ".$endtime.""
. "
"
. " ". $location.""
. "
"
. " ". $description."
"
. " Event Link
"
. " Prizes: ". $prizes."";
$level = "All";
$color = "#444";
if ($leveln == 1) {
$level = "Beginners";
$color = "#63ab23";
}
else if ($leveln == 2) {
$level = "Intermediate";
$color = "orange";
}
else if ($leveln == 3) {
$level = "Advanced";
$color = "#ff0040";
}
$html .= "


Android is an operating system based on the Linux kernel,[12] and designed primarily for touchscreen mobile devices such as smartphones and tablet computers. Initially developed by Android, Inc., which Google backed financially and later bought in 2005,[13] Android was unveiled in 2007 along with the founding of the Open Handset Alliance—a consortium of hardware, software, and telecommunication companies devoted to advancing open standards for mobile devices.[14] The first publicly available smartphone running Android, the HTC Dream, was released on October 22, 2008.[15]
The user interface of Android is based on direct manipulation, using touch inputs that loosely correspond to real-world actions, like swiping, tapping, pinching and reverse pinching to manipulate on-screen objects. Internal hardware such as accelerometers, gyroscopes and proximity sensors are used by some applications to respond to additional user actions, for example adjusting the screen from portrait to landscape depending on how the device is oriented. Android allows users to customize their home screens with shortcuts to applications and widgets, which allow users to display live content, such as emails and weather information, directly on the home screen. Applications can further send notifications to the user to inform them of relevant information, such as new emails and text messages.
Android's source code is released by Google under the Apache License;[12] this permissive licensing allows the software to be freely modified and distributed by device manufacturers, wireless carriers and enthusiast developers. Most Android devices ship with a combination of open source and proprietary software.[3] As of July 2013, Android has the largest number of applications ("apps"), available for download in Google Play store which has had over 1 million apps published, and over 50 billion downloads.[16] A developer survey conducted in April–May 2013 found that Android is the most used platform among developers: it is used by 71% of the mobile developers population.[17]
Android is popular with technology companies which require a ready-made, low-cost and customizable operating system for high-tech devices.[18] Despite being primarily designed for phones and tablets, it also has been used in televisions, games consoles, digital cameras and other electronics. Android's open nature has encouraged a large community of developers and enthusiasts to use the open-source code as a foundation for community-driven projects, which add new features for advanced users[19] or bring Android to devices which were officially released running other operating systems.
As of May 2012, Android became the most popular mobile OS, having the largest installed base, and is a market leader in most countries[20] including the United States; there it has had the highest installed base of mobile phones for years.[21] In the third quarter of 2013, Android's share of the global smartphone shipment market—led by Samsung products—was 81.3%, the highest ever.[22][23][24] In most markets Android-powered phones are the most popular comprising more than half of the overall smartphone sales, including the United States market starting with the September–November 2013 period.[25] The operating system's success has made it a target for patent litigation as part of the so-called "smartphone wars" between technology companies.[26][27] As of September 2013, one billion Android devices have been activated.[28]


If you are interested to learn English in another country you can do it in this school! Invest in your future! If you are interested on it, click here
LThe word application, in IT, refers to a software program that’s designed to perform (do) a certain function (task). Some common applications that you probably use every day are the apps on your mobile phone. So then, an application developer would be an IT professional who develops (designs and writes) the software code for applications.
In IT, the word web is generally used to refer to anything related to the internet. In fact, another term for internet is “the world wide web,” or simply “the web.” So then, a web administrator would be an IT professional who’s in charge of managing and maintaining an online network or system. A system administrator is someone who manages any kind of technological system, and may be referred to as a system admin for short.
The word network is used to refer to a system of computers, telecommunications equipment and other devices such as printers and modems that are linked to each other and/or to the internet. So then, a network engineer would be an IT professional who designs, implements (puts in place) and maintains computer networks.
An information technology manager is an IT professional in charge of planning, implementing and maintaining a company’s network of computer systems, as well as the IT personnel (staff) responsible for the company’s IT functions.


|
DJI Onboard SDK
4.0
|
Logger for DJI OSDK supporting different logging channels. More...
#include <dji_log.hpp>
Inherits DJI::OSDK::Singleton< T >.
Public Member Functions | |
| Log (Mutex *m=0) | |
| Log & | title (int level, const char *prefix, const char *func, int line) |
| Log & | title (int level, const char *prefix) |
| Log & | print () |
| void | enableStatusLogging () |
| Enable logging of status messages called through DSTATUS macro. More... | |
| void | disableStatusLogging () |
| Disable logging of status messages called through DSTATUS macro. More... | |
| void | enableDebugLogging () |
| Enable logging of status messages called through DDEBUG macro. More... | |
| void | disableDebugLogging () |
| Disable logging of status messages called through DDEBUG macro. More... | |
| void | enableErrorLogging () |
| Enable logging of status messages called through DERROR macro. More... | |
| void | disableErrorLogging () |
| Disable logging of status messages called through DERROR macro. More... | |
| bool | getStatusLogState () |
| bool | getDebugLogState () |
| bool | getErrorLogState () |
| virtual Log & | print (const char *fmt,...) |
| Log & | operator<< (bool val) |
| Log & | operator<< (short val) |
| Log & | operator<< (uint16_t val) |
| Log & | operator<< (int val) |
| Log & | operator<< (uint32_t val) |
| Log & | operator<< (long val) |
| Log & | operator<< (unsigned long val) |
| Log & | operator<< (long long val) |
| Log & | operator<< (unsigned long long val) |
| Log & | operator<< (float val) |
| Log & | operator<< (double val) |
| Log & | operator<< (long double val) |
| Log & | operator<< (void *val) |
| Log & | operator<< (char c) |
| Log & | operator<< (uint8_t c) |
| Log & | operator<< (int8_t c) |
| Log & | operator<< (const char *str) |
Logger for DJI OSDK supporting different logging channels.
The Log class is a singleton and contains some pre-defined logging levels. The class provides methods to turn on or off these predefined logging levels. Users can also create their own logging channels using the DLOG macro.
| void DJI::OSDK::Log::disableDebugLogging | ( | ) |
Disable logging of status messages called through DDEBUG macro.
Call this method on the DJI::OSDK::Log.instance() in your program.
| void DJI::OSDK::Log::disableErrorLogging | ( | ) |
Disable logging of status messages called through DERROR macro.
Call this method on the DJI::OSDK::Log.instance() in your program.
| void DJI::OSDK::Log::disableStatusLogging | ( | ) |
Disable logging of status messages called through DSTATUS macro.
Call this method on the DJI::OSDK::Log.instance() in your program.
| void DJI::OSDK::Log::enableDebugLogging | ( | ) |
Enable logging of status messages called through DDEBUG macro.
Call this method on the DJI::OSDK::Log.instance() in your program.
| void DJI::OSDK::Log::enableErrorLogging | ( | ) |
Enable logging of status messages called through DERROR macro.
Call this method on the DJI::OSDK::Log.instance() in your program.
| void DJI::OSDK::Log::enableStatusLogging | ( | ) |
Enable logging of status messages called through DSTATUS macro.
Call this method on the DJI::OSDK::Log.instance() in your program.
| Log& DJI::OSDK::Log::title | ( | int | level, |
| const char * | prefix, | ||
| const char * | func, | ||
| int | line | ||
| ) |
| Log& DJI::OSDK::Log::title | ( | int | level, |
| const char * | prefix | ||
| ) |


Interface ISmintIoAsset
- All Superinterfaces:
ISmintIoDataType
- All Known Implementing Classes:
SmintIoAssetImpl
An asset is a clone/copy of an original content, copied at the event of purchase (see
getContentElementUuid()
). Every purchase creates such a copy - even if the same content (eg: image, video,
etc.) is bought again.
Two types of assets
On Smint.io an asset is a unique collection - with a unique ID getLicensePurchaseTransactionUuid()
- if its
meta data (eg: name, description, licenses, restrictions, etc.) and the attached binary data (eg: picture), where
each binary data has its own additional Binary ID (see ISmintIoBinary.getUuid()
).
There are two type of assets in use with Smint.io.
- Binary Asset - assets with a single binary attached.
- Compound Asset - assets that contain multiple binaries e.g. a recipe containing a picture, some text and some calories information - three binaries in total.
Localized texts with translations
The texts with translations, the possibly available translations are defined by the value of
ISettingsModel.getImportLanguages()
. However,
not all languages might have a valid translation. Languages without a translation might be omitted. Especially if
this is a persistent asset and a new language has been added to the list of languages after storing the asset to the
synchronization target, some existing translations might be missing. Such cases are not detected by the
synchronization job and unchanged assets will not be updated. Only changes on the Smint.io platform are detected. All
changes on the synchronization target are discarded.
- See Also:
-
Method Summary
Modifier and TypeMethodDescriptionProvides the list of binaries, this asset consists of.Provides the unique Smint.io platform ID of the purchase cart this asset was part of.Provides the Smint.io localized name of the collection this asset is part of.Provides the Smint.io ID of the collection this asset is part of.Provides the ID for the content category.Provides the UUID of the content element this asset is a copy of.Return an key, denoting the content provider.Provides the content type of this asset.Provides a localized list of copyright notices to indicate the copyright owner of this asset.Provides the date, when this asset has been created.Provides the localized description for the asset, translated to multiple languages.Provides download constraints to apply to this asset.Provides a list of localized keywords to be used for keyword searches.Provides the date, when this asset has been updated the last time.Provides the name of the licensee.Provides a Smint.io ID for the licensee.This is a Smint.io internal ID of the asset.Provides a list of license terms to apply to this asset.Provides a localized text of the license that applies to this asset.Provides a general type ID of the kind license applying to this asset.Provides localized links to further information regarding the license (e.g.getName()
Provides the name for the asset, translated to multiple languages.Provides the Smint.io localized name of the project this asset has been purchased for.Provides the Smint.io ID of the project this asset has been purchased for.Provides the date, when this asset has been purchased.Provides some release details of this asset, regarding agreements with visible models or property owners.Provides the Web URL to view the asset on the Smint.io platform in the browser.io.smint.clapi.consumer.generated.models.LicensePurchaseTransactionStateEnum
getState()
Provides the current state of the purchase of the license.getUuid()
This is a Smint.io internal ID of the asset.boolean
Defines whether the content has some license restrictions applied.Defines whether the content is for editorial use only.
-
Method Details
-
getContentElementUuid
String getContentElementUuid()Provides the UUID of the content element this asset is a copy of.Assets are copies of content elements. As a source of the asset, content elements form the link to the upstream content provider. Although much its data is copied to the asset, it still is a necessary link to the original source. The asset is copied from the original source by a purchase transaction on the Smint.io platform.
- Returns:
- the Smint.io ID of the original source this asset is a copy of or
null
.
-
getLicensePurchaseTransactionUuid
String getLicensePurchaseTransactionUuid()This is a Smint.io internal ID of the asset.With a purchase you actually buy a license to use the asset, hence the name of this value contains "license" and "purchase transaction".
- Returns:
- the ID of the license purchase transaction, meaning this is the ID of the asset.
-
getUuid
String getUuid()This is a Smint.io internal ID of the asset.Implementing functions need to just call
getLicensePurchaseTransactionUuid()
.- Returns:
- the return value of
getLicensePurchaseTransactionUuid()
.
-
getCartPurchaseTransactionUuid
String getCartPurchaseTransactionUuid()Provides the unique Smint.io platform ID of the purchase cart this asset was part of.Every purchase consists of a single cart, that collects all assets to pay for in a single transaction. At least there is 1 asset in a cart but the amount is unrestricted. An asset can only be part of a single cart but the cart may contain multiple assets.
- Returns:
- the ID of the purchase or
null
.
-
getState
io.smint.clapi.consumer.generated.models.LicensePurchaseTransactionStateEnum getState()Provides the current state of the purchase of the license.Currently supported values are (but might change in the future):
PURCHASE_PHASE_1
PURCHASE_PHASE_2
DOWNLOADING
FINALIZING
COMPLETED
ERROR
CANCELLED
Such a situation might happen in case the asset has been already purchased in the past and therefore is managed by the sync target. Nevertheless the maximum number of usage/downloads have been reached and more must be purchased. If the purchase is being cancelled for some reason, it will be indicated by this flag.
- Returns:
- the ID of the license purchase transaction.
-
getContentProvider
String getContentProvider()Return an key, denoting the content provider.The enumeration key is a simple reading text, which has been defined for each provider as soon as it has been added to the list of supported providers by Smint.io. Its value is arbitrary and uses mixed cases. Non-exhaustive example:
getty
shutterstock
adobestock
istock
panthermedia
Although a known set of values are used, some might be changed and more be added in the near future without any further notice. So implementing classes must support an arbitrary value.
- Returns:
- an enumeration key or
null
if none has been set. - See Also:
-
getContentType
String getContentType()Provides the content type of this asset.The type value is a string representation of an enumerated value. Although a fixes set of values are used, more might be added in the near future. So implementing classes must support an arbitrary value. Possible values are at the moment:
image
video
audio
document
3d
- a 3D videotemplate
- Returns:
- an enumeration key or
null
if none has been set. - See Also:
-
getContentCategory
String getContentCategory()Provides the ID for the content category.The ID is a simple reading text. Its value is arbitrary and uses mixed cases. Non-exhaustive example:
creative
editorial
Although a known set of values are used, some might be changed and more be added in the near future without any further notice. So implementing classes must support an arbitrary value.
- Returns:
- a key of the category of this content or
null
if unknown. - See Also:
-
getName
Provides the name for the asset, translated to multiple languages.The possible translations available are defined by the value of
ISettingsModel.getImportLanguages()
. However, not all languages might have a valid translation. Languages without a translation might be omitted from the map. Especially if this is a persistent asset and a new language has been added to the list of languages. Then the new language might have not yet been stored to this persistent asset.- Returns:
- the multi-language name of the asset or
null
if none have been set yet.
-
getDescription
Provides the localized description for the asset, translated to multiple languages.The possible translations available are defined by the value of
ISettingsModel.getImportLanguages()
. However, not all languages might have a valid translation. Languages without a translation might be omitted from the map. Especially if this is a persistent asset and a new language has been added to the list of languages. Then the new language might have not yet been stored to this persistent asset.- Returns:
- the multi-language description of the asset or
null
if none have been set yet.
-
getKeywords
Provides a list of localized keywords to be used for keyword searches.The list of keywords are usually provided by the upstream content provider (see
getContentProvider()
). These keywords can be used for keyword searches. However, not all keywords are available for every language.- Returns:
- the localized list of keywords or
null
.
-
getReleaseDetails
ISmintIoReleaseDetails getReleaseDetails()Provides some release details of this asset, regarding agreements with visible models or property owners.- Returns:
- release details of this asset or
null
.
-
getCopyrightNotices
Provides a localized list of copyright notices to indicate the copyright owner of this asset.The copyright notice usually is provided by the upstream content provider (see
getContentProvider()
). Not all languages may contain proper copyright notice. If the language to display does not have a notice available, use the one for English or the first one available.- Returns:
- copyrightNotices the localized copyright notices or
null
.
-
getProjectUuid
String getProjectUuid()Provides the Smint.io ID of the project this asset has been purchased for.On Smint.io platform every purchase is related to a project context. It provides more insights about further purchase, other collections and more. So the project ID is necessary to retrieve this context in the future. Eg. the web view of the asset is composed making use of the project ID (see
getSmintIoUrl()
).- Returns:
- the Smint.io ID of the project context for this asset or
null
. - See Also:
-
getProjectName
Provides the Smint.io localized name of the project this asset has been purchased for.On Smint.io platform every purchase is related to a project context. It provides more insights about further purchase, other collections and more. So the project ID is necessary to retrieve this context in the future. Eg. the web view of the asset is composed making use of the project ID (see
getSmintIoUrl()
).- Returns:
- the Smint.io name of the project context for this asset or
null
. - See Also:
-
getCollectionUuid
String getCollectionUuid()Provides the Smint.io ID of the collection this asset is part of.On Smint.io platform every asset may be added to a collection within the project context. The collections can be used to prepare purchase or collect assets for certain tasks before selecting the ones to really buy.
If possible, the name of the project should be visible on the UI to provide a fast feedback to the user for which project this asset has been acquired.
- Returns:
- the Smint.io collection's ID this asset is part of or
null
. - See Also:
-
getCollectionName
Provides the Smint.io localized name of the collection this asset is part of.On Smint.io platform every asset may be added to a collection within the project context. The collections can be used to prepare purchase or collect assets for certain tasks before selecting the ones to really buy.
If possible, the name of the collection should be visible on the UI to provide a fast feedback to the user how this asset has been acquired and its purchase has been prepared.
- Returns:
- the Smint.io collection's name this asset is part of or
null
. - See Also:
-
getLicenseeUuid
String getLicenseeUuid()Provides a Smint.io ID for the licensee.Further information about the licensee can be retrieved from the Smint.io platform using this ID.
- Returns:
- the Smint.io ID of the licensee or
null
.
-
getLicenseeName
String getLicenseeName()Provides the name of the licensee.Further information about the licensee may be stored with the Smint.io platform, but at least this name can be used to display the licensee in the UI of the sync target. Usually this is the business name of the licensee.
- Returns:
- the name of the licensee or
null
.
-
getLicenseType
String getLicenseType()Provides a general type ID of the kind license applying to this asset.The type ID is a simple reading text, which has been defined up-front by Smint.io. Its value is arbitrary and uses mixed cases. Non-exhaustive example:
all
- all is allowed, no restrictions are applied.royalty_free
- royalty free content.rights_managed
- rights managed content with more detailed license restrictions.rights_ready
Although a known set of values are used, some might be changed and more be added in the near future without any further notice. So implementing classes must support an arbitrary value.
- Returns:
- the key of the type of license or
null
.
-
getLicenseText
Provides a localized text of the license that applies to this asset.The localized text contain a textual summary of the license and maybe additional information. This text is intended to be displayed in the UI along the asset.
- Returns:
- the localized text of the license or
null
.
-
getLicenseUrls
Provides localized links to further information regarding the license (e.g. provider license term pages, links to documents, etc.).Provides localized links to further information regarding the license (e.g. provider license term pages, links to documents, etc.). This text is intended to be displayed in the UI along the asset.
- Returns:
- the localized URLs of the license or
null
.
-
getLicenseTerms
ISmintIoLicenseTerm[] getLicenseTerms()Provides a list of license terms to apply to this asset.- Returns:
- the list of license terms of this asset or
null
.
-
getDownloadConstraints
ISmintIoDownloadConstraints getDownloadConstraints()Provides download constraints to apply to this asset.- Returns:
- the download constraints of this asset or
null
.
-
isEditorialUse
Boolean isEditorialUse()Defines whether the content is for editorial use only.In case no such information is available, then
null
is returned. This is the case if the upstream asset provider did not define this value and did not provide any defaults. Hence it is impossible to determine, whether the asset is for editorial use only or not. If the synchronization target does not require a value, none should be set in these cases. If a valid value (decision) is required, it is up to the sync target to implement a reasonable default to be on the safe side of the legal challenge.- Returns:
Boolean.TRUE
in case the asset is for editorial use only andBoolean.FALSE
otherwise. However,null
is returned if no such information is available. Hence neither is applicable.
-
hasRestrictiveLicenseTerms
boolean hasRestrictiveLicenseTerms()Defines whether the content has some license restrictions applied.The kind of license restrictions applicable for this asset can be retrieved with
getLicenseTerms()
.- Returns:
true
in case any licensing restriction has been applied to the asset or not.
-
getBinaries
ISmintIoBinary[] getBinaries()Provides the list of binaries, this asset consists of.Usually an asset contains a single binary, thus the list would consist of a single item. Nevertheless occasionally, more binaries are attached, that contain the same content in different variants. eg: Images of different resolution, videos with banner image, etc. Therefore, each asset may consist of more than one binary.
- Returns:
- a list of attached binaries or
null
if none are linked to this asset.
-
getSmintIoUrl
URL getSmintIoUrl()Provides the Web URL to view the asset on the Smint.io platform in the browser.The URL to the web view of the asset on the Smint.io platform can be used by users, to view more information about the asset on the Smint.io platform. Especially what part of collection it is, further discussions, ratings and feedbacks on this asset. The Smint.io platform provides more data than can possibly be stored with a synchronization target.
Example:https://demo.smint.io/project/21/content-element/7:0:256245306
A user to access this URL still need permissions on the Smint.io platform to do so. Usually a separate user for the platform is needed.
- Returns:
- the URL to the web page on the Smint.io platform for this asset.
-
getPurchasedAt
OffsetDateTime getPurchasedAt()Provides the date, when this asset has been purchased.- Returns:
- the date of purchase of this asset or
null
.
-
getCreatedAt
OffsetDateTime getCreatedAt()Provides the date, when this asset has been created.- Returns:
- the date of creation of this asset or
null
.
-
getLastUpdatedAt
OffsetDateTime getLastUpdatedAt()Provides the date, when this asset has been updated the last time.The last update time is not used to compare for updated content. Times seem to be too prune to different settings on servers of Smint.io and sync target. Hence all meta data of assets are updated, once Smint.io detects a change. Binary data uses a simple, increasing counter as version number (see
ISmintIoBinary.getVersion()
) which can be used to see, which binary is the newest one. Only Smint.io platform will update the binary data, though. Without a single source, increasing counter would not work as they are not unique then.- Returns:
- the date of last update of this asset or
null
.
-


- lenWidParam(boolean, boolean, float) - Method in class liquid.gui.EnviroFlowmetersAndBreakpointsPanel
-
Method adjusts the breakpoint's Length/Width to be within the environment's size.
- lenWidParam(boolean, boolean, float) - Method in class liquid.gui.EnviroObstaclesAndDrainsPanel
-
Method adjusts the obstacle/drain's Length/Width to be within the environment's size.
- liqsParam() - Method in class liquid.gui.ParameterPanel
-
Method adjusts the liquid drop-down, which then adjusts the temperature/viscosity drop-down accordingly.
- liquid.core - package liquid.core
-
- liquid.engine - package liquid.engine
-
- liquid.gui - package liquid.gui
-
- liquid.logger - package liquid.logger
-
- LiquidApplication - Class in liquid.core
-
The Liquid Application class initializes the Fluid Engine, GUI, and
Logger components.
- LiquidApplication() - Constructor for class liquid.core.LiquidApplication
-
Constructor initializes the application components.
- LiquidEngine - Class in liquid.engine
-
LiquidEngine is the central class of the Engine, where all components have been derived from the jBox2D software.
- LiquidEngine() - Constructor for class liquid.engine.LiquidEngine
-
Constructor creates a new instance of the Engine.
- LiquidFileLoader - Class in liquid.logger
-
Class is used to load the config file information for the current program.
- LiquidFileLoader() - Constructor for class liquid.logger.LiquidFileLoader
-
- LiquidFileWriter - Class in liquid.logger
-
Class is used to write the log files of a simulation.
- LiquidFileWriter() - Constructor for class liquid.logger.LiquidFileWriter
-
- LiquidFrame - Class in liquid.gui
-
Class creates the overall frame of the simulator.
- LiquidFrame() - Constructor for class liquid.gui.LiquidFrame
-
Constructor sets the parameters of the frame, such as the size.
- LiquidGUI - Class in liquid.gui
-
LiquidGUI is the central class of the GUI, where all components of the GUI are initialized
here and available for other components to access them when necessary.
- LiquidGUI() - Constructor for class liquid.gui.LiquidGUI
-
Constructor initializes the components of the GUI.
- LiquidGuiVariables - Class in liquid.gui
-
Class will store all of the parameters associated with the simulation.
- LiquidGuiVariables() - Constructor for class liquid.gui.LiquidGuiVariables
-
Constructor initializes some initial values of the parameters declared.
- LiquidLogger - Class in liquid.logger
-
LiquidLogger is the main class of the Logger component.
- LiquidLogger() - Constructor for class liquid.logger.LiquidLogger
-
Constructor initializes the Logger component of the simulation.
- LiquidMenuBar - Class in liquid.gui
-
Class creates the menu bar along the top of the simulator.
- LiquidMenuBar() - Constructor for class liquid.gui.LiquidMenuBar
-
Constructor for the menu bar.
- loadConfigFile(String) - Method in class liquid.logger.LiquidFileLoader
-
Method attempts to read the specified config file, then stores all of
the information onto an ArrayList and sent out as a String[] to read.
- loadLogParam(String) - Method in class liquid.logger.LiquidFileLoader
-
Method attempts to read the specified log file, then stores all of
the information onto an ArrayList and sent out as a String[] to read.
- logUpdate() - Method in class liquid.gui.ParameterPanel
-
The parameters in the parameter panel will get their values updated based on the information from the log file.


The
<pm-dialog></pm-dialog>
component can be used to add a scrolling effect where the letters are rendered
one at a time.
Features:
Click the dialog to skip the animation.
Comes with 3 predetermined scrolling speeds,
slow
,
normal
, and
fast
. You can also provide an arbitrary number if the speeds don't work for
you.
Ability to set the
tone
of the dialog. The only one currently implemented is
scared
Examples:
<pm-dialog speed="slow"><pm-dialog>
This is a dialog using the "slow" speed
<pm-dialog><pm-dialog>
This is a dialog using the "normal" speed.
<pm-dialog speed="fast"><pm-dialog>
This is a dialog using the "fast" speed
<pm-dialog [speed]="100"><pm-dialog>
This is a dialog using a custom speed. The number is how many
milliseconds should be delayed between each character.
<pm-dialog tone="scared"><pm-dialog>
Shaking in your boots??? Use the "scared" tone! Boooooooooo!!


HTTP Basic authentication:
Connect over Tor:
Specterd Version:
Specterd File Hash:
Specterd CLI args:
Use a custom specterd file: Choose file


Introduction
The basic goal of the Cascading Stylesheet (CSS) language is to allow a browser engine to paint elements of the page with specific features, like colors, positioning, or decorations. The CSS syntax reflects this goal and its basic building blocks are:
- The property which is an identifier, that is a human-readable name, that defines which feature is considered.
- The value which describe how the feature must be handled by the engine. Each property has a set of valid values, defined by a formal grammar, as well as a semantic meaning, implemented by the browser engine.
CSS Declarations
Setting CSS properties to specific values is the core function of the CSS language. A property and value pair is called a declaration, and any CSS engine calculates which declarations apply to every single element of a page in order to appropriately lay it out, and to style it.
Both properties and values are case-insensitive by default in CSS. The pair is separated by a colon,':'
, and white spaces before, between, and after properties and values, but not necessarily inside, are ignored.
There are more than 100 different properties in CSS and a nearly infinite number of different values. Not all pairs of properties and values are allowed and each property defines what are the valid values. When a value is not valid for a given property, the declaration is deemed invalid and is wholly ignored by the CSS engine.
CSS Declaration Blocks
Declarations are grouped in blocks, that is in a structure delimited by an opening brace, {
and a closing one, }
. Blocks sometimes can be nested, so opening and closing braces must be matched.
 A declaration block may be empty, that is containing null declaration. White spaces around declarations are ignored. The last declaration of a block doesn't need to be terminated by a semi-colon, though it is often considered good style to do it as it prevents forgetting to add it when extending the block with another declaration.
CSS Rulesets
If style sheets could only apply a declaration to each element of a Web page, they would be pretty useless. The real goal is to apply different declarations to different parts of the document.
CSS allows this by associating conditions with declarations blocks. Each (valid) declaration block is preceded by one or more comma-separated selectors, which are conditions selecting some elements of the page. A selector group and an associated declarations block, together, are called a ruleset, or often simply a rule.
As an element of the page may be matched by several selectors, and therefore by several rules potentially containing a given property several times, with different values, the CSS standard defines which one has precedence over the other and must be applied: this is called the cascade algorithm.
CSS Statements
Rulesets are the main building blocks of a style sheet, which often consists of only a big list of them. But there is other information that a Web author wants to convey in the style sheet, like the character set, other external style sheets to import, font face or list counter descriptions and many more. It will use other and specific kinds of statements to do that.
A statement is a building block that begins with any non-space characters and ends at the first closing brace or semi-colon (outside a string, non-escaped and not included into another {}, () or [] pair).
There are two kinds of statements:
- Rulesets (or rules) that, as seen, associate a collection of CSS declarations to a condition described by a selector.
-
At-rules that start with an at sign,
@
, followed by an identifier and then continuing up the end of the statement, that is up to the next semi-colon (;) outside of a block, or the end of the next block. Each type of at-rules, defined by the identifier, may have its own internal syntax, and semantics of course. They are used to convey meta-data information (like @charset or @import), conditional information (like @media or @document), or descriptive information (like @font-face).
Any statement which isn't a ruleset or an at-rule is invalid and ignored.
References
- All the documentation in this page is taken from MDN


| Id | User Request | User Approve | Type | Duration | Unit | Status | Date Requested | Date Approve | Date Created | ||
|---|---|---|---|---|---|---|---|---|---|---|---|
| {{ leaveRequests.id }} | {{ leaveRequests.userRequested }} | {{ leaveRequests.userApproved }} | {{ leaveRequests.type }} | {{ leaveRequests.duration }} | {{ leaveRequests.unit }} | {{ leaveRequests.status }} | {{ leaveRequests.dateRequested }} | {{ leaveRequests.dateApproved }} | {{ leaveRequests.dateCreated }} |


Hello everyone, today I intend to continue this series that we discussed data structure and for this post we will learn graphs. This incredible structure you can apply to many problems in the real world, so it is one of the most important structures and also very common in interview questions.
So, let’s dive into this new adventure!
💭 “The trick is to fix the problem you have, rather than the problem you want.” - Bram Cohen
Outline
- What is a Graph?
- Basic concepts.
- The main operations and properties.
- Learning BFS and DFS functions.
Graph
Many people often confuse a graph with a tree structure, and that’s happened because a tree is a type of graph!
Basically, a graph is a non-linear structure of a set of vertices V connected by edges E that can be represented as ordered pair of vertices G(V,E) .
More precisely, a graph is composed of paths that contain adjacency vertices connected by edges. Usually, you can find many books and articles using different terms to refer to vertices and edges, the most common of which are:
- Vertex: Nodes or points;
- Edges: Lines, links or arcs;
▪ Graph visualization
One of the most interesting things that make graphs a powerful structure is how they can represent a lot of information for some applications. There are many examples that we can use and the most common are a network of cities, streets, flights, ferries, railway maps, social network connections, and so on…
From theses examples, a graph structure can obtain a lot of information, such as how many cities are close to another or which is the sort path between two cities, for example. Can you see how powerful this structure can be?
Even though a graph is just a collection of nodes and edges, there are two ways to represent it, which are:
- Adjacency Matrices
As the name suggests, this representation uses a square matrix where rows and columns mean that there is a relationship from one vertex to another. We can see how it works in the image below.
Figure 1: Adjacency Matrice visualization.
As we can see, the matrix represents which vertices are connected by edges, we can simply find out if there is a relationship between the vertices looking at the matrix.
- Adjacency List
Is the most common and efficient way to represent a graph, because creates an array that can store all vertices in a list for each vertex of the graph. Using the same set used in the adjacency matrix above:
Figure 2: Adjacency list visualization.
▪ Graph Representations
After talking about visualizations, the next step is to learn how many types of graph exists. Here we will see how the vertices are organized and connected.
Directed or undirected
- Directed
In this type of graph, the edges are directed from one vertex to another. As we can see, the edge between 0 and 1 vertices is directed, right?
Figure 3: Directed graph representation.
- Undirected
Unlike the directed graph, this type of graph has all vertices pointing towards each other, that is, all edges are bidirectional.
Figure 4: Undirected graph representation.
- Cyclic or acyclic
A cycle graph means if the graph contains a path that begins at a given vertex and after few vertices ends at the same starting vertex. The example below contains the following cycle: 5 -> 2 -> 1 -> 4.
Figure 5: Cyclic graph representation.
▪ Basic operations
Okay, now that we already understand what a graph is, let’s see how to implement it. First thing first, we need to create our main class and, as we have seen, there are two ways to build this structure and will use the adjacency list representation, where a key and all its connections are associated.
Let’s see how below:
class Graph {
constructor() {
this.adjacencyList = {}
}
...
}
Simple right? 😁 We just need to initialize the adjacencyList variable that will be used as a dictionary to add key-value pairs. The next step is to know how to insert a vertex in our graph using the dictionary that was created.
When a new vertex is added to the structure, it takes only a constant time, the time complexity of O(1). This is because we just need to add the new element to the array.
Great! Moving forward, we need to use a real-world example to facilitate our understanding and we will use a social network to exemplify operations.
addVertex(vertex){
this.adjacencyList[vertex] = [];
}
A social network needs some users, right? So, let’s fill it out by adding some people from middle-earth using the following code:
const middle_earth = new Graph();
middle_earth.addVertex('Gandalf');
middle_earth.addVertex('Saruman')
middle_earth.addVertex('Frodo')
middle_earth.addVertex('Billy')
middle_earth.addVertex('Sean')
middle_earth.addVertex('Merry')
middle_earth.addVertex('Sméagol')
Well, something is missing from our social network. We need interactions between the users, the next step is to create some connections between the vertices created.
As discussed earlier, the main differences between these types of graphs are in the fact that only the undirected function creates connections on both sides.
The code below shows how we can create connections using directed and undirected approaches.
addEdgeDirected(vertex1, vertex2) {
if(!this.adjacencyList[vertex1]){
this.addVertex(vertex1)
}
if(!this.adjacencyList[vertex2]){
this.addVertex(vertex2)
}
if(!this.adjacencyList[vertex1].includes(vertex2))
this.adjacencyList[vertex1].push(vertex2);
}
addEdgeUndirected(vertex1, vertex2) {
if(!this.adjacencyList[vertex1]){
this.addVertex(vertex1)
}
if(!this.adjacencyList[vertex2]){
this.addVertex(vertex2)
}
if(!this.adjacencyList[vertex1].includes(vertex2))
this.adjacencyList[vertex1].push(vertex2);
if(!this.adjacencyList[vertex2].includes(vertex1))
this.adjacencyList[vertex2].push(vertex1);
}
In this example of social networking, we will use the undirected approach, however, the directed type graph also can be used. Moving on, let’s now imagine that Gandalf added some hobbits and a wizard to his social network.
middle_earth.addEdgeUndirected('Gandalf', 'Billy');
middle_earth.addEdgeUndirected('Gandalf', 'Merry')
middle_earth.addEdgeUndirected('Gandalf', 'Sean')
middle_earth.addEdgeUndirected('Gandalf', 'Frodo')
middle_earth.addEdgeUndirected('Gandalf', 'Saruman')
After that, our graph looks something like this:
Figure 6: Middle-earth network representation.
Awesome! 😁
Okay, moving forward with the discussion, let’s imagine the scenario where the Sméagol user had a bad behaviour and it is necessary to removed it, how we can do this?
For now, we have no way to remove any vertex. So, we need to fix this, right? To delete a vertex from the graph, it is necessary to iterate through the list of each vertex and validate whether an edge exists or not. If it exists, then we have to remove the vertex. Let’s take a look:
removeVertex(vertex) {
if(vertex in this.adjacencyList){
delete this.adjacencyList[vertex];
var vertexList = Object.keys(this.adjacencyList);
vertexList.forEach(element => {
if(this.adjacencyList[element].includes(vertex) == true){
var index = this.adjacencyList[element].indexOf(vertex);
this.adjacencyList[element].splice(index,1);
}
});
}
}
As you may be thinking, this function is O(n) because we need to iterate over the vertices and then remove the element.
And the edges?  What do we have to do? 🧐 Well, to remove an edge, we need to check if the vertices are connected and then remove from the array.
removeEdge(vertex1, vertex2) {
if(this.adjacencyList[vertex1].includes(vertex2)){
var adjacents = this.adjacencyList[vertex1];
var index = adjacents.indexOf(vertex2);
this.adjacencyList[vertex1] = adjacents.splice(index,1);
}
}
Great! Can you see the progress? 🚀
There are functions like print_all_path_destination, print_adjacency_matrix, countPaths, isAdjacent and others that I would like to discuss, but I’ll skip the explanations for not taking too much of your time.
⚡ But if you would like to learn or see others functions that I implemented you can access all the code just clicking here.
Now we are going to use all the acknowledgement that we learned to implement search function.
▪ Graph Search
Let’s dive into the most important topic related to this structure! We want to traverse all the vertices and edges of that graph. What does that mean? Well, we can put an example: Gandalf had a map and try to travel across middle-earth. 😁 But relax, we’ll see all the steps of these functions using an example along the way. Let’s create a graph to be used.
var graph_example = new Graph();
graph_example.addEdgeDirected(0, 1)
graph_example.addEdgeDirected(0, 2)
graph_example.addEdgeDirected(1, 3)
graph_example.addEdgeDirected(1, 4)
graph_example.addEdgeDirected(2, 5)
graph_example.addEdgeDirected(2, 6)
After creating the vertices and edges, our graph will look something like this:
Figure 7: Graph example to be used on BFS and DFS functions.
- Breadth-first search (BFS)
This approach is the most common and used. It starts by considering all vertices as unvisited and all edges undiscovered. With that in mind, we can choose an arbitrary vertex and then discover all vertices connected by an edge and visited.
Every time that an adjacent vertex is visited, we must mark it and insert it in a queue. Since none of the edges that incident on the vertex are undiscovered, we can proceed and explore the next vertex.
Using the example above and considering vertex 0 as the current vertex, the result is:
Visited Vertex: 0
Visited Vertex: 1
Visited Vertex: 2
Visited Vertex: 3
Visited Vertex: 4
Visited Vertex: 5
Visited Vertex: 6
We must repeat the process until no undiscovered and unvisited are left in the structure. When the queue is empty, it means that the algorithm covers all vertices and edges. With all that in mind, let’s put everything in a code.
breadthFirstSearch(current_vertice) {
var vertices = Object.keys(this.adjacencyList);
if(vertices.length === 0){
return;
}else {
var discovered = {};
vertices.forEach(function(item) {
discovered[item] = false;
})
this._breadthFirstSearch(current_vertice, discovered);
}
}
_breadthFirstSearch(vertex, discovered){
var queue = [];
discovered[vertex] = true;
queue.push(vertex);
while(queue.length > 0){
var u = queue.shift();
console.log('Visited Vertex: ' + u);
var listAdjacents = this.adjacencyList[u].sort((a, b) => a - b)
listAdjacents = listAdjacents.sort()
for (let index = 0; index < listAdjacents.length; index++) {
const element = listAdjacents[index];
if(!discovered[element]){
discovered[element] = true;
queue.push(element);
}
}
}
}
- Depth First Search (DFS)
Initially, this function has conditions similar to the BFS function, all vertices are unvisited and edges are not discovered. Then, we can choose an arbitrary vertex that will be our root element, which will be visited and called the current vertex.
Now is when the difference between DFS and BFS functions begins! The current vertex has to explore as far as possible along each vertex visited, moving to the next undiscovered adjacent edge and printing the path.
We must continue this loop until there are no unvisited and undiscovered elements. Instead of queuing, the DFS function uses a stack to find the shortest path. After that, with no undiscovered edges left, we have to go back to the initial visited vertex and start again checking other unvisited vertices until cover all vertices and edges of the graph.
Using vertex 0 as the current vertex, we will obtain the following result:
Visited Vertex 0
Visited Vertex 1
Visited Vertex 3
Visited Vertex 4
Visited Vertex 2
Visited Vertex 5
Visited Vertex 6
depthFirstSearch(current_vertice) {
var vertices = Object.keys(this.adjacencyList);
if(vertices.length === 0){
return;
}
var discovered = {};
vertices.forEach(function(item) {
discovered[item] = false;
})
this._depthFirstSearch(current_vertice, discovered);
}
_depthFirstSearch(current_vertice, discovered){
discovered[current_vertice] = true;
console.log('Visited Vertex ', current_vertice);
var listAdjacents = this.dictAdj[current_vertice].sort((a, b) => a - b)
for (let index = 0; index < listAdjacents.length; index++) {
const element = listAdjacents[index];
if(!discovered[element]){
this._depthFirstSearch(element, discovered);
}
}
}
That’s all folks!
I hope you have fun learning. 😁
Code: https://github.com/FernandoBLima/data-structures ___
So we finished our discussion about Graph structure. 🙌
If you found something I miss out or find this article helpful, feel free to let me know. 😁


Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 12]
| ▼NInfiniteJumper | |
| CDarkness | Handles the translation of the gameobject that chases the player from the bottom of the screen. |
| CDataPersistence | Data persistence. Handles saving and loading of high score. |
| CFadeIn | Simple fade in script for CanvasRenderer. |
| CFollowTarget | Attach to camera to smoothly track player. |
| CGameOver | Handles game over state. On game over: enables game over ui and saves high score. |
| CHead | Handles death of player when InfiniteJumper.Darkness enters trigger. Invokes InfiniteJumper.LevelChunks.OnDeath. |
| CHighScore | Updates highscore UI on main menu. |
| CLevelBuilder | Handles constructing (instantiating) the level chuncks. |
| CLevelChuckPreBuild | A level chuck that is static and built at start. Used to construct the empty level chuck underneath player at game start. |
| CLevelChunk | Level chunk. |
| CLevelChunkManager | Builds new InfiniteJumper.LevelChunks when required. Stores current position and builds new chunks at current y position. |
| CLevelLoader | Responsible from loading the level data from file. |
| CMainMenu | Plays background audio clip if present. Loads game scene if any key is pressed. |
| CPlatform | Attach to the platform tile prefab. Handles destruction when InfiniteJumper.Darkness enters trigger. |
| CPlayer | The main player movement script, also updates current score based on the players y position. |
| CScore | Score UI component for main game scene. |
| CScoreData | Class to store serializable score data. |
| CShadow | Attach to the shadow tile. Destroys this gameobject if its associated platform tile is destroyed. |
| CTilePrefab | Used to map a GameObject to its character representation in file. All prefabs should be of the same size. |
| CUIFlash | User interface flash. Acts as an overlay for the main menu and gameplay scene. |
| CFixedRatio | |


This image illustrates different types and their italic or slanted version.
It shows 8 lines of text: sans-serif, sans-serif-oblique, sans-serif-bold, sans-serif-bold-oblique, serif-bold, serif-bold-italic, serif, serif-italic. We see that italic glyphs are not just slanted with respect to the roman counterparts, but differ in shape as well.


DB Migrations
Ebean has built in support for generating DB migrations and running them
Generating DB Migrations
Note that we can use ebeaninit to add GenerateDbMigration (the code below) to your project.
In src/test/java
add the code below to generate migrations.
In src/test/kotlin
add the code below to generate migrations.
To generate a DB migration we run this main method. The migration DDL for the given platform will be generated based on the changes to the model (e.g. alter table add column etc).
package main;
import io.ebean.annotation.Platform;
import io.ebean.dbmigration.DbMigration;
import java.io.IOException;
public class GenerateDbMigration {
/**
* Generate the DDL for the next DB migration.
*/
public static void main(String[] args) throws IOException {
DbMigration dbMigration = DbMigration.create();
dbMigration.setPlatform(Platform.POSTGRES);
dbMigration.generateMigration();
}
}
package main
import io.ebean.annotation.Platform
import io.ebean.dbmigration.DbMigration
/**
* Generate the DDL for the next DB migration.
*/
fun main(args : Array<!String>) {
// requires jvmTarget 1.8
val dbMigration = DbMigration.create()
dbMigration.setPlatform(Platform.POSTGRES)
dbMigration.generateMigration()
}
We run this manually when we have completed some work and consider it ready to be released.
Running the generation starts Ebean in offline mode, performs a DIFF of the model and generates the migration DDL script.
Running Migration
To run the migration using the built in migration runner, set ebean.migration.run
to true.
In application.yaml
## run migrations when the Ebean starts
ebean:
migration:
run: true
With ebean.migration.run=true
then when the Ebean starts it will look at the
migrations and run any that need to be run. The migration runner will by default create a table
called db_migration
that holds the meta data about the migrations that have been run
and inserts into this table when migrations are successfully executed.


Visualizing Distributed Systems
As I’ve dug into my distributed systems research, one question keeps coming up: “How do you visualize distributed systems?” Distributed systems are hard, so it feels like being able to visualize the data flow would go a long way to understanding them in detail and avoiding bugs. Unfortunately, the same things that make architecting distributed systems difficult also make them hard to visualize.
I don’t have an answer to this question, unfortunately. However, in this post I’d like to state my requirements and highlight some visualizations that I think are important. Hopefully this will be the start of a more complete investigation or at least allow others to comment on what they’re doing and whether or not visualization is important.
Static Visualization
A distributed system can loosely be described as multiple instances of a software program running on different machines that react to events. These events can be either external (a user making a request) or internal (handling requests from other instances). The collective individual behavior of each node informs how the entire system behaves.
One high level view of the design of a system looks at the propagation of events, or messages being sent between nodes in the distributed system. This can be visualized using a message sequence chart which embeds the time flow of a system and displays the interaction between nodes as they generate messages in reaction to received messages.
Message flow diagram for EPaxos
In the message sequence chart, every lane represents a single replica and arrows between them represent message passing and receipt order. Often, crossed arrows represent the difficulty in determining the happens before relationship with respect to message order. These charts are good at defining a single situation and the reaction of the system, but do not do a good job at describing the general interaction. How do we describe a system in terms of the decisions it must make in reaction to received events that might be unordered?
One method of designing a distributed system is to consider the design of only a single instance. Each instance reacts to events (messages) then can update their state or do some work, and generate messages of their own. The receipt and sending of messages defines the collective behavior. This is a simplification of the actor model of distributed computing. This seems like it might make things a bit easier, because now we only have to visualize the behavior of a single instance, and describe message handling as a flow chart of decision making.
Raft message reaction flow chart
The flow chart above represents one of the attempts I’ve made to describe how the Raft consensus protocol works from the perspective of a single replica server. Raft is generally understood to be one of the most understandable consensus protocols, and as such it should be easy to describe visually. Here, messages are represented as colored circles. Raft has two primary RPC messages: request vote and append entries, therefore the circles represent the send and receive events of both RPC messages and their responses (8 total message types).
Each RPC roughly has their own zone in the flow chart. State changes are represented by the purple boxes, decisions by diamonds, and actions by square boxes. As you can see the flow chart is not completely connected, but hopefully by following from a “send” node to a “recv” node, one can track how the system interacts over time as well as individual nodes.
This visualization still needs a lot of help, however. It is complex, and doesn’t necessarily embed all the information of how the complete system handles failure or messages.
Interactive Visualization
The most interesting combination of message traffic and behavior that I’ve seen so far requires JavaScript to create a dynamic, interactive visualization. Here, the user can play with different scenarios to see how the distributed system will react to different events or scenarios. It visualizes both the decision making process of the replica servers, as well as the ordering of messages as they’re sent and received.
RaftScope visualization of the Raft protocol.
One of the first places I encountered this was the RaftScope visualization. Here colored balls with an arrow represent the messages themselves (responses are not filled). The state of each node is shown by the edge color (a timer for followers, dotted for candidates, and solid for leaders). The log of each replica server is also displayed to show how the log repairs itself and commits values.
Moreover, users can also click on nodes and disable them, make “client requests”, pause, or otherwise modify their behavior. This allows custom scenarios to be constructed and interpreted similar to the message sequence diagram, but with more flexibility. The problem is that the entire protocol must be implemented in JavaScript in order to ensure correct visualization (and is therefore a non-trivial, non-development approach to explaining how a system works).
The Secret Lives of Data interactive Raft tutorial
This idea was taken one step further by The Secret Lives of Data, which uses a tutorial style presentation to show in detail each phase of the Raft algorithm. This allows the visualization to show specific scenarios rather than force the user to design them. I hope to see more tutorials for different algorithms soon!
These two examples inspired me to create my own interactive visualization for the work I’m doing on consistency fragmentation. I use a similar design of circles for messages interacting with nodes in a circular topology. Right now it is still unfinished, but I’ve at least put together an MVP of what it might look like.
CloudScope interactive consistency fragmentation visualization
My goal is to feed the visualization actual traces from the backend simulation I’m writing using SimPy or from the logs of live systems. The visualization will be less interactive (in the sense you can’t create specific scenarios) but will hopefully give insight into what is going on in the real system and allow me easier development and architecture.
Conclusion
So I pose to you the following questions:
- Is visualization important to the architecture of distributed systems?
- How can we implement better static and interactive visualizations?
Visualization is not part of my research, but I hope an important part of describing what is happening in the system. Any feedback would be appreciated!


Contact name
City
Country
Is Promoted
Maria Anders
Berlin
Germany
Ana Trujillo
Mexico D.F.
Mexico
Antonio Moreno
Mexico D.F.
Mexico
Thomas Hardy
London
UK


 Get Me Out Of Here! is back for 2019 with an all new line-up of stars looking to face their fears in the jungle over the next few weeks.
Of course, most of us can assume that they haven't volunteered to survive on a diet of rice and beans and eat kangaroo balls for free.
And enrolling celebrities to participate in Bushtucker trials doesn't come cheap.
The highest paid contestant this year is raking in a whopping £500,000, and a TV insider has revealed to The Mirror that ITV bosses have splashed out as much a 1.4 million on fees this year.
Here's a look at what it is thought that the jungle entrants are being paid, and some are earning up to ten times less than their co-stars.
70-year-old Caitlyn Jenner is unsurprisingly the highest paid 2019 camp mate, with a reported £500,000 fee.
If it's true then it would make her one of the highest earners in the show ever, with Noel Edmonds rumoured to have been paid between £500,000 and £600,000 for his appearance last year.
Ant and Dec referred to the rumours in the opening show.
Introducing the show, Dec said: "We've got reality TV royalty Caitlyn Jenner. Most people come into the jungle to lose a few pounds," with Ant adding: "But she's going to be gaining 500,000 of them according to the papers."
Dec then responded, telling Ant, "Don't believe everything you read in the papers, Ant. You know that," suggesting that Caitlyn might not be earning quite so much.
Ex-Arsenal player and football legend Ian Wright is the next best paid star, who has been flown Down Under for a reported fee of £400,000 followed by ex-Girls Aloud singer Nadine Coyle, who will apparently be paid £250,000.
Andy Whyment, who is known for playing factory worker Kirk on Coronation Street, is reportedly the only other campmate to be taking a six-figure pay cheque home too after negotiating a fee of £100,000.
Ex-Eastenders actor Jacqueline Jossa is said to be receiving £75,000 for her jungle stint, alongside Good Morning Britain host Kate Garraway, reports Leeds Live .
Meanwhile, rugby player James Haskell and Radio One DJ Adele Roberts trail slightly behind with their rumoured £50,000 fees.
According to reports, the two celebs with the lowest pay cheques are two of the youngest in the group.
Spandau Ballet bassist Martin Kemp son, Roman Kemp - Capital FM DJ - is thought to be earning £40,000 for his jungle adventure.

He is expected to take home £25,000 for his jungle debut.
It's not known what Irish comedian Andrew Maxwell will be paid.
And apparently, even if they decide that the jungle life isn't for them, they still get paid their full paycheck - well, if history is anything to go by.
When The Only Way Is Essex's Gemma Collins dropped out of the jungle in 2014's series after just three days, she reportedly got paid her full fee anyway.
I'm A Celebrity representatives have declined to comment.


Ecclesiastes 8:4
Where the word of a king is, there is power: and who may say unto him, What doest thou?


Tablet of Vision:
The tablet begins to buzz as the Stone of Commune draws near.
Touch the Stone of Commune to the Tablet of Vision.


Explore
There are so many great beers around the world. Sometimes it can be hard to keep track of all the different kinds! Progressive Beer is a handy web app that is designed to help you learn everything there is to know about beers! Explore the many beer styles in list below for more information.
Beer from around the world!


Toggle navigation
Bob Dylan Lyrics
Downloads
All Songs
All Albums
1960s
Bob Dylan (1962)
The Freewheelin' Bob Dylan (1963)
The Times They Are A-Changin' (1964)
Another Side of Bob Dylan (1964)
Bringing It All Back Home (1965)
Highway 61 Revisited (1965)
Blonde on Blonde (1966))
Bob Dylan's Greatest Hits (1967)
John Wesley Harding (1967)
Nashville Skyline (1969)
1970s
Self Portrait (1970)
New Morning (1970)
Bob Dylan's Greatest Hits, Vol. II (1971)
Pat Garrett & Billy the Kid (1973)
Dylan (1973)
Planet Waves (1974)
Before the Flood (1974)
Blood on the Tracks (1975)
The Basement Tapes (1975)
Desire (1976)
Hard Rain (1976)
Street-Legal (1978)
Bob Dylan at Budokan (1979)
Slow Train Coming (1979)
1980s
Saved (1980)
Shot of Love (1981)
Infidels (1983)
Real Live (1984)
Empire Burlesque (1985)
Biograph (1985)
Knocked Out Loaded (1986)
Down in the Groove (1988)
Dylan & the Dead (1989)
Oh Mercy (1989)
1990s
Under the Red Sky (1990)
The Bootleg Series Volumes 1-3 (Rare & Unreleased) 1961-1991 (1991)
Good As I Been to You (1992)
World Gone Wrong (1993)
Bob Dylan's Greatest Hits Volume 3 (1994)
MTV Unplugged (1995)
Time Out of Mind (1997)
The Bootleg Series Vol. 4: Bob Dylan Live 1966, The "Royal Albert Hall" Concert (1998)
2000s
The Essential Bob Dylan (2000)
Love and Theft (2001)
The Bootleg Series Vol. 5: Bob Dylan Live 1975, The Rolling Thunder Revue (2002)
The Bootleg Series Vol. 6: Bob Dylan Live 1964, Concert at Philharmonic Hall (2004)
The Best of Bob Dylan (2005)
Modern Times (2006)
Together through Life (2009)
2010s
Tempest (2012)
Biograph
Released: November 7, 1985
Length: 214:50
Producer:
Jeff Rosen
Label: Columbia
By Bob Dylan
Side 1
Lay Lady Lay
(appeared on
Nashville Skyline
)
Baby, Let Me Follow You Down
(appeared on
Bob Dylan
) (Traditional, arranged by
Gary Davis
,
Eric von Schmidt
, and
Dave Van Ronk
)
If Not for You
(appeared on
New Morning
)
I'll Be Your Baby Tonight
(appeared on
John Wesley Harding
)
I'll Keep It with Mine
Side 2
The Times They Are A-Changin'
(appeared on
The Times They Area A-Changin'
)
Blowin' in the Wind
(appeared on
The Freewheelin' Bob Dylan
)
Masters of War
(appeared on
The Freewheelin' Bob Dylan
)
The Lonesome Death of Hattie Carroll
(appeared on
The Times They Are A-Changin'
)
Percy's Song
Side 3
Mixed-Up Confusion
Tombstone Blues
(appeared on
Highway 61 Revisited
)
Groom's Still Waiting at the Altar
(appeared on
Shot of Love
)
Most Likely You Go Your Way (And I'll Go Mine)
(appeared on
Before the Flood
) (recorded live on February 14, 1974 (late show) in Los Angeles)
Like a Rolling Stone
(appeared on
Highway 61 Revisited
)
Jet Pilot
Side 4
Lay Down Your Weary Tune
Subterranean Homesick Blues
(appeared on
Bringing It All Back Home
)
I Don't Believe You (She Acts Like We Never Have Met)
Visions of Johanna
Every Grain of Sand
(appeared on
Shot of Love
)
Side 5
Quinn the Eskimo (The Mighty Quinn)
Mr. Tambourine Man
(appeared on
Bringing It All Back Home
)
Dear Landlord
(appeared on
John Wesley Harding
)
It Ain't Me, Babe
(appeared on
Another Side of Bob Dylan
)
You Angel You
(appeared on
Planet Waves
)
Million Dollar Bash
(appeared on
The Basement Tapes
)
Side 6
To Ramona
(appeared on
Another Side of Bob Dylan
)
You're a Big Girl Now
Abandoned Love
Tangled Up in Blue
(appeared on
Blood on the Tracks
)
It's All Over Now, Baby Blue
(recorded live on May 17, 1966 in a
Manchester, England
concert, mistakenly known as the
Royal Albert Hall concert
)
Side 7
Can You Please Crawl Out Your Window?
Positively 4th Street
Isis
(original authors: Bob Dylan and
Jacques Levy
) (recorded live on December 4, 1975 at the
Montreal Forum
in
Montreal, Canada
as part of the
Rolling Thunder Revue
)
Caribbean Wind
Up to Me
Side 8
Baby, I'm in the Mood for You
I Wanna Be Your Lover
I Want You
(appeared on
Blonde on Blonde
)
Heart of Mine
(recorded live on November 10, 1981 in
New Orleans, Louisiana
)
On a Night Like This
(appeared on
Planet Waves
)
Just Like a Woman
(appeared on
Blonde on Blonde
)
Side 9
Romance in Durango
(original authors: Bob Dylan and
Jacques Levy
) (recorded live on December 4, 1975 at the
Montreal Forum
in
Montreal, Canada
as part of the
Rolling Thunder Revue
)
Señor (Tales of Yankee Power)
(appeared on
Street-Legal
)
Gotta Serve Somebody
(appeared on
Slow Train Coming
)
I Believe in You
(appeared on
Slow Train Coming
)
Time Passes Slowly
(appeared on
New Morning
)
Side 10
I Shall Be Released
(appeared on
Bob Dylan's Greatest Hits, Vol. II
)
Knockin' on Heaven's Door
(appeared on
Pat Garrett & Billy the Kid
)
All Along the Watchtower
(appeared on
Before the Flood
) (recorded live on February 14, 1974 (early show) in Los Angeles)
Solid Rock
(appeared on
Saved
)
Forever Young


School bus rollover injures 1 student in western Wisconsin
ARCADIA, Wis. - School officials say one student suffered minor injuries when a school bus rolled over in western Wisconsin.
The crash happened around 7:15 a.m. Tuesday south of Arcadia.
Arcadia Superintendent Lance Bagstad tells the La Crosse Tribune the bus was carrying about 20 children. One student was taken from the scene by ambulance with minor injuries. The rest of the students were taken to Arcadia Middle School.
Trempealeau County Sheriff Brett Semingson says the driver apparently lost control of the bus after going over mud.
No other vehicles were involved.


Please read the previous part Emotional Intelligence and Meditaion Process
Bringing back a wandering attention back to focus is what this third chapter’s essence. The author suggests three key actions for Mindful conversation listening, looping and dipping. These were something new particularly about paying attention to our own feelings while listening to someone that too in a nonjudgmental way. Though I understand these conceptually, as the author says only practice is key. Tried this only couple of times but more practice needed.
As I said I did it only a couple times so it is too early to say anything on how the other person felt.
Posted: 17 Jan 2016


I am from Hyderabad and have been in US since 2004. I am Mizzou Tiger (Masters from Missouri).
I have been with Intuit for 7 years now. My journey here has been really wonderful and rewarding.
Interesting Facts
Enjoys reading everything from fiction to philosophy


At the same time that we are earnest to explore & learn all things
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.


{% extends "base.html" %} {% block content %}
We’d like to help you to read better and faster. Most folks haven’t really worked on their reading skill since learning to read as children.
By learning a couple of simple techniques to practise, you can read faster and understand more.
We want to help you level up your reading ability, whatever your starting point.
There are two things you can do to read faster and understand more:
Offline you do this by running your finger or a pen/stylus (a “regulator”) along the line that you are reading. It helps to keep you focused and prevents you going back over words you have already read. It’s important to not try to push your speed; this is mostly about reading at a comfortable speed and focusing on good habits.
We have a prepared a bunch of articles you can read in this way here, with short comprehension tests afterwards so you check you’re not losing any understanding. An indicator on the screen moves at your preferred speed, and we fade out the lines above and below so your eyes aren’t distracted by what has been or what is coming.
If you run, one of the ways that you increase your speed over long distances is to do sprint training — deliberately going fast over a shorter distance to build up your muscles and your speed.
You should do the same with reading, deliberately making your eyes move about twice as fast as they are used to doing. You will of course not understand the material as well, but the point of the exercise is more to train your eye muscles, to get used to moving and refocusing faster, without worrying about understanding.
 We will give you an article to read and you can either time yourself offline or use the Start & Stop buttons to have the system calculate this for you.


This document defines a means of representing Desal semantics, and a means for extracting the semantics by a computer agent.
if a > b doSomething1() doSomething2() else doSomethingElse1() doSomethingElse2() if a > b : doSomething1(), doSomething2() else : doSomethingElse1(), doSomethingElse2() if a > b { doSomething() doSomethingElse2() } else { doSomethingElse1() doSomethingElse2() }
In the first way, whitespace is significant. In the second and third way, newlines end the block, but otherwise whitespace is not significant.
How to break up Dextr source code into tokens.
Word ::= WordChar + Identifier ::= Word Keyword ::= "$" Word $if else > return { $throw throw } Rationale: Users should be quickly and easily able to tell whether a word is an identifier or a keyword, without having to memorize the list of keywords. Because identifiers are usually more common than keywords, keywords are given the burden of having an extra character instead of identifiers. Move to IDE guidelines: Syntax highlighters are encouraged to hide the $ character in keywords (in display only, not to remove it from source) and differentiate between keywords and identifiers though some other means (e.g. color). Such syntax highlighters must provide a means of switching a word between keyword and identifier. One possibility would be to display the $ in a particular keyword whenever the cursor has been next to or within the keyword for more than half a second. Such syntax highlighters should automatically and immediately recognize when a word has lost or gained a $ and update the way it is displayed immediately e.g. if the $ is removed from a keyword, the syntax highlighter should recognize the change immediately and not continue displaying the word like it is a keyword. Another possibility would be to never show the $ after a keyword has been typed, and ignore $ added in front of identifiers, but have a button, menu item, and/or keyboard shortcut that when activated, flips the meaning of the keyword that the cursor is currently in or next to.
It's always possible to bind the interface of an object to an identifier.
func getInterface{I}(I o) {
return I;
}
dynref o = getMysteryObj()
interface i = getInterface(o)
i o2 = o
"object++" doesn't create a temporary. The object has its increment method called after the object is accessed. The below two groups of code represent the same semantics.
int a = 3
int b = a++
int a = 3
int b = a
++a
required_s ::= ( " " | comment ) + s ::= required_s ? required_ls ::= ( required_s | "\n" | "\t" ) + ls ::= required_ls ? function-interface ::= funcfaceshort | funcfacelong funcfacebase ::= "func" s "(" s funcfaceparameters ? s ")" funcfaceshort ::= funcfacebase s identifier funcfacelong ::= funcfacebase s "(" ls expression ls ")" funcfaceparameters ::= ...
cast ::= expression s "as" s expression example: (foo as Bar)
foo *** operator precendence examples *** interface alpha func beta(int) alpha foo foo.beta(3) //is the same as foo => alpha::beta (3) (alpha o).beta(3) //is the same as cast{alpha}(o).beta(3) //is the same as o => cast{alpha} .beta(3) *** statement block *** indented statements statement 1 statement 2 statement 3 colon then statements: statement 1, statement 2, statement 3 enclosed in braces { statement 0 statement 1 statement 2 statement 3, statement 4 } *** 2007-06-10: adjuncts removed *** func int.times(func() f) for(int i = 0; i < this; i++) f() 3.times func() println "test" func times(int num, func() f) for( int i = 0; i < num; i++ ) f() 3 => times func() println "test" 3..times || println "test" do 3 times: println "test" //same as times( 3, func() println "test" ) //same as times(3, ||println "test") *** functions *** a "function" is an object that implements the "callee" interface (xxx would "callable" be a better name?) function literals create objects with an interface that inherits from callee function declaration - defines a function and binds it to an identifier syntax "func" identifier "(" * [ interface identifier ] (seperated by ,) ")" ? interface statement-block func foo(float a) int return a * 2 syntax for interface of specific types of functions func(float)int f = foo function expressions aka inline functions func{I}(I)int h = |x| x * 3 func(int)int h = |x| x * 3 //can auto convert func(int)int j = { |int x| string str = cast string x int hash = hash(string) return str.toLowerCase() } *** additional semantics *** Desal Text Representation (Dextr, or Desal Dextr) has additional semantics on top of Desal semantics. These semantics are used to obtain Desal semantics from Dextr source code. Most of these semantics involve tokens/objects "grabbing" other tokens/objects. *** example of additional semantics in Dextr *** func doStuff() int return 3 func foo1() function square(ratnum num) ratnum return num * num doStuff() func foo2() function(ratnum num) ratnum return num * num doStuff() In foo1, the function is bound to the identifier "square" and not called. In foo2, the function is not bound to an indentifer. The value returned from doStuff() is fed into it as an argument. So Dextr differentiates between "function expressions" and "function declarations", although in Desal Semantics there is not such differentiation. *** operators *** Operators are able to "grab" what comes before and/or after it. Which operator grabs what is determined by operator precedence. Operators can be thought of as macros. [] grabs what is before it and passes it to the array function string[] is equal to array(string) [int] grabs what is before it and passes it and the int to the array function float[5] is equal to array(float, 5) + grabs what is before and after it, and sends what's after it to the add method of what's before it 3 + 5 is equal to 3.add(5) = grabs what is before and after it, and sends what's after it the assign method of what's before it a = 8 is equal to a.assign(8) + has greater precedence than = a = 3 + 5 is equal to a.assign( 3.add(5) ) The actual functions follow the regular left-to-right behavior. a .assign 3 .add 5 //is equal to a.assign(3).add(5) "not" grabs the boolean that's after it and inverses it not true //is the same as true.inverse() "or" grabs the booleans before and after it foo or bar //is the same as foo.or(bar) if f is a function: f 1 + 2 + f 3 is equal to f(1).add(2).add( f(3) ) function calls have precedence over + *** parameters/arguments *** Parameters are a part of a function, and have names. Arguments are the values passed to functions. //alpha and beta are the parameters function foo(int alpha, float beta) string ... //3 and 7.8 are the arguments foo(3, 7.8) *** function signatures *** a function signature consists of the parameters and the return type *** function calling *** If something follows a function, it will be passed to the function an argument. Like operators, functions are able to "grab" what follows them. If a function grabs a collection (described below), the items in the collection will be passed as arguments. func foo(int arg = 3) ... foo //function not called foo() //function called foo () foo 3 //function called foo(3) //function called foo (3) foo.params //function not called foo .params *** collections *** Things grouped in parenthesis forms a collection. How this collection is touched determines how it is treated. If a collection is grabbed by a function, the elements are passed as arguments to the function. else if the collection has one element the element is evaluated the (...) evaluates to that else error --- functions --- a = (3) The = is an operator. The line is equivalent to: a.assign (3) Assign is a function, so it grabs what follows, "(3)" 3 is passed as an argument to the assignment function. string[] names names = ("Bob", "Sam", "Sally") names.assign ("Bob, "Sam", "Sally") assign here is a var-arg function The strings are passed as arguments to names.assign dynref foo = int[] (3, 5, 7) dynref foo = array(int)(3, 5, 7) dynref foo = int[] 9 dynref foo = arry(int)(9) --- else --- a = (3) + (5) + (8) Operator precendence causes the + to grab arguments before = can get anything. a.assign( (3) .add (5) .add (8) ) Because there's not a function before (3) trying to grab it, and (3) only has one element, (3) evaluates to 3. a.assign( 3 .add (5) .add (8) ) int a = ((3.add(5)) + (8)) Because there's nothing before (3.add(5)) trying to grab something, it evaluates to 3.add(5) int a = (3.add(5).add(8)) int a \n a.assign(3.add(5).add(8)) --- labels and enum shortcuts --- enum bar VALUE_1, VALUE_2, VALUE_3 func foo( int a = 1, int b = 2, int c = 3, bar eBar) ... foo( c: 8 ) foo( 7, 8, 9, = VALUE_1 ) foo( eBar: = VALUE_1 ) foo( a: 1, b: 2, c: 3, eBar: bar.VALUE_1 ) foo( a: 1, b: 2, c: 3, eBar: = VALUE_1 ) foo( 1, 2, 3, bar.VALUE_1 ) **** ----- **** All identifiers are in the same namespace. There are no reserved words. If a user defined idetifier conflicts with a system identifier, the system identifier must be prefixed with "$". The "$" is optional for other user defined identifiers. UTF-8 is default encoding, if none is specified. A BOM on a UTF-8 document shouldn't causes problems. ".desalt" file extension Input consists of a series of Unicode characters. Tokenization processes input character by character to produce a series of tokens. Parsing processes the tokens to extract semantics. *** character types *** illegal control characters Unicode reserved code points Unicode tags surrogates illegal characters cannot appear anywhere in source code not even in comments reserved space tab newline quote " ' ` opening bracket parenthesis ( box bracket [ brace { closing bracket parenthesis ) box bracket ] brace } special + - / * @ $ = \ , . numeral 0 1 2 3 4 5 6 7 8 9 free all Unicode characters not otherwise categorized includes: ! ? _ XXX uncategorized % ~ # ^ | ; & : *** token types *** indentation, line separation, string, opening bracket, closing bracket, special, number, word examples: number 5 700.0 3.03f 6i 0xFF word - a free character optionally followed by free characters and numerals x if else myItem2 myItem3 MyClass IDoStuff foo2bar3baz string "" "foo" "foo bar" '''test 333 test''' "foo \" bar" *** tokenization *** Tokenization begins in ready mode with the first character. --- modes that do not produce tokens --- ready Based on the type of the current character, ready mode switches to the appropriate mode. character type mode to go to ------------------------------------ illegal illegal space space tab indentation newline line seperation quote string opening bracket opening bracket closing bracket closing bracket special special numeral number free word illegal end tokenization unseccessfully line comment if there's a newline character following move to the next newline character and switch to line seperation mode else end tokenization successfully multiline comment if there's an instance of */ following if there's a character after it move to that character switch to ready mode else end tokenization successfully else end tokenization unsuccessfully space go to the next character switch to ready mode --- modes that do produce tokens --- indentation create an indentation token add the current character to it loop go to the next character if it's a tab add it to the token else close the token switch to ready mode line separation create a line separation token go to the next character that isn't a newline switch to ready mode string String processing rules determine when this mode is done. When it's done if an illegal token was encountered switch to illegal mode if some other error occured end tokenization unsuccessfully else string processing rules produced a string token switch to ready mode opening bracket create an opening bracket token for the current character go to the next character switch to ready mode closing bracket create a closing bracket token for the current character go to the next character switch to ready mode special create a special token add the current character to it loop go to the next character if it's a special character add it to the token if token == '//' discard token go to line comment mode if token == '/*' discard token go to multiline comment mode else close the token switch to ready mode number create a number token add the current character to it loop go to the next character if it's a numeral add it to the token if it's an "x" if the token currently consists of "0" add it to the token else end tokenization unsuccessfully if it's a "." if the token does not contain an "x" add it to the token else end tokenization unsuccessfully else close the token switch to ready mode word create a word token add the current character to it loop go to the next character if it's a free character or a numeral add it to the free token else close the token switch to ready mode *** tokens *** In normal text, a token is a series of characters of the same type. Strings and comments are considered to be string and comment tokens. Each of the reserved types are considered seperately here. example 1: func doStuff(ref int arg) int return arg * 2 } tokens: func SPACE doStuff ( ref SPACE int SPACE arg ) SPACE int LINEBREAK SPACE return SPACE arg SPACE * SPACE 2 LINEBREAK } example 2: 423oeuth03928nothunho394898+&*(^%$#&+++oetuhntoh tokens: 423 oeuh0328notho3998 transition from numerals to free characters begins a new token transition from free characters to numerals continues the same token +&*(^%$#&+++ transition from free characters to symbols oetuhntoh transition from symbols to free characters *** identifiers *** An identifier is a token with an assigned meaning. Identifiers must consist of either: all symbols all free characters free characters and numerals Identifiers can never: begin with numerals begin with reserved characters begin with /* end with */ *** default identifiers *** Identifiers that are already defined by default. Some of these can be redefined or overloaded while others can't. includes: if else { } [ ] break class func # + - * / *** reserved identifiers *** An identifier that cannot be (re)defined. includes: if else { } [ ] break class func # *** string tokens *** When the first character of a quote token is found, string processing rules take over. They determine: what characters are part of the string token where normal processing should continue from examples: a + "test" + b a - free - a free token begins - space - the free token ends (the space itself is ignored since it served only to separate) + - symbol - a symbol token begins - space - the symbol token ends " - quote - string processing rules take over and produce a string token - space - the string processing rules said to start here, and it was just a space, which should be discarded + - symbol - a symbol token begins - space - the symbol token ends b - free - a free token begins end of file - the free token ends output tokens: free a symbol + string test symbol + free b "this is a string" 'this is a string' """this is a string""" '''this is a string''' sized-string 16 this is a string *** Enclosers *** Some characters surround other characters to note that the inner characters are grouped together in some way. (...) [...] <...> Enclosers allow things to span multiple lines. *** Blocks *** A block is code that is grouped together. Some identifiers can open blocks. These are known as "block-opening identifiers". These include: "if", "else", "while", colon, opening curly brace Some identifiers can close blocks. These are known as "block-closing identifiers". These include: closing curly brace Some identifiers can close a block and open a new one. These are known as "block-reseting identifiers". These include: "else", "while" The full-stop opens a block and immediately closes it. (Meaning it signifies an empty block.) int a if test doStuff() a = 3 "if" absorbs the following test and then opens a new block. " doStuff" set the indentation for this block to 2 spaces. "a = 3" was not indented, so it closed the block. To ensure the block doesn't include more than it should, include a closing brace. int a if test doStuff() } a = 3 To avoid the indentation requirements, start the block with an opening curly brace {. Note that blocks beginning this way must also end with a closing curly brace }. int a if test { doStuff() } a = 3 -or- int a if test { doStuff() } a = 3 To place the block's code on the same line, begin the block with a colon. int a if test: doStuff() a = 3 -or- int a if test : doStuff() a = 3 The below code doesn't work. int a if test :doStuff() a = 3 -or- int a if test: doStuff() a = 3 *** Phrases *** Phrases are similar to what is often called "statements". Phrases consists of identifiers and/or reserved symbols and/or blocks that are grouped together. Phrases can be ended by linebreaks or commas. Example: In C++, semicolons end statements. doStuff1(); doStuff2(); doStuff3(); In Desal, linebreaks or commas end statements. doStuff1() doStuff2() doStuff3() doStuff1(), doStuff2(), doStuff3() *** Desal Syntax Description Language (DSDL) *** Used to describe the syntax of features of Desal. "text" specific text that must appear newscopeid an identifier that is not defined anywhere else in that scope join the thing before and after this cannot have any whitespace between them paren() the arguments have parenthesis surrounding them opt() the arugments are optional optmult() the arguments may appear 0 or more times type a type that is already defined in that scope userid an identifier that is defined by the user codeblock a block of code block() a block with contents described in the arguments obj identifier for an object that is in scope may be: doStuff(args) if doStuff returns something objid identifier for an objcet that is already defined and in scope (no object literals) either() any 1 of the multiple arguments may appear *** XXX Unsorted Stuff *** if the keyword phrase is ended by a linebreak, the block ends with a curly brace that resides on its own line or another keyword //keyword phrase: "if waitingCount > 0" //keyword: "if" //body: "waitingCount > 0" //ends with a linebreak if waitingCount > 0 doStuff() } "if" test block //the keywords that can end a block depend on what keyword opened the block switch obj case 1 //keyword phrase opened block that can be closed by "case", "fallcase", or "default" doStuff1() case 2 //"case" keyword ended previous block doStuff2() default //"default" keyword ended previous block doStuff0() } } if obj eql current //keyword phrase opened block that can be closed by "elif" or "else" doCurrent() elif obj eql past //"elif" keyword ended previous block doPast() else //"else" keyword ended previous block doFuture() } if the keyword phrase is ended by a colon, the block ends with a line break or a comma if test: doStuff() if test: doStuff(), else: doOtherStuff() //"if" block ended with comma, "else" block ends with linebreak if the keyword phrase is ended by a full-stop, the block must be empty while notReady? //test value of notReady until it evaluates to true if doNothing? else: doStuff() if the keyword phrase is ended by an opening curly brace, the block ends with a closing curly brace if that eql "cool" { buy(that) } if that eql "cool" { buy(that) } //note that "else" can't close this block due to the opening curly brace else { burn(that) } when a block is empty, a warning is raised if test: //empty block ended with linebreak if test //empty block ended with "else" else } //empty block ended with } *** colon *** if a colon is followed by whitespace, it begins a block example: if num1 < num2: doStuff() else, it seperates a namespace identifier from an identifier in that namespace example: std:doStuff() This means the colon character has special meaning beyond that of other reserved characters. *** namespaced operators *** The "boost" library defines a binary "|<" operator. It returns the amount of elements in the array on the left that are less than the number on the right. array int numbers int amount amount = numbers boost:|< 3 amount = numbers boost:op(|<) 3 amount = numbers boost:(|<) 3 amount = numbers boost(|<) 3 with namespace boost: amount = numbers |< 3 with boost:operators: amount = numbers |< 3 with boost:(|<): amount = numbers |< 3 *** tabs and spaces *** The semantics of spaces is to separate characters. The semantics of newlines is to separate actions. The semantics of tabs is to group related actions. Desal partially attempts to require proper use of these characters. *** tabs *** Tabs are only allowed at the beginnig of lines. After any non-tab character, further tabs are not allowed. The first code on a line must be preceded only by 0 or more tabs. *** comments *** Comments are treated as spaces. These lines are equivalent: (end-of-line represented by |) a /* big */ = b /* small */| a = b | *** blocks *** 1. Blocks are opened by some keywords. 2. The block ends when a line with code is encountered that has the same indention as the line that opened the block. 1: if alpha < num //opens a block doStuff() 2: if alpha < num doStuff() else //this line has the same level of indention as the line that opened the above autoblock, so that block is closed ... Lines that are direct children must begin with 1 more tab than the line that opened the block. Within a block, on a line with code: a tab or group of tabs must appear first code must appear second then spaces, comments, and more code may appear example: (tabs represented by 4 underscores) if test ____doStuff1() ____ ____doStuff2() ____doStuff3() is equivalent to: if test { doStuff1() doStuff2() doStuff3() } example 2: /* comment */ doStuff() doStuff()____/* comment */ This is illegal because a tab appeared after code. syntax: ()* means 0 or more tab* (space/comment)* tab* ( code (space/comment)* )*


BD Rainfall Predictor
{% if prediction==1 %}
There is a probability of rain today!!!
{% elif prediction==0 %}
There is not a probability of rain today
{% endif %}


Returns, as a horizontal array of text values, the names of all workbooks referred to by external references in the workbook specified. Use LINKS with OPEN.LINKS to open supporting workbooks.
Syntax
LINKS(document_text, type_num)
Document_text is the name of a workbook, including its path. If document_text is omitted, LINKS operates on the active workbook. If the workbook specified by document_text is not open, LINKS returns the #N/A error value.
Type_num is a number from 1 to 6 specifying the type of linked workbooks to return.
| Type_num | Returns |
| 1 or omitted | Microsoft Excel link |
| 2 | DDE/OLE link (Microsoft Excel for Windows) |
| 3 | Reserved |
| 4 | Not applicable |
| 5 | Publisher (Microsoft Excel for the Macintosh) |
| 6 | Subscriber (Microsoft Excel for the Macintosh) |
Remarks
If the active workbook contains no external references, LINKS returns the #N/A error value.
With the INDEX function, you can select individual workbook names from the array for use in other functions that take workbook names as arguments.
The names of the workbook are always returned in alphabetic order. If supporting workbooks are open, LINKS returns the names of the workbooks; if supporting workbooks are closed, LINKS includes the full path of each workbook.
If type_num is 5 or 6, LINKS returns a two-row array in which the first row contains the edition name and the second row contains the reference.
Examples
If a chart named Chart1 is open and contains links to workbook Data1 and Data2, and the LINKS function shown below is entered as an array into a two-cell horizontal range:
LINKS("Chart1") equals "Data1" in the first cell of the range and "Data2" in the second cell.
In Microsoft Excel for Windows, if the chart named VARIANCE.XLS is open and contains data series that refer to workbook named BUDGET.XLS and ACTUAL.XLS, then:
OPEN.LINKS(LINKS("VARIANCE.XLS")) opens BUDGET.XLS and ACTUAL.XLS.
In Microsoft Excel for the Macintosh, if the workbook named SALES 1991 is open and contains references to the workbook WEST SALES, SOUTH SALES, and EAST SALES, then:
OPEN.LINKS(LINKS("SALES 1991")) opens WEST SALES, SOUTH SALES, and EAST SALES.
Related Functions
CHANGE.LINK Changes supporting workbook links
GET.LINK.INFO Returns information about a link
OPEN.LINKS Opens specified supporting workbook
UPDATE.LINK Updates a link to another workbook
Return to index