Higher margins & sales for gasoline price protection & C-store discounts
Membership Fee: $25 for 6 months    Benefits: 100-gallon price guarantee, discounts on C-store items

Similar to other retail clubs (e.g. big-box retailers) customers pay a membership fee to join your Club. At enrollment, Club members receive a no-risk/no-cost* 100-gallon gasoline price guarantee card valid until the 100 gallons on the card are used up or until the card expires. Members also receive discounts on all or some C-store items.

Price guarantees (or caps) are set by retailers based on targeted fuel margins, market prices & expectations, and other factors at the time the cards are issued, applying the Formulas below. Club members pay the price of gasoline on their card when they use it at a participating location in the state or region where it is designated.

If the station owner is a dealer where the Club member uses his card, the station owner receives the pump price, and the customer pays the card price.  The difference is covered with part of the gains on its offset. Given price caps are established at high margins (e.g. 25 ¢/g) it is highly likely the gains on offsets more than cover the savings realized by Card owners.

While it would be visually appealing, it is not assumed Club members see pump price rollbacks when using their cards. The Club member sees the guarantee price (e.g. $2.94/gal) applied to the gallons in the transaction on his monthly statement.

* No up-front cost.  The member pays the price on the card when the card is used.  Therefore, the card is also no-risk/all-gain.

Formulas
Price Lock = Margin target + Futures + Basis + Rack/Spot diff. + Transp. + Taxes
Price Cap = Price Lock + 10 ¢/g **

** The 10 ¢/g is arbitrary but an important difference between the price cap and price lock.

More information on The Club can be found here and here.  A detailed Example on how the Club works may be made available on request.

Programming 101

A computer program is nothing more than a set of instructions. The program usually receives input data, processes it, and spits back certain results. These instructions are binary words, which can be 32 or 64 bits long*. Each individual processor has different ways of interpreting these instructions and executing them, and exactly how they do this is irrelevant to us. We won’t be going over any hardware-level implementation here.

So, in general, a programmer writes a bunch of instructions/commands using a pre-defined syntax and structure. These patterns are individual to eachprogramming language. If the language being used is a high-level language, then the commands and instructions are usually related to english-language words. A few examples are “do”, “fopen” (“file open”), “print” (or the C-equivalent “printf”), etc.

Classifying a language as “high-level” is the same as saying that the level of abstraction of the language is high. In other words, the commands and instructions the language implements are further (or “higher”) away from machine-language instructions (which are usually limited to adding, subtracting, multiplying, dividing, “jumping”, “storing”, “loading”, etc).

Some examples of high-level programming languages are C, C++, C#, Delphi (and its predecessor, Pascal), and a bunch of others. A low level language is Assembly (asm).

After writing your code in any of these high-level languages, it must be compiled. A compiler program takes your high-level code and generates the equivalent code in Assembly. The assembly code generated is specific to the processor being used (in other words, the same C code would generate different asm codes if compiled in different processors). Then the assembly code is passed through an assembler, who builds the final executable (binary file). The binary generated from it varies according to the operating system (because the functions and instructions are high-level, each of them correspond to different specific and smaller functions and instructions that must interact with the operating system, thus generating different binaries).

To sketch it up:

High-level Code –> [ Compiler ] –> Assembly (low level) code –> [assember] –> Binary instructions (executable file).

Once you have your binary instructions, you can execute them by making a system call to them (in Windows, this is equivalent to the “start” command, or to double clicking the binary file, and in linux, to simply doing “./[binaryname]“).

Interpreted Languages

Some programming languages are of even higher level than the ones I listed above. Those languages aren’t compiled (turned into binary instructions), but instead, have their instructions passed on to an “interpreter”, which will, obviously, “interpret” each command and execute the designated task. The advantage of this approach is the fact that interpreted code can be run under any platform, as long as the correct interpreter is installed on the machine (Perl or Java code will work on any machine that has the correct Java Virtual Machine or Perl interpreter installed). Execution happens WHILE the code is being read by the interpreter.

The disadvantage of this approach is the loss in performance. As a general rule, the more “layers” there are between user and hardware, the lower the performance. Following this line of thinking, it’s easy to conclude that a program written in Assembly will run WAY faster than C code, which will in turn run WAY faster than Java code (the C program will communicate directly with the Operating System, whereas the Java code must first be read by the Virtual Machine, which needs to process it, and only then pass the instructions on to the OS).

Coding in lower level lets you get rid of “useless” instructions (and useless instructions WILL be created by any “automated” interpreter or compiler), but it is also harder, because you work with simpler instructions. Accessing data on a file in C is a piece of cake, while in Assembly it can be hell. On the same line of thought, Java has a bunch of “classes” (won’t be explaining this) that allow you to quickly manipulate different types of files and data, while in C you must do all the handling yourself. Again, this is easier, but slower.

I would also like to mention that the Java Virtual Machine, while being more “complete” in many ways, is also very (very) heavy and slow. The level of abstraction of the Java Language is incredibly high, thus making it incredibly slow. It is also very restrictive (messing with memory isn’t really interesting in this thing).

Overview:

Execution Scheme:

Compiled Languages: Binary File -> Operating System -> Processor
Interpreted Languages: Source Code File -> Interpreter / Virtual Machine -> Operating System -> Processor

Speed/Performance: Assembly >> C/C++/C#/Delphi… > Perl/Python… > Java
Code Specificity: Assembly >> C/C++/C#/Delphi… > Perl/Python… == Java

*: Actually, this is misleading. Depending on the hardware implementation, this can vary. Clueless and I had a chat where he pointed this out to me, and while analysing the position of instructions generated from assembly x86 code, we noticed that in a single binary word (of 32 bits, or 4 bytes) there were two instructions, each of them being 2 bytes long.

Mac or PC?

One of the biggest debates for a small start-up, and one that we experienced first hand, is the issue of how much of your capital to spend on computer stuff.

As we began making our wishlist of software, hardware, and other capital expenses, we realized that the decisions we were making about what to invest in now would probably be with us for the life of the company. What I mean is that it’s rare that a small practice makes a massive switch from PC’s to Macs, or from AutoCAD to Vectorworks, simply because of the financial implications of converting everything and basically starting a new learning curve.
That’s why we decided that reading through the millions of forums and reviews on products (see CAD forums section) was an essential step in determining which professionals out there are happiest with their setups.

In the end, we made a list of criteria and we chose hardware and software to match based on priority. These are the decisions we made, based on the theory that we would spend a little more money to save time and improve efficiency (especially because there are only two of us in the office):

Computers and Operating Systems:
I was a PC girl. He was a Mac guy. However, in the year before the conception of Emu Architects, the frequency with which I made up excuses to use his Macbook Pro over my Dell Inspiron grew exponentially. I eventually converted, and I haven’t looked back since. This key decision to fork out more dough for the Macs ultimately afforded us more flexibility with high power software. Plus, with Parallels, we don’t have to worry when someone sends us a Windows only file format.

CAD Software:
This was to be the core of how our business would operate. After researching to confirm our suspicions, we decided that everyone in the industry who is not using BIM software is completely crazy. We settled on Graphisoft’s ArchiCAD, and we even won a free license from filling out those surveys that you always think are a waste of time (see Graphisoft’s article on our win)! Armed with this fantastic software, we completely eliminated the need for an external 3D software. In fact, we also gained a huge amount in time savings, because of the fact that all cost estimations, project documentation, and rendering are done within ArchiCAD. It truly made it possible for two people to get everything done in the same time as a team of people working on an AutoCAD project. That extra time can now be spent in the rendering or in other communications and presentation material.

Graphic Communications and Presentation Software:
One of our explicit goals as a company is to offer a higher level of communication than is standard practice here in Italy. This meant we needed tools that would allow us to create and publish well designed graphic web material efficiently. We also wanted the ability to create well formatted templates for presentations to clients and correspondence with other professionals. Our communications software now includes:

Artlantis: Although we are still in the demo mode at the moment, we are fairly certain that this secret software will be well worth it. It raises the level of presentation material with respect to time investment drastically. Look forward to future posts about our experiences with it.

RapidWeaver: We recently decided on this relatively inexpensive software for our new website design Our current published website is a quicky from iWeb and is seriously lacking in SEO (search engine optimization) features. Again – the decision to go for this software came from people’s comments in the forums about short learning curves and time efficiency.

Adobe CS4 and Acrobat: We could probably just do with InDesign and Acrobat, actually. This is what we use for all office document templates to ensure consistency of graphic layout. Everything, and I mean everything gets PDF’d before it is archived in our files. We also tend to use Photoshop a lot for quick photo fixing.

Office Administration Software:
We have been very impressed with iWork ‘09, but are also huge supporters of OpenOffice (free!). This is a good area to save some bucks and go for the open source package. In fact, other than Numbers (the iWork version of Excel), we very rarely use normal office software other than to import information sent to us from other people. For quick word processing (which I use to help me save blog posts), we use Bean (free!). The last to mention is, of course, Skype (free!)- which fortunately is becoming quite standard in Europe as a professional communication tool.

In Summary: the stuff we paid for that we couldn’t live without -

our Macs
ArchiCAD
Artlantis
RapidWeaver

And that’s it. Not so big a list, huh? Hopefully this combination will last us for the next decade or so with a few upgrades every now and then. Perhaps by the time we are veterans, BIM will have caught on as the industry standard and we’ll become the slow ones who need to hire employees to increase our CAD productivity. But until then we’ll enjoy the flexibility of remaining a two-person operation.

“Ah, vai lá e apaga direto na câmera as fotos que não quer mais“
um de seus amigos te sugeriu quando vc questionou o que fazer depois de fazer o download das fotos.

“Não, não, por segurança, formate o cartão diretamente em sua câmera“
gritou outro amigo.

e um último amigo te da a dica
“a melhor forma seria uma formatação em baixo nível. Claro, se sua câmera tiver esta função“

Para muitos que estão iniciando na fotografia digital, alguns destes conceitos podem ser muito confusos, como por exemplo: O que é formatação baixo nível, ou o que acontece se eu somente as deletar do cartão?

Muito bem, as descrições a sequir tratarão de certos assuntos mais técnicos mas não iremos aprofundá-los, somente dar uma passada para não ficar certos itens no ar. Também tomaremos com base que todas as câmeras trabalharão da mesma forma, mesmo sabendo que existem funções que variam de marca para marca.

