Forem: Ingi

Security is a Mess – How Plang Helps Fix It

Ingi — Mon, 19 May 2025 11:03:26 +0000

This post dives into Plang, an intent-based programming language that interprets natural language. For more, visit plang.is or get started here.

Security is hard. As developers, we’re not exactly great at it. The issue is that security is binary - it either works 100% or it doesn’t at all. If there’s a flaw in your code, an attacker could gain full access to your system. Worse, you can never truly prove that something is 100% secure. All you can do is try to prevent every possible way in, which requires a lot of experience and a lot of eyes on the code. The only thing that gets you closer to 100% is time and scrutiny.

Scrutiny & Time

That’s the key to secure code: experienced developers looking at it, lots of them, and enough time passing without a breach. We never know it’s secure. We can only hope.

The State of Development

If I asked 10 developers to write code that reads a file into a variable, I’d get 10 different implementations. Some would be buggy. Some would be insecure. That’s where we are today.

LLM Coding

If you use an LLM to write the same thing, it’s the same story. Ask 10 times, and you’ll get 10 different versions-some with security flaws, some with bugs.

Plang

Plang is intent-based programming. That means the developer just describes what they want to happen, and Plang handles it. For example, reading a file looks like this:

- read file.txt into %content%

The intent here is simple: read the contents of file.txt into the variable %content%.

Now here’s the key part: no matter how many developers write this in Plang, or how they phrase it, it will always result in the same underlying code. You can view it yourself here (if you’re technical enough to follow it).

That’s huge. No matter how many billions of lines are written to read files in Plang, they’ll all run through the same ~40 lines of code. (It’s 40 lines because the file module does more than just reading-there’s more to discover.)

Higher Risk Examples

Reading a file is simple. Not typically a big security concern. So let’s take a more sensitive example: password hashing.

Hashing passwords isn’t trivial. You need to really know what you’re doing. Most people don’t. And here are some ways you can get completely SCREWED:

Use the wrong algorithm? You’re screwed.
Don’t use a salt? Screwed.
Use the same salt every time? Screwed.
Use a bad salt? Screwed.
Too few iterations? Screwed.

I’m not even an expert in hashing, so this list is probably missing a few traps.

Ask 10 developers or an LLM 10 times to write a password hashing function, and you’ll get 20 different versions. LLMs might actually outperform humans here-but there’s still variance and risk.

In Plang, here’s how you do it:

- hash %password%, write to %hashedPassword%

You just want the password hashed. If you're curious about the details, you can read the source code.

Now, I’m no specialist, so maybe it’s wrong. But the good news? It’s open source. Anyone can scrutinize it. Experts can review and improve it. I’m not one of them-but plenty of people are.

Usernames and Passwords = BAD

Oh boy. Usernames and passwords. What a nightmare.

They’re a pain for developers to manage, and they’re the weakest link in most systems. The solution? Public/private key cryptography. PGP (Pretty Good Privacy) has been around since the '90s and was basically that. But it was never made easy for developers to implement, so usernames and passwords stuck around.

Here’s where Plang shines again: all developers use the same code when writing functionality. That includes HTTP requests.

For example:

- get https://jsonplaceholder.typicode.com/posts/, write to %posts%

More Security, Fewer Bugs

All of this leads to one simple conclusion:

Plang apps have fewer bugs and are more secure.

This article

Plang Trick: Database Selection Made Easy

Ingi — Thu, 13 Feb 2025 10:16:18 +0000

This post dives into Plang, an intent-based programming language that interprets natural language. For more, visit plang.is or get started here.

When you get data from a database in Plang, it always comes as a list—even if you’re only selecting one row using a primary key. That means if the database returns just one result, it’s still treated as a list with one item.

Basic Example: Getting a User

If you want to grab a user’s ID and name, you would normally do this:

Database
- select id, name from users where %userId%, write to %users%
- write out "Name of user: %users[0].name% and id: %users[0].id%"

Since %users% is a list, you have to access the first item using %users[0]%.

Shortcut: Directly Using Variables

Instead of dealing with a list, you can tell Plang to return just one row and automatically store the values into variables.

Database
- select id, name from users where %userId%, return 1
- write out "Name of user: %name% and id: %id%"

Plang will detect which columns you're selecting and create variables for them, making your code cleaner and easier to read.

Custom Variable Names

You can also rename the columns while selecting:

Database
- select id as userId, name as fullName from users where %userId%, return 1
- write out "Name of user: %fullName% and id: %userId%"

Now, instead of using %id% and %name%, you can refer to them as %userId% and %fullName%—whatever makes sense for your code.

Why This Trick is Useful

No need to handle lists when dealing with single rows.
Makes your code shorter and cleaner.
Lets you use custom variable names for better readability.

A nice little trick to make database queries in Plang way simpler! 🚀

How I Use Plang for System Administration

Ingi — Tue, 29 Oct 2024 12:25:53 +0000

This post dives into Plang, an intent-based programming language that interprets natural language. For more, visit plang.is or get started here.

Plang is a powerful tool, especially when it comes to system administration. Its ability to operate at the programming layer while leveraging various tools gives developers—and sysadmins —an impressive level of control and efficiency.

In system administration, scripts simplify repetitive tasks, and I use Plang specifically to deploy apps to servers. My Plang apps are pretty straightforward, so they don’t need the heavy-duty CI/CD pipeline, which would just add unnecessary complexity.

So, how does it work?

The Plan

My goal is to take the app folder from my development machine and set it up on a Linux server. Here’s what needs to happen:

Zip the app folder to app.zip, excluding any .db and *.sqlite files.
Connect to my Linux server via SFTP.
Upload app.zip.
Clear out any old .build files to avoid using outdated code.
Unzip app.zip on the server.
Set the correct file permissions.
Optionally update the Plang runtime.
Confirm the Plang runtime is working.

