Safe Scripting Syntax - Revision history

Adamcolton at 15:35, 23 August 2018

2018-08-23T15:35:14Z

← Older revision		Revision as of 15:35, 23 August 2018
Line 145:		Line 145:

	[[Category:Code]]		[[Category:Code]]
			[[Category:Projects]]

Adamcolton at 12:31, 2 August 2018

2018-08-02T12:31:31Z

← Older revision		Revision as of 12:31, 2 August 2018
Line 1:		Line 1:
			Maybe just do this: https://github.com/perlin-network/life

	I've already done a first pass of this with the dist.ribut.us VM but the idea fascinates me so I may try and do a more advanced version.		I've already done a first pass of this with the dist.ribut.us VM but the idea fascinates me so I may try and do a more advanced version.

Adamcolton at 19:20, 31 July 2018

2018-07-31T19:20:56Z

← Older revision		Revision as of 19:20, 31 July 2018
Line 141:		Line 141:

	and so on. So the information density is 7/8 bits.		and so on. So the information density is 7/8 bits.

			[[Category:Code]]

Adamcolton at 19:08, 20 July 2018

2018-07-20T19:08:52Z

@@ Line 21: / Line 21: @@
 A VM is primarily defined by it's commands. It can also be configured to limit memory use, running time, running steps and so on.
-A running instance is defined by a set of identifiable scopes. Each scope has 4 sub scopes; ram, rom, code and references. References point to scopes. It keeps track of the current execution pointer.
+A running instance has scopes for code and memory. A memory scope has data, references and a write flag. There is a pointer to the current execution scope and index; 2 reference registers and 2 data registers. The call stack holds scope and index values, but does not store register values. There are two data registers to allow for binary operations. There are two reference registers because that is necessary to copy between scopes. But most operations use the scope in $R0.
 I'm not sure about concurrency. I like it, but it adds complexity. I think the right approach would be to do a V1 with no concurrency, then possibly do a V2 with concurrency.
@@ Line 29: / Line 29: @@
 == Assembly ==
-The assembly starts by expressing the expected arguments and requesting memory. It then requests which language extensions and modules it needs. The assembler needs a VM definition; a list of the commands and modules.
+Assembly is really the core. The byte code needs to be assembled per machine (because the commands are not fixed values).
-I like the idea of memory pages, but it may make more sense to tag pages as read-only, read-write or execute.
+There are variables and conditions, but no loops. This way we can define modules that wrap commands - If A is not available as command define A as a function.
-At the assembly level commands are named and scoped
+An assembly first defines the number of memory blocks it wants. Each memory block starts with a data length, reference length and a type; populated ram, unpopulated ram or rom. For rom it can set literal values or request them from the VM (this is how modules get linked).
-When compiling, these are reduced to bytes. Module commands are replaced with Calls. Language extensions add commands. The total number of commands is fixed, so that determines how many bytes a call requires.
+All operations internal to the scope use data values as ints. So a jump command uses an int.
 == Module Loading ==

Adamcolton at 17:50, 20 July 2018

2018-07-20T17:50:29Z

← Older revision		Revision as of 17:50, 20 July 2018
Line 17:		Line 17:

	== VM Definition ==		== VM Definition ==
	~~A program has~~ 3 ~~top level memory spaces: read-only~~, ~~read-write and executable. There are 3 registry spaces: floating, int~~ and ~~reference~~. ~~Values can be moved between floating and int, but no reference math~~ is ~~allowed. Problem; values~~ can be written to memory and recalled, so you could write a reference to memory then recall it as an int. Maybe I could have each memory block actually zero out those locations and hold references someplace else so that this will always return a 0 as an int. Same in the other direction. Bah... that doesn't make that much sense. Ok, there are just two types; data and references. An RW block only contains data, but also maintains references as a ~~separate index~~.		The spec recognizes 3 types; data, references and code. Code is byte code that can run by a VM instance.

	~~There~~ is also a ~~call stack~~. ~~Values in~~ the ~~call stack are mapped~~ to ~~their register~~.		A VM is primarily defined by it's commands. It can also be configured to limit memory use, running time, running steps and so on.

			A running instance is defined by a set of identifiable scopes. Each scope has 4 sub scopes; ram, rom, code and references. References point to scopes. It keeps track of the current execution pointer.

			I'm not sure about concurrency. I like it, but it adds complexity. I think the right approach would be to do a V1 with no concurrency, then possibly do a V2 with concurrency.

	== Simplicity ==		== Simplicity ==

Adamcolton at 17:10, 20 July 2018

2018-07-20T17:10:41Z

