# System/ReleaseNotes/J903

< System | ReleaseNotes

J903 beta development started in Dec 2020, and 903-beta-a was released 21 Dec 2020.

## Changes to the J engine

**Summary of Changes to the J Language in the release**

**New foreigns**`9!:4`and`9!:5`support Nameref Caching, a way of avoiding name-lookup overhead especially useful when you have many locatives or long search paths.**New foreign**`u 4!:8`(adverb) produces a cached reference to`u`**Old foreigns**`2!:2`and`2!:3`are removed from the language`+/!.0 y`performs(addition with improved accuracy)**compensated summation**`x +/@:*"1!.0 y`performs the computation at twice the precision of floats`x i.!.1 y`assumes that`x`and`y`are both in nondescending order; faster when cells are integer lists. Supports IRS.

** unreleased work in progress**

- bitwise booleans
`x m b. y`implemented with 256-bit instructions (AVX and AVX2 only only) - comparison combinations on bytes performed with word-wide comparisons

** J903 beta-i (the current beta) **

- (64-bit only)
`x ([ -. -.) y`is implemented as a member of the`i.`-family, performing only one hash - (AVX2 only) all loops for arithmetic primitives with heterogeneous arguments recoded, faster
`(> y)`rewritten to avoid needless copying of fill- (AVX2 only) all loops for arithmetic primitives rewritten with better addressing modes, faster
- (64-bit only) special code for
`-.&n`reinstated, applying also to`([ -. -.)&n` - Precomputed searches (
`m&i.`, (`e.&n`, (`i.&1@:>&n`, etc) support comparison tolerance

** J903 beta-h**

- (AVX2 only)
`+/\ y`,`<./\ y`, and`>./\ y`on float lists rewritten - (AVX2 only) all loops for arithmetic primitives with homogeneous arguments recoded, much faster on inplace arguments
- (AVX2 only) internal memory-copying routine rewritten, faster for all sizes, but especially for non-multiples of 32 bytes

** J903 beta-g **

- search for private names faster
- debut of
: pre-parsed parenthesized primitives. Parenthesized expressions that contain only primitives and do not cause executions of a verb (thus**PPPP**`(+/ % #)`but not`(i. 1e8)`) are parsed when an explicit entity is defined, avoiding the overhead of parsing each time the sentence is executed - arithmetic dyads
`+ - % * >. <.`coded to use 256-bit instructions when one argument is float and the other is integer (AVX2 only) `+./\ y`,`*./\ y`,`=/\ y`,`~:/\ y`recoded for boolean arrays of rank >1- All atomic suffix scans
`f/\. y`recoded for boolean arrays of rank >1 `=/\ y`and`~:/\ y`recoded for boolean list arguments

** J903 beta-f **

- fix blunder in
`assert.`: sentence no longer executed if`0=9!:34''` - cached namerefs expose some of the value's characteristics to combining modifiers: IRS and immediate-opening
`x i.!.1 y`assumes that`x`and`y`are both in nondescending order; faster when cells are integer lists. Supports IRS.- Name lookups using the search path recoded, reducing the number of searches; Bloom filter added to public locales to allow fast skipping of locales with few names

** J903 beta-e **

`+/ y`,`<./ y`, and`>./ y`for floating-point`y`with rank >1 rewritten to use less cache bandwidth, >2x faster`+/!.0 y`performs(addition with improved accuracy)**compensated summation**`x +/@:*"1!.0 y`performs the computation at twice the precision of floats

** J903 beta-d**

`x ]\ y`,`x [\ y`, and`x ,\ y`return a virtual result when`x<0`and there is no shard`f/ y`faster on boolean arrays of rank >1 when`f`is a primitive logical operation`+/ y`rewritten for boolean y, faster- special code for
`x f/@:g y`with atomic`f`&`g`rewritten. Most special cases removed, as they are no longer faster than the normal code. Special code is used only when`g`cannot be executed in place. **New foreigns**`9!:4`and`9!:5`support nameref caching, a way of avoiding name-lookup overhead especially useful when you have many locatives or long search paths. Put`". :: 1:'9!:5(1)'`at the top of your script to see if you can use the feature.**New foreign**`u 4!:8`(adverb) produces a cached reference to`u`**Old foreigns**`2!:2`and`2!:3`are removed from the language`|. y`executes in place where possible`u"n`is identical to`u`when`n`equals the ranks of`u`. If you need to generate a compound, use`u"v`.- in
`for_xyz.`loops, a virtual block is used for`xyz`, and`xyz_index`cannot be modified inside the loop - Code for
`atomic/"1 y`when 1-cells of`y`have length 2 rewritten

** J903 beta-c withdrawn **

** J903 beta-b withdrawn **

** J903 beta-a **