When you’re doing this setup for the first time, it's common to miss a step or two—don’t worry. The flexibility of Plang makes it easy to adjust on the fly.

The Deployment

Let’s walk through the deployment by setting up a Deploy.goal file on my computer, and the first line is simply Deploy:

Deploy

Zipping the App

We’ll start by creating a zip file of the app directory, which is in the same location as Deploy.goal:

- zip "./" to "deploy/app.zip", exclude ".db", "*.sqlite", overwrite file

Let's stop here. If you are familiar with programming, you will probably be thinking what is the syntax here? How do I know how to structure this zip command, but here is the thing. Plang does not have strict syntax, it's all about what would you like to happen. Instead of zip "./" to "deploy/app.zip", you say compress the folder I am in and save it to app.zip. Because plang takes your intent and converts it to code. Let's continue.

Connecting via SFTP

Next, I connect to the server using SFTP. I’ve set up a private key with a passphrase for secure access:

- read file '/events/key', into %sshPrivateKey%
- connect to sftp, 
    host: 185.248.121.67, port: 28781, username: root, 
    private key: %sshPrivateKey%, private key passphrase: %Settings.PrivateKeyPassphrase%

Now that we’re logged into the server, we can start deploying.

Uploading and Setting Up

First, let’s upload the zip file:

- upload 'deploy/app.zip' through sftp to '/home/plang/app.zip'

After that, we’ll run a few Linux commands to clean up any previous .build folder and unzip the new code:

- run ssh command, "rm -rf /home/plang/app/.build"
- run ssh command, 'unzip -o /home/plang/app.zip -d /home/plang/app'

Updating the Plang Runtime

For flexibility, I’ve added an option to update the Plang runtime. If I run the script with plang=1, it triggers the update:

- if %plang% = 1 then SetupPlang

Now, let’s create the SetupPlang goal.

The SetupPlang Goal

The SetupPlang goal takes care of a few critical steps:

Downloads the latest version of Plang for Linux.
Unzips plang.zip.
Sets execution permissions for plang and selenium-manager (I use a browser in my app).
Runs plang --version to validate the installation and manages any errors (like creating a symlink or installing i18n).
Restarts the service if it’s running or notifies me if it isn’t installed.

SetupPlang
- run ssh command, 'wget -O /home/plang/plang.zip https://github.com/PLangHQ/plang/releases/latest/download/plang-linux-x64.zip'
- run ssh command, 'unzip -o /home/plang/plang.zip -d /home/plang/plang'
- run ssh command, 'chmod +x /home/plang/plang/plang'
- run ssh command, 'chmod +x /home/plang/plang/selenium-manager/linux/selenium-manager'
- run ssh command, 'plang --version'
    on error message 'No such file or', call CreateSymbolicLink then retry 
    on error message 'command not found', call CreateSymbolicLink then retry 
    on error message contains 'Couldn't find a valid ICU package', call InstallICU then retry
- run ssh command, 'sudo systemctl restart plang', write to %serviceRestart%
    on error message  'plang.service not found', call ServiceNotInstalled ignore error
- write out %serviceRestart%

In the case of errors, I have additional commands to handle them:

CreateSymbolicLink
- write out 'Creating symbolic link'
- run ssh command, 'sudo ln -s /home/plang/plang/plang /usr/local/bin/plang' 
        on error  message contains 'File exists', ignore the error 

InstallICU
- write out 'Installing ICU'
- run ssh command 'sudo dnf install -y libicu'

ServiceNotInstalled
- write out 'Plang service not installed'

Finally, to confirm the Plang runtime is installed, I run:

- run ssh command, 'plang --version', write to %plangVersion%
- write out "App updated at %Now% - %plangVersion%"

Running and Updating

Before building, you’ll need to set up the SshModule in your .module folder. Head over to SshModule on GitHub, build the project, and copy the .dll and .deps files into your .module folder (if you don’t have one yet, just create it).

Once the code is ready, I build it:

plang build

And then, to deploy both the app and Plang runtime, I run:

plang Deploy plang=1

If I only need to update the app, I just execute:

plang Deploy

Here’s an example of the output:

App updated at 29.10.2024 10:57:05 - plang version: 0.15.3.0

Full Code for Reference

Deploy
- zip "./" to "deploy/app.zip", exclude ".db", "*.sqlite", overwrite file
- read file '/events/key', into %sshPrivateKey%
- connect to sftp, 
    host: myhost.server.com, port: 22, username: root, 
    private key: %sshPrivateKey%, private key passphrase: %Settings.PrivateKeyPassphrase%
- upload 'deploy/app.zip' through sftp to '/home/plang/app.zip'
- run ssh command, "rm -rf /home/plang/app/.build"
- run ssh command, 'unzip -o /home/plang/app.zip -d /home/plang/app'
- if %plang% = 1 then SetupPlang
- run ssh command, 'plang --version', write to %plangVersion%
- write out "App updated at %Now% - %plangVersion%"

SetupPlang
- run ssh command, 'wget -O /home/plang/plang.zip https://github.com/PLangHQ/plang/releases/latest/download/plang-linux-x64.zip'
- run ssh command, 'unzip -o /home/plang/plang.zip -d /home/plang/plang'
- run ssh command, 'chmod +x /home/plang/plang/plang'
- run ssh command, 'chmod +x /home/plang/plang/selenium-manager/linux/selenium-manager'
- run ssh command, 'plang --version'
    on error message 'No such file or', call CreateSymbolicLink then retry 
    on error message 'command not found', call CreateSymbolicLink then retry 
    on error message contains 'Couldn't find a valid ICU package', call InstallICU then retry
- run ssh command, 'sudo systemctl restart plang', write to %serviceRestart%
    on error message  'plang.service not found', call ServiceNotInstalled ignore error
- write out %serviceRestart%    

