Ah a LangJam entry ^^
There are plenty more original ideas for one to check out at https://github.com/langjam/jam0001
Teams had 48h to design and implement a programming language based on the theme "first-class comments".
This is a fun idea, but it generates comments that are typically the ones which should not exists in actual code, because they do not add any useful information. Thinking about it I'm not sure it is possible to do better. If the comment can be automatically generated from the source code, then the source code itself will necessarily a be more precise version, making the comment useless. The benefit here is that at least the comments are automatically updated at the same time as the code…
> This is a fun idea, but it generates comments that are typically the ones which should not exists in actual code, because they do not add any useful information
The point is attaching meta info to values which aren't pointless. Say:
weight = 42 /* pounds */;
It's kinda like types, but without the type checks. I'm not purely sarcastic, because boxing values within objects so they have a type has drawbacks.
That said, there are better way of typing values without boxing them.
Woah TIL. I've been looking for a similar language, something that I can do Physics in without having to worry about units/constants. Till now I've used WolframAlpha or just Google. Do you think F# is suited for this, or do you suggest other alternatives?
/** Half the number **
*********************
** Multiplies the number by one half (0.5)
*/
float x2 = x * 0.5F;
/** Copy the number **
*********************
** Stores a copy of the number in a new variable
*/
float y = x;
/** Pointer cast **
******************
** Take the address of the number,
** cast the pointer to a pointer pointing to long,
** and dereference that pointer,
** then store the result in a new variable.
*/
long i = * ( long * ) &y;
/** Subtract and shift **
************************
** Shift the number one bit position to the right,
** then subtract the result from the constant 0x5f3759df
*/
i = 0x5f3759df - ( i >> 1 );
/** Pointer cast **
******************
** Take the address of the number,
** cast the pointer to a pointer pointing to float,
** and dereference that pointer,
** then store the result in an existing variable.
*/
y = * ( float * ) &i;
/** Multiply twice, subtract and multiply again **
*************************************************
** Multiplies the number by itself,
** then multiplies the result by the other number,
** then subtracts that from the constant three halfs (1.5),
** then multiplies that by the number.
** The original number.
** The first number.
** You know what I mean.
*/
y = y * ( 1.5F - ( x2 * y * y ) );
/** Multiply twice, subtract and multiply again **
*************************************************
** Multiplies the number by itself,
** then multiplies the result by the other number,
** then subtracts that from the constant three halfs (1.5),
** then multiplies that by the number.
** The original number.
** The first number.
** You know what I mean.
** This can be removed.
*/
// y = y * ( 1.5F - ( x2 * y * y ) );
/** Return from function **
**************************
** Returns the number
*/
return y;
Which you can also see here [0], in the interpreter, or here[1] for the "let" example. Everything gets it's own scope, with only "global!" and "set!" being able to escape that. (And all the usual flow control like "if", "cond", "for", etc. are just ordinary function calls.)
Sorry, maybe I'm ignorant, but I still don't see it.
What I see is: The scope is not a first-class object. You can't "touch" it.
I see variable shadowing. And I think something that's called "dynamic scope"—or maybe it's just references, not sure.
I'm not 100% sure even what "first-class" scope would look like. I don't know any language that claims having it. I have a few ideas but would like to see some more to find out whether this idea make any sense at all. It's not in the ballpark of "first-class comments" and could be even useful. Maybe. But to know that we would need to have some language to play with.
If I'm understanding what you're calling first-class scope, then Lua's environments would count as a well-developed language with first class scope. Sandboxing Lua (outside of Luajit) is trivial, for example, because you just bind a given environment to a given function. [0]
Scope in my scripting language is also similar - you can definently touch it. That's how "set!" allows you to create a variable, for example. Assignment isn't special. set! is reaching into the scope above itself to place the variable, otherwise it wouldn't be accessible after the set! call. But it is just a function call. (And there's a couple other things like scopedepth to help you index a given scope).
Thank you for the pointer to Lua! Will have a look.
Yes, "scope" is in the end the evaluation environment of some funktion. Usually it's not a first-class object in a particular language, and only available implicitly.
Having it first-class would mean being able to directly manipulate and pass function environments.
Like I said, I'm not sure this makes sense at all. But maybe it could open up some possibilities.
(I came up with the general idea when thinking about what the "implicit scope" in Scala is, or could be seen as).
This is a very interesting idea. I worry that the runtime overhead might be enormous (adding two numbers involves concatenating strings), and cause the space usage of the program to depend on its execution time. I think it's still missing something, like maybe keeping sizes of explanations reasonable by using a machine learned summarizer.
A serious implementation would probably use a binary tree (such as twine [1]), so it would basically boil down to creating a node for each operation. Still expensive, but if you imagine integrating it with, say, Python interpreter, I don't think it would dominate execution time. Memory might be another matter.
"dynamic programming" and "dynamic programming language" and "dynamically typed programming language" are all different terms and mean different things.
"dynamic programming" refers to something different. In practice, it often just means "solving a problem recursively using a memo table." But wikipedia obviously does it more justice [1].
It's a terrible name, and even the person who came up with the name admits that it's terrible: "The word dynamic was chosen [...] because it sounded impressive."
This seems like it would make a brilliant extension for literate programming; a self documenting REPL paired with literate source! And, of course, trivially optimized out of necessary.
This is a docstring annotation on a value (rather than a definition)? And what we recognize as comment syntax from C could also equivalently be, say, an `anno` keyword or punctuation, followed by a more familiar string literal?
let x = 40 + 2 /* the number fourtytwo */;
let x = 40 + 2 anno "the number fourtytwo";
let x = 40 + 2 @"the number fourtytwo";
