Computing on The VikiD Truth

objdump

Sun, 04 Jun 2023 00:49:00 +0400

objdump

The truth behind every program you run: it is just bytes, and those bytes are instructions you can read. objdump is the tool that turns the bytes back into something a human can follow.

What it is, in plain words

objdump is part of GNU binutils (along with as, ld, nm, readelf, strings). Point it at an object file, executable or shared library and it will show you:

the headers – what kind of file, which CPU, where it starts;
the sections – .text (code), .data, .rodata, .bss and friends;
the symbols – names of functions and variables;
the disassembly – machine code translated back into assembly mnemonics.

LLVM ships a near drop-in twin, llvm-objdump, with the same main flags.

Reserve Words

Mon, 22 May 2023 22:02:13 +0400

BASH | Bash Cookbook |

Reserve Words

Here is the truth about Bash reserved words: they are not commands sitting somewhere in /bin – they are part of the language, recognised before anything is looked up. You cannot name a function if, and type if will tell you why.

What it is, in plain words

Reserved words (keywords) are tokens Bash treats specially when they appear where a command name would. The POSIX set plus Bash extensions includes:

Using Variables in Bash

Mon, 22 May 2023 21:53:51 +0400

BASH | Bash Cookbook |

Using Variables in Bash

Here is the truth about Bash variables: they are all strings, and everything interesting is about when those strings get split, expanded or left alone. Master expansion and the rest of the shell starts to behave.

What it is, in plain words

A variable in Bash is a name bound to a string value (arrays are the structured exception). You assign with =, no spaces:

Vagrant

Sun, 21 May 2023 00:39:21 +0400

Vagrant

Here is the truth about Vagrant: it is a script that builds a disposable computer. Point it at VirtualBox (or another provider), write a few lines of Ruby, and every teammate gets the same Linux box with the same packages – recreateable from nothing.

Virtualbox

Sun, 21 May 2023 00:38:02 +0400

Virtualbox

The truth about VirtualBox: it’s the easiest way to have a spare computer you can’t break. Install it, click through a wizard, and you’ve got a whole extra machine in a window – one you can snapshot, wreck and restore in seconds.

Forth

Sat, 20 May 2023 04:36:55 +0400

Forth

Here is the truth about Forth: it is a language that barely exists until you write it. A tiny core of stack operations, and then every new word you define becomes part of the language. Few systems take “grow your own” this literally – PicoLisp is one; Forth is another.

Rust

Fri, 19 May 2023 23:18:13 +0400

Rust

Here is the truth Rust is built on: most bugs that crash systems and open security holes are memory bugs, and a compiler can stop nearly all of them – if you’re willing to talk to it about ownership. Rust is that conversation.

Prototypal Inheritance

Tue, 11 Apr 2023 03:13:18 +0400

Prototypal Inheritance

Here is the truth that makes JavaScript’s object model click: there are no classes in the engine – only objects linked to other objects. The class keyword is tidy syntax over a much older idea called prototypal inheritance.

What it is, in plain words

Every JavaScript object has an internal link to another object, its prototype. When you ask for a property and it isn’t on the object itself, the engine looks at the prototype, then that object’s prototype, and so on until it hits null. That chain is how inheritance works.

with-output-to-string

Sun, 09 Apr 2023 22:39:59 +0400

commonlisp | Functions | with-output-to-string

with-output-to-string

External Link: Macro WITH-OUTPUT-TO-STRING.

The macro WITH-OUTPUT-TO-STRING can be used to create a string output stream, and return the resulting string at the end.

with-output-to-string (var &optional string-form &key element-type)
declaration* form*

=> result*

element-type specifier is defaulted to character.
form* is implicit progn

with-output-to-string creates a character output stream and performs a series of operation that output to the result. automatically closed on exit side effect: the string is modified

Common Lisp Functions

Sun, 09 Apr 2023 22:28:42 +0400

Functions | with-output-to-string

Common Lisp Functions

The truth about functions in Common Lisp: a function is an object, and a name is just one of many ways to reach it. Once you separate “the function” from “the symbol that names it”, the strange-looking #' and funcall suddenly make perfect sense.

What it is, in plain words

A Common Lisp function is a first-class object that takes arguments and returns zero or more values. You create named ones with defun and anonymous ones with lambda:

Windows

Thu, 06 Apr 2023 05:58:58 +0400

Windows | Windows WSL | Operating Systems

Windows

Here’s the plain truth about Windows for someone who lives in Linux: it’s not the enemy, it’s just a different set of assumptions. Once you know where Windows keeps its equivalents of a shell, a package manager and a config file, you can be productive on it in an afternoon – and that’s often all you need.

What it is, in plain words

Windows is Microsoft’s operating system, built on the NT kernel (the design that started with Windows NT in 1993; every version since XP uses it). In 2026 the current desktop release is Windows 11; Windows 10 reached end of support in October 2025, so unpatched Windows 10 machines are now a real security risk unless enrolled in paid extended updates.

Haskell Kata

Thu, 06 Apr 2023 04:16:37 +0400

Haskell | Haskell Kata |

Haskell Kata

Getting Started

min 1 2 max 1 2 }

dbl x = x + x
dbls x y = dbl x + dbl y

dsn x = if x > 100
 then x
 else x*2
dsn' x = (if x > 100 then x else x*3) + 1

nL = [0,1,2,3,4,5,6,7,8,9]
nL ++ [10,11,12]
0:nL
nL!!3
nLL= [nL,nL,nL]
nLL ++ [[0,2]]
[10,11,12]:nLL

length nL
null nL
take 5 nL
drop 5 nL
head [ ]
head nL
tail nL
last nL
init nL
reverse nL
maximum nL
minimum nL
sum nL
product nL
5 `elem` nL
elem 5 nL

[1..10]
['a'..'l']
[3, 4..12]
take 5 [40, 45..]
take 20 (cycle nL)
take 10 (repeat 5)
replicate 4 10

[ dsn x | x <- nL, x > 5 ]
beepBop xs = [ if x < 5 then "beep" else "bop" | x <- xs, odd x]
[ x*y | x <- [2,5,10], y <- [8,10,11]]

Three.js

Sun, 02 Apr 2023 01:54:13 +0400

Three.js | 3DE Code Editor | Making Shapes

Three.js

Making Shapes

Getting Started

Three.js Official Docs Installation

======================================================================================================
Install
======================================================================================================
npm install --save three

npm install --save-dev vite

npx vite

http://localhost:5173

vitejs, using npm, threejs server video, Package management basics

Files, Code

======================================================================================================
index.html
======================================================================================================
<!DOCTYPE html>
<html>
	<head lang="en">
		<meta charset="utf-8">
		<title>My first three.js app</title>
		<style>
			body { margin: 0; }
		</style>
	</head>
	<body>
		<script type="module" src="/main.js"></script>
	</body>
</html>

======================================================================================================
main.js
======================================================================================================

import * as THREE from 'three';

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera( 75, window.innerWidth / window.innerHeight, 0.1, 1000 );

const renderer = new THREE.WebGLRenderer();
renderer.setSize( window.innerWidth, window.innerHeight );
document.body.appendChild( renderer.domElement );

const geometry = new THREE.BoxGeometry( 1, 1, 1 );
const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
const cube = new THREE.Mesh( geometry, material );
scene.add( cube );

camera.position.z = 5;
function animate() {
	requestAnimationFrame( animate );

	cube.rotation.x += 0.01;
	cube.rotation.y += 0.01;

	renderer.render( scene, camera );
}
animate();

to be continued…

Javascript Events

Sun, 02 Apr 2023 01:28:15 +0400

Javascript Events

Here is the truth about events: your JavaScript mostly doesn’t run – it waits. It registers “when this happens, do that”, goes quiet, and the browser (or Node.js) wakes it up when something happens. Learning events is learning to write code that waits well.

What it is, in plain words

An event is a signal that something happened: a click, a key press, a page finishing loading, a network message arriving, a file being read. An event listener (or handler) is a function you attach to a target that will be called when that event fires.

Javascript Functions

Sun, 02 Apr 2023 01:28:00 +0400

Javascript Functions

The truth at the heart of JavaScript: functions are values. You can store them in variables, pass them to other functions, return them, and stick them in objects. Everything clever in the language – callbacks, promises, event handlers, array methods – follows from that one fact.

Javascript Objects

Sun, 02 Apr 2023 01:27:38 +0400

Javascript Objects

Strip away the syntax and here is the truth: a JavaScript object is just a bag of named slots, plus a hidden link to another bag to ask when a slot is missing. Arrays, functions, dates, DOM nodes – all of them are that, underneath.

What it is, in plain words

An object is a collection of properties. Each property has a key (a string or a symbol) and a value (anything – a number, another object, a function). When a property’s value is a function, we call it a method.

Javascript Scope

Sun, 02 Apr 2023 01:27:07 +0400

Javascript Scope

The truth behind scope is simple: every name lives somewhere, and code can only see the names in its own room and the rooms that contain it. That nesting of rooms, decided by where you write the code, is all scope is.

What it is, in plain words

Scope is the region of a program where a name is visible. An environment (the spec calls it an Environment Record) is the actual table, at run time, that maps names to values for that region. Each environment keeps a pointer to its outer environment, forming a chain. When you use a name, JavaScript looks in the current environment, then the outer one, then the next, until it hits the global environment. If the name isn’t there, you get a ReferenceError.

Javascript Variables

Sun, 02 Apr 2023 01:26:09 +0400

Javascript Variables

Here is the truth nobody tells beginners: a variable is not a box that holds a value. It is a name that points at a value. Once that sinks in, half the “weird” behaviour of JavaScript stops being weird.

What it is, in plain words

A variable is a label you attach to a value so you can find it again. In modern JavaScript (everything since ES2015, and everything you should be writing in 2026) you create one with one of two keywords:

Python spaCy NLP Library

Fri, 31 Mar 2023 14:47:25 +0400

Python Libraries, tools and Links | Official Python Docs | Intro to Pygame | spaCy

Python spaCy NLP Library

Here is the truth about spaCy: it is an industrial-strength Natural Language Processing library for Python that treats linguistic annotation as a pipeline of fast, composable components. If you need to tokenise, tag, parse or recognise entities in real text, spaCy is the default workhorse.

What it is, in plain words

spaCy (Explosion AI) provides:

Intro to Pygame Notes

Thu, 30 Mar 2023 23:23:52 +0400

Python Libraries, tools and Links | Official Python Docs | Intro to Pygame

Intro to Pygame Notes

Here is the truth about Pygame: it is a friendly box of SDL bindings that lets Python draw pixels, play sounds and read joysticks – enough to make real games without a 3D engine. If you can write a loop and blit a surface, you can ship a game.