Vamos então começar pelo básico, fazendo uma simples analogia.
Imagine que seu cartão de memória seja um livro. Um simples livro com um índice e as páginas correspondentes. Talvez um livro com aproximadamente 50 páginas de índice (chamado em inglês de table of contentes – TOC) e outras 450 de conteúdo, totalizando 500 páginas.

O funcionamento de câmera, basicamente falando, se comporta da seguinte maneira. Quando você tira uma foto, todas as informações da imagem capturada (todas as informações capturadas pelo sensor) são gravadas em uma página deste livro e então a referência desta página é então registrada no índice do livro (TOC).

Após um exaustivo dia de trabalho fotografando, você então descarrega todas as suas imagens para seu HD e está com seu cartão de memória “pronto” para ser usado em uma nova cobertura. Disse pronto, por já ter efetuado a cópia e um possível backup das imagens em seu computador, mas ainda é necessário apagar seus dados para então abrir espaço para as próximas imagens que serão capturadas.

Vamos analisar alguns métodos existentes para apagar os dados de um cartão.

Deletando as fotos
Quando você deleta uma foto, você está somente apagando a referência desta imagem em seu índice. Isso permite que a câmera saiba que uma determinada página está disponível para ser escrita por cima. De qualquer maneira, este procedimento, em termos práticos, estará somente afetando o índice (TOC) do seu livro, não necessáriamente apagando os dados de uma determinada página, que ainda permanecem lá até que outros dados sejam escritos por cima, ou melhor dizendo, até que outra imagem ocupe o espaço, que para a câmera está disponível.


Formatação Alto Nível
Até os últimos anos, este era o único procedimento de formatação disponível nas câmeras fotográficas. Talvez você não saiba que se chamava formatação alto nível, pois somente era descrito como “FORMAT”. Este era o jeito mais fácil de se apagar tudo de um cartão e começá-lo do zero. Como uma deleção simples, este comando simplesmente vai até o índice do livro (TOC) e apaga todas as suas informações de uma só vez. Como dito, a câmera somente sabe se há ou não uma determinada imagem num cartão, olhando através do TOC, e como não há nada disponível nele, ela assume que todo o espaço estará disponível. Lembrando que este procedimento ainda trabalha somente com a eliminação do conteúdo do TOC, não do cartão como um todo.

Formatação baixo nível
Agora sim falaremo do real destruidor. A formatação baixo nível, não somente apaga os dados do índice(TOC), mas acaba com todo e qualquer conteúdo disponível em todas as páginas do livro. Quando a formatação é completada, você terá um livro sem um índice e com todas páginas preenchidas com zeros, sendo impossível recuperar qualquer tipo de informação que antes existiu neste livro.

O que tudo isso quer dizer?

Se você quer realmente partir do zero e obter a máxima performance em termos de espaço, use a Formatação Baixo Nível, caso sua câmera a possua.

Caso não, tome um pouco mais de cuidado, pois sua câmera irá constantemente sobrescrever nestas certas páginas, que estão teoricamente liberadas. Porém acontece um problema um tanto quanto comum, chamado de fragmentação. Nem todas as imagens ocupam somente uma página. Pode ser que algumas passem para outras páginas, ocupando por exemplo a pagina 342 e 343. Quando vc deleta uma imagem, que está presente nesta página, então de acordo com o TOC, ambas estarão livres. Então é registrada uma nova imagem que somente irá ocupar a página 342. Uma outra imagem é registrada, mas por conter mais informação, esta então ocupará 2 páginas. De acordo com o TOC, a 343 está livre, depois disso somente a 415 está liberada, fazendo com que esta próxima imagem seja registrada ocupando páginas não sequenciais. Isso é o que acontece quando seu HD necessita ser desfragmentado, ficando lento em certas operações.

Não existem somente desvantagens no método de deleção e formatação alto nível. Somente com estes métodos que é possível uma futura recuperação dos dados de um cartão, caso você venha a apagá-lo acidentalmente. Uma vez utilizada a formatação de baixo nível, nada mais é possível ser recuperado.

De forma alguma queremos ditar qual o melhor ou pior método para se apagar o conteúdo de um cartão de memória, mas espero que as informações acima sirvam de base para você escolher a melhor opção no futuro.

Fonte e Texto Original em inglês: Digital Photography School

Hi every LDmicro user / lover,

If we have Linux on Computer, can we have LDmicro on Microcontroller?

My idea is if we have a open source high level code generator for popular microcontroller (e.g. PIC and AVR), all LDmicro friends may work together to build a “super LDmicro” for free.

Soon I will post my idea in detail.

Hamas demanding release of about 1,000 Palestinian prisoners in exchange for captive Israeli soldier Gilad Shalit, held for more than three years in Gaza Strip… From VOA. Full story

This site may contain information about: flight map. For a different topic see line airport to. The blog is also related to: airport transportation.

INTRODUCTION
============

LDmicro generates native code for certain Microchip PIC16 and Atmel AVR
microcontrollers. Usually software for these microcontrollers is written
in a programming language like assembler, C, or BASIC. A program in one
of these languages comprises a list of statements. These languages are
powerful and well-suited to the architecture of the processor, which
internally executes a list of instructions.

PLCs, on the other hand, are often programmed in `ladder logic.' A simple
program might look like this:

   ||                                                                    ||
   ||    Xbutton1           Tdon           Rchatter           Yred       ||
 1 ||-------]/[---------[TON 1.000 s]-+-------]/[--------------( )-------||
   ||                                 |                                  ||
   ||    Xbutton2           Tdof      |                                  ||
   ||-------]/[---------[TOF 2.000 s]-+                                  ||
   ||                                                                    ||
   ||                                                                    ||
   ||                                                                    ||
   ||    Rchatter            Ton             Tnew           Rchatter     ||
 2 ||-------]/[---------[TON 1.000 s]----[TOF 1.000 s]---------( )-------||
   ||                                                                    ||
   ||                                                                    ||
   ||                                                                    ||
   ||------[END]---------------------------------------------------------||
   ||                                                                    ||
   ||                                                                    ||

(TON is a turn-on delay; TOF is a turn-off delay. The --] [-- statements
are inputs, which behave sort of like the contacts on a relay. The
--( )-- statements are outputs, which behave sort of like the coil of a
relay. Many good references for ladder logic are available on the Internet
and elsewhere; details specific to this implementation are given below.)

A number of differences are apparent:

    * The program is presented in graphical format, not as a textual list
      of statements. Many people will initially find this easier to
      understand.

    * At the most basic level, programs look like circuit diagrams, with
      relay contacts (inputs) and coils (outputs). This is intuitive to
      programmers with knowledge of electric circuit theory.

    * The ladder logic compiler takes care of what gets calculated
      where. You do not have to write code to determine when the outputs
      have to get recalculated based on a change in the inputs or a
      timer event, and you do not have to specify the order in which
      these calculations must take place; the PLC tools do that for you.

LDmicro compiles ladder logic to PIC16 or AVR code. The following
processors are supported:
    * PIC16F877
    * PIC16F628
    * PIC16F876 (untested)
    * PIC16F88 (untested)
    * PIC16F819 (untested)
    * ATmega128
    * ATmega64
    * ATmega162 (untested)
    * ATmega32 (untested)
    * ATmega16 (untested)
    * ATmega8 (untested)

It would be easy to support more AVR or PIC16 chips, but I do not have
any way to test them. If you need one in particular then contact me and
I will see what I can do.

Using LDmicro, you can draw a ladder diagram for your program. You can
simulate the logic in real time on your PC. Then when you are convinced
that it is correct you can assign pins on the microcontroller to the
program inputs and outputs. Once you have assigned the pins, you can
compile PIC or AVR code for your program. The compiler output is a .hex
file that you can program into your microcontroller using any PIC/AVR
programmer.

LDmicro is designed to be somewhat similar to most commercial PLC
programming systems. There are some exceptions, and a lot of things
aren't standard in industry anyways. Carefully read the description
of each instruction, even if it looks familiar. This document assumes
basic knowledge of ladder logic and of the structure of PLC software
(the execution cycle: read inputs, compute, write outputs).

ADDITIONAL TARGETS
==================

It is also possible to generate ANSI C code. You could use this with any
processor for which you have a C compiler, but you are responsible for
supplying the runtime. That means that LDmicro just generates source
for a function PlcCycle(). You are responsible for calling PlcCycle
every cycle time, and you are responsible for implementing all the I/O
(read/write digital input, etc.) functions that the PlcCycle() calls. See
the comments in the generated source for more details.

Finally, LDmicro can generate processor-independent bytecode for a
virtual machine designed to run ladder logic code. I have provided a
sample implementation of the interpreter/VM, written in fairly portable
C. This target will work for just about any platform, as long as you
can supply your own VM. This might be useful for applications where you
wish to use ladder logic as a `scripting language' to customize a larger
program. See the comments in the sample interpreter for details.

COMMAND LINE OPTIONS
====================

ldmicro.exe is typically run with no command line options. That means
that you can just make a shortcut to the program, or save it to your
desktop and double-click the icon when you want to run it, and then you
can do everything from within the GUI.