CreateSymbolicLink
- write out 'Creating symbolic link'
- run ssh command, 'sudo ln -s /home/plang/plang/plang /usr/local/bin/plang' 
        on error  message contains 'File exists', ignore the error 

InstallICU
- write out 'Installing ICU'
- run ssh command 'sudo dnf install -y libicu'

ServiceNotInstalled
- write out 'Plang service not installed'

Using Plang in system administration is a real timesaver, making deployment as efficient and straightforward as possible.

Benefits

Using Plang for deployment keeps things simple and readable, cutting down on complexity while making it easier to manage. With Plang’s clear, natural syntax, I can lay out each deployment step almost as if I’m writing in plain language, which makes everything easy to follow and adjust when needed. The modular setup lets me break tasks down, making it easier to tweak specific steps and handle errors. Plang’s built-in retry and error-handling functions add stability, catching issues automatically when they come up.

With flexible variable management, Plang also lets me store command outputs for later use, which is super handy for connecting steps and external systems. Plus, if I need to keep track of metadata or deployment logs, Plang’s built-in database support has that covered without any extra setup. Overall, Plang simplifies deployment scripts with smart, high-level abstractions, trimming down the code compared to traditional scripting languages and saving me serious development time.

More Information

Interested in learning more about Plang? Here are some useful resources to get started:

Basic Concepts and Lessons
Todo Example to build a simple web service
Explore the GitHub repo for source code
Join our Discord Community for discussions and support
Or chat with the Plang Assistant to get help with code generation

In Theory: Interoperability

Ingi — Fri, 11 Oct 2024 15:17:37 +0000

This post dives into Plang, an intent-based programming language that interprets natural language. For more, visit plang.is or get started here.

"Interoperability" sounds like a big word, but it's really just a fancy way of saying you can move data from one system to another, without a ton of hassle.

The Challenge of Moving Data

Back in the early days of software, getting data from one system into another was next to impossible. Each app had its own format, and if you wanted to pull out information, you'd need to know the ins and outs of that system—something only the developers or a few elite hackers could figure out.

The Progress We've Made

Fast forward to today, and things have gotten a lot better. We now have standards like JSON, REST APIs, XML, and SQL databases that make it easier to transfer data between systems. These technologies give us the raw data we need to get info from one platform and put it into another.

But here’s the catch: this only works if you can actually access the raw data. Even now, you still need someone with technical expertise to pull the data out of one system and load it into another. It’s not like these systems are just going to talk to each other by themselves.

Data Behind Closed Doors

Things get a lot trickier when the data you need is locked behind some kind of barrier—like inside a desktop application or hidden away on a website. In those cases, extracting the data can be really hard. So, what do we do? We use people. Humans have to open the website, search for the data, and manually copy it over.

The Data Locked in Our Heads

And then there’s the trickiest type of data: what’s locked inside our own brains. People carry knowledge around with them that’s essential for decision-making, but trying to get that knowledge out is tough. Only recently has technology advanced enough to listen to someone speaking into a mic and transcribe their words.

An Impossible Problem?

I came across this quote in an article on automation that stuck with me:

"No amount of software is going to get you out of there because it is piecing together a bunch of inputs and outputs that are outside the bounds of a system."

The part about "outside the bounds of a system" really hit home. It’s true—no matter how good your software is, there’s always going to be some website or desktop app with data hidden away, or a phone call from a customer that throws everything off. You just can’t build software to handle every single piece of data, everywhere it exists. It seems impossible.

Or Is It?

Let’s explore this idea with a bit of code in Plang. Imagine a scenario where:

You get info from a customer by voice.
You pull their data from an API.
You log into a government website to fetch more details.
You open a desktop app to grab additional info.
Then you combine all this into a single response for the user.

Here’s how you might do that in Plang:

Start
- use 'input' as audio
- use 'output' as audio
- ask "Please tell me your SSN", write to %audio%
- convert %audio% to text, write to %user%
- [llm] system: analyze the input, figure out his SSN
        user: %user%
        scheme: {ssn:string}
- call goal GetUserInfo
- call goal BrowseGovernment
- call goal OpenDesktopApp
- call goal StoreInfo
- call RespondToUser

GetUserInfo
- get http://myinternal.webservice/?ssn=%ssn%, write to %userInfo%

BrowseGovernment
- go to https://goverment.org
- set #username = %Settings.Username%
- set #password = %Settings.Password%
- click #login
- go to https://goverment.org/user/%ssn%
- extract #medicalInfo into %medicalInfo%
- extract #visionInfo into %visionInfo%

OpenDesktopApp
- run myapp.exe, maximize and focus
- click on 1200, 300 / put focus on input box
- type in %ssn%
- click on 1200, 500 / click the search button
- take screenshot, save to file/screenshot.jpg
- [llm] system: analyze the screenshot and give me the text
        user: file/screenshot.jpg
        scheme: { userGlasses: string, userStrength: string }

StoreInfo
- insert into user, %ssn%, %userInfo%, %medicalInfo%, %visionInfo%, %userGlasses%, %userStrength%

RespondToUser
- [llm] system: create a response to user from data
        user: %userInfo%, %medicalInfo%, %visionInfo%, %userGlasses%, %userStrength%
        write to %response%
- convert %response% to audio, write to %audioResponse%
- write out %audioResponse%

In just over 40 lines of code, we’ve pulled data from four very different sources: a voice input, an API, a website, and a desktop application. We’ve brought all that data together in one place to give a single response to the user.

Now, let’s dive into what each piece of the code does next…

Let's Go Over the Code

Let's break down what each part of the Plang code does:

- use 'input' as audio, from default mic

We start by changing the default input. Normally, Plang takes input from the terminal, but here, we're telling it to use the microphone for audio input. This allows us to capture what the user says.

- use 'output' as audio

