A fast, byte-code interpreted language

Last update: Aug 16, 2022

Related tags

Overview

Minima

Minima is a small, portable, and fast programming language written in C.

The Syntax

Minima's syntax is optimized for a fast byte-code translation at the expense of program verbosity. However, it's easy to parse and compile. You can read Minima's documentation here.

Countdown

set i to 10
while dec i {
	extern printl(i)
}

Fizz Buzz

set i to 0
while inc i <= 99 {
	if i % 15 == 0 {
		extern print("fizzbuzz")
	}
	elif i % 5 == 0{
		extern print("fizz")
	}
	elif i % 3 == 0{
		extern print("buzz")
	}
	else {
		extern print(i)
	}
	extern printl
}

Fibonacci

proc fib(n) {
	if n <= 1 {
		return n
	}
	return goproc fib(n - 1) + goproc fib(n - 2)
}
extern print(goproc fib(25))

Factorial

proc fact(n) {
	if n {
		return n * goproc fact(n - 1)
	}
	return 1
}
extern print(goproc fact(50))

Comments

Decriment null crashes release

While this works on the debugger, and the release build while it's being debugged, decrementing null would cause Minima to crash. The source of the bug is still being traced.

opened by TheRealMichaelWang 3
Constant Stack Misalign
A constant stack misalign occured when running fibonacci:

proc fib(n) { if n <= 1 { return n } return goproc fib(n - 1) + goproc fib(n - 2) } extern print(goproc fib(25))

Ultimately the constant stack overruns it's allocated buffer because somewhere along the line while the evaluation counter is being decremented the constant counter is not being decremented. This is a serious bug because it implies one of the following:

A value got corrupted because of a bug in the garbage collector

A constant value is getting garbage collected and is treated as a garbage collector registered value

The whole evaluation system has a fundamental flaw that prevents it from working properly.
opened by TheRealMichaelWang 2
Future & ideas
Interesting language (I kind of like the "messy" conceptual goal :wink:). I have many questions. I'll ask them incrementally on the go.

any plans for concurrency (ideally one leveraging multiple CPU cores)?

what are the basic types (i.e. platform independent) everything (especially composites/objects/...) builds upon? (I'd like to identify the extent to which metaprogramming is possible in this language)

any general performance benchmark measurements? (ideally the state-of-the-art https://github.com/kostya/benchmarks/ )

any FFI support which wouldn't need any manual work (no wrapping, no type definitions, nothing - just try to call it and either it succeeds or it sigsegv/dumps_core/etc.)
opened by dumblob 2
Memory Overflow Crash

When the garbage collection bunds are surpassed and although they no longer they override anything complications regarding tac ability arise when the registration and allocation process is abruptly halted.

opened by TheRealMichaelWang 1
Location nodes for error-causing code not removed

The nodes inserted by a compiler that ultimately result in a syntax, or runtime error are still kept. While it would be a simple matter, removing the error-nodes from a sorted, finalized batch would be problematic.

opened by TheRealMichaelWang 0

Inheritance

Added inheritance to Minima - it's officially an object-oriented language now. Heres a quick example to demonstrate the syntax:

record person {
    name
    age
    proc init(name, age) {
           set this.name to name
           set this.age to age
    }
}
record student extends person {
    gpa
    school
    proc init(name, age, gpa, school) {
            goproc init as this.base(name, age)
            set this.gpa to gpa
            set this.school to school
    }
}
set michael to new student("Michael", 15, 4, "North Hollywood")

opened by TheRealMichaelWang 0

Garbage Collector not Tracing Previous Frame.

Because the garbage collector didn't reset the flags of the previous frames values, tracing would fail on certain values that are already marked as to-collect.

opened by TheRealMichaelWang 0

Releases(0.2.2)

0.2.2(Jul 30, 2021)
While the syntax hasn't changed significantly, or for that matter at all in this release (should it ever?), several major changes and upgrades have been made to Minima's virtual machine and compiler, mostly regarding performance.

Those changes include, but are not limited to the following:

Added a grey-stack area for constants that doesn't rely on dynamic allocations. Because of the fundamental nature of a stack's behavior, certain allocations for constants, not references, can utilize a contiguous block of memory.

Branch jumps, referred to as a skip within the opcode enum, are have their destinations pre-computed during compilation. Minima's previously, and still does utilize a stack-based branching system chiefly because it's easy to compile and doesn't impose any significant performance limitations.

Added tail call optimizations for top-level procedures. Labels are ultimately still utilized, but Minima's compiler may forgo including a new scope/gc clean opcode.

Removed windows dependent code, and added a makefile for compiling with gcc on windows.

Also, it should be noted that a ton of other bugs were patched and fixed - pretty much every issue between #9 and #18 were fixed. And as always, if you notice any bugs or if you're so inclined to propose a feature - feel free to go and make a new issue.

Follow this installation guide if you require detailed installation instruction or if you're not running 64-bit windows.
Source code(tar.gz)
Source code(zip)
minima.exe(70.50 KB)
setup.exe(1.57 MB)
0.2.1(Jul 11, 2021)
Changes in this Release

Added operator overloading for records

Created a separate area in memory that doesn't require dynamic allocation, thereby dramatically increasing performance.

Added hashset.min to the STL

Added map.min to the STL

Source code(tar.gz)
Source code(zip)
minima.exe(72.50 KB)
minima_setup.exe(1.56 MB)
0.2(Jun 26, 2021)

Source code(tar.gz)
Source code(zip)
minima_setup.exe(1.56 MB)
0.1.1(Jun 15, 2021)

Minima, version 0.1.1

The biggest additions in this update revolve around records (Minima's equivalent of C structs, although they support much much more). You can read more about records here. Other major changes include major bug fixes, most notably several involving the garbage collector.

Aside from updates to the Minima interpreter, a small somewhat functional standard library has been added - though, at present, it's still in its's testing phase. To utilize the standard library, which includes a linked list for dynamically sized collections, unzip stl.zip and place it's contents in the same directory as minima.exe. Use the include keyword (ie include "list.min") to include the library.
Source code(tar.gz)
Source code(zip)
minima.exe(49.50 KB)
stl.zip(1.76 KB)
0.1(Jun 9, 2021)

Source code(tar.gz)
Source code(zip)
minima.exe(43.00 KB)

Owner

GitHub

Bond is a cross-platform framework for working with schematized data. It supports cross-language de/serialization and powerful generic mechanisms for efficiently manipulating data. Bond is broadly used at Microsoft in high scale services.

Bond Bond is an open-source, cross-platform framework for working with schematized data. It supports cross-language serialization/deserialization and

2.5k Dec 31, 2022

Inferno® is a distributed operating system. Inferno represents services and resources in a file-like name hierarchy, including devices, network and protocol interfaces, dynamic data sources, and services.Applications are written in a concurrent programming language, Limbo.

Inferno® is a distributed operating system, originally developed at Bell Labs, but now developed and maintained by Vita Nuova® as Free Software. Appli