← Older revision		Revision as of 17:10, 20 July 2018
Line 17:		Line 17:

	== VM Definition ==		== VM Definition ==
	A program has 3 top level memory spaces: read-only, read-write and executable. There are 3 registry spaces: floating, int and reference. Values can be moved between floating and int, but no reference math is allowed. Problem; values can be written to memory and recalled, so you could write a reference to memory then recall it as an int. Maybe I could have each memory block actually zero out those locations and hold references someplace else so that this will always return a 0 as an int. Same in the other direction.		A program has 3 top level memory spaces: read-only, read-write and executable. There are 3 registry spaces: floating, int and reference. Values can be moved between floating and int, but no reference math is allowed. Problem; values can be written to memory and recalled, so you could write a reference to memory then recall it as an int. Maybe I could have each memory block actually zero out those locations and hold references someplace else so that this will always return a 0 as an int. Same in the other direction. Bah... that doesn't make that much sense. Ok, there are just two types; data and references. An RW block only contains data, but also maintains references as a separate index.

	There is also a call stack. Values in the call stack are mapped to their register.		There is also a call stack. Values in the call stack are mapped to their register.

Adamcolton at 17:07, 20 July 2018

2018-07-20T17:07:46Z

← Older revision		Revision as of 17:07, 20 July 2018
Line 15:		Line 15:

	Memory is use bounded. So is computation.		Memory is use bounded. So is computation.

			== VM Definition ==
			A program has 3 top level memory spaces: read-only, read-write and executable. There are 3 registry spaces: floating, int and reference. Values can be moved between floating and int, but no reference math is allowed. Problem; values can be written to memory and recalled, so you could write a reference to memory then recall it as an int. Maybe I could have each memory block actually zero out those locations and hold references someplace else so that this will always return a 0 as an int. Same in the other direction.

			There is also a call stack. Values in the call stack are mapped to their register.

	== Simplicity ==		== Simplicity ==
Line 20:		Line 25:

	== Assembly ==		== Assembly ==
	The assembly starts by expressing the expected arguments and requesting memory. It then requests which language extensions and modules it needs.		The assembly starts by expressing the expected arguments and requesting memory. It then requests which language extensions and modules it needs. The assembler needs a VM definition; a list of the commands and modules.

	I like the idea of memory pages, but it may make more sense to tag pages as read-only, read-write or execute.		I like the idea of memory pages, but it may make more sense to tag pages as read-only, read-write or execute.
Line 55:		Line 60:

	I'll write the compiler as a package and include a command line so it can be used anywhere.		I'll write the compiler as a package and include a command line so it can be used anywhere.

			== GC ==
			The GC will actually be a language extension, but a core one. It has to be configured at runtime. It only runs against read-write memory blocks.

			The header of each block contains a mark-and-sweep flag and the number of references. So it just does a mark and sweep.

	== Memoization ==		== Memoization ==
	A detail, but interesting. The base language should be fully deterministic. Language extensions can set a non-deterministic bit. This way, we can run a deterministic script and record the starting state and the output and memoize the whole process.		A detail, but interesting. The base language should be fully deterministic. Language extensions can set a non-deterministic bit. This way, we can run a deterministic script and record the starting state and the output and memoize the whole process.

			== UTF-8 Style Numeric encoding ==
			* 127: 1 byte 0xxxxxxx
			* 16,384: 2 bytes 10xxxxxx xxxxxxxx
			* 2,097,152 : 3 bytes 110xxxxx xxxxxxxx xxxxxxxx

			and so on. So the information density is 7/8 bits.

Adamcolton: /* Scripting */

2018-07-20T16:12:23Z

Scripting

← Older revision		Revision as of 16:12, 20 July 2018
Line 53:		Line 53:

	The exit operator causes the script to terminate. I think I'm going to leave it up the context to determine if the script was successful or not.		The exit operator causes the script to terminate. I think I'm going to leave it up the context to determine if the script was successful or not.

			I'll write the compiler as a package and include a command line so it can be used anywhere.

	== Memoization ==		== Memoization ==
	A detail, but interesting. The base language should be fully deterministic. Language extensions can set a non-deterministic bit. This way, we can run a deterministic script and record the starting state and the output and memoize the whole process.		A detail, but interesting. The base language should be fully deterministic. Language extensions can set a non-deterministic bit. This way, we can run a deterministic script and record the starting state and the output and memoize the whole process.

Adamcolton at 16:11, 20 July 2018

2018-07-20T16:11:11Z

@@ Line 32: / Line 32: @@
 == Module Loading ==
 There should be standard collections of packages. A server can quickly download an index. When a script requests that a module be included the server can go get it. The risk this avoids is being able to define arbitrary package names and having the runtime make a network request searching for that which becomes identifiable.
 == Memoization ==
 A detail, but interesting. The base language should be fully deterministic. Language extensions can set a non-deterministic bit. This way, we can run a deterministic script and record the starting state and the output and memoize the whole process.

Adamcolton at 16:00, 20 July 2018

2018-07-20T16:00:04Z

@@ Line 15: / Line 15: @@
 Memory is use bounded. So is computation.
 == Memoization ==
 A detail, but interesting. The base language should be fully deterministic. Language extensions can set a non-deterministic bit. This way, we can run a deterministic script and record the starting state and the output and memoize the whole process.