Similarly, we're switching the output to audio. Instead of outputting text to a screen, the program will convert text into an audio stream, which will be played back to the user.

- ask "Please tell me your SSN", write to %audio%

This line sends a spoken request to the user, asking for their SSN. The user's response is captured as audio and stored in the %audio% variable.

- convert %audio% to text, write to %user%

Once we have the user's spoken response, we convert the audio to text and store it in the %user% variable so that we can process it.

- [llm] system: analyze the input, figure out his SSN
        user: %user%
        scheme: {ssn:string}

Here, we ask a large language model (LLM) to analyze the user’s text input to extract the SSN. The result is stored in the %ssn% variable.

Note: This is written as if everything goes perfectly. In reality, you'd need error handling for cases where the user gives invalid input or doesn't follow the expected format.

- call goal GetUserInfo
- call goal BrowseGovernment
- call goal OpenDesktopApp
- call goal StoreInfo
- call RespondToUser

We then call a series of predefined "goals" that perform various tasks:

GetUserInfo fetches customer data from an internal REST API.
BrowseGovernment logs into a government website to retrieve data.
OpenDesktopApp interacts with a desktop app to pull more info.
StoreInfo saves all the collected data.
RespondToUser gives a response back to the user.

GetUserInfo

This is a straightforward REST API call:

- get http://myinternal.webservice/?ssn=%ssn%, write to %userInfo%

We query an internal web service using the SSN as the parameter and store the returned user information in the %userInfo% variable.

BrowseGovernment

This section automates logging into a government website and pulling specific data:

- go to https://goverment.org
- set #username = %Settings.Username%
- set #password = %Settings.Password%
- click #login
- go to https://goverment.org/user/%ssn%
- extract #medicalInfo into %medicalInfo%
- extract #visionInfo into %visionInfo%

We navigate to the government website, input login credentials stored in the Settings, and then log in. Once logged in, we navigate to a page containing the user’s info based on their SSN. We then extract the medical and vision data, saving them into %medicalInfo% and %visionInfo%.

OpenDesktopApp

Interacting with desktop apps is a bit trickier, so we simulate mouse movements and clicks by using pixel coordinates:

- run myapp.exe, maximize and focus
- click on 1200, 300 / put focus on input box
- type in %ssn%
- click on 1200, 500 / click the search button
- take screenshot, save to file/screenshot.jpg
- [llm] system: analyze the screenshot and give me the text
        user: file/screenshot.jpg
        scheme: { userGlasses: string, userStrength: string }

We launch the desktop app myapp.exe, maximize the window, and focus on it. Then we simulate clicking at specific coordinates to place the cursor in the input box and enter the SSN. After clicking "Search," we take a screenshot of the results.

Since we can’t directly extract the data from a desktop app, we upload the screenshot to the LLM, which performs optical character recognition (OCR) to analyze the text in the image. This gives us the variables %userGlasses% and %userStrength%, which hold the extracted data.

StoreInfo

Now that we've gathered all the information, we store it in a database:

StoreInfo
- insert into user, %ssn%, %userInfo%, %medicalInfo%, %visionInfo%, %userGlasses%, %userStrength%

