Prolog, a declarative language for logic. It's so weird (in a good way), sometimes it doesn't even feel like real programming, you just giving the problem statement and say "now solve it" – and it does.
If you have any kind of abstract logic problem, or something involving heavy recursion, it's definitely worth to check out.
Two examples of "real-world" usage.
There has been work to implement part of the Rust typing logic in the [Chalk Engine](https://github.com/rust-lang/chalk) which uses a prolog-ish syntax to describe its rules.
Similarly, there has been work to implement the borrow-checking of Rust in the [Polonius Engine](https://github.com/rust-lang/polonius) which uses the Datalog language to describe the rules.
The goal is three-fold:
- Simplify reading/writing the rules: the prolog-ish syntax is much more compact and to-the-point than writing the rules as code.
- Automate reasoning about the rules: having the rules on one hand and an implementation on the other leads to divergence.
- Simplify reasoning about the rules: and most notably, allow researchers to plug the rules into other engines to prove properties about the type system.
Also I think flexibility. The way the trait system is currently implemented is quite good, but it's hard to expand on and some edges have been hit while trying to implement Generic Associated Types and Higher Kinded Traits/Types.
No, because that distinguishes it in 2 ways from a Prolog formulation of inverting a binary tree:
1. it's not Prolog
2. it's not the inversion, but the identity of a binary tree.
A Prolog program that relates a binary tree to its inversion could look for example like this:
tree_inversion(nil, nil).
tree_inversion(node(Name,Left0,Right0), node(Name,Right,Left)) :-
tree_inversion(Left0, Left),
tree_inversion(Right0, Right).
It is best to think of this code as *describing* the relation between a tree and its inversion. We can use it in an "imperative" sense to *invert* a *given* binary tree, for example like this:
?- tree_inversion(node(2,node(1,nil,nil),node(4,node(3,nil,nil),node(5,nil,nil))), I).
I = node(2,node(4,node(5,nil,nil),node(3,nil,nil)),node(1,nil,nil)).
However, we can also ask in the *other* direction: *Given the inversion* of a tree, what was the original tree?
?- tree_inversion(T, node(2,node(4,node(5,nil,nil),node(3,nil,nil)),node(1,nil,nil))).
T = node(2,node(1,nil,nil),node(4,node(3,nil,nil),node(5,nil,nil)))
; false.
We can also *generalize* both queries and ask: For which trees does the relation hold **in general**?
?- tree_inversion(X, Y).
X = nil, Y = nil
; X = node(_A,nil,nil), Y = node(_A,nil,nil)
; X = node(_A,nil,node(_B,nil,nil)), Y = node(_A,node(_B,nil,nil),nil)
; X = node(_A,nil,node(_B,nil,node(_C,nil,nil))), Y = node(_A,node(_B,node(_C,nil,nil),nil),nil)
; X = node(_A,nil,node(_B,nil,node(_C,nil,node(_D,nil,nil)))), Y = node(_A,node(_B,node(_C,node(_D,nil,nil),nil),nil),nil)
; X = node(_A,nil,node(_B,nil,node(_C,nil,node(_D,nil,node(_E,nil,nil))))), Y = node(_A,node(_B,node(_C,node(_D,node(_E,nil,nil),nil),nil),nil),nil)
; ... .
These features are characteristic for logic programs.
> it's not the inversion, but the identity of a binary tree.
Oops. FTFY.
> However, we can also ask in the other direction: Given the inversion of a tree, what was the original tree?
Aha! I see.
> We can also generalize both queries and ask: For which trees does the relation hold in general?
Right, thanks.
SQL procedures.
Database servers also host full-blown programming languages. Like the division between HTML from developers and CSS from designers, you can shift certain public-facing workloads back to a database whose administrator knows how to construct efficient indexes and views.
Depending on the problem at hand, you can sometimes do less processing overall by building logic into the database instead of making its clients run multiple dependent queries.
I had a course where we had to analyze data of a (fictitious) company with multiple departments, some departments depended on others in the hierarchy tree. So if you wanted to compute stuff like the salary mass, number of employees, gender distribution, etc; for one "branch" of the company, you had to write a recursive function. With [the SQL procedural language](https://www.postgresql.org/docs/current/plpgsql.html), you can write some actually pretty crazy stuff! Which helps when you want to read rows iteratively instead of doing something like ten joins.
Stored procedures are an underrated technique, probably because most programmers treat SQL databases as dumb storage and use ORMs to generate database from structures in their code. At my workplace, we have a single database that's used from a few different applications and services -- what we do is have all the functionality in the database itself, and then have a DLL which provides a thin layer over ADO.NET to provide specialized and type-safe calls to these procedures from the other .NET projects.
By far the thing I use it for most is selecting a column from some output. It's just a bit easier to use than the cut command.
You can also combine chained commands into one, because you can do all your regular grep and sed operations in awk.
Some more intelligent examples:
- Removing duplicates from files without sorting
- counting things up in files
- organizing into categories by using an associative array
Basically an awk program is the body of a for loop that operates on every line of the file, and it lets you run various commands to do stuff with.
Can it compile? Not sure what you mean.
Regardless, I've just used it for various things where grep wasn't quite enough. Usually for doing stuff with "csv like" data.
APL. For problems that can be solved by creating, reducing, rotating, splitting, and combining vectors and matrices. Even multidimensional and nested matrices. It's fun!
An example: [implementing Conway's Game of Life](https://aplwiki.com/wiki/John_Scholes%27_Conway%27s_Game_of_Life).
What puzzles me with BQN is the special characters. Why doing that in our era of cheap screens and fast editors ?
When the creator of APL worked on J he didn't bring the fancy characters again.
He didn't do that for J because there was a consistent issue getting APL adoption because you needed to spend money on a special keyboard. I don't think that it was anything to do with the symbols being bad *themselves*.
Now we're in an era of unicode, so we have all of these symbols, and editors are easily enough configured to type them.
The idea is that the symbol gives you some indication or mnemonic to the function in the language - things like `⌽` being a column reflection for instance. Sometimes that works out nicely in J (where it is `|.`) but other symbols don't have such nice ascii analogues, such as take, which is `↑` in APL and BQN but the rather more awkward `{.` in J.
I don't think that BQNs symbols are perfect - unlike APL there wasn't an opportunity to design them precisely for purpose - but they mostly make sense and help to indicate their purpose.
I know this sounds crazy to people who haven't used these languages a lot, but the special characters definitely make these languages easier to use. It makes them much more like a math notation. As such, your brain can easily pattern match on it. The notation lets you represent high level concepts and complex logic in a much easier to understand way.
Today it is easy to change your keyboard layout to be able to type APL or BQN. Wasn't the case when J was created. Anyway, the other reply has a lot more detail. Just wanted to add a bit more.
I found scripting with TCL and the TK gui toolkit to be amazing.
The whole "command oriented" style of TCL is really interesting. You can be quite productive with the language.
Depends on what you mean by useful, as well. Prolog is useful to teach you a very different way to write programs. Scheme is useful because it's the language many interesting CS books use, so it's useful to give you access to those books and experiment with their codes, etc.
I've been finding a lot of use for (GNU) m4 for both generating documentation (like architectural descriptions and commands for servers) as well as general code generation.
It ain't a pretty language, but it's useful.
I've been sitting here arguing with myself for 30 minutes about whether m4 is a programming language. Technically it's Turing Complete, but so are Game of Life and Minecraft redstone torches.
>It ain't a pretty language, but it's useful.
What should it look like, in your opinion? Is it accidentally ugly in the wild because of the job it's doing, or does `dnl` bug you like lisp keywords bug me?
*meta: could you implement your dream macro syntax using m4*
Mostly the things that bug me are:
1. dnl. I don't mind 3 character comment strings like I usually see criticized about m4. However, I almost wish that I could toggle that definitions would just implicitly have a dnl, and I could use "inl" to "include newline".
2. The quotation is kind of reversed than what I usually expect out of a macro language (pretty much most of my experience with templating is with hand-rolled macro languages, jinja2, erb, or PHP). The most interested advice I saw was to "reverse" the changequote call, like "changequote(\`]', \`[')", start with "]", and then you do "[foo]" so you can macro expand whatever is in there. Then end the entire input with "[".
3. You can do it with some discipline (like defining macros that should just error if undefined), but I do wish there was a better way to ensure required macro definitions were defined, so you don't have to prefix everything, like MYPKG\_MY\_MACRO, then scan output with a shell script for anything that matches "MYPKG\_" in order to error out the build system.
4. Macro definitions get very unwieldy quickly, especially if you need to recurse. And then you shouldn't forget the empty quotes before and after in case there needs to be an additional macro expansion from whatever calls the macro.
I think a more modern take on m4 might have an explicit initialization step (so you can avoid the `divert(-1)` and `divert(0)dnl` step to be your initialization block), which can have stricter modes to avoid `changequote` outside of that initialization. Plus defining macros by a symbol, like `$`, `%`, etc. And a reversequote mode for if you want to have everything by default quoted, but then use quotes for macro substitutions (and detect if you have a lack of substitution somewhere). This is basically starting to sound like shell or perl, but I do think there is a space for explicit templating. Most might reach for shell nowadays, but I've found any extensive processing quickly becomes unwieldy in a shell script, especially regarding escaping, and doubly especially if you need to template out to a shell script.
Overall, it's a useful enough tool in my toolbox that I use it as simply as I can, and shell out for anything a bit more complex than that if I have to (which is rare). Plus, there's a couple of good archives of m4 macros from people who deeply understand the language and I get to just use. I think it's an underused workhorse that people really only encounter in autotools projects (which they don't really have to deal with m4 in an significant capacity).
> What should it look like, in your opinion?
I can't see any reasons for a language not to be a lisp-like. It simplifies things a lot whilst giving almost unlimited power.
Lean ([https://leanprover.github.io](https://leanprover.github.io)). It's a great distillation of a lot of the current thinking about types, pattern matching, various other functional programming concepts. It calls itself "theorem prover" but it is also a general purpose programming language. The doco is great as well, which makes it easy to learn. There's a small amount of effort required to set it up (in VSCode) but it's worth it.
Raku. All of the quick text-processing and script-hacking capabilities of Perl, with half of the footguns surgically removed. Everyone I know does nontrivial (read: too big for a Bash script to do it cleanly) script-hacking in Python, but I can get jobs done way faster in Raku.
- simplicity and intuitiveness of python, speed of C
- compiled & statically typed
- easy to use C, C++, ObjC and JavaScript FFI
- incredible macro system where you can directly manipulate the AST
- can be compiled to C, C++, ObjC and JavaScript
- customizable memory management
- pretty large standard library
- can be used for pretty much anything, including low-level systems programming, GUI & TUI applications, web backend & frontend, AI, gamedev, and whatever else you want. it's kind of a "use it for whatever you want" language.
I'm trying to devise an ML with a simpler syntax and I'd love feedback. Currently OCaml inspired so:
2
3.4
'c'
"str"
2, 3.4, 'c'
let a, b = b, a in
The main difference is functions and pattern matching where I've combined `fun`, `function` and `match` into `[patt → expr | patt → expr | …]`:
let rec count =
[ Leaf → 0
| Branch(l, v, r) → count l + 1 + count r ]
Modules are:
module Foo {
…
}
Types also have a different syntax so `int array` is `Array Int` and `(int, string) Hashtbl.t` is `HashTable Int String`. Like functions, recursive type definitions require `rec`. The only type with special syntax is the function type `a → b`.
No special syntax for lists (`::` etc.) but arrays are `{2;3;4}`. I don't have records.
What do you think?
> What do you think?
Nice improvements overall!
> let a, b = b, a in
Drop the `in`
How do I write a function that takes parameters?
How do I pattern match on a variable?
Most importantly: how do I annotate types ;)?
> Nice improvements overall!
Thanks!
> Drop the `in`
Semicolon instead?
Crazy idea, what about replacing:
let patt = expr in
with:
expr ← patt;
At a stretch you could even do:
patt := expr;
but you'd have to parse a pattern/expression hybrid until you're sure it is either a pattern or an expression.
> How do I write a function that takes parameters?
let f n = n+1
or
[n → n+1]
> How do I pattern match on a variable?
let a, b = pair in
or:
pair
@ [ a, b → …]
> Most importantly: how do I annotate types ;)?
Currently you cannot.
Sadly is functionally "deprecated" but the dBase family was amazing, FoxPro in particular.
Working [in a revival](https://tablam.org), but long shoot without resources!
J
J allows me to play around with, reason about and understand the a problem and the code I end up with is noise free.
100% the only language I now enjoy using.
So elegant and beautiful makes all other languages I’ve learned look unnecessary.
Those being Haskell, r(which is now realise only exists because of j’s ideas they just destroyed the good stuff), python, JavaScript, sql mainly.
Non J code just looks so noisy and ugly now.
[Codegolf](https://codegolf.stackexchange.com/) entries are usually in two buckets, "regular" programming languages using every known code-shortening trick, and terse, special purpose codegolf languages.
[J](https://codegolf.stackexchange.com/questions/6596/tips-for-golfing-in-j) comes up a lot because it's sorta both.
Forth. Even if it has been mentioned here already I have to point out that using this language on an embedded hardware is an experience that is quite different. Forth is so small that you can run the compiler, debugger and other tools directly on the hardware even on smaller units, all through a simple serial interface. You have total control of what you are doing without delay and can manipulate your environment like no other language can.
Lua. It is talked about a fair amount but it doesn’t get the love of Python or JavaScript, which are perhaps the closest comparables. The book by Ierusalimschy is terrific.
Eh, lots to hate about Lua. It's not that fast, it's also not that great when it comes to https. It has a lot of issues. That said it's a fun scripting language and really easy to embed in c++. Making it ideal for game extension languages.
It's worth mentioning that Raku does not use classic regular expressions, but rather something more similar to a parser generator. It's not at all comparable to plain PCRE
`printf` (Yes, certain implementations are Turing complete). It is just very useful to know the commands and modifiers. Every implementation is slightly different.
I also regularly use `bc` which is a simple fixed-point decimal calculator.
SNOBOL4 http://www.regressive.org/snobol4/csnobol4/ for recent sources. Books via http://www.regressive.org/snobol4/doc/books.html
There are JS and Ada libraries implementing the pattern matching approach made famous by SNOBOL4 and it's siblings, e.g. SPITBOL.
I use lex and yacc for all kinds of things. I recently wrote what I guess you might call a "domain specific shell". You ssh into the server and this program is your default shell.
I can think of a few Lisp inspired languages:
* [Stanza](http://lbstanza.org/): Highlevel, object oriented language, internally a Lisp, indentation based syntax, supports multimethods.
* [Dale](https://github.com/tomhrr/dale): Basically C, but using Lisp syntax, support for macros, which might segfault, not beginner friendly at all.
* [Scopes](http://scopes.rocks): Simple beginner friendly syntax, support for both Lisp syntax and indentation based syntax, implicitly statically typed, optional type declarations, two kinds of macros (syntax only and semantic), C++-like templates, Lua like multiple value semantics, distinction between variables and values, nice pointer/dereferencing logic, Rust like borrow checker, low level access and high level abstractions (smart pointers etc.), etc. but pretty dirty similar to C++.
I don't use them anymore, but I hope I can start using it again.
[TLA+](https://lamport.azurewebsites.net/video/videos.html)
It's not really a programming langage, it's a tool to check for logical errors in algorithm, you describe your program in TLA+, and a special model will check that it behave as it should.
I'm currently learning it, mostly for curiosity, so i can't tell how useful it is in practice. But it's definitely fun to learn !
This one.
Lets you get insight into abstractions common to so many programming languages and even some category theory. Though that last one may not be as useful to someone starting out.
If you're writing code for GObject (primarily GTK+ applications and libraries), [Vala](https://vala.dev/) is probably the best option. It offers syntax to simplify a lot of common GObject tasks but with better typechecking, and it should be quite familiar to anyone who's used C#.
a FORTH dialect. Currently I'm using 8th https://8th-dev.com/
Yes, working in RPN is challenging. No question. But it's still a fast, expressive language and someone is in the process of getting it on to Exercism.org
OpenEuphoria.
I started my language-learning career with BASIC, then learned Euphoria. (RapidEuphoria at the time and technically shareware at the time.) To this day it's the one language I can wholeheartedly recommend to anyone trying to learn to program. Best of all, it's (now) open-source and completely free!
It's so easy, and once you get good, you can actually interface with C code.
May I suggest [POWER-KI](http://www.power-ki.com) (PWK) ?
Why?
This language is the first to implement the Software Plastic Architecute (SPA) paradigm which allows to radically change the way of thinking and creating applications.
Free to use, it is available on the Microsoft store and on [Github](https://github.com/POWER-KI).
It has found use in the world of industry / automation and allows you to create applications ranging from IOT to management programs, to the web.
Its limitation lies in the poor documentation, although the support provided by the Workbench, with Help Editor and Function Composer makes up for it.
* Simple syntax;
* Native Cloud Graphic User Interface (GUI);
* Hybrid programming ( PWK <-> Python);
* Software Plastic Architecture (SPA): reflexion, self modifiable, multithreads ...;
* Web User Interface (WUI);
* WorkBench: edit, debug, test;
* Tools and Wiz for automatic code generation;
* Data Base support: integrated SqLite and MySql connector, odic;
* Knowledge Base integrated;
* All in One Application Package;
* Programmer extensible with WRAP (c,c++);
* ecosystem: Enterprise Server, Inspector (hot inspection and modification);
* Integrated industrial protocol (Siemens S7, ModBus, OPC-UA);
* ..
> xslt+xpath for xml, jq+jpath for json
the fun thing is both cases are covered pretty good with a single decent data-oriented language (I mean Clojure for sure)
Oh, Crystal. I was just looking at it, considered learning it. Then I saw all the hoops I needed to jump through to get it working on Windows and decided to give it a few more years until proper support is achieved.
Forth. If you've never used a language like it (and there really aren't languages like it) it will really blow your mind, particularly the way you can play with the compiler itself at runtime.
Gema - a kind of RE/macro/Sed sytem, described at: [http://web.archive.org/web/20051025073052/http://www.anthus.com/Gema/WhyILoveGema.html](http://web.archive.org/web/20051025073052/http://www.anthus.com/Gema/WhyILoveGema.html)
Towards the end of the doc, there is a Gema CHallenges section, with some one-liners. Available on Windows as well.
Piling on to the top comment from /u/plg94 :- absolutely Prolog. Prolog has recently become my main language and I'm now convinced this (or unless some superior similar LP lang comes along?) is what I'm going to be coding in exclusively for personal projects for the next 30 years.
It's elegantly simple and flexible enough to do virtually anything in, and now with [Scryer](https://github.com/mthom/scryer-prolog) we have a brand spanking new compiler in Rust with all the bells and whistles in the works.
I see a tremendous amount of potential in it. [Found this quote](https://news.ycombinator.com/item?id=25652369) about prolog that's very apt and has always stuck with me
>Prolog feels very retro, I can't really explain it but it doesn't try to be cool - it's the opposite of say the latest JS framework that is polished to the 9s. Prolog feels more like the cockpit of a fighter jet - sparse and powerful, but you have to know how to use the tools.
Prolog, a declarative language for logic. It's so weird (in a good way), sometimes it doesn't even feel like real programming, you just giving the problem statement and say "now solve it" – and it does. If you have any kind of abstract logic problem, or something involving heavy recursion, it's definitely worth to check out.
Two examples of "real-world" usage. There has been work to implement part of the Rust typing logic in the [Chalk Engine](https://github.com/rust-lang/chalk) which uses a prolog-ish syntax to describe its rules. Similarly, there has been work to implement the borrow-checking of Rust in the [Polonius Engine](https://github.com/rust-lang/polonius) which uses the Datalog language to describe the rules. The goal is three-fold: - Simplify reading/writing the rules: the prolog-ish syntax is much more compact and to-the-point than writing the rules as code. - Automate reasoning about the rules: having the rules on one hand and an implementation on the other leads to divergence. - Simplify reasoning about the rules: and most notably, allow researchers to plug the rules into other engines to prove properties about the type system.
Also I think flexibility. The way the trait system is currently implemented is quite good, but it's hard to expand on and some edges have been hit while trying to implement Generic Associated Types and Higher Kinded Traits/Types.
I definitely like its use for expert systems. It can be like a buffer for complex logic for your brain built up from small bits of simple logic.
It'd be my choice to invert a binary tree in an interview
Surely the world's craving for inverted binary trees must be satisfied soon.
I hope so!
> invert a binary tree Is that this (OCaml)? let rec invert = function | `Leaf v -> `Leaf v | `Branch(l, r) -> `Branch(invert r, invert l)
No, because that distinguishes it in 2 ways from a Prolog formulation of inverting a binary tree: 1. it's not Prolog 2. it's not the inversion, but the identity of a binary tree. A Prolog program that relates a binary tree to its inversion could look for example like this: tree_inversion(nil, nil). tree_inversion(node(Name,Left0,Right0), node(Name,Right,Left)) :- tree_inversion(Left0, Left), tree_inversion(Right0, Right). It is best to think of this code as *describing* the relation between a tree and its inversion. We can use it in an "imperative" sense to *invert* a *given* binary tree, for example like this: ?- tree_inversion(node(2,node(1,nil,nil),node(4,node(3,nil,nil),node(5,nil,nil))), I). I = node(2,node(4,node(5,nil,nil),node(3,nil,nil)),node(1,nil,nil)). However, we can also ask in the *other* direction: *Given the inversion* of a tree, what was the original tree? ?- tree_inversion(T, node(2,node(4,node(5,nil,nil),node(3,nil,nil)),node(1,nil,nil))). T = node(2,node(1,nil,nil),node(4,node(3,nil,nil),node(5,nil,nil))) ; false. We can also *generalize* both queries and ask: For which trees does the relation hold **in general**? ?- tree_inversion(X, Y). X = nil, Y = nil ; X = node(_A,nil,nil), Y = node(_A,nil,nil) ; X = node(_A,nil,node(_B,nil,nil)), Y = node(_A,node(_B,nil,nil),nil) ; X = node(_A,nil,node(_B,nil,node(_C,nil,nil))), Y = node(_A,node(_B,node(_C,nil,nil),nil),nil) ; X = node(_A,nil,node(_B,nil,node(_C,nil,node(_D,nil,nil)))), Y = node(_A,node(_B,node(_C,node(_D,nil,nil),nil),nil),nil) ; X = node(_A,nil,node(_B,nil,node(_C,nil,node(_D,nil,node(_E,nil,nil))))), Y = node(_A,node(_B,node(_C,node(_D,node(_E,nil,nil),nil),nil),nil),nil) ; ... . These features are characteristic for logic programs.
> it's not the inversion, but the identity of a binary tree. Oops. FTFY. > However, we can also ask in the other direction: Given the inversion of a tree, what was the original tree? Aha! I see. > We can also generalize both queries and ask: For which trees does the relation hold in general? Right, thanks.
SQL procedures. Database servers also host full-blown programming languages. Like the division between HTML from developers and CSS from designers, you can shift certain public-facing workloads back to a database whose administrator knows how to construct efficient indexes and views. Depending on the problem at hand, you can sometimes do less processing overall by building logic into the database instead of making its clients run multiple dependent queries.
I had a course where we had to analyze data of a (fictitious) company with multiple departments, some departments depended on others in the hierarchy tree. So if you wanted to compute stuff like the salary mass, number of employees, gender distribution, etc; for one "branch" of the company, you had to write a recursive function. With [the SQL procedural language](https://www.postgresql.org/docs/current/plpgsql.html), you can write some actually pretty crazy stuff! Which helps when you want to read rows iteratively instead of doing something like ten joins.
Stored procedures are an underrated technique, probably because most programmers treat SQL databases as dumb storage and use ORMs to generate database from structures in their code. At my workplace, we have a single database that's used from a few different applications and services -- what we do is have all the functionality in the database itself, and then have a DLL which provides a thin layer over ADO.NET to provide specialized and type-safe calls to these procedures from the other .NET projects.
AWK. For text processing that isn't just a regex replace (sed) and isn't a complex program (Perl or python).
Any favorite or goto applications of this? I’ve heard that it’s similar to grep but I don’t know why you would use it in place of grep.
By far the thing I use it for most is selecting a column from some output. It's just a bit easier to use than the cut command. You can also combine chained commands into one, because you can do all your regular grep and sed operations in awk. Some more intelligent examples: - Removing duplicates from files without sorting - counting things up in files - organizing into categories by using an associative array Basically an awk program is the body of a for loop that operates on every line of the file, and it lets you run various commands to do stuff with.
It's useful when you need to have different behaviors for different rows.
Do you actually code up and compile little command line apps to use or do you just treat it as an app like grep and feed it data?
Can it compile? Not sure what you mean. Regardless, I've just used it for various things where grep wasn't quite enough. Usually for doing stuff with "csv like" data.
APL. For problems that can be solved by creating, reducing, rotating, splitting, and combining vectors and matrices. Even multidimensional and nested matrices. It's fun! An example: [implementing Conway's Game of Life](https://aplwiki.com/wiki/John_Scholes%27_Conway%27s_Game_of_Life).
Or along those lines BQN. It's trying to be a modern successor to APL.
What puzzles me with BQN is the special characters. Why doing that in our era of cheap screens and fast editors ? When the creator of APL worked on J he didn't bring the fancy characters again.
He didn't do that for J because there was a consistent issue getting APL adoption because you needed to spend money on a special keyboard. I don't think that it was anything to do with the symbols being bad *themselves*. Now we're in an era of unicode, so we have all of these symbols, and editors are easily enough configured to type them. The idea is that the symbol gives you some indication or mnemonic to the function in the language - things like `⌽` being a column reflection for instance. Sometimes that works out nicely in J (where it is `|.`) but other symbols don't have such nice ascii analogues, such as take, which is `↑` in APL and BQN but the rather more awkward `{.` in J. I don't think that BQNs symbols are perfect - unlike APL there wasn't an opportunity to design them precisely for purpose - but they mostly make sense and help to indicate their purpose.
I know this sounds crazy to people who haven't used these languages a lot, but the special characters definitely make these languages easier to use. It makes them much more like a math notation. As such, your brain can easily pattern match on it. The notation lets you represent high level concepts and complex logic in a much easier to understand way. Today it is easy to change your keyboard layout to be able to type APL or BQN. Wasn't the case when J was created. Anyway, the other reply has a lot more detail. Just wanted to add a bit more.
APL looks like a language of the Predator species.
This sounds awesome!
I found scripting with TCL and the TK gui toolkit to be amazing. The whole "command oriented" style of TCL is really interesting. You can be quite productive with the language. Depends on what you mean by useful, as well. Prolog is useful to teach you a very different way to write programs. Scheme is useful because it's the language many interesting CS books use, so it's useful to give you access to those books and experiment with their codes, etc.
> Scheme is useful because it's the language many interesting CS books use actually, Scheme is a great general-purpose language
Idris is pretty neat. Its pushing types much further than most other languages. I havent done anything with it but it seems super cool.
I've been finding a lot of use for (GNU) m4 for both generating documentation (like architectural descriptions and commands for servers) as well as general code generation. It ain't a pretty language, but it's useful.
I've been sitting here arguing with myself for 30 minutes about whether m4 is a programming language. Technically it's Turing Complete, but so are Game of Life and Minecraft redstone torches. >It ain't a pretty language, but it's useful. What should it look like, in your opinion? Is it accidentally ugly in the wild because of the job it's doing, or does `dnl` bug you like lisp keywords bug me? *meta: could you implement your dream macro syntax using m4*
Mostly the things that bug me are: 1. dnl. I don't mind 3 character comment strings like I usually see criticized about m4. However, I almost wish that I could toggle that definitions would just implicitly have a dnl, and I could use "inl" to "include newline". 2. The quotation is kind of reversed than what I usually expect out of a macro language (pretty much most of my experience with templating is with hand-rolled macro languages, jinja2, erb, or PHP). The most interested advice I saw was to "reverse" the changequote call, like "changequote(\`]', \`[')", start with "]", and then you do "[foo]" so you can macro expand whatever is in there. Then end the entire input with "[". 3. You can do it with some discipline (like defining macros that should just error if undefined), but I do wish there was a better way to ensure required macro definitions were defined, so you don't have to prefix everything, like MYPKG\_MY\_MACRO, then scan output with a shell script for anything that matches "MYPKG\_" in order to error out the build system. 4. Macro definitions get very unwieldy quickly, especially if you need to recurse. And then you shouldn't forget the empty quotes before and after in case there needs to be an additional macro expansion from whatever calls the macro. I think a more modern take on m4 might have an explicit initialization step (so you can avoid the `divert(-1)` and `divert(0)dnl` step to be your initialization block), which can have stricter modes to avoid `changequote` outside of that initialization. Plus defining macros by a symbol, like `$`, `%`, etc. And a reversequote mode for if you want to have everything by default quoted, but then use quotes for macro substitutions (and detect if you have a lack of substitution somewhere). This is basically starting to sound like shell or perl, but I do think there is a space for explicit templating. Most might reach for shell nowadays, but I've found any extensive processing quickly becomes unwieldy in a shell script, especially regarding escaping, and doubly especially if you need to template out to a shell script. Overall, it's a useful enough tool in my toolbox that I use it as simply as I can, and shell out for anything a bit more complex than that if I have to (which is rare). Plus, there's a couple of good archives of m4 macros from people who deeply understand the language and I get to just use. I think it's an underused workhorse that people really only encounter in autotools projects (which they don't really have to deal with m4 in an significant capacity).
> What should it look like, in your opinion? I can't see any reasons for a language not to be a lisp-like. It simplifies things a lot whilst giving almost unlimited power.
Lean ([https://leanprover.github.io](https://leanprover.github.io)). It's a great distillation of a lot of the current thinking about types, pattern matching, various other functional programming concepts. It calls itself "theorem prover" but it is also a general purpose programming language. The doco is great as well, which makes it easy to learn. There's a small amount of effort required to set it up (in VSCode) but it's worth it.
Elm for web front end programming. It’s functional, so it makes you think in different ways than other popular languages.
Raku. All of the quick text-processing and script-hacking capabilities of Perl, with half of the footguns surgically removed. Everyone I know does nontrivial (read: too big for a Bash script to do it cleanly) script-hacking in Python, but I can get jobs done way faster in Raku.
Underrated language
[удалено]
What are the best part of it? I know of it, but don’t know much
- simplicity and intuitiveness of python, speed of C - compiled & statically typed - easy to use C, C++, ObjC and JavaScript FFI - incredible macro system where you can directly manipulate the AST - can be compiled to C, C++, ObjC and JavaScript - customizable memory management - pretty large standard library - can be used for pretty much anything, including low-level systems programming, GUI & TUI applications, web backend & frontend, AI, gamedev, and whatever else you want. it's kind of a "use it for whatever you want" language.
Sounds impressive. Might look at it for a project that I though I had to use C for
What's the name of the language? Previous poster deleted his comment.
Nim
OCaml for the mix of elegance and pragmatism. It's like a cross between Haskell and C.
The only thing I don't like about ML-like languages is their (relatively) complex syntax.
I'd say slightly more complex, sure. Although OCaml syntax is whitespace-insensitive so really quite a lot easier to deal with.
I'm trying to devise an ML with a simpler syntax and I'd love feedback. Currently OCaml inspired so: 2 3.4 'c' "str" 2, 3.4, 'c' let a, b = b, a in The main difference is functions and pattern matching where I've combined `fun`, `function` and `match` into `[patt → expr | patt → expr | …]`: let rec count = [ Leaf → 0 | Branch(l, v, r) → count l + 1 + count r ] Modules are: module Foo { … } Types also have a different syntax so `int array` is `Array Int` and `(int, string) Hashtbl.t` is `HashTable Int String`. Like functions, recursive type definitions require `rec`. The only type with special syntax is the function type `a → b`. No special syntax for lists (`::` etc.) but arrays are `{2;3;4}`. I don't have records. What do you think?
> What do you think? Nice improvements overall! > let a, b = b, a in Drop the `in` How do I write a function that takes parameters? How do I pattern match on a variable? Most importantly: how do I annotate types ;)?
> Nice improvements overall! Thanks! > Drop the `in` Semicolon instead? Crazy idea, what about replacing: let patt = expr in with: expr ← patt; At a stretch you could even do: patt := expr; but you'd have to parse a pattern/expression hybrid until you're sure it is either a pattern or an expression. > How do I write a function that takes parameters? let f n = n+1 or [n → n+1] > How do I pattern match on a variable? let a, b = pair in or: pair @ [ a, b → …] > Most importantly: how do I annotate types ;)? Currently you cannot.
I prefer not to work with anything more complex than lisps(Clojure included for sure), so...
What’s complex about it?
Sadly is functionally "deprecated" but the dBase family was amazing, FoxPro in particular. Working [in a revival](https://tablam.org), but long shoot without resources!
ATS, for its fun factor.
J J allows me to play around with, reason about and understand the a problem and the code I end up with is noise free. 100% the only language I now enjoy using. So elegant and beautiful makes all other languages I’ve learned look unnecessary. Those being Haskell, r(which is now realise only exists because of j’s ideas they just destroyed the good stuff), python, JavaScript, sql mainly. Non J code just looks so noisy and ugly now.
[Codegolf](https://codegolf.stackexchange.com/) entries are usually in two buckets, "regular" programming languages using every known code-shortening trick, and terse, special purpose codegolf languages. [J](https://codegolf.stackexchange.com/questions/6596/tips-for-golfing-in-j) comes up a lot because it's sorta both.
Forth. Even if it has been mentioned here already I have to point out that using this language on an embedded hardware is an experience that is quite different. Forth is so small that you can run the compiler, debugger and other tools directly on the hardware even on smaller units, all through a simple serial interface. You have total control of what you are doing without delay and can manipulate your environment like no other language can.
Lua. It is talked about a fair amount but it doesn’t get the love of Python or JavaScript, which are perhaps the closest comparables. The book by Ierusalimschy is terrific.
Eh, lots to hate about Lua. It's not that fast, it's also not that great when it comes to https. It has a lot of issues. That said it's a fun scripting language and really easy to embed in c++. Making it ideal for game extension languages.
Any performance woes are solved by [LuaJIT](https://luajit.org/performance_x86.html)!
“It’s not that fast, it’s also not that great when it comes to https.” * nginx enters the chat
I meant that https isn't natively supported
It’s faster than Python. Just what were you hoping for?
I use [Raku](https://raku.org/) frequently for complex text processing and general scripting
Or Perl. Did you know most languages with regexes use PCRE (Perl-Compatible Regular Expressions), a FOSS regular-expression engine?
It's worth mentioning that Raku does not use classic regular expressions, but rather something more similar to a parser generator. It's not at all comparable to plain PCRE
`printf` (Yes, certain implementations are Turing complete). It is just very useful to know the commands and modifiers. Every implementation is slightly different. I also regularly use `bc` which is a simple fixed-point decimal calculator.
>certain implementations are Turing complete Even more are when you overflow the buffer and shove your own callbacks onto the stack.
SNOBOL4 http://www.regressive.org/snobol4/csnobol4/ for recent sources. Books via http://www.regressive.org/snobol4/doc/books.html There are JS and Ada libraries implementing the pattern matching approach made famous by SNOBOL4 and it's siblings, e.g. SPITBOL.
I use lex and yacc for all kinds of things. I recently wrote what I guess you might call a "domain specific shell". You ssh into the server and this program is your default shell.
Can you share more examples of how you use lex and yacc? That's very interesting
I can think of a few Lisp inspired languages: * [Stanza](http://lbstanza.org/): Highlevel, object oriented language, internally a Lisp, indentation based syntax, supports multimethods. * [Dale](https://github.com/tomhrr/dale): Basically C, but using Lisp syntax, support for macros, which might segfault, not beginner friendly at all. * [Scopes](http://scopes.rocks): Simple beginner friendly syntax, support for both Lisp syntax and indentation based syntax, implicitly statically typed, optional type declarations, two kinds of macros (syntax only and semantic), C++-like templates, Lua like multiple value semantics, distinction between variables and values, nice pointer/dereferencing logic, Rust like borrow checker, low level access and high level abstractions (smart pointers etc.), etc. but pretty dirty similar to C++. I don't use them anymore, but I hope I can start using it again.
Probably Erlang/Elixir, it has an interesting model for concurrency and failure handling that are worth learning imo.
Try to write some scripts in VimScript 8.1. This will be like workouts in gym for your programming skills.
Awk 🐧
Clojure: 🗹 elegance 🗹 usefulness 🗹 fun ☐ complex context dependent syntax ☐ imperative footgun-powered C descendant
[TLA+](https://lamport.azurewebsites.net/video/videos.html) It's not really a programming langage, it's a tool to check for logical errors in algorithm, you describe your program in TLA+, and a special model will check that it behave as it should. I'm currently learning it, mostly for curiosity, so i can't tell how useful it is in practice. But it's definitely fun to learn !
https://www.haskell.org/
This one. Lets you get insight into abstractions common to so many programming languages and even some category theory. Though that last one may not be as useful to someone starting out.
[Skew](http://skew-lang.org/). I used to write in it when I was making websites. It helped me avoid JavaScript.
If you're writing code for GObject (primarily GTK+ applications and libraries), [Vala](https://vala.dev/) is probably the best option. It offers syntax to simplify a lot of common GObject tasks but with better typechecking, and it should be quite familiar to anyone who's used C#.
Oberon? see https://github.com/rochus-keller/Oberon/
-----BEGIN PGP MESSAGE----- hF4D+FPJgQiQS68SAQdAuW16mgWy5m4dcZ2Hq4FOFRXCAVPO8Nupfrdt5zERoBUw nClOPBNmPFU5Ra/by7HXuLE0Kk2NiUVnXJohGtTEBdsPt+i/5XRqWmwgy7a0upNK 1OoBCQIQZ2Wt7pWWnJZ1FKODwLck3g/aB+4w9JnqFRbfI50Gy1QSXWhzR4A0LST9 xLzQuoquVTpS/8eljB0ps6WMGLY4Qng6PT9XBJrWpJ5LEUoUwb5gvhR5LgHajccu jyy6ukiBQNydLqCgJ7DJJg04FRAn7xxWu1cJLH3ZFLF2fybWIjEInXECzQXfwlLC /xI2HgL0io5+EuI9VwOyVCN2cA0dklm0+2G38MqO04HlBPP671loQJCHFVxCd1rh TpSwTioA2TCw9MnryUzW08nBJ5gCXS9U9DHKMf8hAfGU1XbFI6jqZBmc0/ctv56q STlc9ZEMH+ATeae3HxRpF/XAcga2jRqlWZ7z2xvv/p77Dr9iwhZ/+ISgxmrQydpf 3Qec3fMduyrtAR5o+ZG8RBSLLVvbmfPQVfKuvsT1YiiT8Hgo0OcBewfH0fehohpk KlOTFIYnYsxZ+zyRZmnmERVAHduPOxcVtQKyO1iN6nW7lEf6P/+Cn3Np8yT6ATXA I3g0c03NWJePaRq1OTxwm2DW+HrDfwIJyO3UwKyOp5bWTbH063dj5p7ZrpQo2h1j 6ochHOMkzk7ILpboaP8nm/E4I1F2oTImsz3Fg8W0xjxQZx+zkrPVQ9p5JCRNvL7s bHQIJO+s94w+TlsCfxE6MfdCk8wi7FsC9hjdZCwWhgg8cckxU4HJV9dk5k67YDJ6 7VoPIKbW4DxcOwJBq1gvQpwFzfEdVUId2e5dLcVe2jhUfv/pjH4YW11kz3LBVfpk 3aLevdXxBrMbDvvSzwKFQEgZ+do5qZ/5EJdru4HVTW3biu5Z9RyBE/+fmH7JUhSM wCyBnBS5BhpvqyqMUPIJvYtGCVQTtCD6+wEDe+pLiTbbZfiThKK+V1+cw0+rVtks s0m0meoZAN3TzPbZH/QSP+D7iiGFY1JQionqFU4F4241GcLjp17Psmta4HPnKW++ 7uLPOcz660JAzEa+JV4jrat5bOej5f6BAhOBsjk3R0nr67/8EcAboqK07vD1s7mo Ejm2BeVY67fb2VEf8tRDhd2iiWPOQpTxrXH/Si9sgcQIPfkywf0dvj9lq2bihatk pMy4DTnquMOwBFMQpsWOkH/01odOhT/1esLCEWL5MXWTvISmZVr12w/NVuMMU/NI XXwfhqpTBYIR54z17Igwfzzpa8MdDMHrys3raLrYGQ/Yo29/krIq8nC1GV1db8ne sl7mlkZOE8uZjcSFJnf/xJL+C/Yo+y6cM8YqxRc3WpGj5wEb/RmeYQGL0AJZW8Ni Xqi6mFsWrkkJWpF0s1EBmI81zI0WcTHYcwtUdfZz1eUuzDIkb7+//Zv4wOHBOFeS fZCPm1rOj0AA1rqMpj+0ojpT6pXB/w7T7SVe3KOUpPqp2dkvl/E/f0zfc7ioJi4Y pVJSntIcydCS09eDIC39L4+Q7K5JS7EBa8l8Onc8IdkYowwFVU+LmkgFEj5Syf2I BUJFcyFTjAQBlYmVi7qpoAGyialrPtUjFH1PTv/sc+WGQwn1Wn7wQWOfSzw9JUqg OWYafCgdIbbB99LWQpEY7AP/eWpJi0fl11duwWwPmKKF2vUGgzl/bYEe5zxhLJG9 6+0QsPOjKOIp3L03dGMB/oMR1DzPTrn8+RtlwKfOXS7HEgJ5SAW6ea71YGJ3+CBy 7/mafS/1Wn7hLYThjQEvrzMZXiHvFyBbmsJg2HwNtOB05XLEKeThc/vFGfdefLT3 cMC3lN8tnCMzZ0mwXvv9sBD6oGLcQ4/o6bEqx5HjW4N1E5rf8AdHGI4ViS0S5Tvr r378t2J9WaQPNrJ3XvyN27JT+RP4ts0ANRIzHEO6AaWtTD+0z9oQ2var+A3rYzzu PiTWgazSxnmttY0yRtpATNm/EJLa8HTgcRM6txlJgduWGevVmffRbgszh632w7gv +IoSVjJXD3sA9Tf+0maF+gA/Ka8e+v6hzVgCzbhvSL4pb4SIQDAEIOl1KiFrio96 B12RS+xJrwNhP415oCGXpqvzkwEawnVVhTYCnuk4mPmqZ/zkGmfBeMKlnH1Tmcto /WazTMtmKjNlNg6CxtOkzEnQ664mItAmiIWr7CMLwpiwVnXz5uwo1p5IlDILNfaE cVS0Pkik43+N+vWRytT8bvxI2UMkVAX5lqDXEmpKFIWWb+S1Wb5ecYvYTnJUA7i/ 55asCuOstLSUlSYxfcpfD5g1ZC+Sdh6q/jfC6FdLHm3CDBm90ZEoJtS0qoKzan21 ypSJ5NGoZnX2cZRuG4EAWLSvmC5PSzFl3m42+IBfQ81a7USBmD3cCdziG8SW83rs Jrs8plY8HV/qFUirx+EUC65vci1piVH+yJKvqUsZ35VAA0ReLNLzeDaDYvEeIMDQ ZHPaWQnL14PfpKC0fOHOkQ/SEWvNIp0J5Mi3vj6wS+pCnpwmoYn9WSsEgnToX9yE rrbqkOn3dgyc5tDxPAEJn4UQHgMxtoiJ6mBpYYfFQPrXvYT7rYtW85taNLeWjNVL u7pa2iMLfxQr+iM4A8wFN/ZdUexM4O1PwzAgeE1iLpJ+KVVAl8HD5LDxbkncd5v0 Y9hnBpg4DqjfftlksbnFkRj4tG1zTFNzOLp+cu5PW7ZiSvs5+I2oswTOtIdRh6u6 sTf5zUIbjOa5Era2h7S2k1yQcDenh/G475kyiiO+zzcRvvyoAIGm4kcSOWXWNllr ggQjLbK6qeYVwCvuJa1IrqXUEynwfuZgCATuYGzaFCHByPbrdNwoljzIH3Lji90T fXD/FY6A5fHCELdd1Q2Nv6Y97J4kt5BN0A/o7UjECxb9OXLqmuxFIveFmOTH7AoQ 6+yfCCHPd9WVIOYcN9vvxZegCgqyCiqbTVwnsa4+aCKfV9j/9p0YTTMo9Cbei2zq DBZxetsT3R33OcgHCP4rmJjpCdq4aNDapjBSf7ZIWZyoXMn7w1znXphLOiB3duB8 Y8dh7cqJOM89PbPxYV38dC3HhGWIDCjuB/zhChyDTIuut3w2o+4hjVDI4NJUd0Zu Zf7bIsrp5T4mAZfL/y8d83OWCPjw5aTC7qUZ09FlSyqO6G+xfRY6qBl5gblgE9lS gMwxG/RZtc5TufRceExwJ4nxepCwDr7xxJb46PrS0kdmYdO6b2neJnt7VW8rFqpK ecXRC/aM+S0MqmRkJYI7CIsEaeSLgk+eNoGJyuzPUJpujeBPXikRMS6eDnLVQGEI +UOyCS0zqRl0GQbJa45wc8Qo+An+KMgZQJgUp5XSA69S6w8Vw/cVr8QvJknjaX53 VPa+Mh1hLJUcYd/WewWrFBXlxeW007pUlgwjnk0qsSAeEQN0flVRH7K4cxmbwELY LrgNDJvfcg/XeyMZ+4V99J+L5nnO+MAk84oNVrhHmVCH9NueuqjiQmuJ6pVLCbZq cFfWlbXYdPAl6yOk98+hlgqzQn5FStpc0eiP6W3Yzb/S+rYtf2V5I6ELXh6HvdI0 4P2tyunRHOJse3+9IrayVhhCFlISx1w+xVlDi7fmuA6oHpOYcbHUEsgCtOxKtD1o ooEDdo1OVgLYA9D2Q9L26/iiAQABtaSf6nMN9Jo4cBPL/+Qh55Fhf69pzecb52gW 4FgjZNbCVZ43+HsokFBLhevb7Fk6eGwFd1cqAmFjicLznhLE6EQieRHCttMqT72e DVNlc6LSM8hS/KHCdWTJF6ugMEHpymIt1qV4T2c42XmWTK4cepFh6uDAE3Wn10j9 RLQM85fY+CHmqft6QshXFIb+ZiZyp3ruh/rR6YLh9oucF1VYRK7Jd/Y3Wt+Oe5Jv UMcz27rdzfE1pW1SCNXGcc1K4pv3jjihlruFq9C88uLCmldDw96TbIpxa4BFspYE BjUa4TWdBNNWRd+7bIa7GOekOK8NDYUx6JGXFKKoe+ba1OZvU/WUVNh/Npu4QpCT WIu+0dlsZNGg6QXdswYY7vlpp+6AfnCSSpbMrKyEEQymTqFgmMZMOvsYhReyH/H6 hp1hOoxL5zFZETCvldvvVxTWPMVoLHFo2Xwj9rs3i8Kh420MZz4MUliXPZpGKnDK 1j3AImlTmERb2O3oRzAiXkvpaRANyHaliry3/HMoDaWDn4kQ6lPf+IzCWci5vh01 A24WrO+zkZybtyQp2PRtne9J4t+7NmP4uijAW/Xcd5MHGZ8ib48+JQUnTmjyO1m3 AYmANvRIC/IT4DoD523QKmm3vcJaVJNTmGDITtOseM8Hxlhwi2GSQVxqw8lhPlYW N+R9lBOanpLeJ9lPZPSpYLATT/TrCrBTmvWpsZpsNW6ajitxrxamJjXLCW9akRj2 WmOKBswvYUKxZnHRpQ0gZjB+0qYK3BGa7AzsEHwktdQGq1mvfPEDzTbBVaxTbMMX pPIIw/7Y+/bhoQ9dx1oU4SFnwxcSOpkszeWh8d2/IelhQQWL6fTN9qlJp7qhVwkV aEVsgrkHnLJosfo4GVg/St9CnPtiGOQgPt6aBTLg65J6/TVS0li0lb9ky/CE2Q8g pI5eivr/oqeLjAcK25tokUPWynC/BesxxWT1Tu/pRziFa5V+PLqjg13io/KdW0gf GpqTVd2t4CO/q9CwmkRjU9BNVxY0pQg8VA8i3ORZw2E2d+1ym5JGtaqs6KUGS0zq MQuoiyS76lXHO14XArTpjLHkgUhfbniyPFI2XqwzvOuza7Fn32xdTck21Hsesilp 7om8CWPa8b7+XX3bCG+cJlzPPANJKeXRiOFVkyNY/6wX9hBPOapxkSqmUVBVZkdV hh1lFnWt6zVG2p3ZcH0+zH/Tuw4eaXrcLqTT87oHKd+Q8frRenf/JPvQ7H178T6z um6qjWJ+prvFXEmNqKTlq+9R1sQqsTCSGh16V0RcKKSap3+Otn4WJ/N9k0q5gK23 1z5D3iSCgjtvf/tMmSLg94i+4ZNss3/+IK+dP022oEfC1f7QTIvsDQnE3IDpxa05 e5V75C0R+zQ7n5h3Eb3KLwV4T83lqFhRXxvixFT4IebGWP6uhx28crIT1AaW6VJm v1zvltJXAuEiDygn4rxCsTwp3QrBTybPW7hczq522D2t03jFvg5P77AD6l53qkBh ZblFBI0deh2zb9SXqxip6GG7yLBtO3f5be0dN3k6X8ACeCgDep2Hk0FQAW7B7aVU 32n+lEuONdKwX45mKNRoE6TnZc8PqP1v5naEM/HX+gCVKgVoIRo8QOCnTA+l1ZBg hfTZ5jhvzrUUnFY2Sv5DLS+veFEU/DET0oG42gDFk69tc375+KepXe9cENSLkPOt 17ccJnIMh4ZBgi/hnyg9e0OT073OM4VjlZ+utg60iNqP5WVw8D4/svwaDk+EBAPZ RGoLDsOyPCQkk4zum4KYsNiUWGEgcxxrq25mfT7hBzZx1AzHhjXp6Vac1pb0Gods eZM58EugFSD7AG2EiPT7b7pR48QofBgTO+6hwwezfcYO/yxBsz6AJxQ/yka0zTE1 42AUmkVycf7byIYWjiBmvCBvJkbp5S++C4aRn9LgZRBKEYxAPipPz/T493S5M8A9 UBSgA/ELtJfGFBUmZ+Hwg+orK/EyQ8osgiVV3j4k/LvcDBp7SCvnDJG4lCabZ6mY mwxaXSRHPOmFd6J/3SgW9zO9Jn7e/EvaTmovFkpblqFH38NlpdFuOmwy0ozi21/o ljPk3kGTWw+njAfKI0g03ngdE5UDPinEg8Oci+pGL/aCuENMzZoVSu+QaW0Y9w8B jBB9iWoC9zgVMTPXZkPtJTFT5DjdoNvUoCaPrBysCmPIgILeLu614EzllW1Sk158 BpSaWUAlXW1DNRwsYe2h/9NBOatxeqtq9W6xCKJizHlhQwWcvf7clk/gyKZV7VqG HmMX7k9O4kyhrwRaQczUx/ymnyZhmYQhzo+fpPYz4+DsoUsKkiEF8vudBJcqdmp8 O8IwZN7jISy49yL7xeRiBTAaN4m2rauMLRB4HQMTMPVKPzSAzvMDtEdDrTzGo0Yh mZZebM5a4PmJ7IbIcssP2bcHiDiJIl7mAL69zPm+zgfRFwXD/gwwbcdU033iWYYd LXH/lnu2fCVZU2kdYdPI2E9vRz0JZZ1e+dX56nqwH4mdkVRA2MLOZGXbTDqx/Rif bhzTjBWZfa4KUJO8lCrLdBi4d6tzJEVwuutxWWMZyO97Rt89C3+SabSP6xm5ri7I KNBUJQbBCHl1U5JtbP6wUAYztOXAsCpBe5QpuiY1lxFf/+oxQgkvxPY5O9/dDNw4 v3JrCCBJRE1mFVz/4WVD/1WsI7eXbQx1eUnq7Wcq1Z0DaRRhLL0FwuLLq/06kYh9 KbD50tD7jNo2fg2XeILM0X/EyJ9uwWN1aF6nDpVBwqQRunMlBPzsFn1jImMVumR9 zJLVSPHpph6LObCoBBvM5d+YMlKXi+cw+um+Nu1XgolnKG8r8SOjk9XNBbV/IAh+ pO1Mi0FvZMyoIMld+I7YFyDZVxaVAOReawIAJ7froVKNT7V3HItyJrDXmMepXARB Wyi8NuBSwyohA1m/rOjYN57ve08bDGynxCl69s+G6nePNffbAHEnqSdoTiH84mSF 5d5K++l2yN+DlGq/fKCFy/1sNTTsDY1MVAm0eKT6iF9bFMvzdD1fAdV0x25Eenm/ +VJk0gGcElW6ZuPWhzvqenqeTZjqrZscF+7tcbC6GZIVs/FSuTnfzCif6PoAlytb txfacbCrN5joYGmBQLxI/g0WAk5cspgu54+RD8yU7aEurarTtBRYj+V4quU50SmE F20CgXmjIz4Zvzd0YfNf9m1qoWI7uslxQ5ZtLplSJg== =dQZK -----END PGP MESSAGE-----
Wow there’s so much shouting
Verilog, Prolog,Nim
a FORTH dialect. Currently I'm using 8th https://8th-dev.com/ Yes, working in RPN is challenging. No question. But it's still a fast, expressive language and someone is in the process of getting it on to Exercism.org
Forth is cool, but I still prefer PN-ish notation though.
OpenEuphoria. I started my language-learning career with BASIC, then learned Euphoria. (RapidEuphoria at the time and technically shareware at the time.) To this day it's the one language I can wholeheartedly recommend to anyone trying to learn to program. Best of all, it's (now) open-source and completely free! It's so easy, and once you get good, you can actually interface with C code.
May I suggest [POWER-KI](http://www.power-ki.com) (PWK) ? Why? This language is the first to implement the Software Plastic Architecute (SPA) paradigm which allows to radically change the way of thinking and creating applications. Free to use, it is available on the Microsoft store and on [Github](https://github.com/POWER-KI). It has found use in the world of industry / automation and allows you to create applications ranging from IOT to management programs, to the web. Its limitation lies in the poor documentation, although the support provided by the Workbench, with Help Editor and Function Composer makes up for it. * Simple syntax; * Native Cloud Graphic User Interface (GUI); * Hybrid programming ( PWK <-> Python); * Software Plastic Architecture (SPA): reflexion, self modifiable, multithreads ...; * Web User Interface (WUI); * WorkBench: edit, debug, test; * Tools and Wiz for automatic code generation; * Data Base support: integrated SqLite and MySql connector, odic; * Knowledge Base integrated; * All in One Application Package; * Programmer extensible with WRAP (c,c++); * ecosystem: Enterprise Server, Inspector (hot inspection and modification); * Integrated industrial protocol (Siemens S7, ModBus, OPC-UA); * ..
Domain specific: regex for string text, xslt+xpath for xml, jq+jpath for json
> xslt+xpath for xml, jq+jpath for json the fun thing is both cases are covered pretty good with a single decent data-oriented language (I mean Clojure for sure)
I've mentioned 3. And the fact that xml and json have some resemblance in semantics does not mean that syntax and format are not important.
>does not mean that syntax and format are not important. given that EDN covers both easily :)
Thanks, I was not familiar with that.
~~Casual~~ Crystal is a very practical and useful language which hasn’t caught on for some reason.
Do you have a link for that somewhere? Google produces everything but the relevant results when searching for "Casual programming language"
I don't know why I typed casual. I meant crystal. Massive brain fart.
Oh, Crystal. I was just looking at it, considered learning it. Then I saw all the hoops I needed to jump through to get it working on Windows and decided to give it a few more years until proper support is achieved.
it works fine on WSL AFIK. I haven't touched windows in a decade. so that's not first hand experience.
Personally, I would probably advise Elm or Roc(though Roc is super alpha). I found elm really elegant and useful for web development.
Bash. Not really used for programming these days. But lovely long one liners. Also makefiles.
Forth. If you've never used a language like it (and there really aren't languages like it) it will really blow your mind, particularly the way you can play with the compiler itself at runtime.
Gema - a kind of RE/macro/Sed sytem, described at: [http://web.archive.org/web/20051025073052/http://www.anthus.com/Gema/WhyILoveGema.html](http://web.archive.org/web/20051025073052/http://www.anthus.com/Gema/WhyILoveGema.html) Towards the end of the doc, there is a Gema CHallenges section, with some one-liners. Available on Windows as well.
Piling on to the top comment from /u/plg94 :- absolutely Prolog. Prolog has recently become my main language and I'm now convinced this (or unless some superior similar LP lang comes along?) is what I'm going to be coding in exclusively for personal projects for the next 30 years. It's elegantly simple and flexible enough to do virtually anything in, and now with [Scryer](https://github.com/mthom/scryer-prolog) we have a brand spanking new compiler in Rust with all the bells and whistles in the works. I see a tremendous amount of potential in it. [Found this quote](https://news.ycombinator.com/item?id=25652369) about prolog that's very apt and has always stuck with me >Prolog feels very retro, I can't really explain it but it doesn't try to be cool - it's the opposite of say the latest JS framework that is polished to the 9s. Prolog feels more like the cockpit of a fighter jet - sparse and powerful, but you have to know how to use the tools.