Janet: A Hidden Gem in the World of Programming Languages

So, you’re probably on the hunt for a new programming language to add to your toolkit, or maybe you’re just curious about what’s out there. Let’s talk about Janet, a language that’s all about simplicity, flexibility, and versatility. This little gem offers everything from scripting to embedded systems, blending functional and imperative programming styles with ease.

One of the coolest things about Janet is how simple it is. Seriously, the syntax is so clean and intuitive that even those new to programming will have no trouble picking it up. Imagine needing to prototype something quickly but not wanting to deal with verbose syntax or a bloated setup. Janet is your go-to. Picture this: a “Hello, World!” program in Janet needs just a single line of code.

(print "Hello, World!")

That’s it. The entire ecosystem of Janet, from the core library to the interpreter, compiler, and assembler, is super compact at less than 1MB in total. This makes Janet incredibly light, portable, and perfect for embedding into other applications without dragging along a ton of extra baggage.

One of Janet’s biggest flexes is its support for both functional and imperative programming styles. Why choose one when you can have the best of both worlds, right? Want to go the functional route using higher-order functions and closures? Easy. Prefer loops and conditionals instead? Also covered. Here are two ways to write a simple function that sums a list:

Functional style:

(defn sum [s]
  (reduce + 0 s))

Imperative style:

(defn sum [s]
  (let [total 0]
    (for i 0 (length s)
      (set total (+ total (s i))))
    total))

This dual nature means you can pick the approach that suits your needs the best, making Janet a versatile tool for a wide range of tasks.

If scripting is your thing, Janet is built for it. Thanks to its lightweight runtime and fast startup times, you can write scripts that execute shell commands effortlessly. Imagine needing to automate some system tasks or interact with the shell—Janet handles it gracefully with tools like the $ macro:

(use sh)
($ echo "Hello, Janet!")

Such seamless integration makes Janet perfect for scripting and system automation.

When it comes to embedded systems, Janet shines brightly. You can add Janet scripting to an application with just a single C source file and a header. This makes Janet easy to weave into existing systems, adding a powerful scripting layer without the heavyweight footprint of a full runtime environment. Threading, networking, and subprocess handling are all part of Janet’s arsenal, making it a strong candidate for embedded applications.

Janet stands out with its support for Parsing Expression Grammars (PEGs), which are far more powerful than regular expressions. This capability makes parsing text data like config files a breeze. Check out this snippet that uses PEGs to parse a todo list:

(defn parse-todo [text]
  (let [peg (peg "todo" (or (peg "task" (seq (str "- [ ] ") (capture (many (not (str "\n")))))
                           (peg "done" (seq (str "- [x] ") (capture (many (not (str "\n"))))))))]
    (peg/parse peg text)))

PEGs in Janet are a lifesaver when you need to tackle complex text parsing tasks.

Concurrency and multithreading are part of Janet’s toolkit too. Multi-core processors are the norm now, and Janet lets you take full advantage of them effortlessly. Here’s a simple example demonstrating how you can use threads in Janet:

(defn worker [name]
  (print (str "Worker " name " started"))
  (sleep 1000)
  (print (str "Worker " name " finished")))

(thread (worker "A"))
(thread (worker "B"))

The built-in support for concurrency means your applications can be more efficient and responsive.

Another neat trick Janet has up its sleeve is the ability to compile programs into statically-linked native binaries. This means you can distribute your Janet programs without making users install a separate runtime environment. That’s super handy for deploying scripts and tools where you can’t control the software environment.

Janet also has a growing community and plenty of resources. There’s a REPL (Read-Eval-Print Loop) for interactive coding, extensive documentation, user-contributed examples, and package listings to help you find and install libraries. There are also spaces like the Janet Zulip instance and GitHub discussions, where you can dive into community support.

The real-world applications of Janet are quite broad. From automating tasks to system scripting and even building custom tools, Janet does it all. Here’s a quick example of a simple todo list application built with Janet:

(defn add-task [tasks task]
  (conj tasks task))

(defn mark-done [tasks index]
  (let [task (nth tasks index)]
    (assoc tasks index (str "[x] " (subs task 4)))))

(defn print-tasks [tasks]
  (for [task tasks]
    (print task)))

(def tasks @["- [ ] Task 1" "- [ ] Task 2"])

(print-tasks tasks)
(add-task tasks "- [ ] New Task")
(mark-done tasks 0)
(print-tasks tasks)

This example showcases how you can create a functional todo list app with Janet, showing just how practical and versatile the language can be.

To wrap it up, Janet is a hidden gem in the programming world. Its blend of simplicity, functionality, and easy embeddability makes it a fantastic choice for a variety of applications. Whether you’re automating tasks, delving into embedded systems, or just exploring a new language, Janet is definitely worth your time.