What it is, in plain words

Pygame is a community library wrapping SDL2 for Python. It gives you:

Cuis Terse Guide

Thu, 30 Mar 2023 20:31:26 +0400

Terse Guide

Cuis Terse Guide

x _ 4.

z := 5.

x _ y _ z _ 6.

x _ (y _ 6) + 1.

x _ Object new.

x _ 123 class.
x _ Object allInstances.

x _ Integer allInstances.
x _ Integer allSuperclasses.

w _ 1.2 hash.

t _ x copy.
y _ x shallowCopy.
y _ x veryDeepCopy.

TranscriptWindow openTranscript. Transcript
Transcript clear.
Transcript show: 'hello world'.
Transcript nextPutAll: 'Hello World'.
Transcript nextPut: $A.
Transcript space.
Transcript tab; nextPut: $A; space; tab; nextPut: $B.
Transcript newLine.

'Hello' printOn: Transcript.
'Yellow' storeOn: Transcript.
Transcript endEntry.

'Literals are objects that are created when you compile a method'

| b x |

b _ true.
b _ false.
x _ nil.
x _ 1.

x _ 3.14.
x _ 2e-1.
x _ 2.0e-2.

x _ 7/8.

x _ 16r0F.
x _ 16rFFFFFFFF.
x _ 16rFFFFFFFF negated.
x _ -1.

x _ 'hello'.
x _ 'I''m here'.
x _ $A.
x _ $ .
x _ #aSymbol.
x _ #(3 2 1).
x _ #('abc' 1 $a).
x _ #[3 2 1 0].
x _ #[1.0 3.12 6.03e23].

x _ {'hello' size. Float pi. 1.0 arcTan}.
x _ `{'hello' size. Float pi. 1.0 arcTan}`.

x _ `{ 1. 3. 5. 7. 11. 13. 17} asSet`.

"Booleans"
| b x y |
x _ 1. y _ 2.
b _ ( x = y).
b _ ( x ~= y).
b _ ( x == y).
b _ ( x ~~ y).
b _ ( x > y ).
b _ ( x < y).
b _ ( x >= y).
b _ ( x <= y).
b _ b not.
b _ (x < 5) & ( y > 1).
b _ (x < 5) | (y > 1).
b _ (x < 5) and: (y > 1).
b _ (x < 5) or: (y > 1).
b _ (x < 5) eqv: (y > 1).
b _ (x < 5) xor: (y > 1).
b _ 5 between: 3 and: 12.
b _ 123 isKindOf: Number.
b _ 123 isMemberOf: SmallInteger.
b _ 123 respondsTo: #sqrt.
b _ x isNil.
b _ x isZero.
b _ x positive.
b _ x strictlyPositive.
b _ x negative.
b _ x even.
b _ x odd.
b _ x isInteger.
b _ x isLiteral.
b _ x isNumber.
b _ x isSymbol.
b _ $A isUppercase.

“Bit-Wise”

x _ 16rFF bitAnd: 16r0F. "and bits"
x _ 16rF0 bitOr: 16r0F. "or bits"
x _ 16rFF bitXor: 16r0F. "xor bits"
x _ 16rFF bitInvert. "invert bits"
x _ 16r0F bitShift: 4. "left shift "
x _ 16rF0 bitShift: -4. "right shift"
x _ 16r80 bitAt: 8. "bit at position (0|1)"
x _ 16r80 highBit. "position of highest bit set"
b _ 16rFF allMask: 16r0F. "test if all bits set in mask are set in receiver"
b _ 16rFF anyMask: 16r0F. "test if any bits set in mask are set in receiver"
b _ 16rFF noMask: 16r0F. "test if all bits set in mask are clear in receiver"

The i3 Window Manager

Thu, 30 Mar 2023 09:22:22 +0400

The i3 Window Manager

i3 Config File

i3wm:refcard The location of this file is ../home/user/.i3/config.

These are some notes on the i3 config file. It is not the complete file.

# Set the Mod Key
set $mod Mod4

default_border pixel 1
default_floating_border normal
hide_edge_borders none

bindsym $mod+u border none
bindsym $mod+y border pixel 3
bindsym $mod+n border pixel normal

# Font for window tiles. Will also be used by the bar unless a different font
# is used in the bar {} block below.
font xft:URWGothic-Book 11

floating_modifier $mod

bindsym $mod+Return exec alacrity
bindsym $mod+Shift+q kill

bindsym $mod+d exec --no-startup-id dmenu_recency

bindsym $mod+z exec --no-startup-id morc_menu

bindsym XF86MonBightnessUP exec "xbacklight -inc 1; notify-send 'brightness up'"
bimdsym XF86MonBrightnessDown exec "xbacklight -dec 1; notify-send 'brightness down'"

bindsym $mod+Ctrl+b exec terminal -e 'bmenu'
bindsym $mod+F2 exec firefox

# File Managers
bindsym $mod+F3 exec pcmanfm
bindsym $mod+F4 exec ranger
bindsym $mod+Shift+F3 exec pcmanfm_pkexec

# The Console Audio Player
bindsym $mod+F5 exec terminal -e 'mocp'

bindsym $mod+t exec --no-startup-id pkill picom
bindsym $mod+Ctrl+t exec --no-startup-id picom -b

# Notification Daemon
bindsym $mod+Shift+d --release exec "killall dunst; exec notify-send 'restart dunst'"

# Screenshots
bindsym $Print exec --no-startup-id i3-scrot
bindsym $mod+Print -release exec --no-startup-id i3-scrot -w
bindsym $mod+Shift+Print --release exec --no-startup-id i3-scrot -s

bindsym $mod+Shift+h exec xdg-open /usr/share/doc/manjaro/i3_help.pdf

bindsym $mod+Ctrl+x --release exec --no-startup-id xkill

# change focus, move and split
bindsym $mod+j focus left
bindsym $mod+k focus down
bindsym $mod+l focus up
bindsym $mod+semicolon focus right

bindsym $mod+Shift+j move left
bindsym $mod+Shift+k move down
bindsym $mod+Shift+l move up
bindsym $mod+Shift+semicolon move right

workspace_auto_back_and_forth yes
bindsym $mod+b workspace back_and_forth
bindsym $mod+Shift+b move container to workspace back_and_forth; workspace back_and_forth

bindsym $mod+h split h; exec notify-send 'tile horizontally'
bindsym $mod+v split v; exec notify-send 'tile vertically'
bindsym $mod+q split toggle

# toggle fullscreen
bindsym $mod+f fullscreen toggle

bindsym $mod+s layout stacking
bindsym $mod+w layout tabbed
bindsym $mod+e layout toggle split

bindsym $mod+Shift+Space floating toggle

bindsym $mod+space focus mode_toggle
bindsym $mod+Shift+s stick toggle

bindsym $mod+a focus parent

bindsym $mod+Shift+minus move scratchpad

bindsym $mod+Ctrl+Right workspace next
bindsym $mod+Ctrl+Left workspace prev

set $ws1 1:term
set $ws2 2:browser
set $ws3 3:emacs
set $ws4 4:lisp
set $ws5 5:cuis

bindsym $mod+1 workspace $ws1
# etc... etc...

bindsym $mod+Ctrl+1 move container to workspace $ws1
# etc... etc...

bindsym $mod+Shift+1 move container to workspace $ws1; workspace $ws1
# etc... etc...

assign [class="Thunderbird"] $ws1

for_window [title="alsmixer"] floating enable border pixel 1
for_window [class="calamares"] floating enable border normal
for_window [title="i3_help"] floating enable sticky enable border normal
for_window [class="OBlogout"] fullscreen enable
for_window [class="(?i)virtualbox"] floating enable border normal
# etc... etc...

for_window [urgent=latest] focus

bindsym $mod+Shift+c reload
bindsym $mod+Shift+r restart

bindsym $mod+shift+e exec "i3-nagbar -t warning -m 'You pressed the exit shortcut. Do you really want to exit i3? This will end your X session.' -b 'Yes, exit i3' 'i3-msg exit'"

bindsym $mod+0 mode "$mode_system"
mode "$mode_system"{
 bindsym l exec --no-startup-id i3exit lock, mode "default"
 bindsym s exec --no-startup-id i3exit suspend, mode "default"
 bindsym u exec --no-startup-id i3exit switch_user, mode "default"
 bindsym e exec --no-startup-id i3exit logout, mode "default"
 bindsym h exec --no-startup-id i3exit hibernate, mode "default"
 bindsym r exec --no-startup-id i3exit reboot, mode "default"
 bindsym Shift+s exec --no-startup-id i3exit shutdown, mode "default"

 bindsym Return mode "default"
 bindsym Escape mode "default"
}

bindsym $mod+r mode "resize"
mode "resize" {
 bindsym j resize shrink width 5 px or 5 ppt
 bindsym k resize grow height 5 px or 5 ppt
 bindsym l resize shrink height 5 px or 5 ppt
 bindsym semicolon resize grow width 5 px or 5 ppt

 bindsym Left resize shrink width 10 px or 10 ppt
 bindsym Down resize grow height 10 px or 10 ppt
 bindsym Up resize shrink height 10 px or 10 ppt
 bindsym Right resize grow width 10 px or 10 ppt
}

bindsym $mod+9 exec --no-startup-id blurlock

bindsym $mod+m bar mode toggle

Kmonad Keyboard

Wed, 21 Sep 2022 01:43:13 +0400

Kmonad Keyboard

The truth about keyboards is that the layout printed on the keys is just a suggestion. Between the switch and your program sits software that decides what each key means – and KMonad lets you rewrite that decision completely.

What it is, in plain words

KMonad is a keyboard remapper written in Haskell. It grabs your physical keyboard at a low level, runs every key event through a configuration you write, and emits new events through a virtual keyboard. Because it works below the window system, the result works everywhere: in X11, Wayland, the Linux console, even in a login prompt. It runs on Linux, macOS and Windows.

Computing

Thu, 15 Sep 2022 05:29:55 +0400

Computing

Fortran

Here’s a truth that surprises most programmers: the oldest high-level language still in heavy use isn’t a relic – it’s quietly running the world’s weather forecasts, climate models and supercomputers. Fortran is old; modern Fortran is not.

Apple Related Stuff

Thu, 15 Sep 2022 02:06:34 +0400

Here is the truth about Apple computers for a Linux person: under the polished glass, a Mac is a Unix machine – a certified one, in fact. With a package manager, a tiling window manager and a few keyboard tweaks, it can feel surprisingly close to home.

Cuis Smalltalk

Mon, 12 Sep 2022 01:39:35 +0400

Terse Guide

Cuis Smalltalk

