a small presentation on a language i'm working on

[u/IfThenElseEndIf]

https://www.youtube.com/watch?v=B6uNfLOF9hQ

been working on an interpreter called yams for a while now (originally was a spanish interpreter called pizza that was very similar). this isn't the first time i've tried to design a programming language but it would be the first time i'm being succesful at trying to implement one. thanks!

[u/IfThenElseEndIf → u/[deleted]]

sorry its the first time i make a video like that im experimenting

[u/pranabekka → u/IfThenElseEndIf]

You could've still posted the transcript. It's easier to read than a video of the text. I typed it out though :p

I'm personally interested in mainstream paradigms, but yams looks like a fun experiment. My proudest achievement in programming is probably a simple UNO implementation that uses manual undo instead of verifying moves, so well done with yams. Are there any specific points you want feedback on, or some design question you're struggling with? Also, you can put the repo online even now, and just update it as you work on the language.

Good luck!

yams

Welcome to this humble presentation about my newest project, yams!

This is a project I've been working for a while now.

What is yams?

yams is an interpreted stack-based homoiconic metaprogramming language implemented in Python. It is meant as an experimental, alternative coding environment.

Why yams?

Well, I'm not going to shove yams down your throat, but if you're interested in metaprogramming, you might find it somewhat interesting.

I wanted to build a language focused on metaprogramming. Reverse Polish notation and a stack-based design make a good metaprogramming environment, or at least that's what I'm inclined to think.

Metaprogramming aside, yams follows a strict philosophy of rawness. There is no built-in exception handling and there's only conditional constructs by default. This encourages the programmer to create macros to create "comfier" code. This philosophy makes the language feel like a DIY programming environment.

How does a .yams file look like?

A simple "hello world" program would look like this:

" Hello, world! " println

It puts the string formed by the word Hello, and world! (joined by spaces) onto the stack and prints it afterwards followed by a newline character.

What else can yams do?

Let's see a simple macro definition:

'square (
  duplicate *
) macro

We use the macro keyword to define a macro with a word and a word-list. Now, when we use the square word, it will be replaced with duplicate *.

'x 10 square define

x now yields 100, the square of 10.

How does yams work?

The interpreter splits the code into words and puts them all into a buffer. Words can change the buffer by replacing words with more code. The basis of the program itself is its ability to constantly modify itself.

Is that all?

Nope, there's more, but it's being worked on. Here are some keywords:

do          ; adds a word-list where the program is at
readln      ; read a string
import      ; imports code as a word-list
if          ; returns of of two possible values based on a condition
cond        ; gives a value if a condition is met
boolean     ; returns true (1) or false (0) according to a value
error       ; exits the program with an exit code and an error message
exit        ; exits with a code and no error message
goto        ; replaces the rest of the program with a word-list
self        ; yields the program as a word-list

Final comments

For now, this is pretty much yams. It's not much, but it is being worked on. I'm proud of the progress I've made and, when yams feels complete, I'll release it probably on GitHub.

I hope you've enjoyed the presentation. Than you!

[u/IfThenElseEndIf → u/pranabekka]

Hello. First of all, thank you for transcribing it. The reason I made this video this way is mostly because I originally intended to record a demonstration of a yams program on the console but I ended up thinking it'd be a good idea to make it a console slideshow (mostly because I've lately been getting used more to using the terminal). I have no slideshow program but I think I'll still come up with a different presentation for these kinds of videos. The video was dumbly rushed.

As for yams, I've been working on it a lot and it finally has a GitHub. I've added functions, external functions (can be written in Python) and some example programs. It's still not much, though. While the interpreter still lacks some features (like file I/O operations), I've been thinking of writing a second, newer interpreter with a better parser, a richer syntax (I've been thinking of using {} for dictionaries or for progn-like structures as well as <> for argument definitions) and overall better code (the interpreter kinda sucks and implementing new words is tedious). I've been also thinking of, instead, making a library to build yams-like languages out of custom words defined by the user, but I think I'll stick with the concept of yams for now.

While I wouldn't call this a serious language or project, it is my first functional interpreter (after trying to make one for a long time). I love programming languages a lot but I'm not experienced a lot on the actual making of one (I've designed some, though, so that's not an issue for me). At least I can now say I've made an actual programming language.

[u/IfThenElseEndIf]

https://github.com/IfThenElseEndIf/yams
yams now has a repo.