Projects »

Humble programming language

This is a hobby project. I gather my ideas of what an ideal programming language (for me) would work like. The definition is nowhere near complete or consistent. If you have comments or suggestions send me an email.

• Basic Concepts
• Syntax
  • Code Structure
    • The rule of continuing lists vertically
  • Variables and Values
• Namespaces
• Commands
• Further questions
• Related posts

Basic Concepts

• Humble code can be embedded and edited on a web page through a browser.

• Source code is rich-text with:

  • bullet-lists for listing actions,
  • numbered/dash lists for listing values,
  • tables for dictionaries, variable and command definitions.

  A plain-text version of the language should also be available.

• The main values are:

  • code readability,
  • language simplicity,
  • implementation simplicity.

Syntax

Code Structure

	plain-text	HTML
action (command call)	(command arg1 arg2 ...)	command arg1 arg2
list (array)	[item1, item2, ...]	item1 item2 item3
dictionary	{key1: val1, key2: val2, ...}	key1 value1 key2 value2 key3 value3
comments (top level)	Humble supports literate programming. All text that is at the top-most level of a file/page and is not an action, list or dictionary is treated as comment.
comments (inside code)	/* multiline comment text */	Italic text denotes comments
	// single-line comment	// You should still start comment with "//" after executable code on the same line.

The rule of continuing lists vertically:

• You can continue listing action arguments as a nested list. You can continue listing list items as a nested list.
• Semicolon at the end of parent line is gnored.

Code	Equivalent
(print Hello World!)	print: Hello World!
(print (get-temperature) (get-wind-speed))	print: get-temperature get-wind-speed
(set arr [a,b,c])	set arr [ // note the "[" a b c

Variables and Values

Unquoted strings separated by spacing are treated as string or number values. To get a value of a variable you can use $var which is a shorthand for (value var) or even ($ var).

Code	Description
print Hello "World"	Executes command print with two string arguments "Hello" and "World".
set x 42 print x= $x	Sets the value of the variable x. Should print out "x= 42".
set rect { h: 10, w: 20 } set rect.h 15 set rect[w] 25 print $rect[h] x $rect.w	Creates an object rect with two properties (h and w). Modifies the properties. Prints out "15 x 25", using the values of the properties.

Namespaces

• Namespaces organize variables into groups.
  • Variable names inside a namespace are unique.
  • Variables from a separate namespace can be accessed by adding the name of the namespace before the name of the variable.
• Namespaces are hierarchical: a name in one namespace may point to another namespace.
• There is one global top-level namespace reserved for modules. A name in this namespace points to a module namespace.
  • Modules are defined in files (or web pages). One file per module and one module per file (or webpage).
• A namespace for a variable name in source code should be clearly visible.

Dictionary notation is used to express namespaces:

• A dictionary defines a set of variables in the current namespace unless it is used as an argument or it is a command definition (see below).

Example

Code	Equivalent
x 42 arr a b c rect h 10 w 20 area (* $h $w)	set x 42 set arr [a,b,c] rect set h 10 set w 20 set area multiply $h $w

Commands

I am still working on this part. This will probably change in the future.

Functions are called "commands" in Humble. This is due to a number of reasons which I will someday explain elsewhere.

• A command consists of a number of command clauses.
  (This is similar to Erlang functions.)
• A command clause consists of an argument list and a value or an action list.
• The result of the last action in the command clause is returned when executing the command clause.

Code	Description
[x] add $x 1	This creates an anonymous command that returns a value increased by 1
factorial [0] 1 [x] multiply: $ x factorial: - $x 1	This creates a recursive command factorial. (factorial 0) always returns 1. Other calls to factorial multiply its argument with argument - 1.

Further questions

I am still experimenting with different notations for:

• Defining commands in plain-text.
• Using patterns and guards (like Erlang) in command clauses.
• Variables, their values and references to variables.

One idea I want to try out is to express plain-text Humble code as YAML. I'm guessing that adding action notation to it would be nough.

Related posts

1. 2011-04-27 Notes from discussion on "Usefulness of inventing programming languages"
2. 2011-04-12 Usefulness of inventing programming languages

About me

I am a web developer and a civic activist living in Vilnius, Lithuania.

Tinklaraštis lietuvių kalba.

 

Current projects:

ObjectFS – data access API for JavaScript and other scripting languages.

KąVeikiaValdžia.lt / PolicyFeed – a government news aggregator and filter.

Humble – a programming language expressed by bullet-lists and tables.

 

Meta

RSS

 

Ads

(cc) BY-SA 2011 Emilis Dambauskas, emilis.d@gmail.com.

Powered by GitHub Pages, Background image by Patrick Hoesly