If LDmicro is passed a single filename on the command line
(e.g. `ldmicro.exe asd.ld'), then LDmicro will try to open `asd.ld',
if it exists. An error is produced if `asd.ld' does not exist. This
means that you can associate ldmicro.exe with .ld files, so that it runs
automatically when you double-click a .ld file.

If LDmicro is passed command line arguments in the form
`ldmicro.exe /c src.ld dest.hex', then it tries to compile `src.ld',
and save the output as `dest.hex'. LDmicro exits after compiling,
whether the compile was successful or not. Any messages are printed
to the console. This mode is useful only when running LDmicro from the
command line.

BASICS
======

If you run LDmicro with no arguments then it starts with an empty
program. If you run LDmicro with the name of a ladder program (xxx.ld)
on the command line then it will try to load that program at startup.
LDmicro uses its own internal format for the program; it cannot import
logic from any other tool.

If you did not load an existing program then you will be given a program
with one empty rung. You could add an instruction to it; for example
you could add a set of contacts (Instruction -> Insert Contacts) named
`Xnew'. `X' means that the contacts will be tied to an input pin on the
microcontroller. You could assign a pin to it later, after choosing a
microcontroller and renaming the contacts. The first letter of a name
indicates what kind of object it is.  For example:

    * Xname -- tied to an input pin on the microcontroller
    * Yname -- tied to an output pin on the microcontroller
    * Rname -- `internal relay': a bit in memory
    * Tname -- a timer; turn-on delay, turn-off delay, or retentive
    * Cname -- a counter, either count-up or count-down
    * Aname -- an integer read from an A/D converter
    * name  -- a general-purpose (integer) variable

Choose the rest of the name so that it describes what the object does,
and so that it is unique within the program. The same name always refers
to the same object within the program. For example, it would be an error
to have a turn-on delay (TON) called `Tdelay' and a turn-off delay (TOF)
called `Tdelay' in the same program, since each counter needs its own
memory. On the other hand, it would be correct to have a retentive timer
(RTO) called `Tdelay' and a reset instruction (RES) associated with
`Tdelay', since it that case you want both instructions to work with
the same timer.

Variable names can consist of letters, numbers, and underscores
(_). A variable name must not start with a number. Variable names are
case-sensitive.

The general variable instructions (MOV, ADD, EQU, etc.) can work on
variables with any name. This means that they can access timer and
counter accumulators. This may sometimes be useful; for example, you
could check if the count of a timer is in a particular range.

Variables are always 16 bit integers. This means that they can go
from -32768 to 32767. Variables are always treated as signed. You can
specify literals as normal decimal numbers (0, 1234, -56). You can also
specify ASCII character values ('A', 'z') by putting the character in
single-quotes. You can use an ASCII character code in most places that
you could use a decimal number.

At the bottom of the screen you will see a list of all the objects in
the program. This list is automatically generated from the program;
there is no need to keep it up to date by hand. Most objects do not
need any configuration. `Xname', `Yname', and `Aname' objects must be
assigned to a pin on the microcontroller, however. First choose which
microcontroller you are using (Settings -> Microcontroller). Then assign
your I/O pins by double-clicking them on the list.

You can modify the program by inserting or deleting instructions. The
cursor in the program display blinks to indicate the currently selected
instruction and the current insertion point. If it is not blinking then
press <Tab> or click on an instruction. Now you can delete the current
instruction, or you can insert a new instruction to the right or left
(in series with) or above or below (in parallel with) the selected
instruction. Some operations are not allowed. For example, no instructions
are allowed to the right of a coil.

The program starts with just one rung. You can add more rungs by selecting
Insert Rung Before/After in the Logic menu. You could get the same effect
by placing many complicated subcircuits in parallel within one rung,
but it is more clear to use multiple rungs.

Once you have written a program, you can test it in simulation, and then
you can compile it to a HEX file for the target microcontroller.

SIMULATION
==========

To enter simulation mode, choose Simulate -> Simulation Mode or press
<Ctrl+M>. The program is shown differently in simulation mode. There is
no longer a cursor. The instructions that are energized show up bright
red; the instructions that are not appear greyed. Press the space bar to
run the PLC one cycle. To cycle continuously in real time, choose
Simulate -> Start Real-Time Simulation, or press <Ctrl+R>. The display of
the program will be updated in real time as the program state changes.

You can set the state of the inputs to the program by double-clicking
them in the list at the bottom of the screen, or by double-clicking an
`Xname' contacts instruction in the program. If you change the state of
an input pin then that change will not be reflected in how the program
is displayed until the PLC cycles; this will happen automatically if
you are running a real time simulation, or when you press the space bar.

COMPILING TO NATIVE CODE
========================

Ultimately the point is to generate a .hex file that you can program
into your microcontroller. First you must select the part number of the
microcontroller, under the Settings -> Microcontroller menu. Then you
must assign an I/O pin to each `Xname' or `Yname' object. Do this by
double-clicking the object name in the list at the bottom of the screen.
A dialog will pop up where you can choose an unallocated pin from a list.

Then you must choose the cycle time that you will run with, and you must
tell the compiler what clock speed the micro will be running at. These
are set under the Settings -> MCU Parameters... menu. In general you
should not need to change the cycle time; 10 ms is a good value for most
applications. Type in the frequency of the crystal that you will use
with the microcontroller (or the ceramic resonator, etc.) and click okay.

Now you can generate code from your program. Choose Compile -> Compile,
or Compile -> Compile As... if you have previously compiled this program
and you want to specify a different output file name. If there are no
errors then LDmicro will generate an Intel IHEX file ready for
programming into your chip.

Use whatever programming software and hardware you have to load the hex
file into the microcontroller. Remember to set the configuration bits
(fuses)! For PIC16 processors, the configuration bits are included in the
hex file, and most programming software will look there automatically.
For AVR processors you must set the configuration bits by hand.

INSTRUCTIONS REFERENCE
======================

> CONTACT, NORMALLY OPEN        Xname           Rname          Yname
                             ----] [----     ----] [----    ----] [----

    If the signal going into the instruction is false, then the output
    signal is false. If the signal going into the instruction is true,
    then the output signal is true if and only if the given input pin,
    output pin, or internal relay is true, else it is false. This
    instruction can examine the state of an input pin, an output pin,
    or an internal relay.

> CONTACT, NORMALLY CLOSED      Xname           Rname          Yname
                             ----]/[----     ----]/[----    ----]/[----

    If the signal going into the instruction is false, then the output
    signal is false. If the signal going into the instruction is true,
    then the output signal is true if and only if the given input pin,
    output pin, or internal relay is false, else it is false. This
    instruction can examine the state of an input pin, an output pin,
    or an internal relay. This is the opposite of a normally open contact.

> COIL, NORMAL                  Rname           Yname
                             ----( )----     ----( )----

    If the signal going into the instruction is false, then the given
    internal relay or output pin is cleared false. If the signal going
    into this instruction is true, then the given internal relay or output
    pin is set true. It is not meaningful to assign an input variable to a
    coil. This instruction must be the rightmost instruction in its rung.

> COIL, NEGATED                 Rname           Yname
                             ----(/)----     ----(/)----

    If the signal going into the instruction is true, then the given
    internal relay or output pin is cleared false. If the signal going
    into this instruction is false, then the given internal relay or
    output pin is set true. It is not meaningful to assign an input
    variable to a coil.  This is the opposite of a normal coil. This
    instruction must be the rightmost instruction in its rung.

> COIL, SET-ONLY                Rname           Yname
                             ----(S)----     ----(S)----

    If the signal going into the instruction is true, then the given
    internal relay or output pin is set true. Otherwise the internal
    relay or output pin state is not changed. This instruction can only
    change the state of a coil from false to true, so it is typically
    used in combination with a reset-only coil. This instruction must
    be the rightmost instruction in its rung.

> COIL, RESET-ONLY              Rname           Yname
                             ----(R)----     ----(R)----

    If the signal going into the instruction is true, then the given
    internal relay or output pin is cleared false. Otherwise the
    internal relay or output pin state is not changed. This instruction
    instruction can only change the state of a coil from true to false,
    so it is typically used in combination with a set-only coil. This
    instruction must be the rightmost instruction in its rung.

> TURN-ON DELAY                 Tdon
                           -[TON 1.000 s]-

    When the signal going into the instruction goes from false to true,
    the output signal stays false for 1.000 s before going true. When the
    signal going into the instruction goes from true to false, the output
    signal goes false immediately. The timer is reset every time the input
    goes false; the input must stay true for 1000 consecutive milliseconds
    before the output will go true. The delay is configurable.

    The `Tname' variable counts up from zero in units of scan times. The
    TON instruction outputs true when the counter variable is greater
    than or equal to the given delay. It is possible to manipulate the
    counter variable elsewhere, for example with a MOV instruction.

> TURN-OFF DELAY                Tdoff
                           -[TOF 1.000 s]-

    When the signal going into the instruction goes from true to false,
    the output signal stays true for 1.000 s before going false. When
    the signal going into the instruction goes from false to true,
    the output signal goes true immediately. The timer is reset every
    time the input goes false; the input must stay false for 1000
    consecutive milliseconds before the output will go false. The delay
    is configurable.

    The `Tname' variable counts up from zero in units of scan times. The
    TON instruction outputs true when the counter variable is greater
    than or equal to the given delay. It is possible to manipulate the
    counter variable elsewhere, for example with a MOV instruction.

> RETENTIVE TIMER               Trto
                           -[RTO 1.000 s]-

    This instruction keeps track of how long its input has been true. If
    its input has been true for at least 1.000 s, then the output is
    true. Otherwise the output is false. The input need not have been
    true for 1000 consecutive milliseconds; if the input goes true
    for 0.6 s, then false for 2.0 s, and then true for 0.4 s, then the
    output will go true. After the output goes true it will stay true
    even after the input goes false, as long as the input has been true
    for longer than 1.000 s. This timer must therefore be reset manually,
    using the reset instruction.

    The `Tname' variable counts up from zero in units of scan times. The
    TON instruction outputs true when the counter variable is greater
    than or equal to the given delay. It is possible to manipulate the
    counter variable elsewhere, for example with a MOV instruction.

> RESET                        Trto             Citems
                           ----{RES}----     ----{RES}----

    This instruction resets a timer or a counter. TON and TOF timers are
    automatically reset when their input goes false or true, so RES is
    not required for these timers. RTO timers and CTU/CTD counters are
    not reset automatically, so they must be reset by hand using a RES
    instruction. When the input is true, the counter or timer is reset;
    when the input is false, no action is taken. This instruction must
    be the rightmost instruction in its rung.

> ONE-SHOT RISING                  _
                           --[OSR_/ ]--

    This instruction normally outputs false. If the instruction's input
    is true during this scan and it was false during the previous scan
    then the output is true. It therefore generates a pulse one scan
    wide on each rising edge of its input signal. This instruction is
    useful if you want to trigger events off the rising edge of a signal.

> ONE-SHOT FALLING               _
                           --[OSF \_]--

    This instruction normally outputs false. If the instruction's input
    is false during this scan and it was true during the previous scan
    then the output is true. It therefore generates a pulse one scan
    wide on each falling edge of its input signal. This instruction is
    useful if you want to trigger events off the falling edge of a signal.

> SHORT CIRCUIT, OPEN CIRCUIT
                           ----+----+----      ----+     +----

    The output condition of a short-circuit is always equal to its
    input condition. The output condition of an open-circuit is always
    false. These are mostly useful for debugging.

> MASTER CONTROL RELAY
                           -{MASTER RLY}-

    By default, the rung-in condition of every rung is true. If a master
    control relay instruction is executed with a rung-in condition of
    false, then the rung-in condition for all following rungs becomes
    false. This will continue until the next master control relay
    instruction is reached (regardless of the rung-in condition of that
    instruction). These instructions must therefore be used in pairs:
    one to (maybe conditionally) start the possibly-disabled section,
    and one to end it.

> MOVE                      {destvar :=  }      {Tret :=     }
                           -{ 123     MOV}-    -{ srcvar  MOV}-

    When the input to this instruction is true, it sets the given
    destination variable equal to the given source variable or
    constant. When the input to this instruction is false nothing
    happens. You can assign to any variable with the move instruction;
    this includes timer and counter state variables, which can be
    distinguished by the leading `T' or `C'. For example, an instruction
    moving 0 into `Tretentive' is equivalent to a reset (RES) instruction
    for that timer. This instruction must be the rightmost instruction
    in its rung.

> ARITHMETIC OPERATION       {ADD  kay  :=}       {SUB  Ccnt :=}
                            -{ 'a' + 10   }-     -{ Ccnt - 10  }-

>                            {MUL  dest :=}       {DIV  dv :=  }
                            -{ var * -990 }-     -{ dv / -10000}-

    When the input to this instruction is true, it sets the given
    destination variable equal to the given expression. The operands
    can be either variables (including timer and counter variables)
    or constants. These instructions use 16 bit signed math. Remember
    that the result is evaluated every cycle when the input condition
    true. If you are incrementing or decrementing a variable (i.e. if
    the destination variable is also one of the operands) then you
    probably don't want that; typically you would use a one-shot so that
    it is evaluated only on the rising or falling edge of the input
    condition. Divide truncates; 8 / 3 = 2. This instruction must be
    the rightmost instruction in its rung.

> COMPARE               [var ==]        [var >]        [1 >=]
                       -[ var2 ]-      -[ 1   ]-      -[ Ton]-

>                       [var /=]       [-4 <   ]       [1 <=]
                       -[ var2 ]-     -[ vartwo]-     -[ Cup]-

    If the input to this instruction is false then the output is false. If
    the input is true then the output is true if and only if the given
    condition is true. This instruction can be used to compare (equals,
    is greater than, is greater than or equal to, does not equal,
    is less than, is less than or equal to) a variable to a variable,
    or to compare a variable to a 16-bit signed constant.

> COUNTER                      Cname          Cname
                           --[CTU >=5]--  --[CTD >=5]--

    A counter increments (CTU, count up) or decrements (CTD, count
    down) the associated count on every rising edge of the rung input
    condition (i.e. what the rung input condition goes from false to
    true). The output condition from the counter is true if the counter
    variable is greater than or equal to 5, and false otherwise. The
    rung output condition may be true even if the input condition is
    false; it only depends on the counter variable. You can have CTU
    and CTD instructions with the same name, in order to increment and
    decrement the same counter. The RES instruction can reset a counter,
    or you can perform general variable operations on the count variable.

> CIRCULAR COUNTER             Cname
                           --{CTC 0:7}--

    A circular counter works like a normal CTU counter, except that
    after reaching its upper limit, it resets its counter variable
    back to 0. For example, the counter shown above would count 0, 1,
    2, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 2,.... This is useful in
    combination with conditional statements on the variable `Cname';
    you can use this like a sequencer. CTC counters clock on the rising
    edge of the rung input condition condition. This instruction must
    be the rightmost instruction in its rung.

> SHIFT REGISTER            {SHIFT REG   }
                           -{ reg0..3    }-

    A shift register is associated with a set of variables. For example,
    this shift register is associated with the variables `reg0', `reg1',
    `reg2', and `reg3'. The input to the shift register is `reg0'. On
    every rising edge of the rung-in condition, the shift register will
    shift right. That means that it assigns `reg3 := reg2', `reg2 :=
    reg1'. and `reg1 := reg0'. `reg0' is left unchanged. A large shift
    register can easily consume a lot of memory. This instruction must
    be the rightmost instruction in its rung.

> LOOK-UP TABLE             {dest :=     }
                           -{ LUT[i]     }-

    A look-up table is an ordered set of n values. When the rung-in
    condition is true, the integer variable `dest' is set equal to the
    entry in the lookup table corresponding to the integer variable
    `i'. The index starts from zero, so `i' must be between 0 and
    (n-1). The behaviour of this instruction is not defined if the
    index is outside this range. This instruction must be the rightmost
    instruction in its rung.

> PIECEWISE LINEAR TABLE    {yvar :=     }
                           -{ PWL[xvar]  }-

    This is a good way to approximate a complicated function or
    curve. It might, for example, be useful if you are trying to apply
    a calibration curve to convert a raw output voltage from a sensor
    into more convenient units.

    Assume that you are trying to approximate a function that converts
    an integer input variable, x, to an integer output variable, y. You
    know the function at several points; for example, you might know that

        f(0)   = 2
        f(5)   = 10
        f(10)  = 50
        f(100) = 100

    This means that the points

        (x0, y0)   = (  0,   2)
        (x1, y1)   = (  5,  10)
        (x2, y2)   = ( 10,  50)
        (x3, y3)   = (100, 100)

    lie on that curve. You can enter those 4 points into a table
    associated with the piecewise linear instruction. The piecewise linear
    instruction will look at the value of xvar, and set the value of
    yvar. It will set yvar in such a way that the piecewise linear curve
    will pass through all of the points that you give it; for example,
    if you set xvar = 10, then the instruction will set yvar = 50.

    If you give the instruction a value of xvar that lies between two
    of the values of x for which you have given it points, then the
    instruction will set yvar so that (xvar, yvar) lies on the straight
    line connecting those two points in the table.  For example, xvar =
    55 gives an output of yvar = 75. (The two points in the table are
    (10, 50) and (100, 100). 55 is half-way between 10 and 100, and 75
    is half-way between 50 and 100, so (55, 75) lies on the line that
    connects those two points.)

    The points must be specified in ascending order by x coordinate. It
    may not be possible to perform mathematical operations required for
    certain look-up tables using 16-bit integer math; if this is the
    case, then LDmicro will warn you. For example, this look up table
    will produce an error:

        (x0, y0)    = (  0,   0)
        (x1, y1)    = (300, 300)

    You can fix these errors by making the distance between points in
    the table smaller. For example, this table is equivalent to the one
    given above, and it does not produce an error:

        (x0, y0)    = (  0,   0)
        (x1, y1)    = (150, 150)
        (x2, y2)    = (300, 300)

    It should hardly ever be necessary to use more than five or six
    points. Adding more points makes your code larger and slower to
    execute. The behaviour if you pass a value of `xvar' greater than
    the greatest x coordinate in the table or less than the smallest x
    coordinate in the table is undefined. This instruction must be the
    rightmost instruction in its rung.

> A/D CONVERTER READ           Aname
                           --{READ ADC}--

    LDmicro can generate code to use the A/D converters built in to
    certain microcontrollers. If the input condition to this instruction
    is true, then a single sample from the A/D converter is acquired and
    stored in the variable `Aname'. This variable can subsequently be
    manipulated with general variable operations (less than, greater than,
    arithmetic, and so on). Assign a pin to the `Axxx' variable in the
    same way that you would assign a pin to a digital input or output,
    by double-clicking it in the list at the bottom of the screen. If
    the input condition to this rung is false then the variable `Aname'
    is left unchanged.

    For all currently-supported devices, 0 volts input corresponds to
    an ADC reading of 0, and an input equal to Vdd (the supply voltage)
    corresponds to an ADC reading of 1023. If you are using an AVR, then
    connect AREF to Vdd. You can use arithmetic operations to scale the
    reading to more convenient units afterwards, but remember that you
    are using integer math. In general not all pins will be available
    for use with the A/D converter. The software will not allow you to
    assign non-A/D pins to an analog input. This instruction must be
    the rightmost instruction in its rung.

> SET PWM DUTY CYCLE          duty_cycle
                           -{PWM 32.8 kHz}-

    LDmicro can generate code to use the PWM peripheral built in to
    certain microcontrollers. If the input condition to this instruction
    is true, then the duty cycle of the PWM peripheral is set to the
    value of the variable duty_cycle. The duty cycle must be a number
    between 0 and 100; 0 corresponds to always low, and 100 corresponds to
    always high. (If you are familiar with how the PWM peripheral works,
    then notice that that means that LDmicro automatically scales the
    duty cycle variable from percent to PWM clock periods.)

    You can specify the target PWM frequency, in Hz. The frequency that
    you specify might not be exactly achievable, depending on how it
    divides into the microcontroller's clock frequency. LDmicro will
    choose the closest achievable frequency; if the error is large then
    it will warn you. Faster speeds may sacrifice resolution.

    This instruction must be the rightmost instruction in its rung.
    The ladder logic runtime consumes one timer to measure the cycle
    time. That means that PWM is only available on microcontrollers
    with at least two suitable timers. PWM uses pin CCP2 (not CCP1)
    on PIC16 chips and OC2 (not OC1A) on AVRs.

> MAKE PERSISTENT            saved_var
                           --{PERSIST}--

    When the rung-in condition of this instruction is true, it causes the
    specified integer variable to be automatically saved to EEPROM. That
    means that its value will persist, even when the micro loses
    power. There is no need to explicitly save the variable to EEPROM;
    that will happen automatically, whenever the variable changes. The
    variable is automatically loaded from EEPROM after power-on reset. If
    a variable that changes frequently is made persistent, then the
    EEPROM in your micro may wear out very quickly, because it is only
    good for a limited (~100 000) number of writes. When the rung-in
    condition is false, nothing happens. This instruction must be the
    rightmost instruction in its rung.

> UART (SERIAL) RECEIVE          var
                           --{UART RECV}--

    LDmicro can generate code to use the UART built in to certain
    microcontrollers. On AVRs with multiple UARTs only UART1 (not
    UART0) is supported. Configure the baud rate using Settings -> MCU
    Parameters. Certain baud rates may not be achievable with certain
    crystal frequencies; LDmicro will warn you if this is the case.

    If the input condition to this instruction is false, then nothing
    happens. If the input condition is true then this instruction tries
    to receive a single character from the UART. If no character is read
    then the output condition is false. If a character is read then its
    ASCII value is stored in `var', and the output condition is true
    for a single PLC cycle.

> UART (SERIAL) SEND             var
                           --{UART SEND}--

    LDmicro can generate code to use the UARTs built in to certain
    microcontrollers. On AVRS with multiple UARTs only UART1 (not
    UART0) is supported. Configure the baud rate using Settings -> MCU
    Parameters. Certain baud rates may not be achievable with certain
    crystal frequencies; LDmicro will warn you if this is the case.

    If the input condition to this instruction is false, then nothing
    happens. If the input condition is true then this instruction writes
    a single character to the UART. The ASCII value of the character to
    send must previously have been stored in `var'. The output condition
    of the rung is true if the UART is busy (currently transmitting a
    character), and false otherwise.

    Remember that characters take some time to transmit. Check the output
    condition of this instruction to ensure that the first character has
    been transmitted before trying to send a second character, or use
    a timer to insert a delay between characters. You must only bring
    the input condition true (try to send a character) when the output
    condition is false (UART is not busy).

    Investigate the formatted string instruction (next) before using this
    instruction. The formatted string instruction is much easier to use,
    and it is almost certainly capable of doing what you want.

> FORMATTED STRING OVER UART                var
                                   -{"Pressure: \3\r\n"}-

    LDmicro can generate code to use the UARTs built in to certain
    microcontrollers. On AVRS with multiple UARTs only UART1 (not
    UART0) is supported. Configure the baud rate using Settings -> MCU
    Parameters. Certain baud rates may not be achievable with certain
    crystal frequencies; LDmicro will warn you if this is the case.

    When the rung-in condition for this instruction goes from false to
    true, it starts to send an entire string over the serial port. If
    the string contains the special sequence `\3', then that sequence
    will be replaced with the value of `var', which is automatically
    converted into a string. The variable will be formatted to take
    exactly 3 characters; for example, if `var' is equal to 35, then
    the exact string printed will be `Pressure:  35\r\n' (note the extra
    space). If instead `var' were equal to 1432, then the behaviour would
    be undefined, because 1432 has more than three digits. In that case
    it would be necessary to use `\4' instead.

    If the variable might be negative, then use `\-3d' (or `\-4d'
    etc.) instead. That will cause LDmicro to print a leading space for
    positive numbers, and a leading minus sign for negative numbers.

    If multiple formatted string instructions are energized at once
    (or if one is energized before another completes), or if these
    instructions are intermixed with the UART TX instructions, then the
    behaviour is undefined.

    It is also possible to use this instruction to output a fixed string,
    without interpolating an integer variable's value into the text that
    is sent over serial. In that case simply do not include the special
    escape sequence.

    Use `\\' for a literal backslash. In addition to the escape sequence
    for interpolating an integer variable, the following control
    characters are available:
        * \r   -- carriage return
        * \n   -- newline
        * \f   -- formfeed
        * \b   -- backspace
        * \xAB -- character with ASCII value 0xAB (hex)

    The rung-out condition of this instruction is true while it is
    transmitting data, else false. This instruction consumes a very
    large amount of program memory, so it should be used sparingly. The
    present implementation is not efficient, but a better one will
    require modifications to all the back-ends.

A NOTE ON USING MATH
====================

Remember that LDmicro performs only 16-bit integer math. That means
that the final result of any calculation that you perform must be an
integer between -32768 and 32767. It also mean that the intermediate
results of your calculation must all be within that range.

For example, let us say that you wanted to calculate y = (1/x)*1200,
where x is between 1 and 20. Then y goes between 1200 and 60, which
fits into a 16-bit integer, so it is at least in theory possible to
perform the calculation. There are two ways that you might code this:
you can perform the reciprocal, and then multiply:

   ||         {DIV  temp  :=}          ||
   ||---------{ 1 / x       }----------||
   ||                                  ||
   ||          {MUL  y  :=  }          ||
   ||----------{ temp * 1200}----------||
   ||                                  ||

Or you could just do the division directly, in a single step:

   ||           {DIV  y  :=}           ||
   ||-----------{ 1200 / x }-----------||

Mathematically, these two are equivalent; but if you try them, then you
will find that the first one gives an incorrect result of y = 0. That
is because the variable `temp' underflows. For example, when x = 3,
(1 / x) = 0.333, but that is not an integer; the division operation
approximates this as temp = 0. Then y = temp * 1200 = 0. In the second
case there is no intermediate result to underflow, so everything works.

