Andrew Keats Steakeye

Anti-hype LLM reading list

Goals: Add links that are reasonable and good explanations of how stuff works. No hype and no vendor content if possible. Practical first-hand accounts of models in prod eagerly sought.

Foundational Concepts

Pre-Transformer Models

System design cheat sheet

It can be used for interviews or assessments.

1. Understand problem and scope:

Recognize stakeholders and prioritize them. Create RACI matrix
Understand business drivers of the project
Recognize end-users of the project and understand how they will use that system
Check functional requirements
Define external dependencies
Suggest additional features
Remove items that interviewer considers out of scope

How to write a generic View renderer

Taken in part from discussions/solutions mentioned [here]this aurelia/templating#35)

Please also look at view-manager and aurelia-form for inspiration. Maybe also look here for example of dynamic data grid with rows and columns :)

Notes: This works for me as well. I only had to change view.bind(this.bindingContext); to view.bind(this); as I wanted to bind to the model itself (not its parent) and initially failed on using click delegates.

Alternative!?

System Design Cheatsheet

Picking the right architecture = Picking the right battles + Managing trade-offs

Basic Steps

Clarify and agree on the scope of the system

User cases (description of sequences of events that, taken together, lead to a system doing something useful)
- Who is going to use it?
- How are they going to use it?

##Sass Functions Cheat Sheet

RGB Functions
HSL Functions
Opacity Functions
Other Color Functions
List Functions
Map Functions
Selector Functions
String Functions

SCSS

Website: http://sass-lang.com/
Docs: http://sass-lang.com/guide
Tutorial: https://www.codecademy.com/learn/learn-sass

Global Setup

Install on OS X: sudo gem install sass

CLI Usage

Version info: sass -v

The three design patterns (Adapter, Facade and Bridge) all produce the result of a clean public API. The difference between the patterns are usually due to a subtle context shift (and in some cases, a behavioural requirement).

Adapter

The primary function of an Adapter is to produce a unified interface for a number of underlying and unrelated objects.

You will notice this pattern being utilised in many applications. For example, ActiveRecord (the popular Ruby ORM; object-relational mapping) creates a unified interface as part of its API but the code underneath the interface is able to communicate with many different types of databases. Allowing the consumer of the API to not have to worry about specific database implementation details.

The principle structure of this pattern is:

A quick overview of the node.js streams interface with basic examples.

This is based on @brycebaril's presentation, Node.js Streams2 Demystified

Overview

Streams are a first-class construct in Node.js for handling data.

Think of them as as lazy evaluation applied to data.

	/**
	* Creates a [FlowTestObserver] instance and starts collecting the values of the [Flow] immediately.
	* You must call [FlowTestObserver.finish] after all the values have been emitted to the flow in order to continue.
	*/
	fun <T> Flow<T>.test(scope: CoroutineScope): FlowTestObserver<T> {
	return FlowTestObserver(scope, this)
	}

	/**
	* A test class that collects the values of the provided `flow` in its own coroutine. The collected values are

	$Username = "su"
	$Password = "password"

	$group = "Administrators"

	$adsi = [ADSI]"WinNT://$env:COMPUTERNAME"
	$existing = $adsi.Children \| where {$_.SchemaClassName -eq 'user' -and $_.Name -eq $Username }

	if ($existing -eq $null) {