Here, we insert the SSN, user info, medical data, vision data, and any additional information (like the user's glasses prescription and strength) into the user database.

RespondToUser

Finally, we respond to the user by creating a custom response based on the data we’ve collected:

RespondToUser
- [llm] system: create a response to user from data
        user: %userInfo%, %medicalInfo%, %visionInfo%, %userGlasses%, %userStrength%
        write to %response%
- convert %response% to audio, write to %audioResponse%
- write out %audioResponse%

We ask the LLM to generate a response that summarizes all the information we've gathered. The LLM crafts the message using the %userInfo%, %medicalInfo%, %visionInfo%, and other data. Once the response is created, we convert it to audio and play it back to the user.

Conclusion

This entire flow—from gathering audio input to pulling data from various sources and returning a spoken response—happens in around 40 lines of code, demonstrating how powerful interoperability using plang can be.

The title of this article is "In Theory: Interoperability" because, in reality, you can't do all this in Plang today.

What’s missing is the ability to listen to a user, convert their audio to text, and automate desktop interaction. These pieces just need to be built—there are no real technical barriers. Once those modules are in place, the code you see above should work just fine.

You then of course have all the exceptions to handle, errors, when do you know when user has stopped speaking and so on.

More Information

Interested in learning more about Plang? Here are some useful resources to get started:

Basic Concepts and Lessons
Todo Example to build a simple web service
Explore the GitHub repo for source code
Join our Discord Community for discussions and support
Or chat with the Plang Assistant to get help with code generation

Introduction to Plang: Master Coding Quickly and Easily!

Ingi — Thu, 03 Oct 2024 18:51:17 +0000

What is Plang?

Imagine telling a computer what to do as easily as giving instructions to a friend. That’s exactly what Plang allows you to do! With Plang, you can write out tasks in simple steps, and the computer follows your instructions without the need for complicated coding. Just use plain language to command the computer!

Ready to dive into a fun project that’ll get you hooked on programming? Let’s get started!

Step 1: Prepare to Write Your First Program

Before we begin coding in Plang, you'll need to install it on your computer. But don’t worry, it’s a breeze! Just follow these steps:

Download Plang: Head to Plang's GitHub page and follow the simple installation guide.
Create a Project Folder: Set up a folder on your computer for all your Plang programs. Give it a fun name like "MyFirstPlang."

Step 2: Writing Your First Program

Let’s start by creating a program that asks for your name and age, and then responds with a message. You’ll save this in a file called Start.goal.

Here’s what the code looks like:

Start
- ask "What is your name?", write to %name%
- ask "How old are you?", write to %age%
- write out "Hello, %name%! You are %age% years old."

What does this code do?

First, the program asks for your name and age.
Then, it prints a message like: "Hello, Alex! You are 10 years old."

It’s that simple! When you run the program, the computer will interact with you and display the answers you provide.

Step 3: Saving and Running Your Program

Now let’s run your program:

Save your file as Start.goal.
Open your terminal (or command prompt) and navigate to your project folder.
Type plang build to build your program.
Run it by typing plang.

Once you do this, the program will ask for your name and age, and display the message you’ve written.

Step 4: Interacting with Files

What if you want the program to interact with a file, like updating today’s date in a document? Let’s see how that works.

Start
- read file 'diary.txt', into %content%
- set %content% = "Hello diary"
- save %content% to 'diary.txt', overwrite file

This code:

Reads a file called diary.txt.
Adds 'Hello diary' to the content.
Saves the updated content back to the file.

Step 5: Build a To-Do List App

Let’s create something useful: a simple To-Do list app!

Set up a database for your tasks:

Setup
- create table tasks, columns: task(string, not null), due_date(datetime)

Now let’s add tasks and display them:

Start
- insert into tasks, task='Do homework', due_date=%Now+2hours%
- insert into tasks, task='Feed the dog', due_date=%Now+30minutes%
- select * from tasks, write to %allTasks%
- write out %allTasks%

When you run this, the program will save tasks like "Do homework" and "Feed the dog" and display them on the screen.

Step 6: Connecting Your Program to the Web

Let’s make things more interesting by getting data from the internet! Here’s an example that pulls posts from a website:

Start
- get https://jsonplaceholder.typicode.com/posts, write to %posts%
- write out %posts%

This will grab posts from the web and display them in your program, making it feel like a mini web browser!

Step 7: Understanding Goals and Steps

In Plang, everything revolves around goals and steps. A goal is like the main task you want to accomplish, and the steps are the smaller actions needed to achieve it. For example:

Goal: "Create a task."
Steps: "Ask for task name, ask for due date, save task to list."

It’s like following a recipe, breaking things down into clear instructions that are easy to follow.

Conclusion

With Plang, programming becomes simple, fun, and approachable. By breaking tasks down into clear steps, you can accomplish a lot without needing to learn complex commands.

What’s Next?

Create your own project: Maybe a program to track your favorite games or books!
Explore Plang’s capabilities: Try adding more functionality, like sending a message or setting reminders.
Share your project: Show your friends how easy and exciting coding can be!

Questions to Think About:

What other projects could you build using Plang’s goals and steps?
How could you expand your To-Do list app, like adding task deletion or reminders?
Can you write a program that helps you with daily tasks like homework or scheduling?

More Information

Interested in learning more about Plang? Here are some useful resources to get started:

Basic Concepts and Lessons
Todo Example to build a simple web service
Explore the GitHub repo for source code
Join our Discord Community for discussions and support
Or chat with the Plang Assistant to get help with code generation

In Theory: Automatic Unit Testing with Plang

Ingi — Mon, 16 Sep 2024 09:14:41 +0000

This post dives into Plang, an intent-based programming language that interprets natural language. For more, visit plang.is or get started here.

In Plang, you can bind events to goals and steps, which opens up a fascinating possibility for automatic testing. Let's walk through an example, starting with something simple: adding two numbers.

A Simple Example: Adding Two Numbers

Here’s a basic code snippet in Plang:

AddTwoNumbers
- %num1% + %num2%, write to %sum%
- write out %sum%

To build automatic unit tests, let's first think about the usual process of testing logic manually. Without automation, you’d run something like this:

plang num1=1 num2=2

This would output:

Automating the Process

Because Plang lets us bind events to steps, we can automate this process. For example:

Events
- before each step, call PrepareUnitTest
- after each step, call MakeUnitTest

Here’s how it works:

The PrepareUnitTest goal stores the variables in the current step.
The MakeUnitTest goal captures the output, like the value of %sum%.

Once that’s in place, we can even ask the LLM to generate unit tests for us. This results in a JSON file with the relevant test values.

A Developer’s Interface

At this point, a developer would likely need a simple interface—a GUI—to tweak those values, add new tests, or remove unnecessary ones. Each module would define its own rules for unit testing, especially for handling I/O operations like HTTP requests, which would require special considerations.

With this setup, automatic testing becomes a streamlined part of the development process, enhancing efficiency and reliability in Plang projects.

In Theory

This post is titled In Theory because, at this point, automatic unit testing with Plang is just that—a theory. It hasn’t been implemented or tested yet, but there’s no reason it couldn’t be. The concept is sound; it’s just a matter of engineering time.

More Information

Interested in learning more about Plang? Here are some useful resources to get started:

Basic Concepts and Lessons
Todo Example to build a simple web service
Explore the GitHub repo for source code
Join our Discord Community for discussions and support
Or chat with the Plang Assistant to get help with code generation

I love how clean Plang is

Ingi — Mon, 09 Sep 2024 10:34:47 +0000

This article explores Plang, an intent-based programming language designed to interpret natural language. For more information, visit plang.is or take your first steps

I am creating an app. It's a great way to develop the language. If it's not supported and I feel like it works, I will implement it

So I am setting up monitoring on variables in GUI. React style.

It goes like this

Start
- monitor %number1%, %number2%, call Calculate
/ more code

Calculate
- set %number1% + %number2%, as %sum%
- set #sum = %sum% / we are setting(updating) the GUI

So in few lines you are monitoring the variables. Amazing. Plang still blows my mind.

Now I have this project, and I know I am monitoring somewhere variables, so I search for it.

And the results, 3, that is it. And it's clean

I just liked that.

In Theory: Self-Correcting Software - Part 2

Ingi — Sat, 07 Sep 2024 15:32:09 +0000

This article explores Plang, an intent-based programming language designed to interpret natural language. For more information, visit plang.is or take your first steps

In a previous article on self-correcting software, I demonstrated how Plang code can self-correct. It was a simple proof of concept, but let's dive deeper into how this works.

How Plang Works

Plang compiles into JSON files—essentially instructions—that are saved into a .pr file. This .pr file tells the Plang runtime how to execute your code. Keep this .pr file in mind as it plays a crucial role in what follows.

Example of a Basic Instruction:

- read file.txt to %content%

This would generate a JSON instruction like so:

{
    "ModuleType":"FileModule",
    "FunctionName": "ReadTextFile",
    "Parameters": [{"path": "file.txt"}]
}

The Plang runtime will load the appropriate FileModule, and if you examine the Program.cs file, you'll find a method called ReadTextFile.

This is where Plang is currently at, in version 0.1.

The Challenge: Refactoring and Compatibility

Now, imagine we want to refactor the method name from ReadTextFile to ReadContentOfTextFile in the Program.cs.

Any Plang code that uses the old method name(ReadTextFile) will break and throw an error like this:

Error:
    Message: Method 'ReadTextFile' could not be found. 'ReadTextFile' is defined in your instruction file
    Key: MissingMethod

In the previous article, I showed how Plang can bind events to goals (functions) or steps (lines of code). We’ll use this feature to handle method refactoring gracefully.

Self-Correcting Code in Action

We start by creating an event listener that catches this specific error:

Events
- on any error where key="MissingMethod", call FixCode

Step 1: Collect Available Methods

First create FixCode.goal and give it the title

FixCode

Next, we want to resolve the MissingMethod error by finding the updated method in the FileModule.

We need to gather all available methods in FileModule. We can access what module caused the error from the %!step.ModuleType% property:

- get all available methods in %!step.ModuleType%, write to %methods%

ProTip: In Plang, the %!step% variable always contains the current step running, including its ModuleType, which points to the FileModule. If you want to know what properties are in %!step%, just write it out - write out %!step%

This will include methods like ReadContentOfTextFile. Here's an example of what it might look like:

[
  {
    "Method": "public async Task<string> ReadContentOfTextFile(string path, string returnValueIfFileNotExisting = '', bool throwErrorOnNotFound = false, bool loadVariables = false, bool emptyVariableIfNotFound = false, string encoding = 'utf-8')",
    "Description": "Read the content from a file. Formerly ReadTextFile"
  },
  {
    "Method": "public async Task WriteToFile(string path, string content, bool overwrite = false, bool loadVariables = false, bool emptyVariableIfNotFound = false, string encoding = 'utf-8')",
    "Description": "Write content to a file"
  }
  ...
  ...
  ...
]

Step 2: Read the Failing Instruction

Next, we read the instruction .pr file for the step that triggered the error:

- read %!step.AbsolutePrPath%, into %instructions%

AbsolutePrPath is a property of the %!step% variable that points to the location of the .pr file on your hard drive

Step 3: Call the LLM to Fix the Code

We can now pass the problem to a language model (LLM) to update the method name:

- [llm] system: The user is attempting to execute code, but the method was not found, possibly due to renaming.
              These are the instructions to call the C# code: %instructions%
              These are the available methods: %methods%
              Rewrite the instructions
      user: %!error.Message%
      scheme: {instructions:string}

With this input, the LLM can generate the corrected code and return it in the %instructions% variable.

Step 4: Write the Corrected Code

Finally, we overwrite the .pr file with the corrected code and re-execute the step:

- write %instructions% to %!step.AbsolutePrPath%
- retry step

Final Solution:

The complete self-correcting code looks like this:

FixCode
- get all available methods in %!error.ModuleType%, write to %methods%
- read %!step.AbsolutePrPath%, into %instructions%
- [llm] system: The user is attempting to execute code, but the method was not found, possibly due to renaming.
              These are the instructions to call the C# code: %instructions%
              These are the available methods: %methods%
              Rewrite the instructions
      user: %!error.Message%
      scheme: {instructions:string}
- write %instructions% to %!step.AbsolutePrPath%
- retry step

In-Theory Article

This is still theoretical—these modules aren't yet available in Plang, and some features like retry step and get all available methods aren't implemented. But once the language matures, this will work.

So why haven’t I implemented this yet? Well, Plang is evolving fast, and there are a thousand things to work on. But I wanted to outline this approach first.

Plang's Upgrade Path

This opens up a fascinating upgrade path for Plang. Since Plang is still in its early stages, breaking changes are common. This approach would allow upgrades to happen almost automatically, minimizing the need for manual fixes.

Of course, there's still a lot of engineering ahead, but the conceptual problem is solved.

Extending Plang with Modules

It's easy to extend Plang using modules. For example, to interact with Google Drive, you could install the Google.Drive module:

Start
- get list of all my files in "tAff2u44jU2nZgpJkbY5mSwW3" on Google Drive, %files%
- write out "List of all files: %files%"
- go through %files%, call ProcessFile

ProcessFile
- download file from Google Drive, fileId=%item.id%, save it to file/%item.name%

Now imagine the module developer updates the API and renames methods. Thanks to our self-correcting system, your code would still work without any changes on your end.

A Word of Caution

As programmers, we’re naturally skeptical about automated fixes happening without confirmation. This is where unit tests come into play. But that’s a topic for another article.

More Information

Interested in learning more about Plang? Here are some useful resources to get started:

Basic Concepts and Lessons
Todo Example to build a simple web service
Explore the GitHub repo for source code
Join our Discord Community for discussions and support
Or chat with the Plang Assistant to get help with code generation

Translating with Ease: Automating Translations with Plang

Ingi — Tue, 03 Sep 2024 15:00:45 +0000

So, I recently had a client setting up a new website, and everything was written in English. The catch? They needed to translate it all into Icelandic. The developers handed over an Excel file with about 350 keywords to translate. Not a massive task, but still enough to be a bit of a time sink if done manually.

Here's a peek at how the Excel file looked:

Instead of slogging through it by hand, I figured I'd try out Plang to see if I could streamline the process and save everyone some time.

Try it

If you like to try this, then install Plang and get a basic understanding of how Plang works

Getting Started

First off, setting things up is a breeze. Just create a Translate.goal file and open it in your favorite text editor.

Kick things off with the line:

Translate

Reading the Excel File

Next up, we need to read the Excel file. Here’s how you do it in Plang:

- read file translations.xlsx, sheet:translations, into %translations%

This tells Plang to grab the data from the translations sheet in translations.xlsx and load it into the %translations% variable.

Splitting the List

With 350 keywords, sending everything to the language model in one go might be overkill. To avoid confusion (for the model and us), we split the list into chunks of 20 items:

- [code] split %translations% with 20 items in them,
     write to %translationsLists%

Now, %translationsLists% contains multiple smaller lists, each with 20 keywords.

Processing the List

Next, we loop through each chunk in %translationsLists% and call TranslateList for each one:

- foreach %translationsLists%, call TranslateList

This step makes sure each group of keywords gets processed.

Time to Translate

Here’s where the magic happens. We get the language model to translate the keywords into Icelandic:

TranslateList
- [llm] system: Translate the messages to Icelandic, leave key as is
    user: %item%
    scheme:[{key:string, message:string}]
    write to %translated%

After this, %translated% contains the Icelandic translations paired with the original keywords.

Saving the Translations

Finally, we save the translations into a CSV file:

- append %translated% to csv file 'translate.csv'

And that’s it! We’ve got our translations neatly saved in translate.csv.

Wrapping Up

In about five minutes, I put together a script that automates translating a list of keywords. Here's the full code:

Translate
- read file translations.xlsx, sheet:translations, into %translations%
- [code] split %translations% with 20 items in them,
     write to %translationsLists%
- foreach %translationsLists%, call TranslateList 

TranslateList
- [llm] system: Translate the messages to Icelandic, leave key as is
    user: %item%
    scheme:[{key:string, message:string}]
    write to %translated%
- append %translated% to csv file 'translate.csv'

It’s important to note that even though the heavy lifting is automated, a human still needs to review the translations. They’ll catch the context-specific nuances that the model might miss.

Feel free to tweak this approach for your own projects. Let me know how it works for you!

More Information

If Plang is interesting to you, you should dig a bit deeper:

Basic concepts and lessons
Simple Todo example is a good start
Check out the GitHub repo
Meet up on Discord or GitHub discussions to get help and for general chat
And plang.is, the official Plang website
Chat with the current Plang assistant

In Theory: Self-Correcting Software

Ingi — Sun, 01 Sep 2024 15:27:46 +0000

This article explores Plang, an intent-based programming language designed to interpret natural language. For more information, visit plang.is or take your first steps

In Plang, you can bind events to goals(functions) and steps(line of code), a feature that proves incredibly powerful.

Let's consider a scenario: you want to ensure that a user is logged in before they can call a function in the /admin route.

No problem in Plang:

Events
- before any goal in /admin, call AuthenticateUser

AuthenticateUser
- select id as userId from users where %Identity% and role='admin', return 1 row
- if %userId% is empty then
    - show error "You don't have permission"

And there you have it—authentication is solved in just 4 lines of code.

How does this translate to self-correcting software?

Self-Correcting Software

Let's say I'm making a POST request to a service:

CreateUserAsExample
- post https://example.org/api/createuser
    {name:"%name%", }

Now, let's bind an event to all error that happen in step.

Events
- on error on any step, call SelfCorrect

SelfCorrect
- [llm] system: fix this plang code...
    user:%!error.Message%
    write to %code%
- write to %!error.Goal.RelativePath%
- build plang code
- retry step

Here, we've instructed the LLM to fix the Plang code.

If the /api/createuser service now requires more than just a name, it will return an error message such as "{error:"You need to provide Email (%email%)"}.

Asking the current Plang assistant to handle this scenario would give you an updated response:

CreateUserAsExample
- post https://example.org/api/createuser
    {name:"%name%", email:%email%}

Now, plang code can save the new code to its path, build and run the code.

But What if the Email is Still Empty?

Yes, the %email% field might still be empty.

In this case, you need to traverse up the call stack and fix the previous goal. Once one issue is resolved, the same principle applies to the next one. It's just a matter of engineering.

More Information

If Plang is interesting to you, you should dig a bit deeper:

Basic concepts and lessons
Simple Todo example is a good start
Check out the GitHub repo
Meet up on Discord to discuss or get help
Chat with the Plang Assistant

A Beginner's Guide to Implementing Events in Plang

Ingi — Fri, 30 Aug 2024 15:27:19 +0000

This article explores Plang, an intent-based programming language designed to interpret natural language. For more information, visit plang.is or take your first steps

Welcome to this step-by-step tutorial on implementing and managing events in your Plang applications.

Events in Plang allow you to trigger specific actions at various stages in your application’s lifecycle, during the build process, or under certain conditions. This guide covers setting up events, handling errors, managing builder events, and more.

1. Setting Up Events

To start, you'll need to establish the structure for events in your Plang application:

Create an events Directory

Begin by creating a folder named events in your project’s root directory.
Create the Events.goal File

Inside the events folder, create a file named Events.goal. This is where you'll define your events.

2. Application Lifecycle Events

Lifecycle events allow you to execute specific actions when your application starts or ends. Here’s how to set them up:

Events
- before app starts, call !AppStarting
- before app ends, call !AppEnding

Next, create AppStarting.goal and AppEnding.goal files in the events folder:

AppStarting.goal:

AppStarting
- write out 'App is starting'

AppEnding.goal:

AppEnding
- write out 'App is ending'

before app starts: Triggers the AppStarting action before the application starts.
before app ends: Triggers the AppEnding action before the application shuts down.

Plang is flexible with its syntax. You don’t have to write exactly before app starts; you can phrase it as when the app starts..., on app start..., or any other way that clearly conveys your intent.

3. Events with Goals and Steps

Plang enables you to trigger events before or after specific goals within a directory or globally after each goal:

Events
- before each goal in 'api/*', call !AuthenticateUser
- after each goal, call !Analyze.LogInfoAboutGoal

Before each goal in 'api/*': Runs AuthenticateUser before any goal in the api directory.
After each goal: Runs LogInfoAboutGoal after every goal in your project.

4. Error Handling Events

Handling errors effectively is essential. Plang allows you to define events that trigger when errors occur:

Events
- on error in step, call !LoggerStepError
- on error on goal, call !LoggerGoalError

on error in step: Calls LoggerStepError when an error occurs in any step.
on error on goal: Calls LoggerGoalError when an error occurs in any goal.

For more detailed error handling, refer to the ErrorHandler documentation.

5. Builder Events

Events related to the Plang builder can be defined in a BuilderEvents.goal file:

BuilderEvents
- before each step, call !AnalyzeCode
- after each step, call !AnalyzeCode

Plang already uses this build event internally to validate all goals. After your first build, you can find this at /events/external/plang/builder/CheckGoals.goal.

Before and after each step: AnalyzeCode is called before and after each step during the build process, ensuring consistent code analysis.

6. Conditional Events

You may want to trigger events only under certain conditions, such as in debug mode:

Events
- before each step, call !SendDebug, only when start parameter is '--debug'

To trigger this event, run your application with:

plang --debug

The SendDebug event is triggered only if the --debug parameter is passed at startup. Plang’s debugger itself uses this feature, which you can find at /events/external/plang/runtime/SendDebug.goal after your first debug session.

7. Using Available Variables

Within your events, you can access information about the current goal, step, or event using predefined variables:

%!goal%: Represents the current goal.
%!step%: Represents the current step.
%!event%: Represents the current event.

These variables are useful for passing context-sensitive information to your event handlers.

8. External Events

To integrate external events from other sources, place external event files in the following directory structure:

events/external/{appName}/

For example, events related to plang would be placed in events/external/plang/, created automatically when you build or run a debugger.

9. Binding Events to Variables

In Plang, you can bind events to variables to monitor their lifecycle (creation, update, or deletion):

- when %name% is created, call VariableNameIsCreated
- when %email% is changed, call VariableEmailIsChanged
- when %zip% is changed or created, call VariableZipIsChanged
- when %name% is deleted, call VariableNameIsDeleted

This setup allows dynamic event handling based on how variables change in your application.

10. Types of Events in Plang

Plang provides various event types for different scenarios:

Before and After Events: Trigger actions before or after specific goals or steps.
Error Events: Handle errors by triggering specific actions when an error occurs.
Conditional Events: Execute actions based on specific conditions or parameters.
Build Events: Manage events during the build process.
Variable Events: Bind actions to changes in variable states.

11. Source Code Reference

If you're interested in exploring the underlying code for event management in Plang, you can check out the following files in the Plang repository:

EventBuilder.cs: Handles the creation of event files.
EventRuntime.cs: Manages the runtime execution of events.
EventBinding.cs: Contains objects used for event management in both the builder and runtime.

These resources will help you gain a deeper understanding of how events are managed in Plang.

More Information

If Plang is interesting to you, you should dig a bit deeper:

Basic concepts and lessons
Simple Todo example is a good start
Check out the GitHub repo
Meet up on Discord to discuss or get help

Messaging in Plang

Ingi — Fri, 19 Jul 2024 10:31:06 +0000

This article explores Plang, an intent-based programming language designed to interpret natural language. For more information, visit plang.is or take your first steps

Plang has built-in messaging. It uses the Nostr protocol by default to do this.

Before We Start

Make sure to install Plang.

Note that building code in Plang costs money as it uses LLM. If you have an OpenAI key, you can use that. Instructions are available on your first build.

Plang is a programming language where you write the code in natural language. I call it intent programming because you just need to write your intent and the LLM will figure out what you would like to do.

To understand it, make sure to go through some of the lessons we have.

Prepare

There are some Nostr clients out there. I recommend Damus (iOS) and Amethyst (Android).

Download either of these clients to your phone. This allows us to communicate with the Plang app we are building in this tutorial.

After you have set it up, create a new account and find the public address by clicking your profile picture and going into your profile.

The public address will start with 'npub.....'.

Copy this address, so you have 'npub.....' in your clipboard.

Set Up Code

Let's get started. You should have Plang installed and create a new folder on your computer (you choose the location).

Let's create the folder MessageTest. Inside the folder, create a file called Start.goal. This is the default entry point into your app.

Now write the code:

Start
- get the public address for message, write to %publicAddress%
- write out 'Your address is: %publicAddress%'
- listen to message from 'npub...', 
    on new message call ProcessMessage, content of goes into %message%

ProcessMessage
- write out 'Message from phone: %message%'

Now build and run it:

plang exec

It should now print out the Nostr public address and listen for messages:

Your address is: npub....

Try sending a message from your phone to the npub address that was printed out.

Send a Message

Now we want to send a message to our phone.

Create a new file SendMessage.goal:

Make sure to put in you npub address from your phone instead of 'npub....'

SendMessage
- send a message to 'npub....',
    content=%content%

Build the code:

plang build

And run the code with some content:

plang SendMessage content="Hello"

Your phone should receive a message with the content "Hello."

More Information

If Plang is interesting to you, you should dig a bit deeper:

Basic concepts and lessons
Simple Todo example is a good start
Documentation on the message module
Check out the GitHub repo
Meet up on Discord to discuss or get help