If you are seeing problems with your math, then check intermediate
results for underflow (or overflow, which `wraps around'; for example,
32767 + 1 = -32768). When possible, choose units that put values in
a range of -100 to 100.

When you need to scale a variable by some factor, do it using a multiply
and a divide. For example, to scale y = 1.8*x, calculate y = (9/5)*x
(which is the same, since 1.8 = 9/5), and code this as y = (9*x)/5,
performing the multiplication first:

   ||         {MUL  temp  :=}          ||
   ||---------{ x * 9       }----------||
   ||                                  ||
   ||           {DIV  y  :=}           ||
   ||-----------{ temp / 5 }-----------||

This works for all x < (32767 / 9), or x < 3640. For larger values of x,
the variable `temp' would overflow. There is a similar lower limit on x.

CODING STYLE
============

I allow multiple coils in parallel in a single rung. This means that
you can do things like this:

   ||       Xa               Ya        ||
 1 ||-------] [--------------( )-------||
   ||                                  ||
   ||       Xb               Yb        ||
   ||-------] [------+-------( )-------||
   ||                |                 ||
   ||                |       Yc        ||
   ||                +-------( )-------||
   ||                                  ||

Instead of this:

   ||       Xa               Ya        ||
 1 ||-------] [--------------( )-------||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||       Xb               Yb        ||
 2 ||-------] [--------------( )-------||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||       Xb               Yc        ||
 3 ||-------] [--------------( )-------||
   ||                                  ||

This means that in theory you could write any program as one giant rung,
and there is no need to use multiple rungs at all. In practice that
would be a bad idea, because as rungs become more complex they become
more difficult to edit without deleting and redrawing a lot of logic.

Still, it is often a good idea to group related logic together as a single
rung. This generates nearly identical code to if you made separate rungs,
but it shows that they are related when you look at them on the ladder
diagram.

                  *                 *                  *

In general, it is considered poor form to write code in such a way that
its output depends on the order of the rungs. For example, this code
isn't very good if both Xa and Xb might ever be true:

   ||       Xa         {v  :=       }  ||
 1 ||-------] [--------{ 12      MOV}--||
   ||                                  ||
   ||       Xb         {v  :=       }  ||
   ||-------] [--------{ 23      MOV}--||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||      [v >]             Yc        ||
 2 ||------[ 15]-------------( )-------||
   ||                                  ||

I will break this rule if in doing so I can make a piece of code
significantly more compact, though. For example, here is how I would
convert a 4-bit binary quantity on Xb3:0 into an integer:

   ||                                   {v  :=       }  ||
 3 ||-----------------------------------{ 0       MOV}--||
   ||                                                   ||
   ||       Xb0                  {ADD  v  :=}           ||
   ||-------] [------------------{ v + 1    }-----------||
   ||                                                   ||
   ||       Xb1                  {ADD  v  :=}           ||
   ||-------] [------------------{ v + 2    }-----------||
   ||                                                   ||
   ||       Xb2                  {ADD  v  :=}           ||
   ||-------] [------------------{ v + 4    }-----------||
   ||                                                   ||
   ||       Xb3                  {ADD  v  :=}           ||
   ||-------] [------------------{ v + 8    }-----------||
   ||                                                   ||

If the MOV statement were moved to the bottom of the rung instead of the
top, then the value of v when it is read elsewhere in the program would
be 0. The output of this code therefore depends on the order in which
the instructions are evaluated. Considering how cumbersome it would be
to code this any other way, I accept that.

BUGS
====

LDmicro does not generate very efficient code; it is slow to execute, and
wasteful of flash and RAM. In spite of this, a mid-sized PIC or AVR can
do everything that a small PLC can, so this does not bother me very much.

The maximum length of variable names is highly limited. This is so that
they fit nicely onto the ladder diagram, so I don't see a good solution
to that.

If your program is too big for the time, program memory, or data memory
constraints of the device that you have chosen then you probably won't
get an error. It will just screw up somewhere.

Careless programming in the file load/save routines probably makes it
possible to crash or execute arbitrary code given a corrupt or malicious
.ld file.

Please report additional bugs or feature requests to the author.

Thanks to:
    * Marcelo Solano, for reporting a UI bug under Win98
    * Serge V. Polubarjev, for not only noticing that RA3:0 on the
      PIC16F628 didn't work but also telling me how to fix it
    * Maxim Ibragimov, for reporting and diagnosing major problems
      with the till-then-untested ATmega16 and ATmega162 targets
    * Bill Kishonti, for reporting that the simulator crashed when the
      ladder logic program divided by zero
    * Mohamed Tayae, for reporting that persistent variables were broken
      on the PIC16F628
    * David Rothwell, for reporting several user interface bugs and a
      problem with the "Export as Text" function

COPYING, AND DISCLAIMER
=======================

DO NOT USE CODE GENERATED BY LDMICRO IN APPLICATIONS WHERE SOFTWARE
FAILURE COULD RESULT IN DANGER TO HUMAN LIFE OR DAMAGE TO PROPERTY. THE
AUTHOR ASSUMES NO LIABILITY FOR ANY DAMAGES RESULTING FROM THE OPERATION
OF LDMICRO OR CODE GENERATED BY LDMICRO.

This program is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License along
with this program. If not, see <http://www.gnu.org/licenses/>.

Jonathan Westhues

Rijswijk      -- Dec 2004
Waterloo ON   -- Jun, Jul 2005
Cambridge MA  -- Sep, Dec 2005
                 Feb, Mar 2006
                 Feb 2007
Seattle WA    -- Feb 2009

Email: user jwesthues, at host cq.cx

This fantastic animation helps you visualize the world in the dimensions we tend not to understand so well, i.e. those numbered 4 through 10. Unfortunately, I can’t embed it here, but it’s through the link. You just have to fold space to get there.

Imagining the Tenth Dimension [via BoingBoing]

The Cadillac Way

A fuel card-based Price Protection Program is a “Cadillac” way to achieve higher fuel margins and sales — and increase customer loyalty. A detailed document on the program may be downloaded here. This post is an overview.

In a fuel card-based program, price lock and price cap fuel cards may be obtained by consumers and used at participating stations in a particular region or state until the fixed-price or capped-price gallons on the fuel card run out or until the expiration date (if any) on the card.  Following are images of what the fuel cards might look like:

Specific examples of price lock and price cap cards may be viewed here.

If price lock cards have expiration dates and expire before all the gallons are used, card owners may be reimbursed an expiration value. Price cap cards always have expiration dates, but no expiration value.

Responses to a fuel card-based price protection program survey show strong consumer interest in utilizing fuel cards.  Responses are summarized here.

Next … Storage – the Classic Way

Overview:

CBIR (Content Based Image Retrieval) is one of the key topics under discussion of modern researchers in the field of computer sciences. Image retrieval, object identification and recognition are main areas under consideration in this field. Main topics of discussion, in the domain of CBIR, are the relation between low level feature set and high level semantic feature and accurate image segmentation process. I will concentrate on the topic of relating low level and high level features in later posts. But before we go in the depth of this topic, I would like to shed some light on the basic approaches previously adopted in this arena. My this post will serve as the basis and background information for the detailed discussion about what are low level features and high level concepts, how we can reduce the semantic gap between them, and how we can over come the complexity and over head caused by subjective human perception.

Introduction to CBIR:

Over the last many years, Content Based Image Retrieval (CBIR) has become an active field of research. While many visual feature representation techniques have been developed and research is being carried out, the two distinct features of CBIR systems have relatively been ignored

1. The gap between High level concepts and low level features.
2. Subjectivity of human perception of visual content.

How human beings identify an object, form a perception about it, and how they translate it to a high level query? These are the questions that one should be considering if goal is to develop a successful CBIR system is to be developed which can function in the very manner the human’s object and content identification system works.

Before we look at the modern approaches to the CBIR system development, we must get ourselves accustomed with the old techniques and their draw backs so that we can identify that why CBIR systems lack behind in the above mentioned features. Thus enabling us to identify and propose a way to sort these problems out.

Need of Image retrieval system:

Let’s go slow and see that why exactly do we need a CBIR system. This way we will have a clearer view of the problem and therefore we will be able to identify a directed course of action to the solution of the underlying problem.

One need of such system is to extract relative information from given data sets, which can further be used in relevant systems. CBIR system may work independently or as a plug in to be integrated with a complex system, depending on the need and requirements.

Graphical and multimedia based applications are becoming an essential part of today’s life. With advances in computer technologies, and huge amount of digital data being generated, stored, transmitted, analyzed and accessed every moment, the very question that comes to an observer’s mind in that where and how to use it in such a fashion that it may benefit every user. In order to utilize this vast amount of data in general and specific applications, an effective and efficient system of interpreting and accessing this data is required. Such a system will form its basis from the advancing fields of data mining, pattern recognition, computer vision, and computer graphics. As the human beings are the consumers, so the solution must be in accord to the psychological inferences of human beings.

Many such systems have been developed over the years. The field of image retrieval was initiated in 1970s and ever since research is being carried out to find the perfect solution to the problem of recognition and retrieval. Our primary goal is to identify, i.e. recognize, a certain object in given visual data. We will later look into the aspect of retrieving data from a repository given a sample of the object. Reason being that we can not retrieve anything unless we know what is it that we need to fetch? Or we can say that we can not retrieve any information from a pile of data unless we have a mechanism to identify it.

Methodologies of image retrieval:

In the field of computer sciences, we have one good thing that makes a lot of things very clear. We are required to solve problems, and find an efficient way to make computer do it. We measure the solution’s accuracy and effectiveness with a universally perfect system, i.e. human beings. Therefore in order to do so, we infer the solution from the very methods a human expert exercises for solving a similar problem.

When it comes to the problem domain of efficient data retrieval of visual data, human beings are the perfect candidates for making observations, and deducting solutions based on the results of the study. Reasons being;

1. We can communicate with them, thus data retrieval is easier.
2. Sample sets of results are deducted from the data produced by them.
3. We have to match our system with that of human being’s image recognition and retrieval system to know the effectiveness and efficiency of the proposed system.

Therefore, all the methodologies which have yet been devised are based upon the studies about how human beings process visual information.

The basic methodologies being followed in field of image retrieval based on the contents are

1. Keyword annotation based Image retrieval
2. Content Based(CBIR)

Let’s take a look at both these approaches and what these have to offer.

Keyword annotation based Image retrieval:

When considering the sample system, and observing the responses of human beings towards different visual information, the very basic approach that comes to one’s mind is to map keywords to images. And this, in fact, is the one of the earliest and traditional approach towards the solution of this problem.

Every human being has subjective perception, but some things are constant and common. Therefore they are referred to with same keywords (in one language). For example, chair, table, glass etc. these are common words of language, and almost everyone has the same perception regarding these words. But for uncommon keywords, especially related to esthetics, nouns, etc. everyone has subjective perception.

In keyword annotation approach, images are annotated with related keywords manually. They can then be retrieved by their corresponding annotations. But the main problem is that every indexer has his own perception, and same is true for searcher or end user. Thus, we have some problems with this approach. Major three problems in this regards are Firstly, the large amount of manual effort required to be put in for developing annotations, secondly, the differences in interpretation of image contents and inconsistency of keyword assignment among different indexers due to perceptual differences, and thirdly, the ever growing image data repository size, about which we can never claim that all of the images in the image base are indexed. These problems make this approach infeasible, inconsistent and highly expensive in terms of both monetarily and time wise.

In short we can say that Due to the manual annotation, the major drawbacks of this approach are

1. Perception of human beings is a subjective attribute. Therefore everyone will annotate an image differently; hence accuracy of search is subjective.
2. The amount of manual labor that is required to be put in to annotate the contents.
3. With the increased size of image repository, the performance of the system reduces drastically.

The question is that can we optimize this approach in such a manner that it becomes feasible regarding operational costs and monetary costs? Also, can we make its results accurate? And if we can do so, then to what extent?

An example of keyword annotation based image search is Google (images.google.com). If you have used the services of Google for image search, you must have the idea how relevant the results are. Google tries its best to retrieve relevant results, but its search criteria are based on the comparison of search string or search keywords with image caption. Therefore, we get all those images as results which have some or all keywords present in their caption, or URL.

CBIR (Content Based Image retrieval):

Now that we have observed the keyword annotation based approach, and observed its major drawbacks, we take a look at the alternate approach, CBIR (Content Based Image Retrieval). In this approach we use the available resources as much as we can and improvise new techniques to optimize our results as well as our costs.

In CBIR based systems, we not only use the human-assigned keywords, but also utilize the visual content of the images, such as color, texture, and shape features, as the image index. By doing so, we are able to greatly alleviate, or overcome, the difficulties of pure keyword annotation based image retrieval approach. This approach makes things quite easy, as now feature extraction process can now be made automatic, and image’s own content is always constant. This approach reduces the task of keyword annotation from indexing every image to indexing only features, which means exponential difference in costs.

Now let’s see that what exactly are the major categories of features in CBIR based approach.

In CBIR, features are divided into two major categories,

1. High level semantic-based features: concepts, such as key words, and text descriptors used by humans to interpret images and similarity.
2. Low level features: such as color, shape, and textures.

Over the last many years, researchers have come up with many approaches and sophisticated algorithms to describe low level features, but these approaches and algorithms fail to adequately model the image semantics, i.e. high level concepts present in the given image and thus have many limitations when dealing with broad content image data bases. Along with that, extensive experiments with the CBIR based systems have shown that low level features are often not able to portray the high level semantic concepts present in user’s mind, and therefore, the performance of the CBIR based systems is far from user’s expectations. In other words, we can say that there is too much room present for researchers to improve upon the existing systems.

CBIR is a field with great margins for research, the problem of low level feature correspondence with high level features is a substantial one, and an effective mapping between them is the key to a sound CBIR system.

In next post, I will be discussing different aspects of the model system, i.e. human being’s perception, identification and recognition, and annotation systems.

By,

Umar Jamil Mughal

Part 2: Making Money

As discussed in Part 1 (Post #4), fuel gross margin must exceed 10 ¢/g for a retailer to profit on fuel sales. Given that, history shows retailers actually lose money on gasoline sales 25% of the time (see the cumulative frequency line on the chart). Weak and unprofitable margins are likely to continue given increased competition and other market pressures.

Fuel retailers leave themselves at the mercy of the market for fuel margins. They react to the most volatile component of fuel cost (i.e. the rack price), their own sales volumes, and what the competition is doing. Is that any way to run a business? Retailers try to make up for low fuel margins with high margin C-store sales. But that “strategy” just masks the problem; it doesn’t solve it. Is the primary business of gas stations to sell gas or store items? Is the reason most people stop at gas stations to get gas or something in the store?

How can retailers directly solve the problem of low fuel margins; i.e. how do they make money on the money margin? As discussed in Post #1, retailers need to be proactive about their fuel margins. Essentially, that just means retailers need to control their rack prices. The easiest and most effective way to control rack prices is to control futures. Remember from Post #2, futures prices set spot prices that, in turn, set rack prices –

Futures prices à Spot prices à Rack prices

Returning to the equation for fuel gross margin:

FGM = Retail price – Futures – Basis – (Rack/Spot differential) – Transportation – Taxes

If the Futures price is locked or limited, the retailer controls the most volatile and heaviest potential drag on fuel margins. The futures price may be locked with futures contracts or commodity funds (see Post #3); it may be limited with futures or commodity fund call options. On balance, locking the futures price with a commodity fund (UGA for gasoline, UHN for diesel fuel) is the simplest and most economic choice (e.g. 6 shares of UGA is equivalent to 100 gallons of gasoline futures). A commodity fund may be held indefinitely (like a stock) without the need for “rolling” the position like a futures contract. The fuel retailer may then easily hold the commodity fund until an advantageous time to sell. (More on that “advantageous time” in Post #9.)

The Basis is an important component but less volatile and less of a potential drag on fuel margins. For example, since 2005, the Basis for U.S. gasoline has averaged 4.1 ¢/g with a standard deviation of 8.2 ¢/g. Over the same period, gasoline futures have averaged 195.2 ¢/g with a standard deviation of 56.3 ¢/g.

The Rack/Spot differential is a relatively stable and predictable 1 to 3 ¢/g. It reflects the cost of moving product from spot locations to rack locations, plus the cost of operating a rack.

Transportation is the cost of trucking product from a rack to a retail station. It is also stable and predictable and averages 2 ¢/g.

Lastly, Taxes are a combination of federal and state taxes and are stable enough (though too high!). Taxes by state and product are shown here http://www.api.org/statistics/fueltaxes/.

What’s the bottom line? Control futures and you control the money margin. Control the money margin and you make money selling fuel – consistently and predictably. Even better, control futures and you may increase sales and customer loyalty, and achieve other benefits. That’s called a Fuel Price Protection Program.

Next …
The Roads to Higher Margins: Fuel Card or Storage

Part 1: Where’s the Money?

Fuel gross margin or FGM is the money margin for fuel retailers. It is the common measure of fuel sales profitability. FGM minus net operating cost (NOC) equals a station’s net fuel profit margin. Given that most retail stations have an NOC of 10 ¢/g or more, FGM must exceed 10 ¢/g for a station to profit by selling gasoline or diesel fuel.

The equation for fuel gross margin is:

Fuel Gross Margin (FGM) = Retail price – Delivered Cost – Taxes

Delivered Cost = Rack price + Transportation

Rack price = Spot Price + Rack/Spot differential

Spot Price = Futures price + Spot/Futures differential

(The Spot/Futures differential is referred to as the Basis.)

Bringing all the components together:

FGM = Retail price – Futures – Basis – (Rack/Spot differential) – Transportation – Taxes

Fuel retailers control their retail price, though the retail price is affected by factors outside the retailer’s control (competitor prices, fuel sales volumes, convenience store sales and traffic). Fuel retailers have no control over the other components of FGM – futures, basis, rack/spot differential, transportation costs, and taxes. Retailers are at the mercy of the market for those other components. So, in effect, retailers have very little control over their FGMs and, therefore, little control over their net fuel profit margin.

Given the significant volatility in futures prices, some degree of volatility in basis, and little (but some) volatility in the rack/spot differential, transportation, and taxes, it is not surprising that data over the last five years show a wide range in FGMs. This wide range is exhibited in the following histograms (frequency distributions) based on U.S. average data and is representative of areas across the country.

As indicated on the charts, the 5-year average FGM for regular gasoline is 18.4 ¢/g (median 16.7 ¢/g) and the 5-year average FGM for diesel fuel is 22.5 ¢/g (median 20.2 ¢/g). In 2009, the average FGM for regular gasoline decreased to 14.9 ¢/g.

California shows a similar pattern:

With NOCs of 10 ¢/g or higher, the net profit margin in 2009 on regular gasoline in the U.S. is less than 5 ¢/g, and less than 4 ¢/g in California.

Will average FGMs improve on their own? Not likely, given increased competition in retail fuel marketing from big-box retailers and grocery stores, whose primary objective is profitable store sales – not profitable fuel sales. Add a weak economy and political pressures to keep retail prices down and you have a recipe for FGMs averaging 12 to 17 ¢/g for the foreseeable future.

So what’s a fuel retailer to do? Most have decided to make the best of their C-store sales and hope for the best with FGMs. Will C-store sales make up for low margin fuel sales? For some, yes. For others … that’s a big gamble and, as the casinos in Las Vegas can attest, few gamblers win.

Well informed and creative fuel retailers will also make the best of their C-store sales, but they will go on offense to improve their fuel sales profitability. Going on offense entails understanding and utilizing currently available tools to manage futures prices and basis, and thereby actually set forward FGMs – not just hope the competition disappears or the market magically gets better.

Which type of retailer are you?  Do you want to just hope the market takes care of your business, or do you want to take care of your business?

Next …
Part 2: Making Money

Achieving all three – regardless of the number of retail sites

Retail gasoline and diesel fuel margins are volatile, unreliable, and sometimes unprofitable.  All fuel retailers know that, but most are unaware (or unwilling) to take advantage of opportunities in the wholesale markets to improve fuel margins.  They focus instead on increasing sales of profitable merchandise from C-stores; i.e. they take a “Costco-lite” approach to their fuel margin challenge.
 
Why are fuel margins so tight?  Competition, of course, but equally (or maybe, more) important is the fact that fuel retailers react to the market (rack and delivered prices, competitor prices, existing sales volumes) when setting pump prices.  In such a reactive mode, fuel margins are a hope-for-the-best proposition.  Fuel retailers are at continual risk of fuel sales being marginally profitable, and sometimes unprofitable.  (Statistics show gasoline fuel gross margins are below net operating costs roughly 25% of the time).

What to do about fuel margins?  Raise pump prices?  No, that drives sales down and customers away.  Focus on merchandise and food sales?  Ok, but that masks the problem and forces C-store owners onto big-box retailers’ and grocery store chains’ turf.  Hope you outlast the competition and then raise pump prices?  Everyone else is doing that, and how long is that going to take — assuming you make it to the “promised land” of less competition?
In order for fuel retailers to capture higher fuel margins (and achieve other benefits) they must go on offense.  The best defense is a good offense.  Offense against what?  The futures market where gasoline and diesel prices (among other commodity prices) are set.  Evidence is overwhelming — statistical and behavioral — that the futures market sets spot prices which set rack prices that, lastly, set retail prices.  In short, the futures market is the driver.  And it’s going to stay that way.  The good news is tools are available that enable retailers to control their “margin destination” and, at the same time, the “price destination” of their customers.  Friendly tools.  Today.

Famous Yiquan founder Wang Xiang Zhai’s had a very famous quote: “拳要打得逸” – martial art [at its highest level] should be yi.

拳: fist, boxing, martial art
要: should
打: hit, play, do
得: like
逸: leisurely, comfortable, cool, detached, graceful, elegant.

Yi is a one of those very Chinese concepts (like xuan) that is, although very well-known, used all the time, very difficult to explain:

You may hear Chinese-speaking people use the words “high level” a lot. This whole rating thing is very deeply ingrained in the culture. Traditionally, there are 9 levels (品 pin). Level 1-3 of course are high level, 4-6 middle, and 7-9 low.

In Chinese calligraphy and painting, we use the terms 能(neng), 妙(miao), 神(shen) in rating art. They map to lower, middle, and high. Neng means capable, technically proficient. Miao means excellent, clever, ingenious, subtle. Shen mean divine. We say “craft at its highest stage approaches art, art at its highest stage approach Dao.” Neng is the craft stage. Most of the calligraphy you see on restaurant signs, they are neng. Miao is the art stage. Shen is the dao stage – art at a level where it is spiritual. Then there’s an extra-level on top of the usual 9 – 逸 Yi . Together we call these Si Ge(格) – 4 levels.

Yi is this stage above the 9 levels we normally use to rate man-made objects. It is by definition very rare, for example everyone agrees, no calligraphy produced after Jin Dynasty (the one before Tang) can be called Yi.

So what is yi then?

Yi is a very Daoist concept, opposite of Confucian ideas. In Confucian thought they don’t talk about freedom, they talk about institution. Confucius lived in a time of prolonged warfare, he thought the problem with the world can be summarized with people not behaving like the father, son, brother, and husbands. Everyone in the society has a place in the grand hierarchy, with emperor on top, and everyone must fulfill the duties that comes with that position. The Daoists have different ideas: we are part of nature. Nature is good, our essential problem is we got away from that. We think we’re so clever, but it’s all very petty, and we willingly become slaves of our unnatural desires (e.g. the desire to make enough money so we can drive around in luxury automobiles does not come from the spiritual part of us).

So yi is a way of thinking, a way of living, above the mundane, often vulgar aspect of live. It’s being free. Being in touch with our highest aspiration as spiritual beings. Being true to our original nature. Being one with the universe (how could it be otherwise). Being simple, plain, genuine; of classical elegance and noble austerity. Yi is free, beautiful, artistic. Only when you’re really free can you find real comfort, ease. With comfort and ease come a sense of lightness.

People often use “dragon in the sky”, “fish in water” as examples of 遊逸 you yi. 遊 is often mistranslated as swimming when people say swimming dragon. You is leisurely cruising. In Chinese mythology, the dragon is said to be “able to expand or shrink to any size, adapt itself to any situation comfortably.” It can fly, even though it has no wings (why be so literal when it’s magical), so it’s the ultimate symbol of freedom. It is divine, magical, beyond our normal, limited levels of existence. So you can say dragon represent state of yi.

A classic example of this freedom is that, most of the calligraphy people regard as yi, those were actual drafts of articles, not the final version. When these great calligraphers were making the drafts, their mind is on what they want to write, not how well they write those characters. They are completely natural at that moment. In Chinese we call this ‘xin shou liang wang’ – the mind and the hands forget about each other. Many of them, upon finishing the draft, realized the result, and try to replicate but couldn’t. Because they were then thinking “write well, don’t make mistakes, make this part feel more free…”.

Like any art, martial art has rules and conventions. We need those guidelines to become good in the first place. But after that, can we be free of them? Yi is the stage that is beyond conventions. Free from convention doesn’t mean you can do anything. When Pavarotti sings “Nessun Dorma”, when he totally loses himself in the music, when we the audience loses ourselves in that performance, forgetting we’re even in a theater, it’s art at its highest, most natural level, what we would like to call Yi. But Pavarotti still have to sing the exact words and notes in Nessun Dorma. It’s one of those paradoxes (how many positive numbers are there – infinite), finite and infinite at the same time.

An obvious limit for fighting is you’re trying to survive. So at a fundamental level your actions are limited by that that intent. But with yi, you are basically free, so it’s this xuan stage where you care but you also don’t really care. This is where a lot of people misunderstand when talking about “ling kong jin”. Are there times when a master can throw someone without actual touching? Definitely yes. But it’s not like other skills in that you can consciously duplicate. Because you were acting naturally to the unique circumstance at the moment (which is impossible to replicate), you didn’t mean to throw the person without touching, just like you didn’t mean to create world’s greatest example of calligraphy when you’re drafting. But that was the result. You have all the capabilities to produce such moments, when everything outside is just right. But it’s not really a technique you can mechanically reproduce or practice for.

Another common expression is “when great sculptor create a statue, he leaves no tool marks”. The product is like a work of nature, with no traces of human hand.

So that’s what fighting should be like at highest level. Your responses may not look like any movement in the form, but it is 100% correct, 100% appropriate, as if it is the most natural thing for you to do. You do it with style, ease, grace, and playfulness.  There is a popular physical activity outside of China where people are seeking this same state of mind, same ideal level of skill – surfing.

In traditional Chinese culture, the words fang (方 – rectangular/square) and yuan (圓 – circular) appear together very often.

In the case of Taiji Quan, the rectangular/square refers to the four main skills of Taiji Quan (peng, lu, ji, an) and the four supplementary skills (cai, lie, zhou, kao). In ancient times, before we have the understanding of the natural world we have today, Chinese people though “heaven is round while the earth is square (rectangular)”. Heaven is thought to be round because it envelops the earth, and seemingly without boundaries and seams. Earth was thought to be square in that you can readily assign the four cardinal directions and four diagonal directions, delineate it in a grid-like manner (“earth is like a go board”).

In Chinese culture people believed Dao (Tao), the universal principle, can explain every thing in this world. So even people in what was considered “low-level” pursuits try to explain and elevate what they do by mapping it to those high-level philosophical principles. In this way the 5 main skills of Xingyi where mapped to 5 elements, the 8 palms of Bagua Zhang mapped to 8 trigrams, and the 4 main skills and 4 supplementary skills of Taiji mapped to coordinates of earth in Chinese cosmology. If you have the earth (4 cardinal + 4 corner skills) and the heaven (circles), then you have everything right?

Today it’s hard to say how we got internal martial art skills: did people think “this is way Dao works, the soft can overcome the hard, how do we apply it to martial art?”, or did martial art skill get to a point of high efficiency where people start to connect the dots: “hey, through clever timing and direction and manipulation of other aspects of force (not just speed and power, but also angle, direction, duration, etc), in this case we successfully dealt with a large force of this type using a smaller force of this type, this is soft overcoming the hard! Let’s investigate it further, because according to Dao we should be able to deal with all types of forces in a similar manner…” My guess is it’s probably the later.

The abstract principles of Daoism does a great job of explaining how and why internal martial art skills work on a physical level. However we need to be aware of the cultural tendency mentioned above, and be careful of its inherent pitfalls in trying to find one-to-one correspondence between martial art and philosophy/religion:

• Traditionally people say there are 36 (one of those magic numbers) main types of jin (trained force) in Taiji Quan. In reality there are more than 36 basic types. So her we need to be careful not to miss something important.
• On the other hand, in the overall scheme of things, historical martial art is a small dao (xiao dao). Meaning what we’re trying to do is simple – try to kill another person with bare hands and some simple tools. It’s not solving the world financial crisis. It is but a tiny subset (very partial one at that, not a perfect microcosm) of our overall experience of life, universe, and everything. So it’s futile to map 64 palms of our form to the all-encompassing, rich, dense layers of meanings that are embedded in Yi Jing’s 64 trigrams.

“I know Kungfu.”   – Neo from The Matrix

Most people in the West thinks the word “kungfu” means martial art in Chinese.  Actually kungfu is the Cantonese pronunciation of the word gongfu (功夫).  Perhaps the usage is different in the south, but for rest of China, gongfu doesn’t really mean martial art.  In modern Chinese, the term for martial art is wushu.  Wu (武) means martial, and shu (术) means skill, technique, method, tactic.

So what does kungfu/gongfu mean?  Amazingly, there does not seem to be a perfect one-to-one match in English.  Gongfu in Chinese means level of execution.  Since level of execution is directly related to amount of effort spent practicing it, it also means effort.  As a generic term, you can talk about gongfu in anything, it’s not exclusive to martial art.

The important distinction here is that gongfu is a separate concept from skill. You can have high level execution of a low level skill, just as you can have high level execution of a high level skill.

For example, say there is a need to move a 500 pound weight. Person A decides to approach it using the most direct way possible – he tries to move it with his bare hands.  At first he couldn’t do it. So he practiced and practiced, until he become so strong that he can move that stone by his own muscle alone.

Person B decides to study principle of movement in nature.  And after years of studying, he figure out a way to use levers, pulleys, and wheels to move the same object, albeit with much less physical exertion.

In Chinese we say Person A used a low level skill, but its execution is very high level.  Whereas Person B exemplifies the usage of a high(er) level skill.  Here we cannot say what the first person did was not difficult. It was.   But compared to what the second person did, the principles involved are much simpler, lower level.  For Person B, after achieving the necessary awareness, understandings, and implementing that knowledge and understanding in the form of a machine, the physical work the second person has to do to operate the machine to move the same stone is easy. But the nature of the work, the operating principles of this approach, the effort involved to arrive at this state, are said to be complex.

Another important reason we say the first approach, one that anyone can readily understand and instinctively gravitate to, is low level, is that there is a very low upper limit on what can be accomplished using that approach. You can never go to the moon that way; whereas with the second approach, the upper limit of things you can achieve with that is much higher.

In terms of martial art, if the effectiveness (“can I win?”) of our art relies mostly on speed and strength, that even a tiny drop-off means we will lose to all our peers (eg. see Mike Tyson and Roy Jones Jr. in boxing), then the limit of our art is we cannot beat anyone stronger, faster (younger) than us.  On the other hand, if the effectiveness of the skill does not depend as much on pure conditioning, but rather on things like sensitivity and clever manipulation of force, then we can beat someone who is stronger (within same order of magnitude).

If our art is all about unleashing the maximum amount of force possible to destroy any obstacle in the way (we don’t care what they are), then the limit is we may not last very long on the real battlefield. However, if one of the central tenants of our art is to avoiding any unnecessary expenditure of energy, then we can last longer, perhaps survive encounters with multiple opponents.

It is important to point out that in martial art at least, “high level” deosn’t mean our training is not physical.  In the end the design goal of every martial art is to make a person the best fighter he can be.  In some arts the approach is to make his movement as strong as possible.  In more advanced arts more emphasis is put on using the high level skill possible.

Ideally we want both:  physically we want our body to come as close to their theoretical limitations as possible; and in usage, be able to accomplish as much as possible utilizing its resources in the most skillful manner possible.

Here skill is the force multiplier: if you designed optimal lever-pulley-wheel mechanism for the specific task at hand, and you built you developed your body to its limit, now that same 500 pound push can move a 5,000 pound object. This is the ideal state we all want to achieve – high level execution of high level skill.

In real life applications, we cannot really separate skill from gongfu.  They are combined to form what we can call ability. In Chinese, when we talk about someone’s overall martial ability/prowese, we use the term wugong (武功).  So ability is a product of skill and gonfu.

This then means even if you’re studying a high level skill, if your gongfu is not good enough, you can be less effective than someone studying a lower level skill, but has very good gongfu in it.  For example, if Person P’s art is pistol shooting, but he’s a lousy shot, out of shape, and can’t even hit the target well in stationary situations, and Person K is the world’s fastest, best knife thrower, and a hardened combat veteran.  In this case Person P can easily lose to Person K in real life situations.

Another example is:  if Team A devotes much of time to advanced ball control skills, but neglect conditioning, and it meets up with Team B, though not as skilled, but can run faster and longer.  So that Team B can always get the ball before Team A.  Team A cannot win because it never gets a chance to apply its skills in the first place.

In today’s traditional martial art community at least, we have two common problems: on one hand people who practice higher level type skills don’t practice enough, and therefore don’t do well in real fights.  And on the other hand there are groups of people who train really hard, the type of skill they practice are very simple, but they can win in real competitions.

Most people, unless they are students of martial art, and used to think critically about it, will not realize what they are seeing is high level execution of low level skill beating low level execution of high level skill. This can cause them to doubt if high level skills ever worked (“can you really fight with Taiji?”), or confusing high level gongfu in low level skill with high level execution of high level skill (“I want to study internal martial art because it has the most powerful fa jins”).

We need to care about these distinctions because to reach our goal, we need to know what we’re doing:

If our goal is to get to Los Angeles from New York by car, we have to know where LA is, where we are, know how to read a map, know how the road system works, how to drive, etc.  Any lack of clarity on these things can prevent us from reaching the destination.   We cannot think “if I just put my foot on gas as long and hard as I can, I will automatically get there”.

Internal martial art training is very complex, there’s a lot to understand. If we’re not clear on what we’re doing, the harder we step on the gas (“bigger fajin, bigger than any opponent”), the further we may end up from our real goal (“how to use the least amount of necessary force to do everything”). We need to understanding what that high level execution of high level skill should be like, what type of skill and gongfu are involved in that, the training methods for acquiring those, and finally, “putting down a lot of gongfu” (effort), both physical and mental.

If  you have got the right qualifications then why not nurse your career back to health by getting a nursing job in Australia.  

If you are a registered nurse/midwife  or enrolled nurse  who has been employed previously in the Australian nursing workforce, but you have not worked as a nurse/midwife in Australia for 12 months, you may be eligible for cash bonuses to encourage you to come back to work in a public or private hospital, or residential aged care home.

If you are not located  here then why not come and join the thousands of others making the move Nursing in Australia.  

Firstly, decide whether you want to make the move a permanent one or temporary.  Spend time finding information on where you want to settle in Australia.  Once you have made your decision you will need to choose the right visa for you.

Whether you have a high level of skills and experience or need to gain additional skills, there is a visa to suit you.  There are excellent career opportunities with permanent and temporary work available in Australia.  You can be in or outside Australia when you apply for a visa to work as a nurse.

Applying for a visa through a migration agent make sure the agent is registered with MARA.

http://www.health.wa.gov.au/home/   The government website has job vacancies in Perth.

Wussten Sie, dass ein durchschnittlich großer Busen ohne BH, sich beim Joggen im Schnitt 8,5 cm vertikal von seiner normalen Position wegbewegt und dass es für die unterschiedlichen Sportarten passende Sport-BHs gibt? Die neue Seite mein-sport-bh.de informiert jetzt über die Vorteile, die ein Sport-BH beim Ausüben Ihrer Lieblinssportart bringt und welchen BH Sie dafür benötigen.

Zusammen mit der Triumph Sportmarke triaction werden alle aktuellen Sport-BHs in den vier Leistungslevel von Low bis Extreme vorgestellt. Das triaction Actionmeter hilft bei der Vorauswahl der richtigen Belastungsstufe, um den idealen BH für jede Sportart zu finden. Wenn Sie wünschen, können Sie den richtigen Sport-BH gleich im trend-wäsche.de Onlineshop unkompliziert bestellen.