Here is the truth about Cuis: it is Smalltalk stripped back to something one person can understand completely – a personal computing environment that still fits in a single mind. If Pharo is a bustling city, Cuis is a well-kept village with excellent roads.

GNU Smalltalk

Mon, 12 Sep 2022 01:32:06 +0400

GNU Smalltalk

Here’s the truth about GNU Smalltalk: it’s Smalltalk without the world around it – no windows, no image browser, just the language in a terminal, run like a script. That makes it the quickest way to taste Smalltalk’s ideas, and also explains why most people eventually move on to Pharo or Cuis.

awk

Tue, 06 Sep 2022 12:34:23 +0400

awk

Here is the truth about awk: it is a whole programming language disguised as a command, built for one job – reading text line by line and pulling out the columns you care about. Nearly fifty years on, it still beats writing a script for that job.

What it is, in plain words

awk (named after its authors Aho, Weinberger and Kernighan, Bell Labs, 1977) reads input one record (usually a line) at a time, splits each record into fields (usually on whitespace), and runs your pattern → action rules against it:

xrandr

Tue, 06 Sep 2022 12:14:39 +0400

xrandr

Here is the truth about multi-monitor Linux: the compositor draws, but xrandr decides what exists to draw on. One command can rearrange your whole desk – and a bad one can leave you staring at a black screen, so it’s worth learning carefully.

What it is, in plain words

xrandr (X Resize And Rotate) is the command-line tool for configuring displays under X11: resolution, refresh rate, rotation, and how multiple monitors sit relative to each other. It talks to the X server via the RandR extension. On a laptop it is how you enable an external monitor; on a desktop, how you arrange three screens into one desktop.

Burn an ISO to USB Disk

Tue, 06 Sep 2022 05:52:51 +0400

Burn an ISO to USB Disk

Here is the truth about writing an ISO to a USB stick: the stick becomes the image, byte for byte – it is not a folder you copy files into. Treat it like imaging a disk and you won’t end up with a stick that won’t boot.

Odin

Mon, 05 Sep 2022 06:40:28 +0400

Odin

Here is the truth Odin is built on: most programs are about transforming data, so the language should make data obvious and get out of the way. No classes, no hidden allocations, no garbage collector – just a clean, modern take on what C was trying to be.

Zig Language

Tue, 30 Aug 2022 05:35:16 +0400

Zig Language

Here is the truth Zig is aimed at: C is still the lingua franca of systems, but its undefined behaviour, header files and build story are a tax everyone pays. Zig keeps C’s honesty about memory and lays that tax down.

Bash case statements

Mon, 29 Aug 2022 00:33:21 +0400

Bash case statements

Here is the truth about case in Bash: it is not a weaker if – it is a pattern matcher, and patterns are where it earns its keep. When you find yourself writing a chain of [[ $x == … ]] branches, case is usually clearer.

Bash - if statements

Mon, 29 Aug 2022 00:28:43 +0400

Bash - if statements

if [ condition ]; then # you can use [[ ]] also
 your code
fi

if [[ "${UID}" -eq 0 ]]
then
 echo 'You are root'
else
 echo 'You are not root'
fi

#!/bin/bash

if [ $(whoami) = 'root' ]; then
	echo "You are root"
fi

In one line:

Emacs Notes

Sun, 28 Aug 2022 12:15:52 +0400

Emacs Notes

Start an emacs server.

systemctl --user enable emacs

Close an emacs client, see delete-frame

Copy emacs text to the clipboard:

