LAMAlib - Lightweight Assembler MAcro library for cc65
Version: 0.22
Date: 2023-05-21
Author: Wil Elmenreich (wilfried at gmx dot at)
License: The Unlicense (public domain)
Installation and Usage
To use LAMAlib you need to have cc65 installed. Get it at https://cc65.github.io
Possibility 1: Install in cc65
There is a script install_lamalib.bat included which does the following:
- Copies all LAMAlib*.inc files into directory asminc of your cc65 installation.
- Copies the file LAMAlib.lib into directory lib of your cc65 installation.
You don't need to keep the original folder of LAMAlib, but you probably want to keep a copy of the documentation, LAMAlibdoc.html
In your programs,
- add a line .include "LAMAlib.inc" at the top of your assembler file
- assemble with command cl65 yourprog.s -lib LAMAlib.lib -C c64-asm.cfg -u __EXEHDR__ -o yourprog.prg
- alternatively, use the provided shellscripts ass.bat / ass.sh: ass yourprog.s
Usage: ass [-20|-128] asmfile [startaddr]
Calls the cl65 assembler and linker and creates an executable .PRG for the C64, unless -20 or -128 is specified, then the program will be assembled for the VIC20 or C128, respectively.
Possibility 2: Keep LAMAlib separately
Keep a copy of the LAMAlib folder in a sister directory of your project. You need then to link to the library via its relative or absolute path.
In your programs,
- add a line .include "../LAMAlib/LAMAlib.inc" at the top of your assembler file (the forward slash works on Linux as well as on Linux systems)
- assemble with command cl65 yourprog.s -lib ../LAMAlib/LAMAlib.lib -C c64-asm.cfg -u __EXEHDR__ -o yourprog.prg
- when you publish source code of your project you can add LAMAlib to the package. The license of LAMAlib has been chosen to be maximum permissive, so whatever project you have, there should be no problems adding the code.
Points to remember
Please note that the zero flag for 16 operations is not properly set for most macros except CMP. For example after a 16 bit calculation, a CMPAX #00 is necessary to test for zero in AX.
Instead of many zero page variables, the library functions uses self-contained self-modifying codeblocks whenever possible, but some of the more complex functions like division and multiplication use zero page addresses, they are reserved in the segment "ZEROPAGE".
Command documentation
Switches
USE_BASIC_ROM .set [0|1]
This switch tells LAMAlib if it should use calls into BASIC ROM or not. If USE_BASIC_ROM ist set to 0, LAMAlib uses its own implementations for printstr and print number.
The LAMAlib implementations are also faster, so USE_BASIC_ROM can also be set to 0 if you would like to increase performance.
USE_BASIC_ROM does not actually change the ROM configuration.
The switch can be changed multiple times to create program parts using the ROM and parts that do not.
16-bit Emulation Macros
ldax addr
ldax #arg
Loads a 16-bit value into A/X, either from an address or as immediate value
Note that the zero flag is not indicating 0 but indicating a value <256
Supports zero page addressing mode
Registers modified: A,X
stax addr
Stores the value in registers A and X to addr and addr+1
Supports zero page addressing mode
Registers modified: none
adcax addr
adcax #arg
Adds a 16 bit value with carry at an addr or as immediate value to 16 bit value in registers A/X
Supports zero page addressing mode
Result is returned in A/X
Registers modified: A,X
addax addr
adcax #arg
Adds a 16 bit value without carry at an addr or as immediate value to 16 bit value in registers A/X
Supports zero page addressing mode
Result is returned in A/X
Registers modified: A,X
sbcax addr
sbcax #arg
Subtracts the 16 bit value with carry at an addr or as immediate value from 16 bit value in registers A/X
Supports zero page addressing mode
Result is returned in A/X
Registers modified: A,X
subax addr
sbcax #arg
Subtracts the 16 bit value with carry at an addr or as immediate value from 16 bit value in registers A/X
Supports zero page addressing mode
Result is returned in A/X
Registers modified: A,X
rsc arg
rsc #arg
Reverse subtraction with carry, calculate the value of arg - A - C
if the carry is clear before the command, this behaves like rsc
If there is an underflow (arg is larger than A), the carry bit will be set, otherwise carry is clear
rsb arg
rsb #arg
Reverse subtraction, calculate the value of arg - A
The result is not influenced by the carry
If there is an underflow (arg is larger than A), the carry bit will be set, otherwise carry is clear
rscax arg
rscax #arg
16 bit reverse subtraction, calculate the value of arg - AX - C
if the carry is clear before the command, this behaves like rsbax
If there is an underflow (arg is larger than AX), the carry bit will be set, otherwise carry is clear
rsbax arg
rsbax #arg
16 bit reverse subtraction, calculate the value of arg - AX
The result is not influenced by the carry
If there is an underflow (arg is larger than AX), the carry bit will be set, otherwise carry is clear
cmpax addr
cmpax #arg
Compares the value in A/X with the 16 bit value in addr or the immediate value
Supports zero page addressing mode
Result is returned in A/X
Registers modified: A,X
orax addr
orax #arg
Calculates the bitwise OR operation between A/X and a 16 bit value at an addr or as immediate value
Supports zero page addressing mode
Result is returned in A/X
Registers modified: A,X
andax addr
andax #arg
Calculates the bitwise AND operation between A/X and a 16 bit value at an addr or as immediate value
Supports zero page addressing mode
Result is returned in A/X
Registers modified: A,X
eorax addr
eorax #arg
Calculates the bitwise exclusive-or operation between A/X and a 16 bit value at addr or as immediate value
Supports zero page addressing mode
Result is returned in A/X
Registers modified: A,X
aslax
Performs an arithmetic shift left of A/X (essentially a multiplication with 2, MSB goes into carry)
Result is returned in A/X
Registers modified: A,X
asl16 addr
Performs an arithmetic shift left of a 16 bit number at addr
Result at addr, addr+1
Registers modified: none
lsrax
Performs a logic shift right of A/X (essentially a division by 2, LSB goes into carry)
Result is returned in A/X
Registers modified: A,X
lsr16 addr
Performs a logic shift right of a 16 bit number at addr
Result at addr, addr+1
Registers modified: none
rolax
Performs a rotate left of A/X (essentially a multiplication with 2, carry goes into LSB, MSB goes into carry)
Result is returned in A/X
Registers modified: A,X
rol16 addr
Performs a rotate left of a 16 bit number at addr
Result at addr, addr+1
Registers modified: none
rorax
Performs a rotate right of A/X (essentially a division by 2, carry goes into MSB, LSB goes into carry)
Result is returned in A/X
Registers modified: A,X
ror16 addr
Performs a rotate right of a 16 bit number at addr
Result at addr, addr+1
Registers modified: none
negax
Negates the value in A/X
Result is returned in A/X
Registers modified: A,X
absax
Makes the signed 16 bit value in A/X an absolute value
Result is returned in A/X
Registers modified: A,X
incax
Increments 16 bit value in registers A/X
Registers modified: A,X
inc16 addr
Increments the value stored at addr (lo-byte) and addr+1 (hi-byte) as a 16 bit value
Registers modified: none
decax
Decrements 16 bit value in registers A/X
Registers modified: A,X
dec16 addr
Decrements the value stored at addr (lo-byte) and addr+1 (hi-byte) as a 16 bit value
Registers modified: A
incx n
Increments the X register by a value of n
Registers modified: X
Flags affected: N,Z,C
decx n
Decrements the X register by a value of n
Registers modified: X
Flags affected: N,Z,C
incy n
Increments the Y register by a value of n
Registers modified: Y
Flags affected: N,Z,C
decy n
Decrements the Y register by a value of n
Registers modified: Y
Flags affected: N,Z,C
pushax
Pushes AX to the stack and preserves AX
pullax
Pulls AX from the stack
poke arg1,arg2
Copies arg2 into the address of arg1
arg1 can be a constant or AX
arg2 can be a constant or A, X or Y
pokew arg1,arg2
poke word: copies 16 bit value arg2 into the address of arg1 and arg1+1
arg1 will be filled with low byte of arg2
arg2 will be filled with high byte of arg2
arg1, arg2 can be both constants or one can be AX and the other a constant
Regs changed: A, Y (in case AX is used as address)
jsr_ind addr
Executes a subroutine by a vector stored in addr and returns to the command after jsr_ind upon completion with an rts
arg1 will be a 16 bit address containing the vector to jump to
Regs changed: none
Hires Graphics Functions - CURRENTLY UNDER DEVELOPMENT
blank_screen
Waits until rasterbar is below screen area, then blanks the screen and shows only the border color
unblank_screen
Shows the screen again after it was blanked, effective with next frame
bitmap_on
Turn bitmap mode on and initialize tables in case the project uses plotting commands (plot, line, circle, ...)
bitmap_off
Turn bitmap mode off
gfx_clrscr bgcolor,fgcolor
Clear graphics screen and set background and foreground colors
gfx_init [gfxtablebase]
Initializes the look up tables used by the gfx_plot function
The optional argument defines where the look up tables needed by gfx_pset and gfx_pclr are placed ($2c9 bytes). This address should be page-aligned ($xx00). Without the argument, the address $9000 is used as a default.
This macro needs to be called once before using gfx_plot or any function that uses gfx_plot (e.g. gfx_line)
Uses all registers and overwrites memory area gfxtables
gfx_pset
Sets pixel at position x=X register (Carry indicating values > 255), y=Y register
gfx_pclr
Clears pixel at position x=X register (Carry indicating values > 255), y=Y register
gfx_pget
Reads pixel at position x=X register (Carry indicating values > 255), y=Y register
Return value (0 or 1) in A
set_VIC_charset addr
Sets VIC register $D018 to have the charset at the given address
addr must be a constant that is a multiple of $800
This macro does not adjust the VIC bank, see set_VIC_bank
set_VIC_screen addr
Sets VIC register $D018 to have the screen RAM at the given address
addr must be a constant that is a multiple of $400
This macro does not adjust the VIC bank, see set_VIC_bank
set_VIC_addr screen_addr,charset_addr
Sets VIC register $D018 to have the screen RAM and the charset at the given addresses
screen_addr must be a constant that is a multiple of $400, charset_addr a multiple of $800
This macro does not adjust the VIC bank, see set_VIC_bank
set_VIC_bank addr
Sets CIA register $DD00 to have the VIC RAM bank at the given address
addr must be a constant that is a multiple of $4000
Structured Programming
These commands allow you to use constructs like if .. else .. endif, do...loop, for...next, and switch...case in assembly language! The structures can even be nested. The implementation of these structures is basically as efficient as a a handcoded composure of branches, jumps as labels, while it is much easier to write and read.
All macros can be nested.
store reg
Generates self-modifying code for store/restore of a register
Registers can be A,X,Y, or AX (that is A and X)
An example application for store/restore is for saving a register to be able use it in between. An alternative to store/restore are stack push/pull, which is more compact, but 1 cycle slower.
Each store must match with exactly one restore macro using the same register, restore has to be placed later in your code
Registers modified: none
restore reg
Generates the code for restoreing a stored register
Registers can be A,X,Y, or AX (that is A and X)
Each restore must match with exactly one preceding store macro using the same register
Registers modified: the restoreed register
if cond
...
[else]
...
endif
This is a structure for conditional execution
cond can be eq, ne, mi, pl, cc, cs, vc, vs, lt, ge
This corresponds to assembler commands BEQ, BNE, BMI, BPL, BCC, BCS, BVC, BVS
Therefore the amount of code between if and else must not exceed the range of a branch instruction (127 byte for a forward branch)
lt (less than) is equal to cc (BCC), ge (greater or equal) is equal to cs (BCS)
using else is optional
Registers modified: none
for X|Y|A|AX|addr,start,to|downto,end,step
...
next
The for loop iterates from the start value to the end value, inclusive. This is similar to the behavior of FOR in BASIC
Counting variable can be an 8-bit register (A,X,Y), a 16 bit register (AX) or a 16 bit memory address/label (parentheses are optional)
start can be a constant or a memory address pointing to the value
end can be a constant or a memory address pointing to the value. The loop is continued including an iteration reaching the end value
start can be a constant or a memory address pointing to the value
to indicates a loop that counts up, downto indicates a loop that counts down
end can be a constant or a memory address pointing to the value
step is optional and defines the increment/decrement (default=1). This value is alway positive, counting down is indicated with downto
When the loop variable is an 8 bit register, start, end, and step are a single byte (or a memory reference to a single byte)
When the loop variable is a 16 bit register (AX) or a 16 bit memory address, start, end, and step are a 16 bit value (or a memory reference to a 16 bit value)
Memory references can also go to zero page. In this case the zero page addressing mode is used which speeds up the code.
When step is larger than 1 or no constant, loops that count down can are limited to a 7 bit (for single register loops) or a 15 bit range
It is possible to nest multiple for loops but each for must be followed by exactly one corresponding next later in the code.
Within a for loop, the macros break and continue can be used to exit the loop or go to next iteration.
Registers modified: the loop register and A for indirectly given step values
Code example that outputs '9876543210':
for A,$39,downto,$30
jsr $ffd2
next
do
...
[until|while cond]
...
loop [until|while cond]
Defines a loop that is exit based on a while or until condition
cond can be eq, ne, mi, pl, cc, cs, vc, vs, lt, ge
This corresponds to assembler commands BEQ, BNE, BMI, BPL, BCC, BCS, BVC, BVS
lt (less than) is equal to cc (BCC), ge (greater or equal) is equal to cs (BCS)
until and while can be used on a seperate line or after loop
There can be any number of until or while conditions, also none, which defines an endless loop
Within a do...loop, the macros break and continue can be used to exit the loop or go to next iteration.
Any line with a until, while, loop until, or while until will be typically preceded with code that sets the respective processor flags, in many cases this
will be a compare instruction. For example the C code while loop:
while(i>1) {
do_something()
i--;
}
would translate into
do
cpy #2 ;1+1
while ge
jsr do_something
dey
loop
Registers modified: A, if the loop variable is X or Y also the respective X or Y register
Code example that waits for joystick 2 button to be pressed:
lda #$10
do
and $dc00
loop until eq
switch [A|X|Y|AX]
[case|case_eq|case_lt|case_ge] num1
...
[break]
[case|case_eq|case_lt|case_ge] num2
...
[break]
[case|case_eq|case_lt|case_ge] num3
...
...
[break]
[default]
endswitch
Defines a selection mechanism to allow the value of a register to change the control flow
case and case_eq are the same function, they trigger if the register value and the comparison value are identical
case_lt ("less than") triggers if the register value is smaller than the comparison value
case_ge ("greater or equal") triggers if the register value is greater or equal than the comparison value
break jumps out of the structure. Other than with the switch structure in C, fallthroughs before another case do not work because there is code generated for the comparison and branch function before each case part.
Only a fallthrough into the default part works correctly.
default performs no comparison but triggers always, there is no need for a break command at the end of default
Registers modified: none
Example:
switch A
case 1:
print "one"
break
case 2:
print "two"
break
case 3:
print "one"
break
default:
print "?"
endswitch
Useful Routines
_ld_reg reg,arg
_st_reg reg,arg
_cp_reg reg,arg
macros to select register for a load, store, and compare operation.
For example, _ld_reg A,#12 translates into lda #12 while _st_reg $1234,Y translates into sty $1234
if reg is blank, A is used as a default
Those functions are mostly used in other macros.
check_C128
Detects if we are on a C128 in C64 mode
returns with carry set for C128
clrscr
Clears the screen
KERNAL ROM needs to be enabled when using this function
Registers modified: A,Y,X
checksum_eor startaddr,endaddr
Returns an 8-bit checksum calculated by EOR-conjunction over all bytes
clear_window
Clears the window that was defined by the window parametes above. When chrout2window is enabled, the same effect can be achieved by lda #147, jsr $FFD2
decimal_flag_to_N
Copies the decimal flag into the negative flag to detect if decimal mode is on
Macro always returns with a cleared Carry
Registers modified: A
delay_cycles arg
Delays for arg cycles using a busy waiting approach. This does not account for interrupts or stolen cycles by VIC badlines.
arg must be a constant >=2
generated code does not need to be aligned, but requires around 0.3 bytes/cycle in memory
Registers modified: none (but flags may be messed up)
delay_ms arg
Delays for arg milliseconds using a busy waiting loop. This does not account for interrupts or stolen cycles by VIC badlines.
When AX is given as argument it waits as many ms as the 16 bit value in A/X
When a number (1-65536) is given as argument it waits this long
Registers modified: A,X
disable_chrout2window
Restores the original Kernal vector and disables the chrout2window mode
disable_NMI
Executes a short routine to disable the NMI
the trick is to cause an NMI but don't ackowledge it
Uses CIA2 Timer A, but the timer can be used afterwards (without IRQ function)
Registers modified: A
diskstatus devicenr
Returns the disk status error message number in A
This code only reads the number without further text
Error codes (listed in decimal) are:
0 OK, no error exists
1 Files scratched response. Not an error condition
20 Block header not found on disk
21 Sync character not found
22 Data block not present
23 Checksum error in data
24 Byte decoding error
25 Write-verify error
26 Attempt to write with write protect on
27 Checksum error in header
28 Data extends into next block
29 Disk id mismatch
30 General syntax error
31 Invalid command
32 Long line
33 Invalid filename
34 No file given
39 Command file not found
50 Record not present
51 Overflow in record
52 File too large
60 File open for write
61 File not open
62 File not found
63 File exists
64 File type mismatch
65 No block
66 Illegal track or sector
67 Illegal system track or sector
70 No channels available
71 Directory error
72 Disk full or directory full
73 Power up message, or write attempt with DOS Mismatch
74 Drive not ready
div16 arg
Multiplies the unsigned 16 bit value in A/X with an imediate value or the 16 bit value stored at addr (lo-byte) and addr+1 (hi-byte)
Implemented as a subroutinge, link with -lib lamalib.lib
This function is not reentrant, don't use in interrupt and main program simultaneously
Result is returned in A/X
Registers modified: all
disable_cbm_shift
disable Commodore-Shift
enable_cbm_shift
enable Commodore-Shift, this key combination toggles between the uppercase/graphics and lowercase/uppercase character set
draw_frame
Draws a frame around the window defined by the window parameters
Note that the frame will go around the window, so it is larger than the defined window
Window parameters:
.import _window_x1,_window_y1,_window_x2,_window_y2
Further configuration parameters (default is a white frame using PETSCII characters):
.import _frame_upper_left
.import _frame_upper_right
.import _frame_lower_left
.import _frame_lower_right
.import _frame_vertical
.import _frame_horizontal
.import _frame_color
For example to change the color of the frame to green, write
.import _frame_color
poke _frame_color,5
enable_chrout2window
Switches the Kernal chrout vector to a routine that prints within a window
The page of the textscreen (stored in $288 / 648) is used to determine the output screen, but if you change the screen page, enable_chrout2window needs to be called again.
Limitations: no backspace, no insert
Note that control character keypresses in direct mode are not handled via $FFD2, therefore pressing for example CLR/HOME will leave the window in direct mode.
Window parameters:
.import _window_x1,_window_y1,_window_x2,_window_y2
For example to set a window starting on column 5, write
.import _window_x1
poke _window_x1,5
getkey
clears the key buffer, waits for a keypress and returns the ASCII value of the pressed key in A
Function depends on Kernal ROM and the IRQ routine regularily scanning the keyboard
identify_SID [baseaddress]
Detects the SID soundchip model
SID detection routine from codebase64 by SounDemon and a tip from Dag Lem
If no base address is given, the standard base address $d400 is used
Overwrites register A
Result is returned in carry
Carry flag is set for 6581, and clear for 8580
include_file_as filename,identifier
This macro helps in linking external files to the project that should be copied into a target area later or accessed directly
filename should be given as a quoted string. If the filename ends with ".prg" it is assumed that the first two byter are the loading address, these bytes are skipped for the calculation of start address and length
Example: include_file_as "sprites.bin",sprites
(identifier)_filestart contains the first address where the file was included (in the example that would be sprites_filestart)s
(identifier)_filestart contains the last address (+1) where the file was included
(identifier)_length contains the length in bytes
This macro is convenient for small projects, consider using a linker for projects with many different large components
install_file identifier[,target_addr]
copies a previously included file to the target address
Example: install_file sprites,$340
if target_addr is omitted, the address is taken from the load address (first two bytes of a PRG file)
if the filetype ist different from PRG, target_addr must be specified
The corresponding command include_file_as filename,identifier must be executed before calling install_file
is_alpha
is_alpha tests if value in Accu is between the values 'a' and 'z' (in lowercase mode).
Return value: Carry set if value is in range, carry cleared otherwise
Registers modified: none
is_not_alpha
is_alpha tests if value in Accu is not between the values 'a' and 'z' (in lowercase mode).
Return value: Carry set if value is outside range, carry cleared otherwise
Registers modified: none
is_digit
is_digit tests if value in Accu is between the values '0' and '9'.
Return value: Carry set if value is a digit, carry cleared otherwise
Registers modified: none
is_not_digit
is_not_digit tests if value in Accu is not between the values '0' and '9'.
Return value: Carry clear if value is a digit, carry set otherwise
Registers modified: none
is_in_range lower,higher
Tests if value in Accu is between the values lower and higher
Return value: Carry set if value is in range, carry cleared otherwise
Registers modified: none
is_not_in_range lower,higher
Tests if value in Accu is outside the values lower and higher
Return value: Carry set if value is outside range, carry cleared otherwise
Registers modified: none
is_in_range_trash_A lower,higher
Tests if value in Accu is between the values lower and higher
If the value was inside, the Carry is set, otherwise the Carry is cleared
Registers modified: A
load_prg filename[,devicenr[,loadaddr]]
Wrapper around ROM load function, prg means that the file is assumed to have a two-byte load address at its start
if device number is 0 or not stated, the last used device numner stored in address $BA is used. In case $BA contains 0, 8 is used as default
if loadaddr is omitted, the load address is defined by the first two bytes of the file
Return value in carry, if carry is set, an error has happened and error code is returned in A:
A = $05 (DEVICE NOT PRESENT)
A = $04 (FILE NOT FOUND)
A = $1D (LOAD ERROR)
A = $00 (BREAK, RUN/STOP has been pressed during loading)
Registers modified: A,X,Y
lowercase_mode
Switches charset to upper/lowercase (text) mode setting and locks the CBM+Shift switch
To switch back, use the macro PETSCII_mode
Registers modified: A
mul16 addr
compactmul16 addr
Multiplies the unsigned 16 bit value in A/X with the 16 bit value stored at addr (lo-byte) and addr+1 (hi-byte)
Implemented as a subroutinge, link with -lib lamalib.lib
mul16 adds a routine of 51 byte to your program the first time you use it
compactmul16 adds a routine of 32 byte to your program the first time you use it
mul16 is about 20% faster than compactmul, we recommend using mul16 in most cases
This function is not reentrant, don't use in interrupt and main program simultaneously
Result is returned in A/X
Registers modified: A,X,Y
neg
Negate A
Registers modified: A
newline
Prints a newline character
KERNAL ROM needs to be enabled when using this function
Registers modified: A
PETSCII_mode
Switches charset to uppercase plus graphical characters (graphics mode) setting and locks the CBM+Shift switch
To switch to upper/lowercase (text) mode, use the macro lowercase_mode
Registers modified: A
primm str
Prints the given string, string is inlined in program code
uses ROM functions, BASIC and KERNAL ROM need to be enabled when using this macro
Registers modified: A,Y,X
print arg1 [arg2 ...]
Prints the arguments as strings or numbers, without a carriage return
An argument in parenthesis will print the 16bit value stored at this address
uses ROM functions, BASIC and KERNAL ROM need to be enabled when using this macro
Use .FEATURE STRING_ESCAPES to enable escapes codes like "\x05" (white) or "\0x0a" (carriage return)
Registers modified: none
println arg1 [arg2 ...]
Prints the arguments as strings or numbers, followed by a carriage return
An argument in parenthesis will print the 16bit value stored at this address
uses ROM functions, BASIC and KERNAL ROM need to be enabled when using this macro
Use .FEATURE STRING_ESCAPES to enable escapes codes like "\x05" (white) or "\0x0a" (carriage return)
Registers modified: none
printax
Prints the number in A/X as a 16 bit unsigned decimal number
BASIC and KERNAL ROM need to be enabled when using this function
Registers modified: A,Y,X
printa
Prints the number in A as a 8 bit unsigned decimal number
BASIC and KERNAL ROM need to be enabled when using this function
Registers modified: A,X
printax_signed
Prints the number in A/X as a 16 bit signed decimal number
BASIC and KERNAL ROM need to be enabled when using this function
Registers modified: A,Y,X
printstr addr
Prints the null-terminated string at addr using the STROUT function
BASIC and KERNAL ROM need to be enabled when using this function
Registers modified: A,Y,X
rand8 [maxvalue-1]
Generate a random number between 0 and 255 which is returned in A.
The argument is optional and can be a number or the Y register
If an argument is given, the value is caclulated between 0 and given number-1
Good and fast random generator for 8bit values based on the X ABC pseudo-random number generator from EternityForest, slight modification by Wil.
Registers modified: A,Y (Y is only used when an argument is used)
rand16 [maxvalue-1]
Get a random number in AX betwenn 0 and 0xFFFF
The argument is optional and can be a number or AX
If an argument is given, the value is caclulated between 0 and given number-1
This function uses the same routine as rand8, therefore calling rand16 will change the state of rand8 as well
Registers modified: A,X,Y (Y is only used when an argument is used)
rand_setseed AX | [[arg1|A|X|Y], arg2|A|X|Y]
Seed is two 8 bit values. Arguments can be numbers or registers. Specifying seed is optional. When no argument is given, the default value for this seed byte is used.
When setting with AX, there is a check to avoid the seed 0 which would cause the PRNG to lock up. The seed affects both, rand8 and rand16 functions.
Registers modified: normally none, except for the case where lo(AX)==0, then A is set to $FF
set_cursor_pos line,column
place the cursor at screen position line,column (counted in characters)
0,0 is upper left corner, 24,39 the lower right corner
arguments can be constants or registers
textcolor color
sets the text color
toggle_carry
Toggles the carry
Registers modified: none
turn_off_cursor
Turns off the blinking cursor and restores the character and color under cursor if necessary.
Requires the KERNAL IRQ routines to be active
If this function is used on the C128, a bank with visible ROM must be active.
Use this before output of a char, otherwise you get inverse character artifacts when blink phase is on
turn_on_cursor
Shows the blinking cursor during program execution
Requires the KERNAL IRQ routines to be active
if this function is used on the C128, a bank with visible ROM must be active.
Turn off cursor briefly before output of a char, otherwise you get inverse character artifacts when blink phase is on
waitkey
Waits until a key is pressed, no meaningful return value
Function works independly of IRQ routine or ROM
Registers modified: A
waitkeyreleased
Waits until all keys are released
Function works independly of IRQ routine
Registers modified: A
readWASDspace
Checks the keyboard for keypresses of W, A ,S, D and Space
Output is a byte in A in the same format as a joystick value
Since movement of joystick 1 disturbs the value, no keys are returen if joystick 1 is moved to any direction
Function does not require the Kernal keyboard routine that is in the IRQ
Registers modified: A,X
makesys [linenumber[,text[, address]]]
Generates the code for a BASIC line with a SYS command, an optional text behind the sys command, and an optional specified entry address
This is similar to the command line option -u __EXEHDR__
Difference is that with this function the code segment starts at $801, so .align is off only by 1
If no SYS address is given, the target address is calculated to be the address right after the BASIC stub
Default line number is 2020
memcopy src_addr,target_addr,length
memcopy_from [AX|addr]
memcopy_to [AX|addr]
memcopy [AX|length]
Copies the memory area src_addr to src_addr+length over target_addr
If the areas are overlapping, then target_addr must be < src_addr
The three parameter version takes three constant numbers
Alternatively, the function can be configured parameter by parameter, either with AX or a constant
Registers modified: A,X,Y
memset start_addr,end_addr,fillvalue
Fills the memory area between start_addr and end_adder with the byte fillvalue
Registers modified: A,X,Y
save_prg filename,devicenr,startaddr,endaddr
Saves the memory from startaddr to endaddr (including the endaddr) using the CBM ROM save function.
The file will have a two-byte load address at its start
if device number is 0, the last used device numner stored in address $BA is used. In case $BA contains 0, 8 is used as default
Return value in carry, if carry is set, an error has happened and error code is returned in A, for example
A = $05 (DEVICE NOT PRESENT)
A = $00 (BREAK, RUN/STOP has been pressed during saving)
Registers modified: A,X,Y
scramble startaddr,endaddr
Scrambles/unscrambles a memory area. To unscramble, call scramble with the same parameters again
scratch_file filename[,devicenr]
Deletes a file on disk. If device number is not stated or 0, the last used device number stored in address $BA is used. In case $BA contains 0, 8 is used as default.
Registers modified: A,X,Y
set_raster_irq rasterline[, isr]
Changes the IRQ source to VIC raster interrupt
Turns off the CIA IRQ source
If isr is given, the address is set in Kernals IRQ vector $314/315
IRQ routine must acknowledge the IRQ source
Interrupts should be turned off or ensured that they won't happen while executing this macro
set_timerA_latch value|AX[,cia base address]
Sets the timer A value of the Complex Interface Adapter (CIA)
If no base address is specified, the base address $DC00 (CIA #1) is used. For CIA #2, a based address of $DD00 must be specified.
Note that the value specifies the reload value of the timer, not the current counter value
Used registers: A
read_timerA [AX[,cia base address]]
Reads the current timer value and puts it into AX
If the high byte changes during the reading, the reading is done again
Used registers: A,X
set_timerB_latch value|AX[,cia base address]
Sets the timer B value of the Complex Interface Adapter (CIA)
If no base address is specified, the base address $DC00 (CIA #1) is used. For CIA #2, a based address of $DD00 must be specified.
Note that the value specifies the reload value of the timer, not the current counter value
Used registers: A
to_scrcode
If the PETSCII value in A belongs to a printable character, it is converted to the corresponding screencode and returned in A
Control codes will lead to an arbitrary byte.
Used registers: A
wait_for_rasterline rasterline[,reg]
Macro inserting code doing busy waiting until the given rasterline is reached
rasterline can be a value between 0 and 311 (for PAL systems) or 261 for NTSC systems, respectively
The routine does not turn off the IRQ, so an IRQ might make it miss the rasterline it is waiting for.
Registers modified: A or the register (A,X, or Y) given as second argument
screen_off
turns off the screen via $d011
The function always sets a 0 as high bit to avoid an unreachable raster irq line.
wait_screen_off
Waits until raster>249 and turns screen off. Since it is necessary to write to $d011 to turn the screen off, we cannot avoid setting the high bit.
The function always sets a 0 as high bit to avoid an unreachable raster irq line.
screen_on
turns the screen back on. Since it is necessary to write to $d011, the high bit of the next raster IRQ will be reset to 0 as a side effect
Interacting with BASIC
setBasicVarnam "varnam"
This macro puts name and type of current variable into $45/46 (on C128 $47/48) in preparation for using ROM routines
The values of $45 and $46 are also put into registers A and X
The varname can be of 1 or 2 characters length plus an optional $ or % to indicate string or integer variables
Example usage:
setBasicVarnam "ab%" sets the integer variable ab%
setBasicVarnam "s$" sets the string variable s$
setBasicVarnam "x1" sets the floating point variable x1
getAddrOfBasicArryVar varnam,arrayidx
The arrayidx must be not larger than decimal 10 for arrays to be created
Example usage:
getAddrOfBasicArryVar "ab%",3 returns the address of AB%(3)
The return value is the variables address in AX
uses zero page addresses $0b, $0c, $0d, $0e, $45, $46
on C128 it uses zero page addresses $0d, $0e, $0f, $10, $47, $48
On the C128, the bank will be set to 1 after return, so this code needs to be in common RAM or in bank 1.
Special Macros for C128 in C128 Mode
shadowIRQ off|on
The C128 IRQ routine copies the values of the shadow registers $11D6-$11E6
into VIC registers $D000-$D010 that control the positions of sprites on the
screen. It further handles the BASIC commands SOUND, PLAY, and SPRITE. To
avoid this, the macro shadowIRQ off puts a 0 into memory address $0A04,
telling the Kernal that BASIC has not been initialized yet.
Cutting the IRQ routine provides a speed gain of about 2.5%
Registers modified: A
set_VIC_RAMbank bank
Tell the MMU to feed RAM bank 0 or 1 to the VIC
This is a C128-only feature
Bank must be 0 or 1
I/O must be enabled for this macro to work


Drag and drop is one of the most popular features in desktop applications and it is xxx in modern web applications for the browser. HTML5 provides a API that, combined with CSS, lets you add all the behavior and necessary visual elements to make the user interaction easy and understandable.
In this article we will provide basic templates for the three most common cases of drag and drop and highlight the main differences between them so the developer chooses the best option based on the requirements of the app.
create common class with the stoppropagation and such and some default values
drag me
drop here
This is the use case shown the most in tutorials but it's not necesserally the one used the most in web apps. Implementing it is as simple as defining the source elements and the destination container and add all the listeners to them.
It's good to know the minimum code that is necessary in order to make the sample work. This part is very important as most problems that developers run into is due to missing this basic structure in their code.
(function() { var dragElement = document.querySelector('#example-1 .src'); var dropContainer = document.querySelector('#example-1 .dest'); // source dragElement.setAttribute('draggable', 'true'); // Enable columns to be draggable. dragElement.addEventListener('dragstart', handleDragStart, false); dragElement.addEventListener('dragend', handleDragEnd, false); dragElement.addEventListener('drag', handleDrag, false); // destination dropContainer.addEventListener('dragover', handleDragOver, false); dropContainer.addEventListener('dragenter', handleDragEnter, false); dropContainer.addEventListener('dragleave', handleDragLeave, false); dropContainer.addEventListener('drop', handleDrop, false); // source handlers function handleDragStart(e) { e.dataTransfer.setData('text/html', 'some data'); } function handleDragEnd(e) {} function handleDrag(e) {} // destination handlers function handleDragOver(e) { e.preventDefault(); // Allows us to drop. return false; } function handleDragEnter(e) {} function handleDragLeave(e) {} function handleDrop(e) { e.stopPropagation(); // stops the browser from redirecting. return false; } }());
The code seems a little bit long but the only thing we did was to add dragstart, dragend and drag events to the source elements and dragover, dragenter, dragleave and drop events to the destination container. Then we wrote the handler functions as placeholders.
Of all the possible listeners we can manipulate in the drag and drop actions we need to cancel the default dragover and drop mouse behaviors with preventDefault and stopPropagation functions. Otherwise, the associated handlers won't be triggered and the drag and drop operation can't be completed by the user.
In the dragstart handler we must set some data (even if it's a placeholder) so all the handlers are also triggered and the browser knows what to do during and after the drag and drop operation is completed.
e.dataTransfer.setData('text/html', 'some data');
Note: Some elements have already some data set by default and we don't need to use setData in those cases such as textareas, input elements with type attribute set to text, text selections or elements with contenteditable attribute set to true.
As of this point, the dragend, drag, dragenter and dragleave handlers will be mainly used to add and remove classes to visually style the elements and help the user understand the interaction. Most of the logic to handle the actions related to the content of the elements will be placed in the dragstart and drop handlers.
It's always recommended to add all the necessary UI elements to help the user know what elements are draggable or how big the drop area is. CSS is the easiest way to add such elements but we will go through these details at the end of the tutorial after we have seen all the use cases logic. ... and the Basic Drag and Drop tutorial already explains how to do that in detail
With CSSwe are able to change the cursor when the mouse is hovering the different elements. However, if we want to change the mouse pointer while the drag action is being performed then we need to use some Javascript to do so
drag me
drop here
Note: As best practice add and remove classes of an element to change its style instead of using the inline syntax of 'element.style.backgroundColor = yellow'. Avoid manipulating classes in methods like dragOver and xxx as it gets triggered several times when the cursor moves. It's more optim to use enter and leave.
and here is all what we need to implement simple drag and drop in html5 the rest of the fancy stuff is implemented using css to add the different effects to cursors, origins and destinations. So the rest of the handlers will be used to add and remove css classes to the elements depending on what stage of the drag and drop we are. It's
Examples of this drag and drop case can be found in apps like visio, yahoo pipes or ... [editors]
list item 0
list item 1
list item 2
list item 3
list item 4
list item 5
The second use case is very similar to the first one but this time all the elements act as both source elements and destination containers. This use case is explained more in detail in the basic drag and drop tutorial. An example of this use case would be any app that wants to have a list of items that can be ordered or modified by the user using drag and drop.
(function() { var srcElement; // source this.handleDragStart = function(e) { e.dataTransfer.setData('text/html', e.target.innerHTML); srcElement = e.target; }; this.handleDragEnd = function(e) {}; this.handleDrag = function(e) {}; // destination this.handleDragOver = function(e) { e.preventDefault(); // Allows us to drop. return false; }; this.handleDragEnter = function(e) {}; this.handleDragLeave = function(e) {}; this.handleDrop = function(e) { e.stopPropagation(); // stops the browser from redirecting. srcElement.innerHTML = e.target.innerHTML; e.target.innerHTML = e.dataTransfer.getData('text/html'); return false; }; var dragElements = document.querySelectorAll('#example-3 .src'); for (var i = 0; i < dragElements.length; i++) { dragElements[i].setAttribute('draggable', 'true'); // Enable columns to be draggable. dragElements[i].addEventListener('dragstart', this.handleDragStart, false); dragElements[i].addEventListener('dragend', this.handleDragEnd, false); dragElements[i].addEventListener('drag', this.handleDrag, false); dragElements[i].addEventListener('dragover', this.handleDragOver, false); dragElements[i].addEventListener('dragenter', this.handleDragEnter, false); dragElements[i].addEventListener('dragleave', this.handleDragLeave, false); dragElements[i].addEventListener('drop', this.handleDrop, false); } }());
The only thing added to the basic template is some logic in the dragStart handler and in the drop handler in order to swap the innerHTML content of the list elements. More importantly, the main change is that we have added all the handlers to every element of the list in a for loop since every element is acting as a source element and a destination container at the same time
drag me
An actual example of this case would be an editor where objects need to be moved around to create a diagram or drawing. Think of a visio editor where you drop several objects in the editor area.
Note: The ghost image visually duplicates the source object. Such source object won't dissapear until we complete the drag and drop operation. If you specifically want that behavior or if you need some advanced feature like grid snapping or .... we recommend the use of a helper library.
Taking the initial template we only need to add a reference to the initial mouse position inside the object we are dragging
this.handleDragStart = function(e) { x_ = e.offsetX; y_ = e.offsetY; dragSrcEl_ = this; }
These values will be used when we finish the drop action together with the offset given by the event in the drop handler so we can position the element correctly.
this.handleDrop = function(e) { e.stopPropagation(); // stops the browser from redirecting. if (dragSrcEl_ != this) { // ??? if (this.innerHTML != '') { // dragSrcEl_.innerHTML = ''; // document.querySelector('#caput').innerHTML += this.innerHTML; } else { dragSrcEl_.innerHTML = this.innerHTML; } // this.appendChild(dragSrcEl_); dragSrcEl_.style.position = 'absolute'; dragSrcEl_.style.top = (e.offsetY - y_ + e.target.offsetTop) + 'px'; dragSrcEl_.style.left = (e.offsetX - x_ + e.target.offsetLeft) + 'px'; // this.innerHTML = e.dataTransfer.getData('text/plain'); }
To make the implementation easier is better to use absolute position on the elements we want to move. Using offset values to get the mouse coordinates or position the element can be more complicated if the DOM tree of the source element or the destination container are more complex. If that's the case then doing such calculations can be solved with any wrapper function to get such coorindates also available in any Javascript library
Browsers automatically set a 'ghost' image of an object next to the mouse pointer while this is being dragged. This image can be modified through the new API but taking advantage of the default behavior we can make an object to be movable at any cordinate of a specified area.
External reference to cursors in dnd
assume absolute position as the best choice get rid of the source image ghost image is only an image drag on the own element in cases of hierarchy you will need a loop [add sample with 3 cases together?] {% endblock %}


This is a list of top notch resources for developers, from breaking news, to tools and repos to make developing more developer friendly.
"The best resources are the ones that can help you learn without holding your hand too much. These are some of my frequently visited sites to check how to make something work or to get some ideas."
Coming Soon!
"Reading is only the beginning. Find a community to support you. This stuff is hard, but you can do it! That said, there are great resources for getting started."
"I like the whole stack, normally I write front to back. Here are some of my favorite sites for developing or just seeing what's going on in the tech world."
The below links are to our class presentations. In each presentation, you can find links to code examples and video recordings of the class.


Home
Contact
Resume
Classes
Good Reads
Color Experiment
Click Me
Oh No!
Looks like you've taken a wrong turn.
dawoodjee.com


What you were looking for
We will design a website for your needs, or code your existing layouts for you in HTML5/CSS3, together with smooth JS/JQuery interactions if needed.
And here it is another paragraph that you can add to explain better your services. It’s up to you to add as many content as you need here. Anyway life is beautiful and you must enjoy it.


Elementwise division. More...
Functions | |
| AFAPI af_err | af_div (af_array *out, const af_array lhs, const af_array rhs, const bool batch) |
| C Interface to divide one array by another array. | |
| AFAPI array | operator/ (const array &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const bool &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const int &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const unsigned &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const char &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const unsigned char &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const long &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const unsigned long &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const long long &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const unsigned long long &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const double &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const float &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const cfloat &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const cdouble &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const bool &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const int &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const unsigned &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const char &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const unsigned char &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const long &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const unsigned long &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const long long &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const unsigned long long &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const double &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const float &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const cfloat &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const cdouble &rhs) |
| AFAPI array | operator/ (const short &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const unsigned short &lhs, const array &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const short &rhs) |
| Divides two arrays or an array and a value. | |
| AFAPI array | operator/ (const array &lhs, const unsigned short &rhs) |
Elementwise division.
C Interface to divide one array by another array.
| [out] | out | result of lhs / rhs . |
| [in] | lhs | first input |
| [in] | rhs | second input |
| [in] | batch | specifies if operations need to be performed in batch mode |
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs
Divides two arrays or an array and a value.
| [in] | lhs | the left hand side value of the operand |
| [in] | rhs | the right hand side value of the operand |
lhs
and rhs


Direct Debit: Active
Amount to pay
£109.60
Chosen payment date
26
Initial payment
£10.60
Monthly payment
£9.00
Payment duration
12 months
Payments made
| Date | Amount | Status | Remaining balance |
|---|---|---|---|
| 26/09/2017 | £9.00 | Successful | £81.00 |
| 26/08/2017 | £9.00 | Successful | £90.00 |
| 27/07/2017 | £10.60 | Successful | £99.00 |


Why can't I edit the "All" view?
This is because it is of type "All" not of type "List", and the "All" type is not editable. You can only have one view of type "All".
If you want to edit this view, you will have to create a new view instead. See other questions on this page for more information.
Why can't I delete the "All" view?
This is because it is set as your default view. To delete this view, go to "Manage Jenkins" > "Configure System" and change the selection in the "Default View" drop-down.
You can't change the default view unless you already have another view created. Once you have changed to a new default view, you can delete the "All" view.
How do I delete the "All" view in "My views"?
To delete this view, go to "People" > "your username/userid" > "Configure" and change the selection in the "Default View" text field (this should actually be a drop-down too!).
Just like the global default view, you can't delete a user's default view unless you already have another view created. Once you have changed to a new default view, you can delete the user's "All" view.
How can I create an "Editable All View"?
You might want a view like "All" that shows all jobs, but perhaps you want to be able to change the columns around a bit. To do this, you need to create a "faux-All" view, by following these steps.
- Create your new view. Give it a name like "All2", and do not choose the type "All" if that option is available. Choose "List" or some other option if you have other plugins installed.
- Find the checkbox labeled "Use a regular expression to include jobs into the view" and check it.
- Enter the regular expression ".*" to pick up all jobs (or use the View Job Filters)
- Configure the view in any other way you like. For example, changing the columns you want to show.
- Save the new view
- Optionally, now you can replace your "All" view with your new view with the remaining steps
- Follow the instructions above for Deleting the All view
- Rename your temporary "All2" view to "All" by clicking the "Edit View" link on the left of that view's page


Nymphalidae
Upperside of male is bright orange with wide black borders and black veins; hindwing has a patch of scent scales. Upperside of female is orange-brown with wide black borders and blurred black veins. Both sexes have white spots on borders and apex. The Viceroy butterfly (Limenitis archippus) is a Mullerian mimic; it has similar coloration and is also distasteful.
Many open habitats including fields, meadows, weedy areas, marshes, and roadsides.
Three flights in the southern states from May-June, July-August, and September-April. Northern colonists have one generation per year, or do not reproduce at all.
Nectar from all milkweeds. Early in the season before milkweeds bloom, Monarchs visit a variety of flowers including dogbane, lilac, red clover, lantana, and thistles. In the fall adults visit composites including goldenrods, blazing stars, ironweed, and tickseed sunflower.


The aim of this plugin is to provide completion for conventional commits, also named semantic commits, inside the VCS Commit dialog.
The plugin provides:
It also offers a certain level of customization, which means allowing personalized and sharable default tokens, and attaching additional Providers for the various parts of the commit message: type, scope, subject, body, footer type and footer value.
Read the full description at GitHub.


Ricardo is a front-end developer based in the Bay Area. A widely acclaimed musician and coder, Ricardo has received many awards. He is competent in Java, HTML/CSS, BootStrap, jQuery, and JavaScript.
See the Pen ATributePage by Ricardo Diaz (@wiseguy) on CodePen.
See the Pen ATributePage by Ricardo Diaz (@wiseguy) on CodePen.
See the Pen ATributePage by Ricardo Diaz (@wiseguy) on CodePen.
See the Pen ATributePage by Ricardo Diaz (@wiseguy) on CodePen.


Dashboard
[[${totalRevenue}]]
€
Income
[[${totalExpenses}]]
€
Outcome
Income By Month
Outcome By Month
Sales By Product
Invoice By Supplier


Trading_UnpaidItemAssistancePreferencesType Class Reference
| Inherits from | NSObject |
| Conforms to | PicoBindable |
| Declared in | Trading_UnpaidItemAssistancePreferencesType.h Trading_UnpaidItemAssistancePreferencesType.m |
Overview
This type defines the UnpaidItemAssistancePreferences container. This container is
used in SetUserPreferences to set the preferences related to the Unpaid Item
Assistant feature. The UnpaidItemAssistancePreferences container is also returned in
GetUserPreferences (if the ShowUnpaidItemAssistancePreference flag is included and
set to true in the request).
@ingroup EBayAPIInterface
Tasks
-
delayBeforeOpeningDispute
This value indicates the number of days that should elapse before the Unpaid
property
Item Assistant mechanism opens an Unpaid Item case on behalf of the seller.
Valid values for this field are: 4, 8, 16, 24, and 32 (days). This field is
ignored if the OptInStatus flag is included and set to false
in the request, or if the seller is not currently opted into the Unpaid Item
Assistant feature in Unpaid Item Assistant Preferences on My eBay. -
optInStatus
Flag to indicate whether or not the Unpaid Item Assistant mechanism is turned on
property
for the seller. Through the Unpaid Item Assistant mechanism, eBay can
automatically file Unpaid Item cases on behalf of the seller. The Unpaid Item
Assistant feature also has options to automatically relist disputed items, to
automatically request a Giving Works donation refund (for Charity listings
only), or to create an ‘Exclusion list’ of buyers who are not subject to the
automatic filing of an Unpaid Item case. -
autoRelist
Flag to indicate whether or not the seller wants eBay to automatically relist
property
items after corresponding Unpaid Item cases are opened and closed through the
Unpaid Item Assistant mechanism without payment. For a multi-quantity listing,
the quantity is adjusted if AutoRelist is set to true.
This field is ignored if the OptInStatus flag is included and
set to false in the request, or if the seller is not currently opted into the
Unpaid Item Assistant feature in Unpaid Item Assistant Preferences on My eBay. -
removeAllExcludedUsers
This field should be included and set to true if the seller wants to clear all
property
users from the Unpaid Item Assistant Exclusion list. The Exclusion list can be
viewed from the Unpaid Item Assistant Preferences in My eBay. Excluded users are
not subject to the automatic filing of Unpaid Item cases. The seller can still
open Unpaid Item cases against excluded users, but these cases must be opened
manually.
Users can be added to Exclusion list through the ExcludedUser
field. The RemoveAllExcludedUsers field is ignored if the
OptInStatus flag is included and set to false in the request,
or if the seller is not currently opted into the Unpaid Item Assistant feature
in Unpaid Item Assistant Preferences on My eBay. -
excludedUser
An eBay User ID for which the Unpaid Item Assistant mechanism is disabled. This
property
field is typically used by a seller who would prefer to file an Unpaid Item
dispute manually for the specified user.
One or more ExcludedUser fields are used in
SetUserPreferences to add users to Unpaid Item Assistant Exclusion
list. Any and all ExcludedUser fields are ignored if the
OptInStatus flag is included and set to false in the request,
or if the seller is not currently opted into the Unpaid Item Assistant feature
in Unpaid Item Assistant Preferences on My eBay.
In GetUserPreferences, one or more ExcludedUser fields
represent the current Excluded user list. -
autoOptDonationRefund
Flag to indicate whether or not the seller wants eBay to automatically request
property
eBay Giving Works donation refunds after Unpaid Item cases are opened and closed
through the Unpaid Item Assistant mechanism without payment. This setting is
only applicable to eBay Charity listings. This field is ignored if the
OptInStatus flag is included and set to false in the request, or if
the seller is not currently opted into the Unpaid Item Assistant feature in
Unpaid Item Assistant Preferences on My eBay. -
any
(public property)
property
Properties
any
(public property)
@property (nonatomic, retain) NSMutableArray *any
Discussion
(public property)
entry type : PicoAnyElement, wrapper for primitive anyelement
Declared In
Trading_UnpaidItemAssistancePreferencesType.h
autoOptDonationRefund
Flag to indicate whether or not the seller wants eBay to automatically request
eBay Giving Works donation refunds after Unpaid Item cases are opened and closed
through the Unpaid Item Assistant mechanism without payment. This setting is
only applicable to eBay Charity listings. This field is ignored if the
OptInStatus flag is included and set to false in the request, or if
the seller is not currently opted into the Unpaid Item Assistant feature in
Unpaid Item Assistant Preferences on My eBay.
@property (nonatomic, retain) NSNumber *autoOptDonationRefund
Discussion
Flag to indicate whether or not the seller wants eBay to automatically request
eBay Giving Works donation refunds after Unpaid Item cases are opened and closed
through the Unpaid Item Assistant mechanism without payment. This setting is
only applicable to eBay Charity listings. This field is ignored if the
OptInStatus flag is included and set to false in the request, or if
the seller is not currently opted into the Unpaid Item Assistant feature in
Unpaid Item Assistant Preferences on My eBay.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_UnpaidItemAssistancePreferencesType.h
autoRelist
Flag to indicate whether or not the seller wants eBay to automatically relist
items after corresponding Unpaid Item cases are opened and closed through the
Unpaid Item Assistant mechanism without payment. For a multi-quantity listing,
the quantity is adjusted if AutoRelist is set to true.
This field is ignored if the OptInStatus flag is included and
set to false in the request, or if the seller is not currently opted into the
Unpaid Item Assistant feature in Unpaid Item Assistant Preferences on My eBay.
@property (nonatomic, retain) NSNumber *autoRelist
Discussion
Flag to indicate whether or not the seller wants eBay to automatically relist
items after corresponding Unpaid Item cases are opened and closed through the
Unpaid Item Assistant mechanism without payment. For a multi-quantity listing,
the quantity is adjusted if AutoRelist is set to true.
This field is ignored if the OptInStatus flag is included and
set to false in the request, or if the seller is not currently opted into the
Unpaid Item Assistant feature in Unpaid Item Assistant Preferences on My eBay.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_UnpaidItemAssistancePreferencesType.h
delayBeforeOpeningDispute
This value indicates the number of days that should elapse before the Unpaid
Item Assistant mechanism opens an Unpaid Item case on behalf of the seller.
Valid values for this field are: 4, 8, 16, 24, and 32 (days). This field is
ignored if the OptInStatus flag is included and set to false
in the request, or if the seller is not currently opted into the Unpaid Item
Assistant feature in Unpaid Item Assistant Preferences on My eBay.
@property (nonatomic, retain) NSNumber *delayBeforeOpeningDispute
Discussion
This value indicates the number of days that should elapse before the Unpaid
Item Assistant mechanism opens an Unpaid Item case on behalf of the seller.
Valid values for this field are: 4, 8, 16, 24, and 32 (days). This field is
ignored if the OptInStatus flag is included and set to false
in the request, or if the seller is not currently opted into the Unpaid Item
Assistant feature in Unpaid Item Assistant Preferences on My eBay.
type : NSNumber, wrapper for primitive int
Declared In
Trading_UnpaidItemAssistancePreferencesType.h
excludedUser
An eBay User ID for which the Unpaid Item Assistant mechanism is disabled. This
field is typically used by a seller who would prefer to file an Unpaid Item
dispute manually for the specified user.
One or more ExcludedUser fields are used in
SetUserPreferences to add users to Unpaid Item Assistant Exclusion
list. Any and all ExcludedUser fields are ignored if the
OptInStatus flag is included and set to false in the request,
or if the seller is not currently opted into the Unpaid Item Assistant feature
in Unpaid Item Assistant Preferences on My eBay.
In GetUserPreferences, one or more ExcludedUser fields
represent the current Excluded user list.
@property (nonatomic, retain) NSMutableArray *excludedUser
Discussion
An eBay User ID for which the Unpaid Item Assistant mechanism is disabled. This
field is typically used by a seller who would prefer to file an Unpaid Item
dispute manually for the specified user.
One or more ExcludedUser fields are used in
SetUserPreferences to add users to Unpaid Item Assistant Exclusion
list. Any and all ExcludedUser fields are ignored if the
OptInStatus flag is included and set to false in the request,
or if the seller is not currently opted into the Unpaid Item Assistant feature
in Unpaid Item Assistant Preferences on My eBay.
In GetUserPreferences, one or more ExcludedUser fields
represent the current Excluded user list.
entry type : NSString, wrapper for primitive string
Declared In
Trading_UnpaidItemAssistancePreferencesType.h
optInStatus
Flag to indicate whether or not the Unpaid Item Assistant mechanism is turned on
for the seller. Through the Unpaid Item Assistant mechanism, eBay can
automatically file Unpaid Item cases on behalf of the seller. The Unpaid Item
Assistant feature also has options to automatically relist disputed items, to
automatically request a Giving Works donation refund (for Charity listings
only), or to create an ‘Exclusion list’ of buyers who are not subject to the
automatic filing of an Unpaid Item case.
@property (nonatomic, retain) NSNumber *optInStatus
Discussion
Flag to indicate whether or not the Unpaid Item Assistant mechanism is turned on
for the seller. Through the Unpaid Item Assistant mechanism, eBay can
automatically file Unpaid Item cases on behalf of the seller. The Unpaid Item
Assistant feature also has options to automatically relist disputed items, to
automatically request a Giving Works donation refund (for Charity listings
only), or to create an ‘Exclusion list’ of buyers who are not subject to the
automatic filing of an Unpaid Item case.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_UnpaidItemAssistancePreferencesType.h
removeAllExcludedUsers
This field should be included and set to true if the seller wants to clear all
users from the Unpaid Item Assistant Exclusion list. The Exclusion list can be
viewed from the Unpaid Item Assistant Preferences in My eBay. Excluded users are
not subject to the automatic filing of Unpaid Item cases. The seller can still
open Unpaid Item cases against excluded users, but these cases must be opened
manually.
Users can be added to Exclusion list through the ExcludedUser
field. The RemoveAllExcludedUsers field is ignored if the
OptInStatus flag is included and set to false in the request,
or if the seller is not currently opted into the Unpaid Item Assistant feature
in Unpaid Item Assistant Preferences on My eBay.
@property (nonatomic, retain) NSNumber *removeAllExcludedUsers
Discussion
This field should be included and set to true if the seller wants to clear all
users from the Unpaid Item Assistant Exclusion list. The Exclusion list can be
viewed from the Unpaid Item Assistant Preferences in My eBay. Excluded users are
not subject to the automatic filing of Unpaid Item cases. The seller can still
open Unpaid Item cases against excluded users, but these cases must be opened
manually.
Users can be added to Exclusion list through the ExcludedUser
field. The RemoveAllExcludedUsers field is ignored if the
OptInStatus flag is included and set to false in the request,
or if the seller is not currently opted into the Unpaid Item Assistant feature
in Unpaid Item Assistant Preferences on My eBay.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_UnpaidItemAssistancePreferencesType.h


The AppSensor Guide can be found here: [https://www.owasp.org/index.php/OWASP_AppSensor_Project]. The guide contains extensive discussions of the methodology behind AppSensor. There are various topics covered, including:
The guide is the best resource for comprehensive coverage of the AppSensor concept as well as coverage of design ideas that are not used by the reference implementation.
Any AppSensor system will need some measure of configuration and setup. One defining characteristic for any AppSensor system is the methods of analysis that are supported. While the guide describes several (behavioral, model-driven, expert-system, stochastic, etc.), the simplest and that chosen by the reference implementation is a policy-driven analysis solution. This section briefly describes the steps involved in configuring a policy upon which to base your analysis.
There are a few primary components of policy-based configuration:
We'll cover each of these briefly.
Detection Points (examples here) represent the specific concerns you are interested in detecting within your application. These are suspcicious activities that may trigger an attack if detected with a certain frequency (defined by the threshold). Part of policy configuration is defining the detection points that your application should be able to handle.
Thresholds are simple definitions used to determine the acceptable number of events over a given period of time, for a given user or group of users. An example might be:
3 IE2 events in 5 minutes for an individual user represents an attack.
There can be more complex definitions of thresholds, namely trends, but these may or may not be necessary in your system.
Responses (examples here) are actions taken as the result of detecting that a certain detection point has crossed its' configured threshold, and therefore now represents an attack. Responses allow you to handle an attack in any way you like, given policy and legal requirements. The reference implementation allows for a chained response order, in which several responses can be configured, and executed as subsequent attacks for the same detection point are registered in the system.
Another key component of a functional AppSensor is the system instrumentation. In order to detect and respond to events, the application and its' surrounding components must be capable of performing the initial event detection. The AppSensor system is responsible for evaluating where an event or series of events constitutes an attack as well as finding the appropriate response for said attack. However, the initial event detection is handled outside AppSensor. There are various ways for this to occur:
Whatever mechanism or set of mechanisms you use, instrumentation is critical as detection must happen first before analysis and response can occur within the AppSensor architecture.
The last step is deployment and monitoring. As with any production system, you must first test, then deploy your AppSensor system.
However, the AppSensor system is somewhat unique in that it is intended to be a monitored and tweaked system. The detection points, thresholds and responses should be evaluated on a regular basis for their efficacy within your environment. The AppSensor Guide provides great planning resources and details about how to perform this step effectively. The insights in the guide should allow you to grow AppSensor with your deployed system.
With proper planning, configuration, deployment and monitoring, AppSensor should be an extremely useful part of your infrastructure and lead to enhanced security awareness and an improved security posture.


Germany says two citizens detained in Hong Kong
SINGAPORE (Reuters) - Two German citizens have been detained in Hong Kong and are receiving consular support, a source at the German foreign ministry said on Friday.
The source said the German consulate in Hong Kong was in touch with lawyers and local authorities, giving no further details.
Hong Kong police said they had detained two foreign men during a “dispersal operation” against a group of protesters gathered in Tuen Mun, a town in the New Territories. Hong Kong has been convulsed by months of protests against perceived meddling by Beijing in the former British colony, which returned to Chinese rule in 1997 under a “one country, two systems” formula guaranteeing freedoms not enjoyed on the mainland.
One of the foreign citizens, a 22-year-old, was arrested for illegal assembly and for breaching a ban on face masks, police said. A 23-year-old was arrested for illegal assembly.
Newspaper Bild earlier reported that two exchange students at Hong Kong’s Lingnan University had been detained in the region. The university could not be reached for comment.


| newTA {quantmod} | R Documentation |
Functions to assist in the creation of indicators or content to be drawn on plots produced by chartSeries.
addTA(ta, order = NULL, on = NA, legend = "auto", yrange = NULL, ...) newTA(FUN, preFUN, postFUN, on = NA, yrange = NULL, legend.name, fdots = TRUE, cdots = TRUE, data.at = 1, ...)
ta |
data to be plotted |
order |
which should the columns (if > 1) be plotted |
legend |
what custom legend text should be added to the chart. |
FUN |
Main filter function name - as a symbol |
preFUN |
Pre-filter transformation or extraction function |
postFUN |
Post-filter transformation or extraction function |
on |
where to draw |
yrange |
length 2 vector of y-axis range |
legend.name |
optional legend heading, automatically derived otherwise |
fdots |
should any ... be included in the main filter call |
cdots |
should any ... be included in the resultant function object.
|
data.at |
which arguement to the main filter function is for data. |
... |
any additonal graphical parameters/default to be included. |
Both addTA
and newTA
can be used to
dynamically add custom content to a displayed chart.
addTA
takes a series of values, either in
a form coercible to xts
or of the same length as
the charted series has rows, and displays the results in
either a new TA sub-window, or over/underlayed on
the main price chart. If the object can be coerced to
xts
, the time values present must only be within
the original series time-range. Internally a merge
of dates occurs and will allow for the plotting
of discontinuous series.
The order
argument allows for multiple column
data to be plotted in an order that makes the most visual
sense.
Specifying a legend
will override the standard
parsing of the addTA call to attempt a guess at a suitable
title for the sub-chart. Specifying this will cause the standard
last value to not be printed.
The ... arg to addTA
is used to set graphical parameters
interpretable by lines
.
newTA
acts as more of a skeleton function, taking
functions as arguments, as well as charting parameters,
and returns a function that can be called in the same
manner as the built-in TA tools, such as addRSI
and
addMACD
. Essentially a dynamic code generator
that allows for highly customizable chart tools with
minimal (possibly zero) coding. It is also possible
to modify the resultant code to further change behavior.
To create a new TA function with newTA
certain arguments
must be specified.
The FUN
argument is a function symbol (or coercible to such)
that is the primary filter to be used on the core-data of a chartSeries
chart. This can be like most of the functions
within the TTR package — e.g. RSI or EMA. The resultant object
of the function call will be equal to calling the function
on the original data passed into the chartSeries function that created the
chart. It should be coercible to a matrix object, of one or more
columns of output. By default all columns of output will be added to the chart,
unless suppressed by passing the appropriately positioned type='n'
as
the ... arg. Note that this will not suppress the labels added to the chart.
The preFUN
argument will be called on the main chart's data prior
to passing it to FUN. This must be a function symbol or a character
string of the name function to be called.
The postFUN
argument will be called on the resultant data
returned from the FUN
filter. This is useful for extracting
the relevant data from the returned filter data. Like preFUN
it must be a function symbol or a character string of the name
of the function to be called.
The yrange
argument is used to provide a custom
scale to the y-axis. If NULL
the min and
max of the data to be plotted will be used for the y-axis
range.
The on
is used to identify which subchart to add the
graphic to. By default, on=NA
will draw the series
in a new subchart below the last indicator. Setting this
to either a positive or negative value will allow for
the series to be super-imposed on, or under, the (sub)chart
specified, respectively. A value of 1 refers to the main chart, and at present
is the only location supported.
legend.name
will change the main label for a new plot.
fdots
and cdots
enable inclusion or suppression
of the ... within the resulting TA code's call to FUN
,
or the argument list of the new TA function, respectively.
In order to facilitate user-specified graphical
parameters it is usually desireable to not impose
artificial limits on the end-user
with constraints on types of parameters available.
By default the new TA function will include the dots
argument, and the internal FUN call will keep all arguments, including
the dots. This may pose issues if the internal function then
passes those ... arguments to a function that can't handle them.
The final argument is data.at
which is the position
in the FUN
argument list which expects the data
to be passed in at. This default to the sensible
first position, though can be changed at the time of creation
by setting this argument to the required value.
While the above functions are usually sufficient
to construct very pleasing graphical additions to
a chart, it may be necessary to modify by-hand
the code produced. This can be accomplished by
dumping the function to a file, or using fix
on it during an interactive session.
Another item of note, with respect to newTA
is the
naming of the main legend label. Following
addTA convention, the first ‘add’ is stripped
from the function name, and the rest of the call's
name is used as the label. This can be overridden
by specifying legend.name
in the construction
of the new TA call, or by passing legend
into
the new TA function. Subtle differences exist, with
the former being the preferred solution.
While both functions can be used to build new indicators without any understanding of the internal chartSeries process, it may be beneficial in more complex cases to have a knowledge of the multi-step process involved in creating a chart via chartSeries.
to be added...
addTA
will invisibly return an S4 object of
class chobTA
. If this function is called
interactively, the chobTA
object will be
evaluated and added to the current chart.
newTA
will return a function object that
can either be assigned or evaluated. Evaluating
this function will follow the logic of any standard
addTA-style call, returning invisibly a chobTA
object, or adding to the chart.
Both interfaces are meant to fascilitate custom
chart additions. addTA
is for
adding any arbitrary series to a chart, where-as
newTA
works with the underlying series with
the main chart object. The latter also
acts as a dynamic TA skeleton generation tool
to help develop reusable TA generation code
for use on any chart.
Jeffrey A. Ryan
chartSeries
,
TA
,
chob
,
chobTA
## Not run: getSymbols('SBUX') barChart(SBUX) addTA(EMA(Cl(SBUX)), on=1, col=6) addTA(OpCl(SBUX), col=4, type='b', lwd=2) # create new EMA TA function newEMA <- newTA(EMA, Cl, on=1, col=7) newEMA() newEMA(on=NA, col=5) ## End(Not run)


I was working on a problem where I had to code a function that would find multiples of 3, 5 and 15 in a set of numbers and then assign those multiples three different words (Fizz, Buzz or Fizzbuzz). I had already made the function to find the specified numbers and return the associated words. But I was struggling to figure out how to pass the set (array) of numbers into that function.
I had tried writing some pseudocode and breaking down what I had to do step by step, but I couldn’t quite wrap my head around exactly what I had to do, I then tried googling and looking at some other solutions online as well as at the supplied solution. Once I had looked at a few other methods and solutions, I would then try and reverse engineer it, until I understood what was going on and what steps I would have to take. It turns out I just had to use a ‘for loop’ to pass the numbers from the supplied array through my FizzBuzz function. That would then equate them to the new array I had made, which would return the new set.
At the beginning I was excited to try and solve the problem. That was then followed by a lot of frustration when I was not sure what to do next. Then some relief once I had spent some time trying to understand other solutions and methods and begun to understand what I needed to do.
What did I learn? That if you get stuck on a problem, chances are someone else out there has gone through a similar thing. So there is probably a solution out there you can break down, understand and implement that will also fit your own problem.
Tell your non tech friend a story about a time you solved a problem in an elegant way?Not sure if it was really elegant, but I was working on the same problem where I had to code a function that would find multiples of 3, 5 and 15 in a set of numbers and then assign those multiples three different words (Fizz, Buzz or Fizzbuzz).
But in this half of the problem I had a clearer idea of what to do, I knew a pretty straight forward way to solve it would be using an if/else statement. So I wrote out the steps I would need to take in pseudocode as well as breaking down the correct code I would have to use. I would often try and break now each of the steps into more complete sentences in the pseudocode almost as if I was explaining it to another person that was not familiar with it, to help ensure I fully understood each of the steps.
It was reassuring to be able to breakdown half of the problem and understand what I needed to do, and really helped me realise that writing down and creating a plan of how you are going to tackle a problem can lead to you more clearly understanding it.
Reflect on how confident you feel using the problem solving techniques and process:Pseudocode is usually the first technique I will try and so far I have found it really helpful when solving a new problem.
Trying something: 5/10More often than not I feel like I don’t yet have the necessary insight or I’m not sure of the right method to solve it straight away. But as I get more confident in my ability, I’m hoping that will change.
Rubber ducky method: 5/10At the moment I have almost been using pseudocode as a stand in for a rubber ducky and have been trying to explain my thought process within that, then reading it back aloud.
Reading error messages: 6/10Have been trying to use it more and more but sometimes it’s a matter of me still not knowing what the error is pointing to exactly.
Console.logging: 7/10Have found it helpful so far but I know I should probably be using more than I currently have been.
Googling: 8/10Probably the process I use the most when I don’t understand a concept or problem.
Asking your peers for help: n/aHave not really relied on this so far, I’m sure everyone would be more than happy to help. But so far I have gravitated towards the other methods before this one. Something to improve upon.
Asking coaches for help: 8/10Have been really helpful and there have been a few instances where I have reached out to my facilitator for some guidance and clarification throughout the sprints.
Improving your process with reflection: 8/10Something that has been really useful so far, especially in trying to retain so much new content within a short amount of time.


The Batman Figure
Fans of DC Multiverse Batman the Animated Series will want to add this Batman Figure to their collection. When two shots rang out, Bruce Wayne’s life changed forever. He pledged himself to justice and he has upheld that oath for years. Wearing many names—the Dark Knight, the World’s Greatest Detective, the Caped Crusader—he has battled tragic foes like The Joker, The Penguin, Mr. Freeze, and so many more. But deep inside, he knows that he shares something with them that most of humanity wouldn’t understand—a commitment to the fight.
Price: £29.99
When his parents were gunned down in front of him, young Bruce Wayne resolved to rid Gotham City of the criminal element that took their lives. He trained extensively to achieve mental and physical perfection, in addition to mastering martial arts, detective techniques, and criminal psychology. Dressing as a bat to prey on criminals’ fears, Batman fights crime with the aid of specialized gadgets and vehicles, operating out of his secretive Batcave below Wayne Manor.
Price: £49.99
Fans of DC Multiverse Batman will want to add this Batman the Detective Comics Modern Figure to their collection. When two shots rang out, Bruce Wayne’s life changed forever. He pledged himself to justice and he has upheld that oath for years. Wearing many names—the Dark Knight, the World’s Greatest Detective, the Caped Crusader—he has battled tragic foes like The Joker, The Penguin, Mr. Freeze, and so many more. But deep inside, he knows that he shares something with them that most of humanity wouldn’t understand—a commitment to the fight.
Price: £84.99
Products Description
Material: PVC Appearance: Character Model Size: about 15 cm Function: collection, decoration, gift Matters needing attention: moisture, high temperature, regular cleaning.
Shipping & Delivery
Order by 5pm for standard shipping within 2-4 working days. Delivery is Monday to Friday, excluding public holidays. Any orders placed after 5pm Friday and over the weekend will not be dispatched until Monday, excluding Public Holidays. We will make every effort to deliver all your items together and at the same time, however in some cases your order may arrive in separate consignments.


This section is used to specify the field or the method which is used to set or get the correlation header.
The access type can be a field or a method
package com.packagename;
public class CustomPayload {
     private String correlationKey; // Will be used for custom correlation.
     String key getCorrelationKey() {
         return correlationKey;
     }
}
In the example above the method 'setCorrelationKey(String key)' of class 'com.packagename.CustomPayload' is the method which will be used to set the payload.
Values to put in this section of the tool for the above example:
Access Type: method
Parameters Types:
Access Method Name: getCorrelationKey
Also as in the example above the field correlationKey of class 'com.packagename.CustomPayload' can directly be used to set the payload as well.
Values to put in this section of the tool for the above example:
Access Type: field
Parameters Type: String key
Field Name: correlationKey


--- layout: default title: Resources permalink: /resources/ ---
| Number | Notebook | Data/Model | Exercises & Extra-curriculum | Slides |
|---|---|---|---|---|
| 00 | TensorFlow Fundamentals | Go to exercises & extra-curriculum | Go to slides | |
| 01 | TensorFlow Regression | Go to exercises & extra-curriculum | Go to slides | |
| 02 | TensorFlow Classification | Go to exercises & extra-curriculum | Go to slides | |
| 03 | TensorFlow Computer Vision | pizza_steak, 10_food_classes_all_data | Go to exercises & extra-curriculum | Go to slides |
| 04 | Transfer Learning Part 1: Feature extraction | 10_food_classes_10_percent | Go to exercises & extra-curriculum | Go to slides |
| 05 | Transfer Learning Part 2: Fine Tuning | 10_food_classes_10_percent, 10_food_classes_1_percent, 10_food_classes_all_data | Go to exercises & extra-curriculum | Go to slides |
| 06 | Transfer Learning Part 3: Scaling up | 101_food_classes_10_percent, custom_food_images, fine_tuned_efficientnet_model | Go to exercises & extra-curriculum | Go to slides |
| 07 | Milestone Project 1: 🍔👁 Food Vision, Template (your challenge) | feature_extraction_mixed_precision_efficientnet_model , fine_tuned_mixed_precision_efficientnet_model | Go to exercises & extra-curriculum | Go to slides |
| 08 | TensorFlow NLP Fundamentals | diaster_or_no_diaster_tweets | Go to exercises & extra-curriculum | Go to slides |
| 09 | TensorFlow NLP Fundamentals | Go to exercises & extra-curriculum | Go to slides | |
| 10 | TensorFlow Time Series Fundamentals & Milestone Project 3 (coming soon) | Go to exercises & extra-curriculum | Go to slides |