text:
# v1.4.0 - 2020-10-16

## Standard library additions and changes

- Added some enhancements to `std/jsonutils` module.
  * Added a possibility to deserialize JSON arrays directly to `HashSet` and
    `OrderedSet` types and respectively to serialize those types to JSON arrays
    via `jsonutils.fromJson` and `jsonutils.toJson` procedures.
  * Added a possibility to deserialize JSON `null` objects to Nim option objects
    and respectively to serialize Nim option object to JSON object if `isSome`
    or to JSON null object if `isNone` via `jsonutils.fromJson` and
    `jsonutils.toJson` procedures.
  * Added a `Joptions` parameter to `jsonutils.fromJson` currently
    containing two boolean options `allowExtraKeys` and `allowMissingKeys`.
    - If `allowExtraKeys` is `true` Nim's object to which the JSON is parsed is
      not required to have a field for every JSON key.
    - If `allowMissingKeys` is `true` Nim's object to which JSON is parsed is
      allowed to have fields without corresponding JSON keys.
- Added `bindParams`, `bindParam` to `db_sqlite` for binding parameters into a `SqlPrepared` statement.
- Added `tryInsert`,`insert` procs to `db_*` libs which accept primary key column name.
- Added `xmltree.newVerbatimText` support create `style`'s,`script`'s text.
- `uri` module now implements RFC-2397.
- Added [DOM Parser](https://developer.mozilla.org/en-US/docs/Web/API/DOMParser)
  to the `dom` module for the JavaScript target.
- The default hash for `Ordinal` has changed to something more bit-scrambling.
  `import hashes; proc hash(x: myInt): Hash = hashIdentity(x)` recovers the old
  one in an instantiation context while `-d:nimIntHash1` recovers it globally.
- `deques.peekFirst` and `deques.peekLast` now have `var Deque[T] -> var T` overloads.
- File handles created from high-level abstractions in the stdlib will no longer
  be inherited by child processes. In particular, these modules are affected:
  `asyncdispatch`, `asyncnet`, `system`, `nativesockets`, `net` and `selectors`.

  For `asyncdispatch`, `asyncnet`, `net` and `nativesockets`, an `inheritable`
  flag has been added to all `proc`s that create sockets, allowing the user to
  control whether the resulting socket is inheritable. This flag is provided to
  ease the writing of multi-process servers, where sockets inheritance is
  desired.

  For a transition period, define `nimInheritHandles` to enable file handle
  inheritance by default. This flag does **not** affect the `selectors` module
  due to the differing semantics between operating systems.

  `asyncdispatch.setInheritable`, `system.setInheritable` and
  `nativesockets.setInheritable` are also introduced for setting file handle or
  socket inheritance. Not all platforms have these `proc`s defined.

- The file descriptors created for internal bookkeeping by `ioselector_kqueue`
  and `ioselector_epoll` will no longer be leaked to child processes.

- `strutils.formatFloat` with `precision = 0` has been restored to the version
  1 behaviour that produces a trailing dot, e.g. `formatFloat(3.14159, precision = 0)`
  is now `3.`, not `3`.
- Added `commonPrefixLen` to `critbits`.

- `relativePath(rel, abs)` and `relativePath(abs, rel)` used to silently give wrong results
  (see #13222); instead they now use `getCurrentDir` to resolve those cases,
  and this can now throw in edge cases where `getCurrentDir` throws.
  `relativePath` also now works for js with `-d:nodejs`.

- JavaScript and NimScript standard library changes: `streams.StringStream` is
  now supported in JavaScript, with the limitation that any buffer `pointer`s
  used must be castable to `ptr string`, any incompatible pointer type will not
  work. The `lexbase` and `streams` modules used to fail to compile on
  NimScript due to a bug, but this has been fixed.

  The following modules now compile on both JS and NimScript: `parsecsv`,
  `parsecfg`, `parsesql`, `xmlparser`, `htmlparser` and `ropes`. Additionally
  supported for JS is `cstrutils.startsWith` and `cstrutils.endsWith`, for
  NimScript: `json`, `parsejson`, `strtabs` and `unidecode`.

- Added `streams.readStr` and `streams.peekStr` overloads to
  accept an existing string to modify, which avoids memory
  allocations, similar to `streams.readLine` (#13857).

- Added high-level `asyncnet.sendTo` and `asyncnet.recvFrom` UDP functionality.

- `dollars.$` now works for unsigned ints with `nim js`.

- Improvements to the `bitops` module, including bitslices, non-mutating versions
  of the original masking functions, `mask`/`masked`, and varargs support for
  `bitand`, `bitor`, and `bitxor`.

- `sugar.=>` and `sugar.->` changes: Previously `(x, y: int)` was transformed
  into `(x: auto, y: int)`, it now becomes `(x: int, y: int)` for consistency
  with regular proc definitions (although you cannot use semicolons).

  Pragmas and using a name are now allowed on the lefthand side of `=>`. Here
  is an example of these changes:
  ```nim
  import sugar

  foo(x, y: int) {.noSideEffect.} => x + y

  # is transformed into

  proc foo(x: int, y: int): auto {.noSideEffect.} = x + y
  ```

- The fields of `times.DateTime` are now private, and are accessed with getters and deprecated setters.

- The `times` module now handles the default value for `DateTime` more consistently.
  Most procs raise an assertion error when given
  an uninitialized `DateTime`, the exceptions are `==` and `$` (which returns `"Uninitialized DateTime"`).
  The proc `times.isInitialized` has been added which can be used to check if
  a `DateTime` has been initialized.

- Fix a bug where calling `close` on io streams in `osproc.startProcess` was a noop and led to
  hangs if a process had both reads from stdin and writes (e.g. to stdout).

- The callback that is passed to `system.onThreadDestruction` must now be `.raises: []`.
- The callback that is assigned to `system.onUnhandledException` must now be `.gcsafe`.

- `osproc.execCmdEx` now takes an optional `input` for stdin, `workingDir` and `env`
  parameters.

- Added a `ssl_config` module containing lists of secure ciphers as recommended by
  [Mozilla OpSec](https://wiki.mozilla.org/Security/Server_Side_TLS)

- `net.newContext` now defaults to the list of ciphers targeting
  ["Intermediate compatibility"](https://wiki.mozilla.org/Security/Server_Side_TLS#Intermediate_compatibility_.28recommended.29)
  per Mozilla's recommendation instead of `ALL`. This change should protect
  users from the use of weak and insecure ciphers while still provides
  adequate compatibility with the majority of the Internet.

- A new module `std/jsonutils` with hookable `jsonTo,toJson,fromJson` operations for json
  serialization/deserialization of custom types was added.

- A new proc `heapqueue.find[T](heap: HeapQueue[T], x: T): int` to get index of element ``x``
  was added.
- Added `rstgen.rstToLatex` a convenience proc for `renderRstToOut` and `initRstGenerator`.
- Added `os.normalizeExe`.
- `macros.newLit` now preserves named vs unnamed tuples.
- Added `random.gauss`, that uses the ratio of uniforms method of sampling from a Gaussian distribution.
- Added `typetraits.elementType` to get the element type of an iterable.
- `typetraits.$` changes: `$(int,)` is now `"(int,)"` instead of `"(int)"`;
  `$tuple[]` is now `"tuple[]"` instead of `"tuple"`;
  `$((int, float), int)` is now `"((int, float), int)"` instead of `"(tuple of (int, float), int)"`
- Added `macros.extractDocCommentsAndRunnables` helper.

- `strformat.fmt` and `strformat.&` support `specifier =`. `fmt"{expr=}"` now
  expands to `fmt"expr={expr}"`.
- Deprecations: instead of `os.existsDir` use `dirExists`, instead of `os.existsFile` use `fileExists`.

- Added the `jsre` module, [Regular Expressions for the JavaScript target.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions).
- Made `maxLines` argument `Positive` in `logging.newRollingFileLogger`,
  because negative values will result in a new file being created for each logged
  line which doesn't make sense.
- Changed `log` in `logging` to use proper log level for JavaScript,
  e.g. `debug` uses `console.debug`, `info` uses `console.info`, `warn` uses `console.warn`, etc.
- Tables, HashSets, SharedTables and deques don't require anymore that the passed
  initial size must be a power of two - this is done internally.
  Proc `rightSize` for Tables and HashSets is deprecated, as it is not needed anymore.
  `CountTable.inc` takes `val: int` again not `val: Positive`; i.e. it can "count down" again.
- Removed deprecated symbols from `macros` module, some of which were deprecated already in `0.15`.
- Removed `sugar.distinctBase`, deprecated since `0.19`. Use `typetraits.distinctBase`.
- `asyncdispatch.PDispatcher.handles` is exported so that an external low-level libraries can access it.

- `std/with`, `sugar.dup` now support object field assignment expressions:
  ```nim
  import std/with

  type Foo = object
    x, y: int

  var foo = Foo()
  with foo:
    x = 10
    y = 20

  echo foo
  ```

- Proc `math.round` is no longer deprecated. The advice to use `strformat` instead
  cannot be applied to every use case. The limitations and the (lack of) reliability
  of `round` are well documented.

- Added `getprotobyname` to `winlean`. Added `getProtoByname` to `nativesockets` which returns a protocol code
  from the database that matches the protocol `name`.

- Added missing attributes and methods to `dom.Navigator` like `deviceMemory`, `onLine`, `vibrate()`, etc.

- Added `strutils.indentation` and `strutils.dedent` which enable indented string literals:
  ```nim
  import strutils
  echo dedent """
    This
      is
        cool!
    """
  ```

- Added `initUri(isIpv6: bool)` to `uri` module, now `uri` supports parsing ipv6 hostname.

- Added `readLines(p: Process)` to `osproc`.

- Added the below `toX` procs for collections. The usage is similar to procs such as
  `sets.toHashSet` and `tables.toTable`. Previously, it was necessary to create the
  respective empty collection and add items manually.
    * `critbits.toCritBitTree`, which creates a `CritBitTree` from an `openArray` of
       items or an `openArray` of pairs.
    * `deques.toDeque`, which creates a `Deque` from an `openArray`.
    * `heapqueue.toHeapQueue`, which creates a `HeapQueue` from an `openArray`.
    * `intsets.toIntSet`, which creates an `IntSet` from an `openArray`.

- Added `progressInterval` argument to `asyncftpclient.newAsyncFtpClient` to control the interval
  at which progress callbacks are called.

- Added `os.copyFileToDir`.

## Language changes

- The `=destroy` hook no longer has to reset its target, as the compiler now automatically inserts
  `wasMoved` calls where needed.
- The `=` hook is now called `=copy` for clarity. The old name `=` is still available so there
  is no need to update your code. This change was backported to 1.2 too so you can use the
  more readable `=copy` without loss of compatibility.

- In the newruntime it is now allowed to assign to the discriminator field
  without restrictions as long as the case object doesn't have a custom destructor.
  The discriminator value doesn't have to be a constant either. If you have a
  custom destructor for a case object and you do want to freely assign discriminator
  fields, it is recommended to refactor the object into 2 objects like this:

  ```nim
  type
    MyObj = object
      case kind: bool
      of true: y: ptr UncheckedArray[float]
      of false: z: seq[int]

  proc `=destroy`(x: MyObj) =
    if x.kind and x.y != nil:
      deallocShared(x.y)
  ```
  Refactor into:
  ```nim
  type
    MySubObj = object
      val: ptr UncheckedArray[float]
    MyObj = object
      case kind: bool
      of true: y: MySubObj
      of false: z: seq[int]

  proc `=destroy`(x: MySubObj) =
    if x.val != nil:
      deallocShared(x.val)
  ```
- `getImpl` on enum type symbols now returns field syms instead of idents. This helps
  with writing typed macros. The old behavior for backwards compatibility can be restored
  with `--useVersion:1.0`.
- The typed AST for proc headers will now have the arguments be syms instead of idents.
  This helps with writing typed macros. The old behaviour for backwards compatibility can
  be restored with `--useVersion:1.0`.
- ``let`` statements can now be used without a value if declared with
  ``importc``/``importcpp``/``importjs``/``importobjc``.
- The keyword `from` is now usable as an operator.
 This is more consistent with the
  built-in operations. The following always used to compile (and still does):
  ```nim
  proc mydiv(a, b): int {.raises: [].} =
    a div b # can raise an DivByZeroDefect
  ```

  Now also this compiles:
  ```nim
  proc mydiv(a, b): int {.raises: [].} =
    if b == 0: raise newException(DivByZeroDefect, "division by zero")
    else: result = a div b
  ```

  The reason for this is that `DivByZeroDefect` inherits from `Defect` and
  with `--panics:on` `Defects` become unrecoverable errors.

- Added the `thiscall` calling convention as specified by Microsoft, mostly for hooking purposes.
- Deprecated the `{.unroll.}` pragma, because it was always ignored by the compiler anyway.
- Removed the deprecated `strutils.isNilOrWhitespace`.
- Removed the deprecated `sharedtables.initSharedTable`.
- Removed the deprecated `asyncdispatch.newAsyncNativeSocket`.
- Removed the deprecated `dom.releaseEvents` and `dom.captureEvents`.

- Removed `sharedlist.initSharedList`, was deprecated and produces undefined behaviour.

- There is a new experimental feature called "strictFuncs" which makes the definition of
  `.noSideEffect` stricter. [See here](manual_experimental.html#stricts-funcs)
  for more information.

- "for-loop macros" (see [the manual](manual.html#macros-for-loop-macros)) are no longer
  an experimental feature. In other words, you don't have to write pragma
  `{.experimental: "forLoopMacros".}` if you want to use them.

- Added the ``.noalias`` pragma. It is mapped to C's ``restrict`` keyword for the increased
  performance this keyword can enable.

- `items` no longer compiles with enums with holes as its behavior was error prone, see #14004.
- `system.deepcopy` has to be enabled explicitly for `--gc:arc` and `--gc:orc` via
  `--deepcopy:on`.

- Added the `std/effecttraits` module for introspection of the inferred effects.
  We hope this enables `async` macros that are precise about the possible exceptions that
  can be raised.
- The pragma blocks `{.gcsafe.}: ...` and `{.noSideEffect.}: ...` can now also be
  written as `{.cast(gcsafe).}: ...` and `{.cast(noSideEffect).}: ...`. This is the new
  preferred way of writing these, emphasizing their unsafe nature.

## Compiler changes

- Specific warnings can now be turned into errors via `--warningAsError[X]:on|off`.
- The `define` and `undef` pragmas have been de-deprecated.
- New command: `nim r main.nim [args...]` which compiles and runs main.nim, and implies `--usenimcache`
  so that the output is saved to $nimcache/main$exeExt, using the same logic as `nim c -r` to
  avoid recompilations when sources don't change.
  Example:
  ```bash
  nim r compiler/nim.nim --help # only compiled the first time
  echo 'import os; echo getCurrentCompilerExe()' | nim r - # this works too
  nim r compiler/nim.nim --fullhelp # no recompilation
  nim r --nimcache:/tmp main # binary saved to /tmp/main
  ```
- `--hint:processing` is now supported and means `--hint:processing:on`
  (likewise with other hints and warnings), which is consistent with all other bool flags.
  (since 1.3.3).
- `nim doc -r main` and `nim rst2html -r main` now call `openDefaultBrowser`.
- Added the new hint `--hint:msgOrigin` will show where a compiler msg (hint|warning|error)
  was generated; this helps in particular when it's non obvious where it came from
  either because multiple locations generate the same message, or because the
  message involves runtime formatting.
- Added the new flag `--backend:js|c|cpp|objc` (or -b:js etc), to change the backend; can be
  used with any command (e.g. nim r, doc, check etc); safe to re-assign.
- Added the new flag `--doccmd:cmd` to pass additional flags for runnableExamples,
  e.g.: `--doccmd:-d:foo --threads`
  use `--doccmd:skip` to skip runnableExamples and rst test snippets.
- Added the new flag `--usenimcache` to output binary files to nimcache.
- `runnableExamples "-b:cpp -r:off": code` is now supported, allowing to override
  how an example is compiled and run, for example to change the backend.
- `nim doc` now outputs under `$projectPath/htmldocs` when `--outdir` is unspecified
  (with or without `--project`); passing `--project` now automatically generates
  an index and enables search.
  See [docgen](docgen.html#introduction-quick-start) for details.
- Removed the `--oldNewlines` switch.
- Removed the `--laxStrings` switch for mutating the internal zero terminator on strings.
- Removed the `--oldast` switch.
- Removed the `--oldgensym` switch.
- `$getType(untyped)` is now "untyped" instead of "expr", `$getType(typed)` is
  now "typed" instead of "stmt".
- Sink inference is now disabled per default and has to enabled explicitly via
  `--sinkInference:on`. *Note*: For the standard library sink inference remains
  enabled. This change is most relevant for the `--gc:arc`, `--gc:orc` memory
  management modes.

## Tool changes

- `nimsuggest` now returns both the forward declaration and the
  implementation location upon a `def` query. Previously the behavior was
  to return the forward declaration only.

## Bugfixes

- Fixed "repr() not available for uint{,8,16,32,64} under --gc:arc"
  ([#13872](https://github.com/nim-lang/Nim/issues/13872))
- Fixed "Critical: 1 completed Future, multiple await: Only 1 await will be awakened (the last one)"
  ([#13889](https://github.com/nim-lang/Nim/issues/13889))
- Fixed "crash on openarray interator with argument in stmtListExpr"
  ([#13739](https://github.com/nim-lang/Nim/issues/13739))
- Fixed "Some compilers on Windows don't work"
  ([#13910](https://github.com/nim-lang/Nim/issues/13910))
- Fixed "httpclient hangs if it recieves an HTTP 204 (No Content)"
  ([#13894](https://github.com/nim-lang/Nim/issues/13894))
- Fixed ""distinct uint64" type corruption on 32-bit, when using {.borrow.} operators"
  ([#13902](https://github.com/nim-lang/Nim/issues/13902))
- Fixed "Regression: impossible to use typed pragmas with proc types"
  ([#13909](https://github.com/nim-lang/Nim/issues/13909))
- Fixed "openssl wrapper corrupts stack on OpenSSL 1.1.1f + Android"
  ([#13903](https://github.com/nim-lang/Nim/issues/13903))
- Fixed "C compile error with --gc:arc on version 1.2.0 "unknown type name 'TGenericSeq'"
  ([#13863](https://github.com/nim-lang/Nim/issues/13863))
- Fixed "var return type for proc doesn't work at c++ backend"
  ([#13848](https://github.com/nim-lang/Nim/issues/13848))
- Fixed "TimeFormat() should raise an error but craches at compilation time"
  ([#12864](https://github.com/nim-lang/Nim/issues/12864))
- Fixed "gc:arc cannot fully support threadpool with FlowVar"
  ([#13781](https://github.com/nim-lang/Nim/issues/13781))
- Fixed "simple 'var openarray[char]' assignment crash when the openarray source is a local string and using gc:arc"
  ([#14003](https://github.com/nim-lang/Nim/issues/14003))
- Fixed "Cant use expressions with `when` in `type` sections."
  ([#14007](https://github.com/nim-lang/Nim/issues/14007))
- Fixed "`for a in MyEnum` gives incorrect results with enum with holes"
  ([#14001](https://github.com/nim-lang/Nim/issues/14001))
- Fixed "Trivial crash"
  ([#12741](https://github.com/nim-lang/Nim/issues/12741))
- Fixed "Enum with holes cannot be used as Table index"
  ([#12834](https://github.com/nim-lang/Nim/issues/12834))
- Fixed "spawn proc that uses typedesc crashes the compiler"
  ([#14014](https://github.com/nim-lang/Nim/issues/14014))
- Fixed "Docs Search `Results` box styling is not Dark Mode Friendly"
  ([#13972](https://github.com/nim-lang/Nim/issues/13972))
- Fixed "--gc:arc -d:useSysAssert undeclared identifier `cstderr` with newSeq"
  ([#14038](https://github.com/nim-lang/Nim/issues/14038))
- Fixed "issues in the manual"
  ([#12486](https://github.com/nim-lang/Nim/issues/12486))
- Fixed "Annoying warning: inherit from a more precise exception type like ValueError, IOError or OSError [InheritFromException]"
  ([#14052](https://github.com/nim-lang/Nim/issues/14052))
- Fixed "relativePath("foo", "/") and relativePath("/", "foo") is wrong"
  ([#13222](https://github.com/nim-lang/Nim/issues/13222))
- Fixed "[regression] `parseEnum` does not work anymore for enums with holes"
  ([#14030](https://github.com/nim-lang/Nim/issues/14030))
- Fixed "Exception types in the stdlib should inherit from `CatchableError` or `Defect`, not `Exception`"
  ([#10288](https://github.com/nim-lang/Nim/issues/10288))
- Fixed "Make debugSend and debugRecv procs public in smtp.nim"
  ([#12189](https://github.com/nim-lang/Nim/issues/12189))
- Fixed "xmltree need add raw text, when add style element"
  ([#14064](https://github.com/nim-lang/Nim/issues/14064))
- Fixed "raises requirement does not propagate to derived methods"
  ([#8481](https://github.com/nim-lang/Nim/issues/8481))
- Fixed "tests/stdlib/tgetaddrinfo.nim fails on NetBSD"
  ([#14091](https://github.com/nim-lang/Nim/issues/14091))
- Fixed "tests/niminaction/Chapter8/sdl/sdl_test.nim fails on NetBSD"
  ([#14088](https://github.com/nim-lang/Nim/issues/14088))
- Fixed "Incorrect escape sequence for example in jsffi library documentation"
  ([#14110](https://github.com/nim-lang/Nim/issues/14110))
- Fixed "HCR: Can not link exported const, in external library"
  ([#13915](https://github.com/nim-lang/Nim/issues/13915))
- Fixed "Cannot import std/unidecode"
  ([#14112](https://github.com/nim-lang/Nim/issues/14112))
- Fixed "macOS: dsymutil should not be called on static libraries"
  ([#14132](https://github.com/nim-lang/Nim/issues/14132))
- Fixed "nim jsondoc -o:doc.json filename.nim fails when sequences without a type are used"
  ([#14066](https://github.com/nim-lang/Nim/issues/14066))
- Fixed "algorithm.sortedByIt template corrupts tuple input under --gc:arc"
  ([#14079](https://github.com/nim-lang/Nim/issues/14079))
- Fixed "Invalid C code with lvalue conversion"
  ([#14160](https://github.com/nim-lang/Nim/issues/14160))
- Fixed "strformat: doc example fails"
  ([#14054](https://github.com/nim-lang/Nim/issues/14054))
- Fixed "Nim doc fail to run for nim 1.2.0 (nim 1.0.4 is ok)"
  ([#13986](https://github.com/nim-lang/Nim/issues/13986))
- Fixed "Exception when converting csize to clong"
  ([#13698](https://github.com/nim-lang/Nim/issues/13698))
- Fixed "[Documentation] overloading using named arguments works but is not documented"
  ([#11932](https://github.com/nim-lang/Nim/issues/11932))
- Fixed "import os + use of existsDir/dirExists/existsFile/fileExists/findExe in config.nims causes "ambiguous call' error"
  ([#14142](https://github.com/nim-lang/Nim/issues/14142))
- Fixed "import os + use of existsDir/dirExists/existsFile/fileExists/findExe in config.nims causes "ambiguous call' error"
  ([#14142](https://github.com/nim-lang/Nim/issues/14142))
- Fixed "runnableExamples doc gen crashes compiler with `except Exception as e` syntax"
  ([#14177](https://github.com/nim-lang/Nim/issues/14177))
- Fixed "[ARC] Segfault with cyclic references (?)"
  ([#14159](https://github.com/nim-lang/Nim/issues/14159))
- Fixed "Semcheck regression when accessing a static parameter in proc"
  ([#14136](https://github.com/nim-lang/Nim/issues/14136))
- Fixed "iterator walkDir doesn't work with -d:useWinAnsi"
  ([#14201](https://github.com/nim-lang/Nim/issues/14201))
- Fixed "cas is wrong for tcc"
  ([#14151](https://github.com/nim-lang/Nim/issues/14151))
- Fixed "proc execCmdEx doesn't work with -d:useWinAnsi"
  ([#14203](https://github.com/nim-lang/Nim/issues/14203))
- Fixed "Use -d:nimEmulateOverflowChecks by default?"
  ([#14209](https://github.com/nim-lang/Nim/issues/14209))
- Fixed "Old sequences with destructor objects bug"
  ([#14217](https://github.com/nim-lang/Nim/issues/14217))
- Fixed "[ARC] ICE when changing the discriminant of a return value"
  ([#14244](https://github.com/nim-lang/Nim/issues/14244))
- Fixed "[ARC] ICE with static objects"
  ([#14236](https://github.com/nim-lang/Nim/issues/14236))
- Fixed "[ARC] "internal error: environment misses: a" in a finalizer"
  ([#14243](https://github.com/nim-lang/Nim/issues/14243))
- Fixed "[ARC] compile failure using repr with object containing `ref seq[string]`"
  ([#14270](https://github.com/nim-lang/Nim/issues/14270))
- Fixed "[ARC] implicit move on last use happening on non-last use"
  ([#14269](https://github.com/nim-lang/Nim/issues/14269))
- Fixed "[ARC] Compiler crash with a recursive non-ref object variant"
  ([#14294](https://github.com/nim-lang/Nim/issues/14294))
- Fixed "htmlparser.parseHtml behaves differently using --gc:arc or --gc:orc"
  ([#13946](https://github.com/nim-lang/Nim/issues/13946))
- Fixed "Invalid return value of openProcess is NULL rather than INVALID_HANDLE_VALUE(-1) in windows"
  ([#14289](https://github.com/nim-lang/Nim/issues/14289))
- Fixed "ARC codegen bug with inline iterators"
  ([#14219](https://github.com/nim-lang/Nim/issues/14219))
- Fixed "Building koch on OpenBSD fails unless the Nim directory is in `$PATH`"
  ([#13758](https://github.com/nim-lang/Nim/issues/13758))
- Fixed "[gc:arc] case object assignment SIGSEGV: destroy not called for primitive type "
  ([#14312](https://github.com/nim-lang/Nim/issues/14312))
- Fixed "Crash when using thread and --gc:arc "
  ([#13881](https://github.com/nim-lang/Nim/issues/13881))
- Fixed "Getting "Warning: Cannot prove that 'result' is initialized" for an importcpp'd proc with `var T` return type"
  ([#14314](https://github.com/nim-lang/Nim/issues/14314))
- Fixed "`nim cpp -r --gc:arc` segfaults on caught AssertionError"
  ([#13071](https://github.com/nim-lang/Nim/issues/13071))
- Fixed "tests/async/tasyncawait.nim is recently very flaky"
  ([#14320](https://github.com/nim-lang/Nim/issues/14320))
- Fixed "Documentation nonexistent quitprocs module"
  ([#14331](https://github.com/nim-lang/Nim/issues/14331))
- Fixed "SIGSEV encountered when creating threads in a loop w/ --gc:arc"
  ([#13935](https://github.com/nim-lang/Nim/issues/13935))
- Fixed "nim-gdb is missing from all released packages"
  ([#13104](https://github.com/nim-lang/Nim/issues/13104))
- Fixed "sysAssert error with gc:arc on 3 line program"
  ([#13862](https://github.com/nim-lang/Nim/issues/13862))
- Fixed "compiler error with inline async proc and pragma"
  ([#13998](https://github.com/nim-lang/Nim/issues/13998))
- Fixed "[ARC] Compiler crash when adding to a seq[ref Object]"
  ([#14333](https://github.com/nim-lang/Nim/issues/14333))
- Fixed "nimvm: sysFatal: unhandled exception: 'sons' is not accessible using discriminant 'kind' of type 'TNode' [FieldError]"
  ([#14340](https://github.com/nim-lang/Nim/issues/14340))
- Fixed "[Regression] karax events are not firing "
  ([#14350](https://github.com/nim-lang/Nim/issues/14350))
- Fixed "odbcsql module has some wrong integer types"
  ([#9771](https://github.com/nim-lang/Nim/issues/9771))
- Fixed "db_sqlite needs sqlPrepared"
  ([#13559](https://github.com/nim-lang/Nim/issues/13559))
- Fixed "[Regression] `createThread` is not GC-safe"
  ([#14370](https://github.com/nim-lang/Nim/issues/14370))
- Fixed "Broken example on hot code reloading"
  ([#14380](https://github.com/nim-lang/Nim/issues/14380))
- Fixed "runnableExamples block with `except` on specified error fails with `nim doc`"
  ([#12746](https://github.com/nim-lang/Nim/issues/12746))
- Fixed "compiler as a library: findNimStdLibCompileTime fails to find system.nim"
  ([#12293](https://github.com/nim-lang/Nim/issues/12293))
- Fixed "5 bugs with importcpp exceptions"
  ([#14369](https://github.com/nim-lang/Nim/issues/14369))
- Fixed "Docs shouldn't collapse pragmas inside runnableExamples/code blocks"
  ([#14174](https://github.com/nim-lang/Nim/issues/14174))
- Fixed "Bad codegen/emit for hashes.hiXorLo in some contexts."
  ([#14394](https://github.com/nim-lang/Nim/issues/14394))
- Fixed "Boehm GC does not scan thread-local storage"
  ([#14364](https://github.com/nim-lang/Nim/issues/14364))
- Fixed "RVO not exception safe"
  ([#14126](https://github.com/nim-lang/Nim/issues/14126))
- Fixed "runnableExamples that are only compiled"
  ([#10731](https://github.com/nim-lang/Nim/issues/10731))
- Fixed "`foldr` raises IndexError when called on sequence"
  ([#14404](https://github.com/nim-lang/Nim/issues/14404))
- Fixed "moveFile does not overwrite destination file"
  ([#14057](https://github.com/nim-lang/Nim/issues/14057))
- Fixed "doc2 outputs in current work dir"
  ([#6583](https://github.com/nim-lang/Nim/issues/6583))
- Fixed "[docgen] proc doc comments silently omitted after 1st runnableExamples"
  ([#9227](https://github.com/nim-lang/Nim/issues/9227))
- Fixed "`nim doc --project` shows '@@/' instead of '../' for relative paths to submodules"
  ([#14448](https://github.com/nim-lang/Nim/issues/14448))
- Fixed "re, nre have wrong `start` semantics"
  ([#14284](https://github.com/nim-lang/Nim/issues/14284))
- Fixed "runnableExamples should preserve source code doc comments, strings, and (maybe) formatting"
  ([#8871](https://github.com/nim-lang/Nim/issues/8871))
- Fixed "`nim doc ..` fails when runnableExamples uses `$`  [devel] [regression]"
  ([#14485](https://github.com/nim-lang/Nim/issues/14485))
- Fixed "`items` is 20%~30% slower than iteration via an index"
  ([#14421](https://github.com/nim-lang/Nim/issues/14421))
- Fixed "ARC: unreliable setLen "
  ([#14495](https://github.com/nim-lang/Nim/issues/14495))
- Fixed "lent is unsafe: after #14447 you can modify variables with "items" loop for sequences"
  ([#14498](https://github.com/nim-lang/Nim/issues/14498))
- Fixed "`var op = fn()` wrongly gives warning `ObservableStores` with `object of RootObj` type"
  ([#14514](https://github.com/nim-lang/Nim/issues/14514))
- Fixed "Compiler assertion"
  ([#14562](https://github.com/nim-lang/Nim/issues/14562))
- Fixed "Can't get `ord` of a value of a Range type in the JS backend "
  ([#14570](https://github.com/nim-lang/Nim/issues/14570))
- Fixed "js: can't take addr of param (including implicitly via `lent`)"
  ([#14576](https://github.com/nim-lang/Nim/issues/14576))
- Fixed "{.noinit.} ignored in for loop -> bad codegen for non-movable types"
  ([#14118](https://github.com/nim-lang/Nim/issues/14118))
- Fixed "generic destructor gives: `Error: unresolved generic parameter`"
  ([#14315](https://github.com/nim-lang/Nim/issues/14315))
- Fixed "Memory leak with arc gc"
  ([#14568](https://github.com/nim-lang/Nim/issues/14568))
- Fixed "escape analysis broken with `lent`"
  ([#14557](https://github.com/nim-lang/Nim/issues/14557))
- Fixed "`wrapWords` seems to ignore linebreaks when wrapping, leaving breaks in the wrong place"
  ([#14579](https://github.com/nim-lang/Nim/issues/14579))
- Fixed "`lent` gives wrong results with -d:release"
  ([#14578](https://github.com/nim-lang/Nim/issues/14578))
- Fixed "Nested await expressions regression: `await a(await expandValue())` doesnt compile"
  ([#14279](https://github.com/nim-lang/Nim/issues/14279))
- Fixed "windows CI docs fails with strange errors"
  ([#14545](https://github.com/nim-lang/Nim/issues/14545))
- Fixed "[CI] tests/async/tioselectors.nim flaky test for freebsd + OSX CI"
  ([#13166](https://github.com/nim-lang/Nim/issues/13166))
- Fixed "seq.setLen sometimes doesn't zero memory"
  ([#14655](https://github.com/nim-lang/Nim/issues/14655))
- Fixed "`nim dump` is roughly 100x slower in 1.3 versus 1.2"
  ([#14179](https://github.com/nim-lang/Nim/issues/14179))
- Fixed "Regression: devel docgen cannot generate document for method"
  ([#14691](https://github.com/nim-lang/Nim/issues/14691))
- Fixed "recently flaky tests/async/t7758.nim"
  ([#14685](https://github.com/nim-lang/Nim/issues/14685))
- Fixed "Bind no longer working in generic procs."
  ([#11811](https://github.com/nim-lang/Nim/issues/11811))
- Fixed "The pegs module doesn't work with generics!"
  ([#14718](https://github.com/nim-lang/Nim/issues/14718))
- Fixed "Defer is not properly working for asynchronous procedures."
  ([#13899](https://github.com/nim-lang/Nim/issues/13899))
- Fixed "Add an ARC test with threads in a loop"
  ([#14690](https://github.com/nim-lang/Nim/issues/14690))
- Fixed "[goto exceptions] {.noReturn.} pragma is not detected in a case expression"
  ([#14458](https://github.com/nim-lang/Nim/issues/14458))
- Fixed "[exceptions:goto] C compiler error with dynlib pragma calling a proc"
  ([#14240](https://github.com/nim-lang/Nim/issues/14240))
- Fixed "Cannot borrow var float64 in infix assignment"
  ([#14440](https://github.com/nim-lang/Nim/issues/14440))
- Fixed "lib/pure/memfiles.nim: compilation error with --taintMode:on"
  ([#14760](https://github.com/nim-lang/Nim/issues/14760))
- Fixed "newWideCString allocates a multiple of the memory needed"
  ([#14750](https://github.com/nim-lang/Nim/issues/14750))
- Fixed "Nim source archive install: 'install.sh' fails with error: cp: cannot stat 'bin/nim-gdb': No such file or directory"
  ([#14748](https://github.com/nim-lang/Nim/issues/14748))
- Fixed "`nim cpp -r tests/exception/t9657` hangs"
  ([#10343](https://github.com/nim-lang/Nim/issues/10343))
- Fixed "Detect tool fails on FreeBSD"
  ([#14715](https://github.com/nim-lang/Nim/issues/14715))
- Fixed "compiler crash: `findUnresolvedStatic` "
  ([#14802](https://github.com/nim-lang/Nim/issues/14802))
- Fixed "seq namespace (?) regression"
  ([#4796](https://github.com/nim-lang/Nim/issues/4796))
- Fixed "Possible out of bounds string access in std/colors parseColor and isColor"
  ([#14839](https://github.com/nim-lang/Nim/issues/14839))
- Fixed "compile error on latest devel with orc and ssl"
  ([#14647](https://github.com/nim-lang/Nim/issues/14647))
- Fixed "[minor] `$` wrong for type tuple"
  ([#13432](https://github.com/nim-lang/Nim/issues/13432))
- Fixed "Documentation missing on devel asyncftpclient"
  ([#14846](https://github.com/nim-lang/Nim/issues/14846))
- Fixed "nimpretty is confused with a trailing comma in enum definition"
  ([#14401](https://github.com/nim-lang/Nim/issues/14401))
- Fixed "Output arguments get ignored when compiling with --app:staticlib"
  ([#12745](https://github.com/nim-lang/Nim/issues/12745))
- Fixed "[ARC] destructive move destroys the object too early"
  ([#14396](https://github.com/nim-lang/Nim/issues/14396))
- Fixed "highlite.getNextToken() crashes if the buffer string is "echo "\"""
  ([#14830](https://github.com/nim-lang/Nim/issues/14830))
- Fixed "Memory corruption with --gc:arc with a seq of objects with an empty body."
  ([#14472](https://github.com/nim-lang/Nim/issues/14472))
- Fixed "Stropped identifiers don't work as field names in tuple literals"
  ([#14911](https://github.com/nim-lang/Nim/issues/14911))
- Fixed "Please revert my commit"
  ([#14930](https://github.com/nim-lang/Nim/issues/14930))
- Fixed "[ARC] C compiler error with inline iterators and imports"
  ([#14864](https://github.com/nim-lang/Nim/issues/14864))
- Fixed "AsyncHttpClient segfaults with gc:orc, possibly memory corruption"
  ([#14402](https://github.com/nim-lang/Nim/issues/14402))
- Fixed "[ARC] Template with a block evaluating to a GC'd value results in a compiler crash"
  ([#14899](https://github.com/nim-lang/Nim/issues/14899))
- Fixed "[ARC] Weird issue with if expressions and templates"
  ([#14900](https://github.com/nim-lang/Nim/issues/14900))
- Fixed "xmlparser does not compile on devel"
  ([#14805](https://github.com/nim-lang/Nim/issues/14805))
- Fixed "returning lent T from a var T param gives codegen errors or SIGSEGV"
  ([#14878](https://github.com/nim-lang/Nim/issues/14878))
- Fixed "[ARC] Weird issue with if expressions and templates"
  ([#14900](https://github.com/nim-lang/Nim/issues/14900))
- Fixed "threads:on + gc:orc + unittest = C compiler errors"
  ([#14865](https://github.com/nim-lang/Nim/issues/14865))
- Fixed "mitems, mpairs doesn't work at compile time anymore"
  ([#12129](https://github.com/nim-lang/Nim/issues/12129))
- Fixed "strange result from executing code in const expression"
  ([#10465](https://github.com/nim-lang/Nim/issues/10465))
- Fixed "Same warning printed 3 times"
  ([#11009](https://github.com/nim-lang/Nim/issues/11009))
- Fixed "type alias for generic typeclass doesn't work"
  ([#4668](https://github.com/nim-lang/Nim/issues/4668))
- Fixed "exceptions:goto Bug devel codegen lvalue NIM_FALSE=NIM_FALSE"
  ([#14925](https://github.com/nim-lang/Nim/issues/14925))
- Fixed "the --useVersion:1.0 no longer works in devel"
  ([#14912](https://github.com/nim-lang/Nim/issues/14912))
- Fixed "template declaration of iterator doesn't compile"
  ([#4722](https://github.com/nim-lang/Nim/issues/4722))
- Fixed "Compiler crash on type inheritance with static generic parameter and equality check"
  ([#12571](https://github.com/nim-lang/Nim/issues/12571))
- Fixed "Nim crashes while handling a cast in async circumstances."
  ([#13815](https://github.com/nim-lang/Nim/issues/13815))
- Fixed "[ARC] Internal compiler error when calling an iterator from an inline proc "
  ([#14383](https://github.com/nim-lang/Nim/issues/14383))
- Fixed ""Cannot instantiate" error when template uses generic type"
  ([#5926](https://github.com/nim-lang/Nim/issues/5926))
- Fixed "Different raises behaviour for newTerminal between Linux and Windows"
  ([#12759](https://github.com/nim-lang/Nim/issues/12759))
- Fixed "Expand on a type (that defines a proc type) in error message "
  ([#6608](https://github.com/nim-lang/Nim/issues/6608))
- Fixed "unittest require quits program with an exit code of 0"
  ([#14475](https://github.com/nim-lang/Nim/issues/14475))
- Fixed "Range type: Generics vs concrete type, semcheck difference."
  ([#8426](https://github.com/nim-lang/Nim/issues/8426))
- Fixed "[Macro] Type mismatch when parameter name is the same as a field"
  ([#13253](https://github.com/nim-lang/Nim/issues/13253))
- Fixed "Generic instantiation failure when converting a sequence of circular generic types to strings"
  ([#10396](https://github.com/nim-lang/Nim/issues/10396))
- Fixed "initOptParser ignores argument after value option with empty value."
  ([#13086](https://github.com/nim-lang/Nim/issues/13086))
- Fixed "[ARC] proc with both explicit and implicit return results in a C compiler error"
  ([#14985](https://github.com/nim-lang/Nim/issues/14985))
- Fixed "Alias type forgets implicit generic params depending on order"
  ([#14990](https://github.com/nim-lang/Nim/issues/14990))
- Fixed "[ARC] sequtils.insert has different behaviour between ARC/refc"
  ([#14994](https://github.com/nim-lang/Nim/issues/14994))
- Fixed "The documentation for "hot code reloading" references a non-existent npm package"
  ([#13621](https://github.com/nim-lang/Nim/issues/13621))
- Fixed "existsDir deprecated but breaking `dir` undeclared"
  ([#15006](https://github.com/nim-lang/Nim/issues/15006))
- Fixed "uri.decodeUrl crashes on incorrectly formatted input"
  ([#14082](https://github.com/nim-lang/Nim/issues/14082))
- Fixed "testament incorrectly reports time for tests, leading to wrong conclusions"
  ([#14822](https://github.com/nim-lang/Nim/issues/14822))
- Fixed "Calling peekChar with Stream returned from osproc.outputStream generate runtime error"
  ([#14906](https://github.com/nim-lang/Nim/issues/14906))
- Fixed "localPassC pragma should come *after* other flags"
  ([#14194](https://github.com/nim-lang/Nim/issues/14194))
- Fixed ""Could not load" dynamic library at runtime because of hidden dependency"
  ([#2408](https://github.com/nim-lang/Nim/issues/2408))
- Fixed "--gc:arc generate invalid code for {.global.} (`«nimErr_» in NIM_UNLIKELY`)"
  ([#14480](https://github.com/nim-lang/Nim/issues/14480))
- Fixed "Using `^` from stdlib/math along with converters gives a match for types that aren't SomeNumber"
  ([#15033](https://github.com/nim-lang/Nim/issues/15033))
- Fixed "[ARC] Weird exception behaviour from doAssertRaises"
  ([#15026](https://github.com/nim-lang/Nim/issues/15026))
- Fixed "[ARC] Compiler crash declaring a finalizer proc directly in 'new'"
  ([#15044](https://github.com/nim-lang/Nim/issues/15044))
- Fixed "[ARC] C compiler error when creating a var of a const seq"
  ([#15036](https://github.com/nim-lang/Nim/issues/15036))
- Fixed "code with named arguments in proc of winim/com can not been compiled"
  ([#15056](https://github.com/nim-lang/Nim/issues/15056))
- Fixed "javascript backend produces javascript code with syntax error in object syntax"
  ([#14534](https://github.com/nim-lang/Nim/issues/14534))
- Fixed "--gc:arc should be ignored in JS mode."
  ([#14684](https://github.com/nim-lang/Nim/issues/14684))
- Fixed "arc: C compilation error with imported global code using a closure iterator"
  ([#12990](https://github.com/nim-lang/Nim/issues/12990))
- Fixed "[ARC] Crash when modifying a string with mitems iterator"
  ([#15052](https://github.com/nim-lang/Nim/issues/15052))
- Fixed "[ARC] SIGSEGV when calling a closure as a tuple field in a seq"
  ([#15038](https://github.com/nim-lang/Nim/issues/15038))
- Fixed "pass varargs[seq[T]] to iterator give empty seq "
  ([#12576](https://github.com/nim-lang/Nim/issues/12576))
- Fixed "Compiler crashes when using string as object variant selector with else branch"
  ([#14189](https://github.com/nim-lang/Nim/issues/14189))
- Fixed "JS compiler error related to implicit return and return var type"
  ([#11354](https://github.com/nim-lang/Nim/issues/11354))
- Fixed "`nkRecWhen` causes internalAssert in semConstructFields"
  ([#14698](https://github.com/nim-lang/Nim/issues/14698))
- Fixed "Memory leaks with async (closure iterators?) under ORC"
  ([#15076](https://github.com/nim-lang/Nim/issues/15076))
- Fixed "strutil.insertSep() fails on negative numbers"
  ([#11352](https://github.com/nim-lang/Nim/issues/11352))
- Fixed "Constructing a uint64 range on a 32-bit machine leads to incorrect codegen"
  ([#14616](https://github.com/nim-lang/Nim/issues/14616))
- Fixed "heapqueue pushpop() proc doesn't compile"
  ([#14139](https://github.com/nim-lang/Nim/issues/14139))
- Fixed "[ARC] SIGSEGV when trying to swap in a literal/const string"
  ([#15112](https://github.com/nim-lang/Nim/issues/15112))
- Fixed "Defer and --gc:arc"
  ([#15071](https://github.com/nim-lang/Nim/issues/15071))
- Fixed "internal error: compiler/semobjconstr.nim(324, 20) example"
  ([#15111](https://github.com/nim-lang/Nim/issues/15111))
- Fixed "[ARC] Sequence "disappears" with a table inside of a table with an object variant"
  ([#15122](https://github.com/nim-lang/Nim/issues/15122))
- Fixed "[ARC] SIGSEGV with tuple assignment caused by cursor inference"
  ([#15130](https://github.com/nim-lang/Nim/issues/15130))
- Fixed "Issue with --gc:arc at compile time"
  ([#15129](https://github.com/nim-lang/Nim/issues/15129))
- Fixed "Writing an empty string to an AsyncFile raises an IndexDefect"
  ([#15148](https://github.com/nim-lang/Nim/issues/15148))
- Fixed "Compiler is confused about call convention of function with nested closure"
  ([#5688](https://github.com/nim-lang/Nim/issues/5688))
- Fixed "Nil check on each field fails in generic function"
  ([#15101](https://github.com/nim-lang/Nim/issues/15101))
- Fixed "{.nimcall.} convention won't avoid the creation of closures"
  ([#8473](https://github.com/nim-lang/Nim/issues/8473))
- Fixed "smtp.nim(161, 40) Error: type mismatch: got <typeof(nil)> but expected 'SslContext = void'"
  ([#15177](https://github.com/nim-lang/Nim/issues/15177))
- Fixed "[strscans] scanf doesn't match a single character with $+ if it's the end of the string"
  ([#15064](https://github.com/nim-lang/Nim/issues/15064))
- Fixed "Crash and incorrect return values when using readPasswordFromStdin on Windows."
  ([#15207](https://github.com/nim-lang/Nim/issues/15207))
- Fixed "Possible capture error with fieldPairs and genericParams"
  ([#15221](https://github.com/nim-lang/Nim/issues/15221))
- Fixed "The StmtList processing of template parameters can lead to unexpected errors"
  ([#5691](https://github.com/nim-lang/Nim/issues/5691))
- Fixed "[ARC] C compiler error when passing a var openArray to a sink openArray"
  ([#15035](https://github.com/nim-lang/Nim/issues/15035))
- Fixed "Inconsistent unsigned -> signed RangeDefect usage across integer sizes"
  ([#15210](https://github.com/nim-lang/Nim/issues/15210))
- Fixed "toHex results in RangeDefect exception when used with large uint64"
  ([#15257](https://github.com/nim-lang/Nim/issues/15257))
- Fixed "Arc sink arg crash"
  ([#15238](https://github.com/nim-lang/Nim/issues/15238))
- Fixed "SQL escape in db_mysql is not enough"
  ([#15219](https://github.com/nim-lang/Nim/issues/15219))
- Fixed "Mixing 'return' with expressions is allowed in 1.2"
  ([#15280](https://github.com/nim-lang/Nim/issues/15280))
- Fixed "os.getFileInfo() causes ICE with --gc:arc on Windows"
  ([#15286](https://github.com/nim-lang/Nim/issues/15286))
- Fixed "[ARC] Sequence "disappears" with a table inside of a table with an object variant"
  ([#15122](https://github.com/nim-lang/Nim/issues/15122))
- Fixed "Documentation regression jsre module missing"
  ([#15183](https://github.com/nim-lang/Nim/issues/15183))
- Fixed "CountTable.smallest/largest() on empty table either asserts or gives bogus answer"
  ([#15021](https://github.com/nim-lang/Nim/issues/15021))
- Fixed "[Regression] Parser regression"
  ([#15305](https://github.com/nim-lang/Nim/issues/15305))
- Fixed "[ARC] SIGSEGV with tuple unpacking caused by cursor inference"
  ([#15147](https://github.com/nim-lang/Nim/issues/15147))
- Fixed "LwIP/FreeRTOS compile error - missing SIGPIPE and more "
  ([#15302](https://github.com/nim-lang/Nim/issues/15302))
- Fixed "Memory leaks with async (closure iterators?) under ORC"
  ([#15076](https://github.com/nim-lang/Nim/issues/15076))
- Fixed "Bug compiling with --gc:arg or --gc:orc"
  ([#15325](https://github.com/nim-lang/Nim/issues/15325))
- Fixed "memory corruption in tmarshall.nim"
  ([#9754](https://github.com/nim-lang/Nim/issues/9754))
- Fixed "typed macros break generic proc definitions"
  ([#15326](https://github.com/nim-lang/Nim/issues/15326))
- Fixed "nim doc2 ignores --docSeeSrcUrl parameter"
  ([#6071](https://github.com/nim-lang/Nim/issues/6071))
- Fixed "The decodeData Iterator from cgi module crash"
  ([#15369](https://github.com/nim-lang/Nim/issues/15369))
- Fixed "|| iterator generates invalid code when compiling with --debugger:native"
  ([#9710](https://github.com/nim-lang/Nim/issues/9710))
- Fixed "Wrong number of variables"
  ([#15360](https://github.com/nim-lang/Nim/issues/15360))
- Fixed "Coercions with distinct types should traverse pointer modifiers transparently."
  ([#7165](https://github.com/nim-lang/Nim/issues/7165))
- Fixed "Error with distinct generic TableRef"
  ([#6060](https://github.com/nim-lang/Nim/issues/6060))
- Fixed "Support images in nim docgen"
  ([#6430](https://github.com/nim-lang/Nim/issues/6430))
- Fixed "Regression. Double sem check for procs."
  ([#15389](https://github.com/nim-lang/Nim/issues/15389))
- Fixed "uri.nim url with literal ipv6 address is printed wrong, and cannot parsed again"
  ([#15333](https://github.com/nim-lang/Nim/issues/15333))
- Fixed "[ARC] Object variant gets corrupted with cursor inference"
  ([#15361](https://github.com/nim-lang/Nim/issues/15361))
- Fixed "`nim doc ..` compiler crash (regression 0.19.6 => 1.0)"
  ([#14474](https://github.com/nim-lang/Nim/issues/14474))
- Fixed "cannot borrow result; what it borrows from is potentially mutated"
  ([#15403](https://github.com/nim-lang/Nim/issues/15403))
- Fixed "memory corruption for seq.add(seq) with gc:arc and d:useMalloc "
  ([#14983](https://github.com/nim-lang/Nim/issues/14983))
- Fixed "DocGen HTML output appears improperly when encountering text immediately after/before inline monospace; in some cases won't compile"
  ([#11537](https://github.com/nim-lang/Nim/issues/11537))
- Fixed "Deepcopy in arc crashes"
  ([#15405](https://github.com/nim-lang/Nim/issues/15405))
- Fixed "pop pragma takes invalid input"
  ([#15430](https://github.com/nim-lang/Nim/issues/15430))
- Fixed "tests/stdlib/tgetprotobyname fails on NetBSD"
  ([#15452](https://github.com/nim-lang/Nim/issues/15452))
- Fixed "defer doesnt work with block, break and await"
  ([#15243](https://github.com/nim-lang/Nim/issues/15243))
- Fixed "tests/stdlib/tssl failing on NetBSD"
  ([#15493](https://github.com/nim-lang/Nim/issues/15493))
- Fixed "strictFuncs doesn't seem to catch simple ref mutation"
  ([#15508](https://github.com/nim-lang/Nim/issues/15508))
- Fixed "Sizeof of case object is incorrect. Showstopper"
  ([#15516](https://github.com/nim-lang/Nim/issues/15516))
- Fixed "[ARC] Internal error when trying to use a parallel for loop"
  ([#15512](https://github.com/nim-lang/Nim/issues/15512))
- Fixed "[ARC] Type-bound assign op is not being generated"
  ([#15510](https://github.com/nim-lang/Nim/issues/15510))
- Fixed "[ARC] Crash when adding openArray proc argument to a local seq"
  ([#15511](https://github.com/nim-lang/Nim/issues/15511))
- Fixed "VM: const case object gets some fields zeroed out at runtime"
  ([#13081](https://github.com/nim-lang/Nim/issues/13081))
- Fixed "regression(1.2.6 => devel): VM: const case object field access gives: 'sons' is not accessible"
  ([#15532](https://github.com/nim-lang/Nim/issues/15532))
- Fixed "Csources: huge size increase (x2.3) in 0.20"
  ([#12027](https://github.com/nim-lang/Nim/issues/12027))
- Fixed "Out of date error message for GC options"
  ([#15547](https://github.com/nim-lang/Nim/issues/15547))
- Fixed "dbQuote additional escape regression"
  ([#15560](https://github.com/nim-lang/Nim/issues/15560))

repository: nim-lang/Nim

gha_license_id: NOASSERTION

repo_name: nim-lang/Nim


text:
---
layout: page
title: Hexual
description: Exploring album palettes
img: /assets/img/hexual.png
importance: 3
category: play
github: https://github.com/kenjimarshall/Hexual
---

The application is available at [hexual.ca](http://www.hexual.ca). This project is built with a React frontend, Flask backend, and is connected to a MongoDB database.

# What is it?

As the saying goes, _always judge an album by its cover._ I do think album artwork is integral to a record's artistic statement. It's the imagery you internally link to the sound, and the main opportunity to represent the music via a different medium. Hexual is an an effort to explore music through this lens. This idea was inspired by the effort I went through to come up with an aesthetically pleasing wall display of my favorite records. If you're ever in this situation, perhaps wanting to base your interior design choices off the gorgeously warm palette of Radiohead's In Rainbows, this is the place to be!

At its core, Hexual is a database of over 700,000 unique albums and their color palette. I provide tools on the hexual website to freely explore this database.

# The Data

**K-Means clustering** was used to calculate each album's palette.

    Color palette computed from Boards of Canada's album "Tomorrow's Harvest"

Hexual then allows one to find albums with color palettes that match or are imperceptibly different from some input color palette.

**But how do I measure being "imperceptibly different"?**

Naturally, color similarity might be quantified by how close two colors are in the RGB color space. However, **this isn't necessarily true** because the RGB system is not **perceptually uniform**. This means that if you take two pairs of RGB points, where within each pair the distance between the two points is equal, this does NOT mean that the perceptual difference in the two pairs will be the same.

Human perception is more complicated than just perceiving redness, blueness, and greenness. We do have three types of cones in our retina responsible for color perception, but their peak sensitivities do not neatly correspond to red, green, and blue. We are not RGB organisms.

Here's an illustration:

    Euclidean distance is not a description of human perception in RGB

_These two pairs are the same distance away in RGB, but the bottom pair looks way more different than the top pair!_

As such, images are represented in the [CIELAB color space](https://en.wikipedia.org/wiki/CIELAB_color_space). For some background, CIE is the International Commission on Illumination. LAB is a color space where Euclidean distances between colors is more closely correlated to human perception of color. Instead of RGB channels, they use:

- L: white to black
- A: green to red
- B: blue to yellow

The scale in each channel is non-linear, chosen to best represent human perception. In this space, any pairs separated by the same Euclidean distance will have the same difference in perceived color. So, to find albums with imperceptible different palettes, we work in the LAB space.

These are the working principles of Hexual. [Check it out if you have time](http://www.hexual.ca)!

license: MIT

branch_name: refs/heads/master

extension: markdown

gha_language: SCSS

license_type: permissive


text:
---
layout: publication
# The quotes make the : possible, otherwise you can do it without quotes
title: "Delay-Bounded Scheduling"
# YYYY_CONFSHORTNAME_PAPERSHORTNAME
key: 2011_popl_eqr

# conference | journal | poster | workshop
type: conference
redirect_from: /2011/01/delay-bounded-scheduling

# The shortname is used for auto-generated titles
shortname: POPL 2011
# add a 2:1 aspect ratio (e.g., width: 400px, height: 200px) to the folder /assets/images/papers/
image: 2011_popl_eqr.png
# add a 2:1 aspect ratio teaser figure (e.g., width: 1200px, height: 600px) to the folder /assets/images/papers/
image_large: 2011_popl_eqr_teaser.png

# Authors in the "database" can be used with just the key (lastname). Others can be written properly.
authors:
- Michael Emmi
- Shaz Qadeer
- rakamaric

journal-short: POPL
year: 2011

# bibentry: article | inproceedings | phdthesis | book
bibentry: inproceedings
bib:
  booktitle: Proceedings of the 38th ACM SIGPLAN Symposium on Principles of
    Programming Languages (POPL)
  series:
  volume:
  publisher: ACM
  editor:
  pages: 411--422
  doi: 10.1145/1926385.1926432
  address:
  url:
  number:
  month:
  note:

# Add things like "Best Paper Award at InfoVis 2099, selected out of 4000 submissions"
award:

# Use if this paper is linked to an internal project. This will link to the project site
# project: upset

# Use this if you have an external project website
external-project:

# The reference to the video entry
video:
# The reference to the preview video entry
#preview-video:

# the preprint
pdf: 2011_popl_eqr.pdf
# A supplement PDF
supplement:

# Extra supplements, such as talk slides, data sets, etc.
supplements:
#- name: General UpSet
#  # use link instead of abslink if you want to link to the master directory
#  abslink: http://vials.io/talk/
#  # defaults to a download icon, use this if you want a link-out icon
#  linksym: true

# Link to the repository where the code is hosted
code:

# Link to an official preprint server
preprint_server:
#https://doi.org/10.1101/128579

abstract: "<p>
We provide a new characterization of scheduling nondeterminism by allowing
deterministic schedulers to delay their next-scheduled task. In limiting the
delays an otherwise-deterministic scheduler is allowed, we discover concurrency
bugs efficiently - by exploring few schedules - and robustly - i.e.,
independent of the number of tasks, context switches, or buffered events.  Our
characterization elegantly applies to any systematic exploration (e.g.,
testing, model checking) of concurrent programs with dynamic task-creation.
Additionally, we show that certain delaying schedulers admit efficient
reductions from concurrent to sequential program analysis.
</p>"

# After the --- you can put information that you want to appear on the website
# using markdown formatting or HTML. A good example are acknowledgements, extra
# references, an erratum, etc.
---
### Acknowledgements

We thank Ahmed Bouajjani, Pierre Ganty, Rupak Majumdar, and Gennaro Parlato for
providing helpful insight, and the anonymous reviewers for their numerous
comments and suggestions.

extension: md


text:
# TOC Project 2017

Template Code for TOC Project 2017

A telegram bot based on a finite state machine

## Finite State Machine
![fsm](./img/fsm.png)

## Usage
* user
	* Input: "u1"
		* Reply: "one pass,one fail"

	* Input: "u2"
		* Reply: "two pass"

	* Input: "u3"
		* Reply: "I hope I can pass"

	* Input: "mumi"
		* Reply: "mumi.jpg(photo)"

## Author
[F74046593](https://github.com/F74046593)


text:
# Simple C# DllImport benchmarks

This is a set of simple benchmarks to estimate a baseline of the cost of common
scenarions when C# works with native code through `DllImport` & friends.

The test code runs a large number of operations and averages out over the
number of operations, as the resolution of [Stopwatch](https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.stopwatch?view=netcore-3.0) is not small enough.

## Requirements

* Mono >= 5.0
* Dotnet >= 3.0, with both `netcoreapp3.0` and `netcoreapp2.2` frameworks.
* python with pandas and seaborn for plotting the graphics

## Usage

```
$ make
$ make plot
```

## Results

These plots discard the initial iterations as they happen to be quite slow due
to the initial JIT'ing of the managed code. The `x` axis shows the number of
iterations and the `y` axis shows the average time per iteration in
microseconds.

* `ManagedStatic` - Simple call to an empty static method.

![ManagedStatic results](ManagedStatic.png)

* `ManagedVirtual` - Simple call to a virtual instance method

![ManagedVirtual results](ManagedVirtual.png)

* `DllImportDirect` - Call to `fprintf` redirect to `/dev/null`

![DllImportDirect results](DllImportDirect.png)

* `DllImportCustomMarshaller` - Call to `fprintf` but using an empty `ICustomMarshaler` for the string being passed.

![DllImportCustomMarshaller results](DllImportCustomMarshaller.png)

* `DllImportWithCallback` - Call to native `qsort` passing a C# callback.

![DllImportWithCallback results](DllImportWithCallback.png)

## System

* Dell XPS 15 9560
* i7-7700HQ @ 2.8 GHz
* 32 GB RAM
* Ubuntu 19.10
* Mono JIT/`mcs` <IP_ADDRESS> from Mono's repo.
* `dotnet` 3.0.100 from Microsoft's repo, targeting `netcoreapp` both 2.2 and 3.0

repository: lauromoura/csharp-native-benchmarks

repo_name: lauromoura/csharp-native-benchmarks


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

## [1.5.0] - 2020-11-25
### Added
* grumphp config

## [1.4.0] - 2019-07-04
### Added
* .php_cs.cache to Magento2 gitignore

## [1.3.0] - 2019-06-17
### Added
* update folder to ignore

## [1.2.0] - 2019-05-09
### Added
* git ignore for local config editors

## [1.1.0] - 2019-04-02
### Added
* get script
* ignore for git
* ignore for style
* README
* if to check if file is already in dir

### Improved
* ignore get if statements
* Doc and options for ignore get

## [1.0.0] - 2019-03-28
* Initial Setup 🎉

repository: mooore-digital/dotfiles

branch_name: refs/heads/main

gha_language: Shell

repo_name: mooore-digital/dotfiles


text:
# Programmers Universal Group Discord BOT (PUG Bot)
![a1412e5c-2794-47a2-a435-6c947724d477_rw_1200](https://user-images.githubusercontent.com/71369943/116653457-de0c2280-a9a4-11eb-924c-4fabee2aea13.gif)

## Contribute
You can freely contribute to the developement of this bot. To do it, just [open a pull request](https://github.com/PUGroups/PUG-Bot/compare/pull...main).
If you are issuing any kind of problem feel free to [open a new issue](https://github.com/PUGroups/PUG-Bot/issues/new) or to contact us on Discord.

 ## Commands
 A full list of commands is available by using the help command (`?help`). Here's a detailed description of each command. The words beetween the <> are the arguments ("options") of the command.

- ### Music
	- `?play <song query>` allows anyone who is in a voice channel to listen a song. `song query` can be either a YouTube URL or a query  ot search on YouTube (in this case the first result will be automatically selected).
	- `?volume <volume>` allows anyone who is listening to a song to set the bot's volume. `volume` must be a value between 0 and 200.
	- `?stop` makes the bot leave the voice channel where the author is in.

- ### Polls
	- `?poll <text to poll>` allows anyone to start a poll in the channel where the command is sent.

- ### Other commands
	- `?info <user mention>` allows anyone to get info about the pinged user like the join date and the number of roles.
	- `?invite` creates an instant permanent invite to the server.

 - ### Moderation
	 - `?ban <user mention>` allows moderators with the ban members permission to ban anyone in the server. This command works only with roles under the bot one.
	 - `?kick <user mention>` allows moderators with the kick members permission to kick anyone in the server. This command works only with roles under the bot one.
	 - `?unban <user ID>`  allows moderators with the ban members permission to unban anyone in the server. This command works with any banned member.
	 - `?clean <number of messsages>` allows people with admin permission to clean as many messages as they want.
	 - `?cleanup` allows people with admin permission to purge the last 40 messages up.
	 - `?mute <member mention>` allows admins to mute members. A `Muted` role is needed to get this feature working.
	 - `?unmute <member mention>` allows admins to unmute a previously muted member.
	 - `?addword <word to add>` allows admins to add a word to the swear filter. That word will be interted into the database and it will be censore when an user says it.
	 - `?rmword <word to remove>` allows admins to remove a previously added custom swear word.
	 - `?infractions <user mention>` allows anyone to see the number of the infractions of the pinged user. This command does not require any permission.
	 - `?clearall <user mention>` allows admins to clear all the infractions that an user has.

## Resources
 - Code of Conduct
 - Contribution rules
 - Privay Policy
 - License

gha_license_id: MIT


text:
# Passport-Tumblr

[![Build Status](https://travis-ci.org/passport-next/passport-tumblr.svg?branch=master)](https://travis-ci.org/passport-next/passport-tumblr)
[![Coverage Status](https://coveralls.io/repos/github/passport-next/passport-tumblr/badge.svg?branch=master)](https://coveralls.io/github/passport-next/passport-tumblr?branch=master)
[![Maintainability](https://api.codeclimate.com/v1/badges/cfd3cf93fcbb9b44231e/maintainability)](https://codeclimate.com/github/passport-next/passport-tumblr/maintainability)
[![Dependencies](https://david-dm.org/passport-next/passport-tumblr.png)](https://david-dm.org/passport-next/passport-tumblr)
<!--[![SAST](https://gitlab.com/passport-next/passport-tumblr/badges/master/build.svg)](https://gitlab.com/passport-next/passport-tumblr/badges/master/build.svg)-->

[Passport](http://passportjs.org/) strategy for authenticating with [Tumblr](https://www.tumblr.com/)
using the OAuth 1.0a API.

This module lets you authenticate using Tumblr in your Node.js applications.
By plugging into Passport, Tumblr authentication can be easily and
unobtrusively integrated into any application or framework that supports
[Connect](http://www.senchalabs.org/connect/)-style middleware, including
[Express](http://expressjs.com/).

## Install

    $ npm install @passport-next/passport-tumblr

## Usage

#### Configure Strategy

The Tumblr authentication strategy authenticates users using a Tumblr account
and OAuth tokens.  The strategy requires a `verify` callback, which accepts
these credentials and calls `done` providing a user, as well as `options`
specifying a consumer key, consumer secret, and callback URL.

    passport.use(new TumblrStrategy({
        consumerKey: TUMBLR_CONSUMER_KEY,
        consumerSecret: TUMBLR_SECRET_KEY,
        callbackURL: "http://<IP_ADDRESS>:3000/auth/tumblr/callback"
      },
      function(token, tokenSecret, profile, done) {
        User.findOrCreate({ tumblrId: profile.id }, function (err, user) {
          return done(err, user);
        });
      }
    ));

#### Authenticate Requests

Use `passport.authenticate()`, specifying the `'tumblr'` strategy, to
authenticate requests.

For example, as route middleware in an [Express](http://expressjs.com/)
application:

    app.get('/auth/tumblr',
      passport.authenticate('tumblr'));

    app.get('/auth/tumblr/callback',
      passport.authenticate('tumblr', { failureRedirect: '/login' }),
      function(req, res) {
        // Successful authentication, redirect home.
        res.redirect('/');
      });

## Examples

For a complete, working example, refer to the [login example](https://github.com/jaredhanson/passport-tumblr/tree/master/examples/login).

## Tests

    $ npm install --dev
    $ make test

repository: passport-next/passport-tumblr

repo_name: passport-next/passport-tumblr


text:
# MakeGains
A Node.js and MongoDB web app for easy workout tracking and long-term progress aggregation.

I am still actively developing this but it is deployed at http://makegains.herokuapp.com while I optimize it and add features. The app is functional - you can track workouts and see progress metrics - but it's just not the most user friendly yet.

### To-do:
- [x] Correct or replace Mongoose hook issues so that object references are eliminated or created appropriately as objects are created or deleted
- [x] Protect routes based on certain parameters. i.e. Only the owner of an exercise should be able to view data about it
- [x] Correct issue with API call behaving differently based on protocol
- [x] Add UI scripting to sort Exercises displayed
- [ ] Add UI scripting to sort Programs displayed
- [ ] Add UI scripting to sort Workouts displayed
- [ ] Implement a query such that, after a page reload, any sorting the User applied persists after reload
- [ ] Add functionality for a Workout to be logged based on a Program template
- [ ] Add a 'Data' page where a User can see metrics of all types

### Long term goals:
- [ ] Open API routes for mobile app addition
- [ ] Add react native mobile app interface

repository: zach-long/makegains

repo_name: zach-long/makegains


text:
---
title: Using Knot.x Chrome Extension for Fragments Debugging
description: "Presentation of our open source Chrome extension for Knot.x Fragments. Available also in a video format."
author: Voycawojka
keywords: tutorial
order: 30
date: 2020-05-06
layout: tutorial
knotxVersions:
  - 2.2
---

## Overview
In this tutorial, we'll go through a process of implementing a page populated with dynamic data using [Fragments](https://github.com/Knotx/knotx-fragments) and [Fragments Chrome Extension](https://github.com/Knotx/knotx-fragments-chrome-extension).
In this post, we'll focus on a relationship between Fragments and the Chrome Extension so you should already know how to [set up a project](https://knotx.io/tutorials/getting-started-with-knotx-stack/2_0/) and preferably have at least basic understanding of what Fragments are (although it's not necessary).

You'll learn how to:
- integrate with 3rd party APIs
- design a data flow architecture with Fragments
- visualize and debug the flow with the Fragments Chrome Extension

This tutorial is also available as a video:
<iframe width="560" height="315" src="https://www.youtube.com/embed/EWoHqzYGv0w" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

## Fragments

Before explaining what the Extension can help us with, we need to recall what Fragments are. In abstract terms, they are a mechanism for describing data flow and are used primarily to compose data from various sources, e.g. integrate with third-party services (APIs), cloude cache or datatbases. We can use them to define graphs (trees), where each node acts either retrieving or processing data. Those graphs are then evaluated by Knot.x.

For example, imagine a scenario where we need to display what weather is in the user's location. We have a service that can tell us about the user's preferred format (e.g. Celsius or Fahrenheit) and another service for retrieving actual weather information based on the specified format. Fragments make this case trivial. Here's how the simplest case could look like:

![Fragments Example](/img/blog/chrome-extension/fragments-example.png)

There are three nodes defined. First for fetching user's preferred format, second for fetching weather, and third for rendering the fragment. When a node is finished it chooses a state (e.g. _success_, represented by the color green) and then triggers the next node based on its edges. A node with a _success_ state triggers the node defined in its `_success` edge.

If we want to handle errors (e.g. one of the services returns code 500) we can just define additional edges that are triggered when an action fails. All of this without writing a single line of code.

## Fragments Chrome Extension

The Fragments Chrome Extension is an open-source tool for visualizing and debugging fragments. If you enable debug mode, the rendered HTML page (or JSON in case of a restful API) is injected with additional data about fragments processing, that can be read by the extension. The tool displays information about:
- the execution time of fragments and individual nodes inside them
- fragments' structure (in fact, the diagram above is a screenshot from the tool)
- data flow in the graph
- additional data for individual nodes, e.g. a response a node got from a service

The usage of the extension is explained throughout this tutorial. You can download it (TODO: link to the chrome store).

## Writing a simple fragment
As already mentioned, we won't be going into details about how to set up the project. In this tutorial, we model a scenario where an incoming request triggers fetching an HTML page content from some external content repository (like CMS, e.g. AEM or Wordpress). The rendered HTML page looks like this:

![Raw Page](/img/blog/chrome-extension/raw-page.png)

As you can see, it's not even processed right now. There is a raw templating engine markup rendered. In code, it's just a plain HTML with two Knot.x snippets inside. One of them contains markup for the User Details section, and the other for Payment Providers and Offers sections. It's worth noting that while the first snippet uses [Handlebars](https://handlebarsjs.com/), the second one uses [Pebble](https://pebbletemplates.io/) templating engine. It's possible for multiple markups to exist in the same HTML file because snippets are processed independently from each other.

This is how the first snippet looks like in code:

```handlebars
<knotx:snippet data-knotx-task="user-task">
  <div>
    <h2>User details</h2>
    <p>Id: {{fetch-user-info._result.id}}</p>
    <p>Name: {{fetch-user-info._result.first_name}}</p>
    <p>Surname: {{fetch-user-info._result.last_name}}</p>
    <p>Email: {{fetch-user-info._result.email}}</p>
  </div>
</knotx:snippet>
```

The most important thing here is the `data-knotx-task` declaration. It provides information about what [task](https://github.com/Knotx/knotx-fragments/tree/master/engine#task) should process this snippet. In this context "task" basically means "graph". In order for this snippet to be processed by Knot.x Fragments, we need to define a task called `user-task`. Detailed instructions on how to create a configuration for Fragments can be found in the [Fragments Handler Documentation](https://github.com/Knotx/knotx-fragments/tree/master/handler).

Let's start with the following task:

```hocon
user-task {
  action = fetch-user-info
}
```

We defined `user-task` as an object that represents a root node of the graph. Right now, this node contains a single property `action` that defines what action this node is supposed to call.

In this tutorial, we are using mocks with JSON data, so fetching a user should call an appropriate endpoint via HTTP. This is the configuration for the `fetch-user-info` action:

```hocon
fetch-user-info {
  factory = http
  config.endpointOptions {
    path = /user
    domain = webapi
    port = 8080
  }
}
```

The most important property to explain is the `factory` property. It defines which factory should produce the action (thanks to the SPI under the hood). For simplicity, think of the `factory` value as the type of action. In the example, we use the factory that can produce the `http` action - a built-in action that calls a specified address and retrieves data from it. The `config.endpointOptions` property should be self-explanatory. In case you're wondering why the domain is defined as `webapi` - this example runs as a docker swarm configured so that mocks are available at this host. If you're not using docker, it'd be localhost.

Note that we can also write and register our own factories, but it's not in the scope of this tutorial.

If we were to leave the configuration like this we would only fetch data without actually returning anything. We want to render a page though, so we need another node in our task. When the first node succeeds (so user data is fetched), we want to call a node that renders a fragment. This is the updated code for the `user-task`:

```hocon
user-task {
  action = fetch-user-info
  on._success {
    action = te-hbs
  }
}
```

The `on` object contains all transitions (graph edges) we want to be able to handle. The format looks like this:

```hocon
on {
  transition1 { node1 }
  transition2 = node2
  // ...
}
```

In this case we define that after a node with action `fetch-user-info` Knot.x should call a node with action `te-hbs`. This action will render the fragment using handlebars. This is how it looks like:

```hocon
te-hbs {
  factory = knot
  config.address = knotx.knot.te.handlebars
}
```

Perhaps not what you were expecting. The `knot` factory allows for registering actions on the [Vert.x Event Bus](https://vertx.io/docs/vertx-core/java/#event_bus), thus providing more scalability. Knot actions delegate the processing to whatever is defined at the address. With that, we can fully utilise CPU resources (horizontal scaling) or use cluster mode to deploy modules vertically (on different machines) not affecting the graph simplicity.

Here's how the actual handlebars configuration looks like:

```hocon
modules {
  hbsTemplateEngine = "io.knotx.te.core.TemplateEngineKnot"
}

config.hbsTemplateEngine.options {
  instances = 4

  config {
    address = knotx.knot.te.handlebars

    engine {
      factory = handlebars

      config = {
        cacheSize = 1000
      }
    }
  }
}
```

The entire configuration for the first snippet:

```hocon
// tasks.conf

user-task {
  action = fetch-user-info
  on._success {
    action = te-hbs
  }
}

// actions.conf

fetch-user-info {
  factory = http
  config.endpointOptions {
    path = /user
    host = webapi
    port = 8080
  }
}
te-hbs {
  factory = knot
  config.address = knotx.knot.te.handlebars
}
```

Now the User Details section of the first snippet should render like this:

![Rendered User Details](/img/blog/chrome-extension/filled-user-details.png)

Here's when the chrome extension comes in. If we have [Fragment HTML Body Writer](https://github.com/Knotx/knotx-fragments/tree/master/handler/consumer/html) configured
adequately, the extension can read data about fragments from the HTML page. Assuming the extension is installed, let's open the inspector and go to the "Knot.x" tab. We can see a list of fragments on the page:

![Rendered User Details](/img/blog/chrome-extension/list-of-fragments.png)

There are two fragments because we have two Knot.x snippets in HTML. We haven't defined a task for the second one thus it displays a grey square next to it. It means it wasn't processed. Ignore it for now and focus on the first one. It's green so it ended with success. There's also a randomly generated ID, a type (in this tutorial we define every fragment as "snippet"), and the time it took to process the fragment. If we click on the arrow pointing down next to the ID, we should see a list of top-level HTML elements in the snippet. In this case, it's just one div. Hover over it to highlight the div on the page.

Fragment details is the most interesting and useful part of the extension. Click on the fragment on the list to view its details. It should look like this:

![Rendered User Details](/img/blog/chrome-extension/first-snippet-graph.png)

We can drag and zoom using our mouse. The structure of the displayed graph matches the structure we defined in the `user-task` task. Click on the `fetch-user-info` node to see the details of its execution. We can, for example, see what request it sent and exactly what response it got in the `response` property. We can also view node's configuration in the `operation` property.

![Node Details](/img/blog/chrome-extension/node-details.png)

This snippet was simple so let's move on to something more advanced.

## Writing A More Complex Fragment

Now it's time to handle the second snippet. This is how it looks like in the HTML:

```pebble
<knotx:snippet data-knotx-task="payments-task">
  <div>
    <h2>Payment providers</h2>
    <ul>
      {% for provider in data['fetch-payment-providers']._result %}
      <li>
        <p>Payment provider: {{provider.name}}</p>
        <p>Payment URL: {{provider.paymentUrl}}</p>
      </li>
      {% endfor %}
    </ul>

    <h2>Offers</h2>
    <ul>
      {% for offer in data['fetch-offers']._result %}
      <li>
        <p>Offer: {{offer.method}}</p>
        <p>Price: {{offer.price}}</p>
      </li>
      {% endfor %}
    </ul>
  </div>
</knotx:snippet>
```

It contains two sections: Payment Providers and Offers. For the sake of this tutorial, we assume that we retrieve payment information from one service and offers from another. We also assume that both of those sections are user-specific, so we'll need to fetch information about the user too.

Property `data-knotx-task` is defined as `payments-task` so this snippet will be processed by a task with that name. The most straightforward (although far from ideal) configuration for this task would look like this:

```hocon
payments-task {
  action = fetch-user-info

  on._success {
    action = fetch-payment-providers

    on._success {
      action = fetch-offers

      on._success {
        action = te-pebble
      }
    }
  }
}
```

We defined four nodes that execute sequentially one after another. The first one reuses an already defined action called `fetch-user-info`. There are also `fetch-payment-providers` and `fetch-offers` actions that we haven't defined yet. Finally, in the end, there is a node with `te-pebble` action. This snippet uses Pebble templating engine so we have to define a new action for rendering it. If it used handlebars we could reuse our `te-hbs` action.

New actions we have to define are very similar to what we already have. Both fetching actions have `http` factory that calls mocks and `te-pebble` is referencing a knot defined on the event bus. In practice [HOCON](https://github.com/lightbend/config/blob/master/HOCON.md) (the language we are writing the configuration in) allows us to use variables and other means of avoiding copy and paste. For this tutorial, we'll keep it simple though. This is the needed configuration:

```hocon
fetch-payment-providers {
  factory = http
  config.endpointOptions {
    path = /payments
    domain = webapi
    port = 8080
  }
}
fetch-offers {
  factory = http
  config.endpointOptions {
    path = /offers
    domain = webapi
    port = 8080
  }
}
te-pebble {
  factory = knot
  config.address = knotx.knot.te.pebble
}
```

Nothing we haven't seen already. When we load the page now we should see that the second snippet is filled with data. In the Knot.x extension we still see two fragments but this time they both have green boxes next to them - both were processed and ended with success. Click the second fragment on the list to view its details:

![Naive Approach](/img/blog/chrome-extension/naive-second-snippet.png)

It works, but it's not the best approach. Right now the `fetch-offers` node waits for the `fetch-payment-providers` to succeed. There is no reason for that (remember, we assumed that those pieces of information can be retrieved independently). There would also be a problem if `fetch-payment-providers` failed for some reason. Then `fetch-offers` would not execute, even if it would be able to retrieve data and show them to the user. It'd be more efficient and safer if those two nodes could execute in parallel.

There are two types of nodes. Everything we've seen up to this point was so-called "single nodes". They just execute an action. The second type is a composite node. This kind of node contains an array of other root nodes (in fact, those are subgraphs). It executes them in parallel and waits for all of them to complete. If all of them succeed then the composite succeeds. Otherwise, the composite fails. This is how we can reorder our nodes to make use of a composite:

```hocon
payments-task {
  action = fetch-user-info

  on._success {
    actions = [
      {
        action = fetch-payment-providers
      },
      {
        action = fetch-offers
      }
    ]

    on._success {
      action = te-pebble
    }
  }
}
```

After `fetch-user-info` succeeds the composite is started to be processed. It calls `fetch-payment-providers` and `fetch-offers` in parallel. When both of them succeeds the pebble node starts to be processed. We don't need to change any actions, because we've only modified the structure of the graph and not what we do with data.

When we load the page now nothing seems to have changed. However, when we open the chrome extension we can see that the second fragment looks like this:

![Composite](/img/blog/chrome-extension/composite.png)

The white circle represents the beginning of a composite. The second circle is where the composite ended. All subtasks (nodes in the composite) ended with success thus the composite did too. That's why the second circle is green.

This is a good moment to introduce the performance tab. When we open the tab called "Performance View" we'll see a timeline of node execution:

![Timeline](/img/blog/chrome-extension/timeline.png)

By looking at this it's clear that `fetch-payment-providers` and `fetch-offers` executed simultaneously and that the next node (`te-pebble`) executed only after both of them finished.

This is far better from what we had before. There is still room for improvement though. Right now we don't handle any errors. In a real application errors are unavoidable. Let's say that the service that we call to retrieve offers has a long response time. We can simulate it by using a mock `/timeout`. It responds with the same data as `/offers` but it takes three seconds to do so. Swap the endpoint in the `fetch-offers` action:

```hocon
fetch-offers {
  factory = http
  config.endpointOptions {
    path = /timeout
    domain = webapi
    port = 8080
  }
}
```

When we load the page now it should take about three seconds. If we open the Knot.x extension we can immediately spot on the fragment list that the second fragment executed for a long time. When we open the fragments performance view we can see that the problem lays in the composite and specifically in the `fetch-offers` node.

What if such a long time is unacceptable? One approach would be to define a timeout in the `fetch-offers` action. However, we can do better. Knot.x provides us with a built-in implementation of a [Circuit Breaker Pattern](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern). It does so by a [Circuit Breaker Factory](TODO-find-a-link-to-documentation) that acts as a wrapper. Let's see how it can be configured:

```hocon
fetch-offers-cb {
  factory = cb
  doAction = fetch-offers

  config.circuitBreakerOptions {
    maxFailures = 3
    timeout = 500
    resetTimeout = 20000
  }
}
```

The circuit breaker calls the `fetch-offers` action inside of itself (`doAction` property). If the action failed then the circuit breaker assumes something is wrong and won't actually call the action next time it's invoked. It'll just assume failure instead.

We defined the following properties:
- `maxFailures` - number of failures it takes for circuit breaker to assume the action is not working
- `timeout` - the circuit breaker will assume failure after this time
- `resetTimeout` - how long the circuit breaker should wait until it'll allow the action to execute again

Now we need to adjust the task. This is how it should look like now:

```
payments-task {
  action = fetch-user-info

  on._success {
    actions = [
      {
        action = fetch-payment-providers
      },
      {
        action = fetch-offers-cb
      }
    ]

    on {
      _success {
        action = te-pebble
      }
      _error {
        action = te-pebble
      }
    }
  }
}
```

First, we call `fetch-offers-cb` instead of `fetch-offers` in the composite. That's because the `fetch-offers` action will be called inside of `fetch-offers-cb`. Also, since we expect the task to fail, the composite should handle the `_error` transition. It will be called if any subtask ends with anything different than success. In this case, we still want to render the page so we call the `te-pebble` action.

When we reload the page we can see that the Offers section is empty. However, the Payment Providers section should still be filled with data. The tool will show this graph:

![Missing Node](/img/blog/chrome-extension/missing-node.png)

There's a lot of going on here. The `fetch-offers-cb` node is blue. That's because it returned a `_fallback` transition. It's a custom transition. Transitions are nothing more than strings. `_success` and `_error` are standard and they display respectively as green and red. Anything else is a custom transition and is displayed as blue. If we click on the `fetch-offers-cb` node we can see why it returned fallback: `Exception: operation timeout`.

![Circuit Breaker Details](/img/blog/chrome-extension/cb-details.png)

The yellow node with an exclamation mark is a so-called "missing node". It doesn't exist during processing. It's just displayed in the tool as a way to catch the developer's attention. It means that a transition was triggered (in this case `_fallback`) but there was no node to handle it. Because of that, the `_fallback` state was returned to the composite and thus the composite ended with an error (composites can only end with `_success` or `_error`).

Also, note the dashed transitions. They represent a transition that could potentially be triggered, but in this case wasn't.

Finally, let's implement a node to handle the fallback case. The task should now look like this:

```hocon
payments-task {
  action = fetch-user-info

  onTransitions._success {
    actions = [
      {
        action = fetch-payment-providers
      },
      {
        action = fetch-offers-cb

        on._fallback {
          action = fetch-offers-fallback
        }
      }
    ]

    onTransitions {
      _success {
        action = te-pebble
      }
      _error {
        action = te-pebble
      }
    }
  }
}
```

We've added an action called `fetch-offers-fallback` that will be triggered when the circuit breaker returns a `_fallback` transition. This is a transition for the composite's subtask and not for the composite.

The `fetch-offers-fallback` action could retrieve data from cache or another service. In our case it'll just call the `/offers` endpoint:

```hocon
fetch-offers-fallback {
  factory = http
  config.endpointOptions {
    path = /offers
    domain = webapi
    port = 8080
  }
}
```

When we refresh the page we still won't see any offers displayed on the page. We'll get to this in a minute. The graph should look like this:

![Fallback](/img/blog/chrome-extension/with-fallback.png)

As we can see, even though the circuit breaker ended with fallback, the composite as a whole ended with success because of the `fetch-offers-fallback` node.

The only problem left is that we can't see any offers displayed, even though they were retrieved (we can check they were by viewing details of the fallback node). Let's take a look at the HTML snippet:

```html
<knotx:snippet data-knotx-task="payments-task">
  <div>
    <h2>Payment providers</h2>
    <ul>
      {% for provider in data['fetch-payment-providers']._result %}
      <li>
        <p>Payment provider: {{provider.name}}</p>
        <p>Payment URL: {{provider.paymentUrl}}</p>
      </li>
      {% endfor %}
    </ul>

    <h2>Offers</h2>
    <ul>
      {% for offer in data['fetch-offers']._result %}
      <li>
        <p>Offer: {{offer.method}}</p>
        <p>Price: {{offer.price}}</p>
      </li>
      {% endfor %}
    </ul>
  </div>
</knotx:snippet>
```

Pebble retrieves offers data from a key called `fetch-offers`. By default, every action saves data under its name. The problem is that in case of a timeout the action that retrieves data is called `fetch-offers-fallback` and therefore that's where the data is stored. One way to resolve this would be to use an action that rewrites data from one key to another. For the sake of this tutorial, we'll just create additional markup for fallback messages. The Offers section of the snippet will look like this:

```html
<h2>Offers</h2>
<ul>
  {% for offer in data['fetch-offers']._result %}
  <li>
    <p>Offer: {{offer.method}}</p>
    <p>Price: {{offer.price}}</p>
  </li>
  {% endfor %}
  {% for offer in data['fetch-offers-fallback']._result %}
  <li>
    <p>Fallback offer: {{offer.method}}</p>
    <p>Fallback price: {{offer.price}}</p>
  </li>
  {% endfor %}
</ul>
```

If we render the page now, we'll be able to see the fallback offers:

![Fallback Offers](/img/blog/chrome-extension/fallback-offers.png)

## Summary
As you can see Knot.x Fragments allows us to easily define data flow when integrating with 3rd party services. In this example, we rendered a page, but note this mechanism can be used to build restful APIs as well. The Knot.x extension can be used during many processes of building an application. It can be used by developers for debugging purposes, new team members to familiarize themselves with the application's architecture, quality assurance/testers to detect flaws and identify root causes of bugs (is it a frontend, backend or integration problem?) or architects and business people to visualize the data flow and business cases.

The code used in this example can be found [in our samples repository](https://github.com/Knotx/knotx-example-project/tree/master/chrome-extension).

If you are interested in more use cases for the Knot.x Chrome Plugin, please read [this article](https://wttech.blog/blog/2020/knotx-chrome-extension/).

repository: Knotx/knotx-website

gha_language: HTML

repo_name: Knotx/knotx-website


text:
This code goes with our blog here:

to run the code your self, start with updating the cloudinit.yml file with your credentials and socket_id. As well as the private key used to authenticate tunnels with.

```
 email=your_my_socket_email
 password=your_mysocket_passowrd
 socket_id=your_mysoscket_socket_id
 giphykey=your_giphy_API_key

   #THE BELOW NEEDS TO BE UPDATED!
- content: |
    <REDACTED_PRIVATE_KEY>
  path: /home/mysocket/.ssh/id_ed25519
```

Make sure to get a digital ocean token and add it your env:
```export TF_VAR_DO_TOKEN=xxxx```

then start building and bring up the VM's
```
terraform init
terraform plan
terraform apply
```
It will take about two minutes or so for the VM's the spin up and load all the software. After that your service should be globally available.
You can test the load balancing like this:

```for i in {1..20}; do  curl -s YOUR_MYSOCKET_URL | grep Server; done | sort | uniq -c```

when done you can bring it all down with
```terraform destroy```

repository: mysocketio/examples

repo_name: mysocketio/examples


text:
# React Study <img src = "https://reactjs.org/logo-og.png" width = 150  align = right>

> `React`스터디 자료를 정리하는 공간입니다.

## Curriculum

* `React 기초`, `React 심화` 두개의 Section으로 구성할 예정입니다.
* 매주 두 명이 각자 Chapter 한 개씩을 준비합니다.

* **Section 1: React 기초**

> | Chapter | Subject                                  | Note | Presenter                                |
> | ------- | ---------------------------------------- | ---- | ---------------------------------------- |
> | 0       | [VSCode React Setting]() |      | [OhKanghoon](https://github.com/OhKanghoon) |
> | 1       | [JSX](https://github.com/OhKanghoon/ReactStudy/tree/master/1_JSX) |      | [OhKanghoon](https://github.com/OhKanghoon) |
> | 2       | [Props_states_LifeCycle](https://github.com/OhKanghoon/ReactStudy/tree/master/2_Props_states_LifeCycle) |      | [whitewolf23](https://github.com/whitewolf23) |
> | 3       | [JavaScript ES6, ES7]() |      | []() |
> | 4       | [React 이벤트 처리, 믹스인, 컴포넌트 구성](https://github.com/OhKanghoon/ReactStudy/tree/master/4_Event%20Handling_Mixins_Composition) |      | [SujungRim](https://github.com/SujungRim) |
> | 5       | [React 배열 렌더링, 다양한 Input](https://github.com/OhKanghoon/ReactStudy/tree/master/5_Input_and_Array) |      | [iamcho2](https://github.com/iamcho2) |
> | 6       | [Dom 조작(Ref), React Router](https://github.com/OhKanghoon/ReactStudy/tree/master/6_Ref&React-Router) |      | [Dongineer](https://github.com/Dongineer) |

* **Section 2: React 심화**

> | Chapter | Subject                                  | Note | Presenter                                |
> | ------- | ---------------------------------------- | ---- | ---------------------------------------- |
> | 1       | [Redux + Immutable.js](https://github.com/OhKanghoon/ReactStudy/tree/master/7_Redux%20-%20Immutable.js) |      | [NohYujeong](https://github.com/NohYujeong)|
> | 2       | [Redux Middleware](https://github.com/OhKanghoon/ReactStudy/tree/master/8_Redux%20-%20Middleware) |      | [NohYujeong](https://github.com/NohYujeong)|
> | 3       | [Networking(Axios)]() |      | [OhKanghoon](https://github.com/OhKanghoon) |
> | 4       | [SSR (Next.js)]() |      | []()|
> | 5-1       | [TypeScript #1]() | 기본타입~함수 | [SujungRim](https://github.com/SujungRim) |
> | 5-2       | [TypeScript #2]() |      | []()|
> | 5-3       | [TypeScript #3]() |      | []()|
> | 6       | [Jest]() |      | []()|

## Contributors

> 스터디 참여자

* [OhKanghoon](https://github.com/OhKanghoon)
* [whitewolf23](https://github.com/whitewolf23)
* [Dongineer](https://github.com/Dongineer)
* [SujungRim](https://github.com/SujungRim)
* [NohYujeong](https://github.com/NohYujeong)
* [iamcho2](https://github.com/iamcho2)
* [kimminzoo](https://github.com/kimminzoo)

## Contact

- Email<EMAIL_ADDRESS>

repository: SujungRim/ReactStudy

repo_name: SujungRim/ReactStudy


text:
---
layout: post
title: "Repetition, and Persistence"
modified:
categories: posts
excerpt: "Not only we are very bad at persisting in our life plans and goals, we are very bad at knowing how bad we are"
tags: [ ideas for new products ]
image:
  feature:
date: 2015-04-29T11:38:48-04:00
---

I don't need to tell you that like myself, you have rarely stuck to your life long plans. We all make grand plans every new year or every time we are moved by a book, story, movie or a supposedly "life changing" experience.
Depending on how busy we are with our daily lives and depending on how we manage to keep that goal in front of our minds eye, we usually have forgotten all about it in a few days.
I don't know why that is. But that is not even important.
The important thing is people have developed ways to deal with life long plans over the millennia. And that is to have a support group with a calendar. Like you have all sorts of religious groups that stick to a calendar and reward each other (usually not materially) for sticking to the goals and plans and punish each other when someone drifts (by shaming, or fines or more severly).
Now, I being who I am, would much rather find a technological solution to this.
The important question is can we replace the "long term goal oriented support groups" partially or entirely with technology? or at least enhance it to reduce its problems and abuses?

gha_language: JavaScript


text:
# CALCnet-Apps
Internet-enabled programs that operate under the CALCnet graphing calculator networking protocol
Copyright (c) 2010-2017 Christopher Mitchell, aka "Kerm Martian"
https://www.cemetech.net | http://z80.me

Requirements
============
Each of these programs requires [Doors CS 7 or later](https://www.cemetech.net/dcs) to run. Simply install Doors CS, then either run these programs from the Doors CS desktop or (if you enable HomeRun) from the TI-OS homescreen.

Building
========
These programs have been tested with Brass. None has been tested with SPASM, but they should work more or less out-of-the-box. If they don't, feel free to PR this repository with the fixes.

Functionality
=============
Note that much of the functionality on the internet side (clipping webpages, connecting to IRC) is performed by the relevant gCn Hubs. Take a look at [the repository for gCn](https://github.com/KermMartian/gcn) to find the source for those hubs.

repository: KermMartian/CALCnet-Apps

repo_name: KermMartian/CALCnet-Apps