(custom-set-variables '(x-select-enable-clipboard t))

(global-set-key "\C-w" 'clipboard-kill-region)
(global-set-key "\M-w" 'clipboard-kill-ring-save)
(global-set-key "\C-y" 'clipboard-yank)
2{Notes from Mastering Emacs}
In Emacs, the buffer is the data structure.

Useful tips

Use ‘C-x ESC ESC’ (‘repeat-complex-command’)

Navigating Parenthesis

NavigatingParentheses

systemd

Sun, 28 Aug 2022 11:55:25 +0400

systemd

Here is the truth about systemd: it is not “just an init system” – it is a suite that starts the system, supervises services, manages sockets, timers, mounts, devices and logs, and it has largely won. Love it or not, on most Linux boxes in 2026 it is PID 1, and you need to speak its language.

Purescript

Sat, 27 Aug 2022 00:18:37 +0400

Purescript

Here is the truth about PureScript: it’s Haskell’s ideas, aimed at the places JavaScript runs. You get strong static types, purity and type classes, and out comes small, readable JavaScript.

The V Programming Language

Thu, 25 Aug 2022 02:35:41 +0400

The V Programming Language

Here is the truth about V: it wants to be the language you can learn in a weekend and ship with on Monday – Go’s simplicity, C’s speed, Rust’s safety goals, without the steepest parts of any of them. Whether it fully delivers depends on what you need, but the ambition is clear and the tooling is pleasant.

Javascript Control Flow

Wed, 24 Aug 2022 01:03:54 +0400

Javascript Control Flow

Equality

Triple Equals
```
 1 === 1;
```
type
value
Double Equals
```
 1 == 1;
```
Weird Examples

 0 == "0" // true
 0 == "" // true
 0 == [] // true

 0 == null // false
 0 == undefined // false

 "true" == true // false
 "false" == false // false

```
 5 == "5";
```
```
 5 === Number("5");
```
Truthy or Falsy?

 "" // falsy
 [] // truthy
 () // truthy
 NaN // falsy
 Infinity // falsy
 0 // falsy

 "" == false // true
 0 == false // true
 0n == false // true
 Nan == false // false
 null == false // false
 undefined == false // false

memorize the 7 falsy values
- ""
  - 0
  - 0n
  - NaN
  - undefined
  - null
  - false

null == null // true
null == false // false
null == true // false

Objects

Javascript Data Types

Wed, 24 Aug 2022 00:05:54 +0400

Javascript Data Types

There are 8 fundamental data types:

Numbers, Strings, Booleans, Objects, Functions, Undefined, Bigints, Symbols

Variables don’t have types. The values have types. remember to use typeof operator.

Numbers

5 0b101 0o5 0x5 5e7

1. ```
10 * "string" => NaN
10/0 => Infinity
-10/0 => -Infinity

Strings
`"" ’’ ```

let s = “Jane is good” s.length //12 s.toLowerCase() s.toUpperCase()

Common Lisp

Tue, 23 Aug 2022 01:36:02 +0400

Common Lisp

Here is the truth that took me years to see: Common Lisp is not an old language that refused to die – it’s a living system that was finished early. It was standardised in 1994, and code written then still runs unchanged today on fast, native-code compilers. Few languages can say that.

pacman

Tue, 23 Aug 2022 00:11:07 +0400

pacman

pacman -Syu

S stands for sync, y is for refresh (local cache), u is for system update.

pacman -R package_name_ ;to remove a package

To remove a package and its dependencies which are not required by any other installed package:

Working with Windows WSL

Thu, 18 Aug 2022 04:39:08 +0400

Working with Windows WSL

Here is the truth about WSL: it isn’t Linux “emulated” on Windows – it’s a real Linux kernel running in a lightweight virtual machine, wired so tightly into Windows that it feels native. Once you know that, its quirks (networking, file speed, memory) all make sense.

Racket

Wed, 17 Aug 2022 01:06:30 +0400

Racket

Racket is an evolution of the Scheme Language. A Scheme with Batteries and more. Read R6RS Scheme Specs. It always helps.

Initial Grammar

 program ::= {expr | test | def}*
 def ::= (define <variable name> expr)
 test ::= (check-expect expr expr)
 expr ::= string
 ::= number
 ::= (<function> expr*)
 ::= <variable name>
 string ::= "<character>"
 number ::= positive
 ::= negative
 positive ::= mag
 negative ::= -mag
 mag ::= int
 ::= real
 ::= fraction
 int ::= digit*
 digit ::= 0|1|2|3|4|5|6|7|8|9
 real ::= digit*.digit*
 fraction ::= int/nonzero-int
non-zeroint::= <1|2|3|4|5|6|7|8|9>int

DrRacket

If using DrRacket as an IDE. You can get auto-complete while typing “ctrl-/”

Haskell

Sun, 31 Jul 2022 04:52:11 +0400

Haskell

Here is the truth about Haskell: it is the language where the type checker is not a nag – it is a collaborator that writes half the program with you. Once you accept that purity and laziness are features, a lot of software architecture lessons fall out for free.

Web Development Reading List

Fri, 29 Jul 2022 03:02:45 +0400

Web Development Reading List

The web moves fast; good primers don’t. This list is a short shelf of pages that still repay reading – HTML structure, Open Graph tags, favicons done properly. I’ll add to it when something earns a permanent place rather than a week of hype.

Computing Videos and Articles

Wed, 27 Jul 2022 02:13:37 +0400

Computing Videos and Articles

A handful of talks and articles that changed how I think about software – not an algorithmically sorted ocean. Prefer one slow viewing with a notebook open over twenty tabs of background noise.

Python Keywords

Sun, 05 Sep 2021 05:50:54 +0400

Python Keywords

Here is the truth about Python keywords: there are only a few dozen of them, they are the grammar of the language, and you cannot use them as names. Everything else is a builtin or an ordinary identifier.

What it is, in plain words

A keyword (reserved word) is a token the Python parser treats specially. As of Python 3.12/3.13 the set includes:

Input / Output IO

Sat, 28 Aug 2021 07:09:06 +0400

Input / Output IO

Here is the truth about I/O in PicoLisp: everything is a stream or a list of characters, and the same functions that print to your terminal can print into a socket, a file or a string. Once you meet in, out and prin, the rest is composition.

new

Sat, 28 Aug 2021 06:47:27 +0400

new

(new ['flg|num] ['typ ['any ..]]) -> obj

Creates and returns a new object.

If flg is given and non-NIL, the new object will be an external symbol (created in database file 1 if T, or in the corresponding database file if num is given).

typ (typically a list of classes) is assigned to the VAL, and the initial T message is sent with the arguments any to the new object.

box

Sat, 28 Aug 2021 06:45:21 +0400

Computing | Picolisp | ASM | Pil Tutorials |

box

Here is the truth about box in PicoLisp: it is a tiny mutable cell – a cons whose purpose is to hold something that changes while the identity of the cell stays put. When you need a shared, updatable place without inventing a class, you reach for a box.

What it is, in plain words

(box Val) creates a new cell with Val as its value. Access and update with val and set (or related patterns). Because PicoLisp is dynamically typed and list-oriented, a box is often enough where another language would demand an object or an IORef.

Lambda Calculus

Sat, 28 Aug 2021 03:24:22 +0400

Lambda Calculus

Here is a truth that still amazes me: you can build all of computation out of nothing but functions. No numbers, no booleans, no loops, no variables that change – just making functions and applying them. That tiny system is the lambda calculus, and every Lisp, every closure, every => in JavaScript descends from it.

Functional Programming

Sat, 28 Aug 2021 03:19:02 +0400

Functional Programming

Here is the truth functional programming keeps repeating until it sinks in: if you stop changing things, most of your bugs disappear. You write functions that take values and return new values, and you build programs by composing them.

Julia

Fri, 27 Aug 2021 10:40:18 +0400

Julia

This page is derived in large part from the : Think Julia Book. Get new packages at: Julia Observer.

 Keywords
 abstract type baremodule begin break catch
 const continue do else elseif
 end export finally for false
 function global if import in
 let local macro module mutable struct
 primitive type quote return true try
 using struct where while

Operators
- isa
  - n isa Int64
Values and Types
- nothing
  - ```
   typeof(nothing) --> Nothing
```
Formal and Natural Languages
Variables, Expressions and Statements
- Variable names can be as long as you like. They can contain almost all Unicode characters, but they can’t begin with a number.
  - typing unicode: \\:turtle: TAB, \\pi TAB, if you press tab twice you get suggestions
  - The subscript numbers are available in the Unicode character encoding \\_1 TAB, \\_2 TAB, etc. .
  - Superscript numbers are also available ;{ ^2 TAB

Assignment Statements Variable Names Expressions and Statements An expression is a combination of one or more values, variables and operators. A statement is a unit of code that has an effect. Operator Precedence String Operations

Using the C Debugger

Fri, 27 Aug 2021 01:41:01 +0400

Using the C Debugger

The GBD Tutorial, Online Docs

Compile your program with ‘-g’
```
gcc -g main.c
```
run gbd
```
gdb a.out
```
exit gbd
```
(gdb) quit
```

Common Commands

C Syntax

Fri, 27 Aug 2021 00:51:47 +0400

C Syntax

if (TEST) {
 CODE;
} else if(TEST) {
 CODE;
} else {
 CODE;
}

SWITCH

switch(OP) {
 case CONST:
 CODE;
 break;
 default:
 CODE;
}

cppreference:switch
WHILE
```
while(TEST) {
 CODE;
}
```

while(TEST){
 if(TEST2){
 continue;
 }
 CODE;
}

while(TEST){
 if(TEST2){
 break;
 }
 CODE;
}

DO
```
do {
 CODE;
} while(TEST)
```
FOR
```
for (INIT; TEST; POST) {
 CODE;
}
```
ENUM
```
 enum{CONST1, CONST2} NAME;
```
GOTO

if(TEST){
 goto somewhere
}
somewhere:
 CODE;

FUNCTION

TYPE NAME(ARG1, ARG2, ..) {
 CODE;
 return VALUE;
}

TYPEDEF
```
typedef DEF ID;
```
STRUCT
```
struct NAME {
 ELEMS;
} [VAR_NAME];
```

typedef struct [STRUC_NAME] {
 ELEMS;
} ID

UNION
```
union NAME {
 ELEMS;
}[VAR_NAME]
```

Operators

Fri, 27 Aug 2021 00:40:19 +0400

Operators

Operator tables for quick reference – arithmetic, assignment, bitwise, logical and relational. Pictures beat paragraphs when you just need to remember precedence. For deeper C notes see C Programming and Literals.

The Vikid PicoLisp Tutorial

Thu, 26 Aug 2021 01:17:21 +0400

The Vikid PicoLisp Tutorial

Start picolisp

$ pil +

Set some values

(setq A '(This is the value)) # Set the value of 'A'

(put 'A 'key1 'val1) # Store property 'key1'

(put 'A 'key2 'val2) # and 'key2'

inspect them with ‘show’

(show 'A) # Now 'show' the symbol 'A'

(put 'B 'a 'A) # Put 'A' under the 'a'-property of 'B'

(setq Lst '(A B C)) # Create a list with 'B' as second argument

(show Lst 2 'a) # Show the property 'a of the 2nd element of 'Lst'

using vi and v.

Operating Systems

Sun, 22 Aug 2021 04:38:43 +0400

Operating Systems

Virtualization

Here’s the truth behind virtualization: an operating system is just a program that thinks it owns the hardware. Give it something that looks like hardware, and it will happily run – alongside a dozen others on the same machine. That simple trick underpins the cloud, CI pipelines and most server rooms on Earth.

nmtui

Sun, 22 Aug 2021 04:29:28 +0400

nmtui

Here’s the truth about Linux networking in 2026: you rarely configure interfaces by hand any more – a daemon does it, and you just tell the daemon what you want. On most desktops that daemon is NetworkManager, and nmtui is the friendliest way to talk to it from a terminal.

NCDU

Sun, 22 Aug 2021 04:26:18 +0400

NCDU

The truth about a full disk is that it is almost never “everything, a little bit”. It is usually one or two forgotten directories eating most of the space. ncdu is the tool that points straight at them.

What it is, in plain words

ncdu (NCurses Disk Usage) is a terminal program that scans a directory tree, adds up how much space everything takes, and then lets you walk the result interactively: biggest things at the top, arrow keys to dive in, d to delete. It is du with eyes.

Web Development

Sun, 22 Aug 2021 01:20:19 +0400

Web Development

Here is the truth about web development in 2026: the web is still three languages in a trench coat – HTML, CSS and JavaScript – and everything else is tooling piled on to keep those three under control at scale. Learn the three deeply; treat frameworks as temporary.

Vikid's Bash Cookbook

Thu, 29 Jun 2017 06:21:51 +0400

BASH | Bash Cookbook |

Vikid’s Bash Cookbook

Some Simple Stuff

bash --version

ls -adFlLQrRS1

pwd -L, pwd -P

type which, type -a which

apropos zip => man -k, locate which

find

stat, file -b

chsh -s /bin/bash

passwd -el

sudo cat /etc/shells

Common Shell Variables

$USER
$- list all current option flags

Download a website

wget -r -np -k http://somesite.com

Options:

-r (recursive)
-np (don’t follow links to parent directories)
-k to make links in downloaded HTML or CSS point to local files
-nd (no directories): download all files to the current directory
-e robots.off: ignore robots.txt files, don’t download robots.txt files
-A png,jpg: accept only files with the extensions png or jpg
-m (mirror): -r –timestamping –level inf –no-remove-listing
-nc, –no-clobber: Skip download if files exist

Quoting

echo value is $3?!
echo "value is $3?!"
echo 'value is $3?!'

!" is history substitution

C Standard Library

Thu, 29 Jun 2017 02:39:49 +0400

C Standard Library

Here is the truth about the C standard library: it is a small, sharp toolkit – I/O, memory, strings, maths, time – that every hosted C program leans on, and its sharpest edges are still the string and unchecked I/O functions. Knowing what is in ISO C versus what your OS adds is half of reading real code.

vers.h

Thu, 29 Jun 2017 02:06:42 +0400

vers.h

Here is the truth about versioning shell helpers: a tiny wrapper that prints versions of the tools you actually use saves more time than it has any right to. When something breaks after an update, “what am I running?” should be a one-liner.

Picolisp Tutorials

Sat, 24 Jun 2017 03:42:32 +0400

Picolisp Tutorials

Here is the truth about learning PicoLisp: the language is small enough that tutorials can take you from zero to a working app without a 900-page book. The hard part is not syntax – it is trusting that lists, symbols and a handful of forms really are enough.

Find Boxes in Lists

Wed, 21 Jun 2017 13:31:50 +0400

Find Boxes in Lists

Here is the truth about finding boxes on a network: most “discovery” is just asking politely which doors are open, then writing down who answers. The skill is doing it thoroughly, quietly enough for the context, and only where you have permission.

What it is, in plain words

Finding boxes means enumerating live hosts and interesting services on a network – the first phase of any lab, inventory or authorised penetration test. Tools range from a single ping to full-fat scanners like nmap. On a home LAN it is how you remember which Pi has which IP; on an engagement it is how you build the map.

RasberryPi

Sun, 18 Jun 2017 06:20:17 +0400

RasberryPi

Here is the truth about the Raspberry Pi: it’s a real computer that costs about as much as a meal out, small enough to forget in a drawer and open enough to understand all the way down to the pins. That combination is why it changed how people learn computing.

What it is, in plain words

The Raspberry Pi is a family of single-board computers made by Raspberry Pi Ltd (the trading arm of the UK Raspberry Pi Foundation, an education charity). The first model shipped in 2012. A Pi is a whole computer on one board: an ARM processor (Broadcom system-on-chip), RAM, USB, networking, HDMI output, and – the special part – a 40-pin GPIO header that lets software switch real electrical signals on and off.

Algorithms

Mon, 08 May 2017 05:00:32 +0400

Algorithms

Here is the truth about algorithms: they are recipes, and the interesting question is not “does it work?” but “how does the cost grow when the input gets bigger?” Once you start seeing growth rates, a lot of software design stops being guesswork.

penti

Tue, 13 Dec 2016 03:15:15 +0400

Penti

Here is a truth about typing that Alexander Burger (the creator of PicoLisp) took seriously: ten fingers on a QWERTY keyboard is not the only way – and for some jobs, not the best way. Penti is his five-finger keyboard layout: one hand, five keys, every character reachable by chords.

What it is, in plain words

Penti is a chorded keyboard system. You rest five fingers of one hand on five keys (by default the home row asdfg or hjkl;), and you type by pressing combinations of them – chords – instead of hunting for individual keys. A single finger produces a letter; two or three together produce others; modifiers give digits, symbols and control keys. The whole alphabet, numbers and punctuation fit under one hand.

Online VPS, SaaS, PaaS, IaaS

Mon, 12 Dec 2016 22:38:11 +0400

Online VPS, SaaS, PaaS, IaaS

Here is the truth about a VPS: you are renting a virtual machine that thinks it is a computer, and you are its sysadmin. The freedom is real; so is the responsibility when the cron job fills the disk at 3 a.m.

What it is, in plain words

A VPS (Virtual Private Server) is a virtual machine sold by a host – Linode/Akamai, DigitalOcean, Hetzner, OVH, Vultr, Oracle Cloud’s free tier, and many smaller providers. You get a public IP, a chosen Linux image (or your own), CPU/RAM/disk quotas, and root access. Underneath, it’s a KVM (usually) guest on hardware you don’t own.

Using Linode

Mon, 12 Dec 2016 22:15:06 +0400

Using Linode

Here is the truth about Linode: it was one of the first hosts to make renting a serious Linux machine feel like a commodity, and after the Akamai acquisition that spirit mostly survived. A Linode is just a good VPS with a clean API and sane networking defaults.

What it is, in plain words

Linode is a cloud/VPS provider founded in 2003, acquired by Akamai in 2022. You rent virtual machines (Linodes / Nanodes / dedicated CPU instances), object storage, Kubernetes (LKE), managed databases and node balancers in a few dozen regions. Images include Ubuntu, Debian, Alpine, Arch and custom uploads; rescue mode and out-of-band console exist when you lock yourself out.

Logging into Servers with SSH

Mon, 12 Dec 2016 05:11:02 +0400

Logging into Servers with SSH

Here is the truth about SSH: the password is the weakest part of it, and you should almost never use one. SSH is how you get a shell on another machine securely; keys are how you do it without turning a password guess into a break-in.

What it is, in plain words

SSH (Secure Shell) is a protocol and a set of tools (ssh, scp, sftp, ssh-keygen, ssh-agent) that give you an encrypted channel to another computer. Typical uses:

The Vikid Arch Linux Wiki!

Sun, 11 Dec 2016 21:49:05 +0400

The Vikid Arch Linux Wiki!

Here is the truth about Arch Linux: it is not hard – it is manual. Every other distro hides decisions behind an installer; Arch asks you to make them, documents every step, and then gets out of the way. That is either exactly what you want or exactly what you don’t.

What it is, in plain words

Arch Linux is an independently developed, rolling-release GNU/Linux distribution for x86-64 (with official ports for other architectures under the Arch Linux name). Its personality:

Node Js

Sun, 11 Dec 2016 00:02:18 +0400

Node Js

Official Node Documentation On older Ubuntu releases the command was nodejs, not node:

ln -s /usr/bin/nodejs /usr/bin/node

Mixu’s Node Book

Install NVM Manjaro Linux

Use Node Version Manager, NVM.

sudo pacman -S nvm

nvm install --lts
npm install "package name"
nvm uninstall --lts

Getting Started npm

npm install <package-name>

flags:

Ubuntu CommonTasks

Sat, 10 Dec 2016 06:21:07 +0400

Ubuntu CommonTasks

Here is a truth about Ubuntu: most “how do I…?” questions have one canonical answer, and once you know the pattern you stop searching. This page is a pocket card of those answers – the tasks people actually do on a fresh Ubuntu box.

What it is, in plain words

Ubuntu is Debian’s friendlier cousin: same .deb packages and apt, a fixed release cadence (April and October), with LTS releases supported for five years (ten with Ubuntu Pro). The current LTS at the time of writing is 24.04 “Noble Numbat”; non-LTS releases get nine months. Underneath, since 15.04, the init system is systemd, so service management is systemctl and logs are journalctl – the old service apache2 status style still works as a thin wrapper, but the native commands are the ones to learn.

Linux Introspection

Fri, 09 Dec 2016 21:44:03 +0400

Linux Introspection

Here’s a truth that makes Linux wonderful to learn on: the system will tell you almost everything about itself if you just ask. No hidden registry, no magic – mostly plain text files and a handful of honest little commands.

What it is, in plain words

Introspection means a system examining itself. On Linux that means finding out: what distribution and kernel am I running, what hardware is here, what’s running, what’s using the disk, the memory, the network – and why it booted the way it did.

Computer Languages Centre

Fri, 09 Dec 2016 12:41:12 +0400

Computer Languages Centre

Here is the truth about computer languages: they are not competing religions – they are tools shaped by different bets about what matters. Syntax is the paint; the bets (typing, memory, evaluation order, metaprogramming) are the structure.

What it is, in plain words

A programming language is a notation for expressing computation that a machine can carry out. Languages differ along a handful of axes:

Axis	Options	Examples
Typing	static / dynamic / gradual	Rust / Python / TypeScript
Evaluation	strict / lazy	C, JS / Haskell
Memory	manual / GC / ownership	C, Zig / Java, Go / Rust
Paradigm	imperative, FP, OO, logic, concatenative	C, Haskell, Smalltalk, Prolog, Forth
Level	close to metal ↔ close to problem	Assembly ↔ SQL, HTML

“Level” is a spectrum, not a moral hierarchy. Assembly and PicoLisp can both be the right answer.

TLS - Transport Layer Security

Tue, 06 Dec 2016 00:48:26 +0400

TLS - Transport Layer Security

Here is the truth about TLS: it is the reason the lock icon means anything – a protocol that turns an open pipe into a private, authenticated conversation. HTTPS is just HTTP spoken through that pipe.

What it is, in plain words

TLS (Transport Layer Security), successor to the old SSL, is the cryptographic protocol that provides:

pmap

Sun, 04 Dec 2016 04:11:39 +0400

linuxtools

pmap

The truth about a running program’s memory is that it isn’t one big block – it’s a patchwork map of regions, each with its own purpose and permissions. pmap prints that map.

What it is, in plain words

pmap (from the procps-ng package, installed almost everywhere) reports the memory map of a process: every region of virtual address space it has, how big each is, what permissions it has (read, write, execute), and what backs it – a file like /usr/lib/libc.so.6, the heap, the stack, or anonymous memory.

Linux Memory and Process

Sun, 04 Dec 2016 03:19:10 +0400

Linux Memory and Process

The truth behind every running program on Linux: each process believes it has the whole machine’s memory to itself. It doesn’t. The kernel and the CPU are running a very convincing illusion called virtual memory, and once you see how it’s staged, processes stop being mysterious.

Learn Online the Vikid Way

Sun, 04 Dec 2016 02:16:52 +0400

Learn Online the Vikid Way

Here is the truth about learning computing online: the net is a library the size of a planet, and without a reading list you will stand in the doorway forever. The skill is not finding content – it is choosing a thin path and walking it until something clicks.

What it is, in plain words

Online learning for computing means using tutorials, books, courses, documentation, videos and repositories to build skill – usually alone, usually around a day job. It works astonishingly well if you treat it like apprenticeship (make things, show them, fix them) and fails when you treat it like television (watch, nod, forget).

iPython

Sat, 03 Dec 2016 00:34:08 +0400

iPython

Here is the truth about IPython: the best place to learn Python is not a file – it’s a prompt that remembers what you just did, shows you plots, and lets you edit the last thought. IPython is that prompt, and Jupyter is the notebook built around it.

SciPy

Sat, 03 Dec 2016 00:30:25 +0400

SciPy

Here is the truth about SciPy: it is the standard library Python never shipped for science and engineering. Where NumPy gives you arrays, SciPy gives you the algorithms that use them – integration, optimisation, signal processing, statistics, sparse linear algebra and more.

What it is, in plain words

SciPy (pronounced “sigh pie”) is an open-source Python library built on NumPy. It collects battle-tested implementations of classical numerical methods, many of them wrappers around the same Fortran and C libraries (QUADPACK, FFTpACK, ARPACK, ODEPACK, LAPACK) that scientists have trusted for decades. The top-level packages you’ll actually import:

NumPy

Sat, 03 Dec 2016 00:29:14 +0400

NumPy

Here is the truth that makes Python fast at maths: the maths isn’t actually done in Python. NumPy hands whole arrays to compiled C (and Fortran-descended) code in one go, and that single idea – think in arrays, not loops – is what makes the whole scientific Python world possible.

Git

Fri, 02 Dec 2016 02:13:11 +0400

Git

Here is the truth about Git that finally made it click for me: it is not a backup tool and not a file-sync tool – it is a content-addressed database of snapshots, with pointers. Once you see the graph of commits, every confusing command becomes a way of moving those pointers around.

Machine Learning

Thu, 01 Dec 2016 22:59:57 +0400

Machine Learning

Machine learning in a Nutshell:

Data: Raw Environment
Model: Maps input –> Output
Learning: Optimizes Models by finding better parameters to models (patterns).
Predictor: A MLA that is a system that makes predictions
We Represent Data as Vectors
Choose a Model
Optimize using numerical methods

The mathematics needed:

Linear Algebra
- Systems of Equations
  - Matrices
  - Vector Spaces
  - Linear Mappings
  - Affine Spaces
Analytic Geometry
Matrix Decomposition
Vector Calculus
Probability Distributions
Continuous Optimisation
Models vs Data
Linear Regression
Dimensionality
Principal Component Analysis
Density Estimation (Gaussian Mixture Models
Classification with Support Vector Machines

Sources, Links and Reading Lists

Types of Malware

Thu, 01 Dec 2016 02:33:47 +0400

Types of Malware

Here is the truth about malware types: the labels (virus, worm, trojan, ransomware…) describe how a program spreads or what it demands – not how sophisticated it is. A boring script with a clever delivery path beats a clever payload nobody installs.

Scheme

Wed, 30 Nov 2016 08:50:15 +0400

Scheme

I am partial to scheme, I always really appreciated it.

 (define (max-of-list lst)
 (foldr max (first lst) (rest lst)))

R6RS - Revision 6 Scheme Standard

Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major … Read more.

Picolisp Databases

Wed, 30 Nov 2016 08:06:23 +0400

Picolisp Databases

Here is the truth about PicoLisp’s database: it is not a bolt-on library – it is the language’s own object system, made durable. Entities and relations are first-class, transactions are built in, and there is no ORM because you never leave Lisp.

Databases

Wed, 30 Nov 2016 07:56:19 +0400

Databases

Here is the truth about databases: persistence is hard, and “just write it to a file” becomes a nightmare the moment two writers, a crash or a query show up. A database is the carefully engineered answer to those three problems.

Data Recovery

Wed, 30 Nov 2016 06:33:38 +0400

Data Recovery

Here is the uncomfortable truth about data recovery: the moment you notice you’ve lost something, every further write to that disk may be destroying it. Stop. Think. Then recover. Most “I undeleted my files” success stories start with that pause.

What it is, in plain words

Data recovery is retrieving information that seems gone – deleted files, a formatted partition, a filesystem the OS won’t mount, a drive that clicks. It works because “delete” usually means “forget the pointer”, not “erase the bytes”. Until those bytes are overwritten, a tool that understands the filesystem (or ignores it and carves raw content) can find them again.

Network Protocols and Technologies

Wed, 30 Nov 2016 05:18:36 +0400

Network Protocols and Technologies

It probably hasn’t escaped you attention that Computer Networks (Social and Otherwise) are possibly one of the most important technologies invented in the last century. But how do they work? I mean really work under the hood?

Simple Linux Configuration

Wed, 30 Nov 2016 04:21:15 +0400

Simple Linux Configuration

Here is the truth about configuring Linux: almost everything is a text file, and the system will tell you which one if you ask. Once that sinks in, “configuration” stops being a mystery and becomes a short list of files you actually touch.

Assembly Languagess

Wed, 30 Nov 2016 01:43:52 +0400

Assembly Languagess

Links, Sources and Reading List

Some Notes:

ebp is known as the base pointer or the frame pointer.

 1. On entry to your function, you push it (to save the value for the calling function).

 2. Then, you copy esp, the stack pointer, into ebp, so that ebp now points to your function's stack frame.

 3. At the end of your function, you then pop ebp so that the calling function's value is restored.

For some clarification on exactly what is going on -
the push instruction:

 1. puts the value from the specified register (ebp in this case), onto the stack, and
 2. decrements the stack pointer by the appropriate amount.

The pop operation is the opposite -

 1. it increments the stack pointer and takes a value from the stack and
 2. puts it in the specified register.

Linux Tools

Tue, 29 Nov 2016 09:36:50 +0400

Linux Tools

Here is a truth every Linux user eventually learns: the system is covered in small, sharp tools, and fluency means knowing which one to reach for. You don’t memorise every flag – you memorise the names, so that when a problem appears you think “that’s a job for strace” instead of staring at it.

What it is, in plain words

“Linux tools” here means the everyday command-line utilities that inspect, control and debug a running Unix system. Some come from GNU coreutils (ls, cp, sort), some from util-linux and procps-ng (ps, free, mount), some from binutils (objdump, nm, readelf), and some are specialised projects of their own (strace, tcpdump, ncdu). Together they are how you see what the kernel and your programs are actually doing.

Data Structures and Alogrithms

Tue, 29 Nov 2016 00:16:23 +0400

Important Caveat Emptor!

Data Structures and Alogrithms

Here is the truth about data structures and algorithms: a data structure is a bet about which questions you’ll ask most, and an algorithm is how you answer them. Pick the wrong bet and even brilliant code crawls.

What it is, in plain words

This page sits beside Algorithms as a more structure-focused map. The classic cast:

Structure	Good at	Weak at
Array / slice	Index access $O(1)$	Insert at front
Dynamic array (Vec, list)	Amortised append	Mid inserts
Linked list	Splice if you have a pointer	Random access
Stack / queue	LIFO / FIFO patterns	Search
Hash table	Lookup/insert average $O(1)$	Range queries, ordering
BST / tree map	Ordered ops $O(\log n)$	Cache locality vs hash
Heap	Min/max repeatedly	Arbitrary delete
Graph (adj list)	Sparse relations	Dense matrix ops
Trie	Prefix search	Memory use

Why it matters

Databases, compilers, games, routers and ML frameworks are data-structure museums. When a feature is slow, the fix is often “wrong structure” rather than “buy a bigger CPU”. See also big-O notes on the Algorithms page.

Computer Science and Theory

Tue, 29 Nov 2016 00:14:23 +0400

Important Caveat Emptor!

Computer Science and Theory

Here is the truth about computer science: it is not the study of computers any more than astronomy is the study of telescopes. It is the study of processes – what can be computed, how fast, how reliably, and how we express those processes so others (and machines) can carry them out.

What it is, in plain words

Computer science (CS) is the body of ideas that underpins programming, systems and computation itself. A useful map of the territory:

Firewalls

Mon, 28 Nov 2016 10:07:35 +0400

Firewalls

Here is the truth about firewalls: they are not a magic shield – they are deliberate rules about who may speak to whom. A misconfigured firewall is either a locked door with the window open, or a doorstop.

What it is, in plain words

A firewall filters network traffic according to rules. It can run:

Cool Hardware

Mon, 28 Nov 2016 07:03:09 +0400

Cool Hardware

Here is the truth about cool hardware: the best gadgets are the ones that make you understand computing better, not the ones that merely look clever on a desk. A blinking LED you wired yourself beats a sealed plastic brick you can’t open.

What it is, in plain words

This page is a living shelf of hardware worth knowing if you like to tinker: small computers, microcontrollers, unusual keyboards, radios, and tools that sit at the boundary between software and electrons. It is not a buying guide for the latest phone. It is a list of things that teach.

Metasploit & Armitage

Mon, 28 Nov 2016 05:59:34 +0400

Metasploit & Armitage

Here is the truth about Metasploit: it is a library of known doors and the tools to push them – useful in a lab and a liability anywhere you lack permission. The Framework is not magic; it packages other people’s vulnerability research into a consistent interface.

What it is, in plain words

The Metasploit Framework (open source, Rapid7) is a platform for developing, organising and running exploits. Core ideas:

Ettercap

Mon, 28 Nov 2016 02:47:13 +0400

Ettercap

Here is an uncomfortable truth about local networks: most of them still trust whoever is plugged in. Ettercap is the classic tool that demonstrates what a machine sitting on the same LAN can do to that trust – mostly by quietly inserting itself into other people’s conversations.

What it is, in plain words

Ettercap is a free and open-source suite for man-in-the-middle (MITM) attacks on a local network. It can:

Python Language Notes

Sun, 27 Nov 2016 21:45:02 +0400

Python Libraries, tools and Links | Official Python Docs | Intro to Pygame | spaCy

Python Language Notes

Lexical Analysis
Keywords

name ::= lc_letter (lc_letter | "_")*
lc_letter ::= "a"..."z"

1. **Operators and Builtin Functions**
1. 1. **All Types**
 1. ```
 type(obj) --> type object
 ```
 1. ```
 isinstance(obj, typ) --> bool
 ```
 1. ```
 repr(obj) #evaluatable representation
 ```
 1. ```
 str(obj) #printable representation
 ```
 1. ```
 is, is not # are two objects the same
 ```
1. - **All Numeric Types**
 - - ` abs(-1) # 1`
 - ` chr(65) #'A' `
 - ` ord('A')#65 `
 - ` complex(1) #(1+0j) `
 - ` divmod(25,7) #(3,4) `
 - ` pow(2,8) #256 `
 - ` round(2.75,1) #2.8, rounds up `
1. **Objects**
1. ```
int, float, bool, dict, set, tuple, str, bytes
 None

Classification
- Primative, Numeric, Sequence, Container: Can contain other types, Collection
- Common use cases
- - Dictionaries for lookups
    - Tuples for data that is invariant at runtime
    - Lists for dynamic runtime data
Primative Types
- bool -> True, False
- - bool(float("NaN")) --> True
    - bool(0.0) --> False
    - bool(0) --> False
    - bool([]) --> False
- int
- - 2**31 - 1
    - binary: 0b10, bin(20) #'0b10100'
    - octal: 0o77, oct(20) #'0o24"
    - hex: 0xFF, hex(20) #'0x14'
    - int(3.5); int("3.5"); int("1111", 1) --> 15
    - abs(-1)
    - 1//3 #0, integer division
- float
- - 1.41
    - 3e-5
    - float(3), float("3.14")
    - float("nan"), float("inf"), float("-inf")
    - : {round(1.234, 2)
Complex
```
complex(2,3) #(2+3j)
```

1. **Sequence** (Builtin Functions)
1. `len(obj)`
1. - **character** (char): `ord(char)` --> int
 - **strings**
 - ```
 help(str)
 >>> m = """This is
 ... a multiline
 ... string"""
 'This is\na multiline\nstring'
 print(m)
 str(666)
 "Vi er så glad for å høre og lære om Python!" # 'Vi er så glad for å høre og lære om Python!'
 "Vi er s\u00e5 glad for \u00e5 h\xf8re og l\u00e6re om Python!" ' #Vi er så glad for å høre og lære om Python!'
 ```
 - ```
 '\\xe5'
 'å' 
 ```
 - ```
 '\\345' 'å'
 ```
 - ```
 str.title(), str.upper(), str.lower, str.lstrip(), .rstrip, .strip
 var = 'in'
 print(f"I am {var} trouble!")
 ```
 - **f**
 - raw strings `r'this is t raw'`
 - - implicit concatantion `"hello" "world"`
 - bytes `b'this is a byte string'`
 - ```
 b'this is a byte string'.split()
 [b'this', b'is', b'a', b'byte', b'string']
 "Vi er så glad for ".encode('utf-8')
 b'Vi er sa\\xcc\\x8a glad for '.decode('utf-8')
 ```
 - **bytearray**
 - **tuple**
 - ```
 (1,2)
 (False, 1, 'c')
 (2,) + (9,) => (2,9)
 ```
 - **Lists**
 - ```
 [1,2,3]
 [True, False, '7']
 ```
 - ```
 append(x), count(x), extend(L), index(x), insert(x), insert(i,x), pop(x), remove(x), reverse(), sort()
 ```
 - ```
 alist = [0, 1, 2, 3]
 del alist[2] #[0, 1, 3]
 ```
 - **slice**
 - ```
 mylist[:]
 ```
 - - **Sorting Lists**
 - ```
 sorted() #generate a copy
 sort
 sorted(x, reverse=True)
 reverse()
 ```
 - **Numerical Lists**
 - ` range() `
 - ```
 list(range(5))
 list(range(5,11))
 nums = []
 for exp in range(5):
 nums.append(2**exp)
 ```
 - **List Comprehensions**
 - ```
 [2**exp for exp in range(5)]
 ```
 - ` [i**3 for i in range(10) if True] `
 - ```
 f = open("test.txt", 'r')
 data = [line.strip for line in f]
 f.close()
 # now process data
 ```
 - **Generator Expressions**
 - *list comprensions*
 - ```
 f = open("test.txt", 'r')
 data = (line.strip for line in f)
 #now process data before closing the file!
 f.close()
 ```
 - **dictionary**
 - ` {key:value}`
 - ` 'key' in dict `
 - ```
 states = {
 	'ca': 'California',
 	'il': 'Illinois',
 	'fl': 'florida',
 	}
 states['ca']
 states.get('xx', 'default value') # equivalant to: states['xx'] if 'xx' in states else 'default value'
 states.setdefault('xx', 'default value') #in not there set and return the key.
 states['ny'] = 'New York'
 del states['il']
 states.values() #dict_values([...]), <class 'dict_values'>
 states.items()
 states.keys()
 ```
 - ```
 has_key(), keys(), values(), dict.items(), clear(), copy(), update(x), get(x,[y])
 ```
 - **Set**
 - ` {1,2,3}`
 - ```
 s = set()
 s.add(1)
 s.add('foo')
 t = set()
 s | t #union of t & s
 ```
 - *Set Comprehensions*
 - ```
 odd = \{i for i in range(10) if i % 2\}
 ```
 - **Frozenset**
 - **Complex**
1. **Modules and Packages**
1. - **Modules**
 - ```
 import module
 import module as mod
 from module import specific_function
 ```
 - **Packages**
 - *maps*
 - ```
 maps/
 __init__.py
 cities.py
 navigation.py
 gpsdata.py
 ```
 - **__init__.py**
 - ```
 import maps 
 ```
 - ```
 maps.navigation.turn_right() 
 ```
1. **Standard Library / Types**
1. - **math**
 - ```
 import math
 math.sqrt(16)
 PI = math.pi
 math.sin(PI)
 math.log(1000, 10)
 ```
 - **Fraction**
 - **Decimal**
 - **Date**
 - **Array**
 - **range**
 - ```
 range(5)
 ```
1. **Converstion Functions**
1. - `int, float, bool, str, tuple, list, dict, set`
 - `chr(int)` --> char
1. **Operators**
1. - ` + 1 * ** / // % `
 - ` ~ >> << & ^ | `
 - ` < > <= >= <> != == `
 - ` and, or, not `
 - ```
 <string | list> + <string | list>
 'five' + 'four'
 <int> * <string | list>
 <obj> in <seq>
 ```
 - **Function application**
 - ` function(args...)`
 - **Indexing**
 - ` seq[index | range] `
 - **Lookup (dictionaries)**
 - ` d[key] `
1. **Expressions**
1. ```
 Operator Precedence
| no. | operators | description |
| 1 | f(...) | function application |
| 2 | o[l] | index lookups |
| 3 | o.f(...) | method call |
| 4 | ** | exponentiation |
| 5 | -N | sign change |
| 6 | *,/,//,% | numeric |
| 7 | +,- | numeric |
| 8 | <, <=, ... | comparisons |
| 9 | in, not in | membership |
| 10 | not o | logical |
| 11 | and 0 | logical |
| 12 | or | logical |

Rules for Well-formedness

R1
```
 Every Value is well formed
```
R2 (E)

 if E is well formed then (E) is well formed

R3 <uop> E

 <uop> is a unary operation
 if E, then <uop> E is well formed

R4 E1 <bop> E2

 <bop> is a binary operation
 if E1, E2, then E1 <bop> E2

R5 E1[E2]
```
 if E1, E2, the E1[E2]
```
R6 F(A, …)

 if F is a function with A, A1, A2, ... expressions
 then F(), F(A), F(A, A1), F(A, A1, A2), ...

R7 if O.f(E)

 if O, f, E, E1, ...
 then O.f(), O.f(E), O.f(E, E1), ...

Printing

print("hello", 'how')
print("hello", end='')
from pprint import *
pprint(expressions)

1. **Functions**
1. *anonymous*
1. - **lambda**
 - ```
 lambda x: x
 ```
 - **def**
 - ```
 def f(x,y):
 return x + y
 ```
 - ```
 def h():
 "hello"
 #This function returns None
 h() #None
 ```
 - **keyword**
 - ```
 def f(x=0, y=0):
 print("x = ", x, "y = ", y)
 return (x, y)
 f(x=1, 2)
 f()
 f(1)
 ```
 - **Destructuring with Tuples**
 - *positional*
 - ```
 def ff(*a):
 print("first = ", a[0], "Second = ", a[1])
 return (len(a), a)
 ```
 - **Destructuring with Dictionaries**
 - ```
 def fff(**a):
 print(a["first"])
 return a
 ```
 - **destructuring with both**
 - ```
 def g(*a,**b):
 return (a,b)
 ```
1. **Methods**
1. ```
 x+1
 [is actually]
 x.__add__(1)

Magic Methods

__add__(self, y) # x + y
__sub__(self, y) # x - y
__mul__(self, y) # x * y
__mod__(self, y) # x % y
__neg__(self) # -x
__eq__(self, y) # x == y
__ge__(self, y) # x >= y
__gt__(self, y) # x > y
__lt__(self, y) # x < y
__le__(self, y) # x <= y
__ne__(self, y) # x != y
__contains__(self,y) # y in x
__getitem__(self, y) # x[y]
__setitem__(self, i, y) # x[i] = y
__hash__(self) # hash(x)
__int__(self) # int(x)
__iter__(self) # for y in x
__len__(self) # len(x)
__repr__(self) # repr(x)
__str__(self) # str(x)

Some Builtins
```
abs, min, max
type
len
dir
```

gives internal dictionary of names

Penetration Testing

Sun, 27 Nov 2016 11:05:30 +0400

Penetration Testing

Here is the truth about penetration testing: it is authorised breaking, done carefully, so the real breakers have a harder time. Without a clear scope and written permission it is just hacking; with them it is engineering.

What it is, in plain words

A penetration test (pentest) is a structured engagement where an operator attempts to find and exploit vulnerabilities in a system, within agreed rules, and then reports what they found and how to fix it. It answers a sharper question than a vulnerability scan: not “what might be wrong?” but “what can an attacker actually do?”

Linux Security

Sun, 27 Nov 2016 11:05:12 +0400

Linux Security

Here is the truth about Linux security: there is no antivirus product that will save a misconfigured server, and no amount of hardening will save a system you never update. Security is a set of habits – least privilege, small attack surface, quick patches, deep defence – not a package you install.

What it is, in plain words

Linux security covers everything that keeps a Linux system doing only what you intend: authentication, permissions, updates, network exposure, service hygiene, kernel hardening, logging and response. The same kernel runs phones, TVs, supercomputers and the web; the threats differ, but the principles don’t.

Computer Security

Sun, 27 Nov 2016 11:01:30 +0400

Computer Security

Here is the truth about computer security: it is not a product you buy or a department you hire – it is the practice of making systems fail safely when people, software and physics all misbehave. Everything else is technique.

What it is, in plain words

Computer security is the set of ideas and practices that protect the confidentiality, integrity and availability of information and systems (the classic CIA triad). Around those three sit authentication (“who are you?”), authorisation (“what are you allowed to do?”), accountability (logging and audit), and non-repudiation.

Picolisp ASM

Sat, 26 Nov 2016 11:39:51 +0400

Picolisp ASM

 CPU Registers:

 +---+---+---+---+---+---+---+---+
 | A | B | \\ [A]ccumulator
 +---+---+---+---+---+---+---+---+ D [B]yte register
 | C | / [C]ount register
 +---+---+---+---+---+---+---+---+ [D]ouble register
 | E | [E]xpression register
 +---+---+---+---+---+---+---+---+

 +---+---+---+---+---+---+---+---+
 | X | [X] Index register
 +---+---+---+---+---+---+---+---+ [Y] Index register
 | Y | [Z] Index register
 +---+---+---+---+---+---+---+---+
 | Z |
 +---+---+---+---+---+---+---+---+

 +---+---+---+---+---+---+---+---+
 | L | [L]ink register
 +---+---+---+---+---+---+---+---+ [S]tack pointer
 | S |
 +---+---+---+---+---+---+---+---+

 +-------------------------------+
 | [z]ero [s]ign [x,b,c]arry | [F]lags
 +-------------------------------+

 Source Addressing Modes:
 ld A 1234 # Immediate
 ld A "(a+b-c)"
 ld A R # Register
 ld A Global # Direct
 ld A (R) # Indexed
 ld A (R 8) # Indexed with offset
 ld A (R OFFS)
 ld A (R Global)
 ld A (Global) # Indirect
 ld A (Global OFFS) # Indirect with offset
 ld A ((R)) # Indexed indirect
 ld A ((R 8)) # Indexed with offset indirect
 ld A ((R 8) OFFS)
 ld A ((R Global) OFFS)
 ld A ((R OFFS) Global)
 ...

 Destination Addressing Modes:
 ld R A # Register
 ld (R) A # Indexed
 ld (R 8) A # Indexed with offset
 ld (R OFFS) A
 ld (R Global) A
 ld (Global) A # Indirect
 ld (Global OFFS) A # Indirect with offset
 ld ((R)) A # Indexed indirect
 ld ((R 8)) A # Indexed with offset indirect
 ld ((R 8) OFFS) A
 ld ((R Global) OFFS) A
 ld ((R OFFS) Global) A
 ...

 Target Addressing Modes:
 jmp 1234 # Absolute
 jmp Label
 jmp (R) # Indexed
 jmp (R T) # Indexed SUBR
 jmp (Global) # Indirect

========================================================================

 Instruction set:
 nop # No operation

 Move Instructions:
 ld dst src # Load 'dst' from 'src' [---]
 ld2 src # Load 'A' from two bytes 'src' (unsigned) [---]
 ld4 src # Load 'A' from four bytes 'src' (unsigned) [---]
 ldz dst src # Load if Zero 'dst' from 'src' [---]
 ldnz dst src # Load if not Zero 'dst' from 'src' [---]
 lea dst src # Load 'dst' with effective address of 'src' [---]
 st2 dst # Store two bytes from 'A' into 'dst' [---]
 st4 dst # Store four bytes from 'A' into 'dst' [---]
 xchg dst dst # Exchange 'dst's [---]
 movn dst src cnt # Move 'cnt' bytes from 'src' to 'dst' (non-overlapping or src < dst)
 mset dst cnt # Set 'cnt' bytes of memory to B
 save src end dst # Save 'src'..'end' to 'dst' (aligned, non-overlapping or src < dst)
 load dst end src # Load 'dst'..'end' from 'src' (aligned, non-overlapping)

 Arithmetics:
 add dst src # Add 'src' to 'dst' [zsc]
 addc dst src # Add 'src' to 'dst' with Carry [zsc]
 sub dst src # Subtract 'src' from 'dst' [zsb]
 subb dst src # Subtract 'src' from 'dst' with Borrow [zsb]

 inc dst # Increment 'dst' [zs.]
 dec dst # Decrement 'dst' [zs.]
 not dst # One's complement negation of 'dst' [z..]
 neg dst # Two's complement negation of 'dst' [zs.]

 and dst src # Bitwise AND 'dst' with 'src' [zs.]
 or dst src # Bitwise OR 'dst' with 'src' [zs.]
 xor dst src # Bitwise XOR 'dst' with 'src' [zs.]
 off dst src # Clear 'src' bits in 'dst' [zs.]
 test dst src # Bit-test 'dst' with 'src' [zs.]

 shl dst src # Shift 'dst' left into x-bit by 'src' bits [zsx]
 shr dst src # Shift 'dst' right into x-bit by 'src' bits [zsx]
 rol dst src # Rotate 'dst' left by 'src' bits [...]
 ror dst src # Rotate 'dst' right by 'src' bits [...]
 rxl dst src # Rotate 'dst' with x-bit left by 'src' bits [zsx]
 rxr dst src # Rotate 'dst' with x-bit right by 'src' bits [zsx]

 mul src # Multiplication of 'A' and 'src' into 'D' [...]
 div src # Division of 'D' by 'src' into 'A', 'C' [...]

 zxt # Zero-extend 'B' to 'A' [...]
 eq # Set Zero and clear Borrow [z._]
 gt # Clear Zero and Borrow [_._]
 lt # Clear Zero and set Borrow [_.b]
 setx # Set x-bit [--x]
 clrx # Clear x-bit [--_]

 Comparisons:
 cmp dst src # Compare 'dst' with 'src' [zsc]
 cmpn dst src cnt # Compare 'cnt' bytes 'dst' with 'src' [z..]
 slen dst src # Set 'dst' to the string length of 'src' [...]
 memb src cnt # Find B in 'cnt' bytes of 'src' memory [z..]
 null src # Compare 'src' with 0 [zs_]
 nulp src # Check 'src' for null-pointer [z..]
 nul4 # Compare four bytes in 'A' with 0 [zs_]

 Byte addressing:
 set dst src # Set 'dst' byte to 'src' [---]
 nul src # Compare byte 'src' with 0 [z..]

 Types:
 cnt src # Non-'z' if small number [z..]
 big src # Non-'z' if bignum [z..]
 num src # Non-'z' if number [z..]
 sym src # Non-'z' if symbol [z..]
 atom src # Non-'z' if atom [z..]

 Floating point:
 ldd # Load double value pointed to by 'C'
 ldf # Load float value pointed to by 'C'
 fixnum # Convert double with scale 'E' to fixnum in 'E'
 float # Convert fixnum with scale 'A' pointed to by 'X'
 std # Store double value at address 'Z'
 stf # Store float value at address 'Z'

 Flow control:
 jmp adr # Jump to 'adr' [---]
 jz adr # Jump to 'adr' if Zero [---]
 jnz adr # Jump to 'adr' if not Zero [---]
 js adr # Jump to 'adr' if Sign [---]
 jns adr # Jump to 'adr' if not Sign [---]
 jc adr # Jump to 'adr' if Carry set [---]
 jnc adr # Jump to 'adr' if Carry not set [---]
 jb adr # Jump to 'adr' if Borrow set [---]
 jnb adr # Jump to 'adr' if Borrow not set [---]
 jx adr # Jump to 'adr' if x-bit set [---]
 jnx adr # Jump to 'adr' if x-bit not set [---]

 call adr # Call 'adr'
 cc adr(src ..) # C-Call to 'adr' with 'src' arguments
 cc adr reg # C-Call to 'adr' with top of stacked args in 'reg'

 ret # Return [---]
 catch # Prepare non-local jump [---]
 throw # Resolve non-local jump [---]
 func # Convert 'E' to function pointer
 begin # Called from foreign function
 return # Return to foreign function

 Stack Manipulations:
 push src # Push 'src' [---]
 pop dst # Pop 'dst' [---]
 tos dst # Get return entry [---]
 link # Setup frame [---]
 tuck src # Extend frame [---]
 drop # Drop frame [---]

 Evaluation:
 eval # Evaluate expression in 'E'
 eval+ # Evaluate expression in partial stack frame
 eval/ret # Evaluate expression and return
 exec reg # Execute lists in 'reg', ignore results
 prog reg # Evaluate expressions in 'reg', return last result

 System:
 initData # Init runtime data
 initCode # Init runtime code
 initMain # Command in X, arguments in Y, last pointer in Z
 initLib # Library function pointer in A
 stop # Stop (system-dependent)

========================================================================

 Naming conventions:

 Lisp level functions, which would be all of the form 'doXyzE_E', are written
 as 'doXyz' for brevity.

Operating Systems

Sat, 26 Nov 2016 06:00:04 +0400

Operating Systems

Modern Operating Systems | The Minix Book | Virtualization

Processes
Threads
Interprocess Communication
Scheduling
Memory
Virtual Memory
Paging
Segmentation
File Systems
I/O
Clocks
Deadlocks
Encoding
Compression
Caching
Virtualization
Distributed Systems
Security
Cryptography
Authentication
Attacks
Exploits
Malware

The Picolisp Machine

Fri, 25 Nov 2016 22:39:56 +0400

The Picolisp Machine

One of the key features of the picolisp language is that high-level constructs of the language directly map to the underlying machinery, making the whole system both understandable and predictable.

Also please note that there are still a number of possible errors in this Document, it is under active development

Data Types

These are the fundamental datatypes in Picolisp:

vim

Tue, 22 Nov 2016 22:30:18 +0400

vim

vim is one of the tools that you will want to get familiar with in linux. Just like Emacs, vim has it’s adherents who evangelize endlessly about its virtues.

I happen to love both emacs & vim finding that I happen to pop in and out of both continuously while working. You can do everything you want in either one of them, but like many things in life, having multi options you are fairly competent in, is very useful, fun and keeps life interesting.

Characters in C Programming

Tue, 22 Nov 2016 22:10:31 +0400

Characters in C Programming

Here is the truth about characters in C: there are no characters – only small integers that we agree to draw as letters. 'A' is just the number 65 wearing a costume. Everything about text in C, from strings to Unicode, follows from that.

What it is, in plain words

The char type is C’s smallest addressable unit: exactly one byte (sizeof(char) is always 1, and on every mainstream system a byte is 8 bits). A character constant in single quotes, like 'A', is a number – the character’s code in the execution character set, which today is essentially always ASCII for the first 128 values.

Floating-point numbers in C Programming

Tue, 22 Nov 2016 22:09:53 +0400

Floating-point numbers in C Programming

Here is the truth that trips up every programmer once: 0.1 + 0.2 is not 0.3 on your computer – not in C, not in Python, not in JavaScript. Floating-point numbers are not real numbers; they are a clever, finite approximation of them, and knowing where the approximation leaks is the whole skill.

What it is, in plain words

C has three floating-point types:

Type	Usual format	Significant decimal digits	Range (approx.)
`float`	IEEE 754 binary32	~7	$10^{\pm 38}$
`double`	IEEE 754 binary64	~15–16	$10^{\pm 308}$
`long double`	80-bit x87 on x86 Linux, 128-bit on some ARM, same as `double` on Windows/MSVC	18–33	varies

A floating-point number is stored like scientific notation in base 2: a sign, an exponent, and a significand (mantissa).

Integers in C Programming

Tue, 22 Nov 2016 22:07:11 +0400

Integers in C Programming

Here is the truth about integers in C: an int is not a number in the mathematical sense – it’s a fixed number of bits, and the bits run out. Almost every integer bug in C comes from forgetting that.

What it is, in plain words

C has a family of integer types that differ in size (how many bits) and signedness (whether they can be negative):

Strings in C Programming

Tue, 22 Nov 2016 21:52:26 +0400

Strings in C Programming

Here is the truth about strings in C: there is no string type – only arrays of char that we agree end with a zero byte. Every convenience and every CVE in C text handling follows from that convention.

What it is, in plain words

A C string is a contiguous sequence of bytes ending in '\0'. The type used to point at one is char * (or const char * when you promise not to modify). The standard library in <string.h> and <stdio.h> provides the classic tools: strlen, strcpy, strncpy, strcmp, strcat, strchr, strstr, sprintf, snprintf.

Literals

Mon, 21 Nov 2016 22:08:27 +0400

Literals

Here is the truth about literals: they are how values show up in source code before they have a name. Every language has them; C’s are small, strict and easy to get subtly wrong – especially once suffixes and escape sequences enter.

What it is, in plain words

A literal is a notation that writes a value directly: 42, 3.14, 'a', "hello", true. In C (and C-like languages) the form of the literal decides its type and how it’s stored. Related pages cover each family in depth: integers, floats, characters, strings.

Objects in C

Mon, 21 Nov 2016 09:49:09 +0400

Objects in C

Here is the truth about “objects”: the word means different things in different traditions, and fights about OOP usually start from mixed definitions. In Smalltalk an object is a living entity that answers messages; in C++ it is a region of memory with a type; in JavaScript it is a mutable property bag with a prototype link.

What it is, in plain words

An object packages state (data) with behaviour (code that uses that data). Languages implement that idea differently:

Identifiers in C

Mon, 21 Nov 2016 05:40:07 +0400

Identifiers in C

Back to Tokens | Back to C Programming | The Compiler

There are 4 types of Identifiers and each type gets its own namespace.

Label Names, are names that end in a colon, :
Tags for structure, union, and enumeration types
Names of Structure or Union members
Ordinary Identifiers (all others)

struct tag { char tag; ...}

Here you can see we have created a structure with the tag tag, which also has a member tag of the type char.

The Compiler

Mon, 21 Nov 2016 04:06:50 +0400

Back to C programming

The Compiler

The C compiler translates C-source-code into machine code.

The Compiler translates each source file into an object file also known as a module.

If there are more that 1 object files, these are then linked by the linker which outputs a executable.

The executable is what we normally run as a program in the system.

The Translation Phases

The compilation takes place in 8 steps.

C Programming

Mon, 21 Nov 2016 03:47:35 +0400

C Programming

The C programming language is at the heart of GNU/Linux - it is the programming language most of the Linux Kernel and GNU tools is written in.

There are many outstanding books and online resources where you can learn C and as such this site will not try and duplicate these efforts.

Freedom in Computing

Fri, 29 Jul 2016 09:57:30 +0400

Freedom in Computing

date: 29 July 2016

It all started with Richard Stallman, or at least I tell myself that. I am not sure when I realised I wanted freedom in my computing.

But it did start with software or my inability to get the software I wanted in the early 90’s, namely Corel Draw. And now, if I do think of it rightly, it also started with the ‘blue screen of death’ and the amount of work I lost due to it.

Application Development

Wed, 18 May 2016 05:18:22 +0400

Application Development

Here is the truth about application development: shipping software is less about frameworks and more about feedback loops – build something small, put it in front of reality, learn, repeat. Tools change; that loop does not.

What it is, in plain words

Application development is the craft of turning a need into a running program people can use: clarifying the problem, designing a thin slice, implementing, testing, deploying, observing, iterating. It spans CLI tools, desktop apps, mobile, embedded and the web – different skins, same skeleton.

Previews of Build a Computer in Your Head

Thu, 12 May 2016 01:55:15 +0400

Previews of Build a Computer in Your Head

I am writing a new ‘book’ called Build a Computer In Your Head (BCIYH), pronouced as “Bikih”, and I will be posting excerpts/notes regarding the subject here for you to preview and comment upon.

I have been inspired to do this by a few books and projects which you can find at the bottom of this page.

PicoLisp

Thu, 12 May 2016 01:09:25 +0400

PicoLisp

If you have always been interested in Lisp and its variant forms such as **Common Lisp, Scheme, Racket, newLISP and the like, I think that you are really going to love Picolisp.

The original 32 bit implementation is written in C, and supports 32bit programming. Over the years the language has grown and is now available in 64 bit. The really cool things is this time the language is implemented by a [assembler written in picolisp](http://software-lab.de/doc64/asm generic). The picolisp website has all the documentation that you need to get setup and running. It also has an extensive tutorial on the language. So you can get started there.