text:
Tips for Creating/Maintaining a Golfing Language
Creating a golfing language can be hard. Let's help budding golfing language creators out and provide some helpful tips on how to create one.
I'm looking for tips on:

The design process
Implementation
Community engagement

One tip per answer would be appreciated, and tips like "don't create a new language, use an existing one" probably aren't very helpful.
You don't need to have created a golfing language to answer this question. Feel free to answer from personal experiences or from general observations.
See also Tips for launching a language for when you are done creating your language.

The community engagement process is a dupe of this.

@a'_', the launching part is, but I also am interested in seeing how to keep a language going after being launched

@a'_' Oh wow, that first answer of DJMcMayhem♦ is almost exactly what I wrote in my CW answer below regarding point 3, except much more elaborated. Never seen that meta-answer before, so it's funny how similar it is. :D

Here are some suggestions. Sorry that this partially overlaps with other answers, which have been posted as I was writing this.
Design process

One possibility (by all means not the only one) to decide which features (functions, data types, etc.) your language L should have is to base it on another language B that you have been using for long. That way you already have a good idea which functions of B are used most often, and therefore should be included in your language L, and you can assign shorter names in L to functions that are commonly used in B.

Examples:

L = MATL: B = MATLAB/Octave.
L = Pyth: B = Python.
L = Japt: B = JavaScript.
L = Brachylog: B = Prolog.
L = Husk: B = Haskell.
L = ShortC: B = C.
L = V: B = Vim.

Decide which "paradigm" your language will use. Some examples are

Stack-based (Cjam, MATL, 05AB1E);
Tacit (Jelly);
Prefix notation (Pyth);
Infix notation (Pip, Japt);
Fixed arity (Pyth);
Variable arity (CJam, MATL, Japt).

These decisions are quite independent from item 1. For example, MATL's function f has the same functionality as MATLAB's find, but is used differently in that it pops its inputs from the stack and pushes its outputs onto it, whereas MATLAB uses normal function arguments which can be stored in variables.

Incorporate functions from other golfing languages that you find useful. Don't let item 1 (if applicable) limit language L's definition.

Be prepared to add functions in the future. As you (or others) use the language, you will find things it would be nice to add. So reserve some of the "namespace" for future expansion. For example, don't use up all your single-character names at once.

Implementation

Write the compiler (or interpreter) for your language L in a language C that you know well (often C = B).
The compiler is most often actually a transpiler into another language T (which can be the same as B or C). Language T should have a free implementation. That way it is viable to have an online compiler for your language. The compiler will be a program in C that takes source code in L to produce transpiled code in T, and then calls T's compiler/interpreter to run the transpiled code.

A natural choice is C = T. Examples:

L = Japt: B = C = T = JavaScript.
L = Jelly: C = T = Python (and Jelly is inspired by J; but perhaps not so much as to claim that B = J).
L = MATL: B = C = T = MATLAB/Octave.

Community engagement

Host your compiler/interpreter in a public repository such as GitHub, so people can easily download it, create bug reports, suggest new features or even contribute with code.
Write good documentation. That helps users understand your language better. Besides, I found that task more rewarding than I expected. I recommend writing the specification while you are designing the language, not at the end. That way consistency between language behaviour and its specification is ensured.
Ideally the documentation should include some quick reference (table or summary), so experienced users don't have to go to the full documentation simply because they have forgotten the name or the syntax of a function they know.
Create an esolangs page with basic information about your language.
Create a chat room where people can ask and discuss about the language. Visit it often.
Answer questions in your language, with explanations about how the code works. You'll want to do that anyway (it's your language, you will find it fun to use), but this also helps get people curious about your language, and shows some of the language's properties, which might get people interested.
If you chose to base your language L on a language B (see item 1) that is general-purpose and well known, users of B will find it easy to switch to L, which will allow them to provide short answers (in L) with minimal effort (coming from B).

@Λ̸̸ I think you can use that notation, yes. But an interpreter is required for it to be considered a language in CCGC

This has by far the most useful information, so I've marked it as accepted.

I like how everything is written in C ;) (even if C represents a different language)

@Wezl Write in C, write in C...

I don't think you should just steal a builtin from another golfing language directly. You should consider the existing structure of builtins in your language, and, if applicable, do it in operations that are more general that already exist in your language.

Here's a couple of random hints.
Choose your built-in commands and values carefully
Especially when your language is new, it's tempting to add lots of functionality that you think may be useful at some point.
If that turns out to be false, you'll have a mostly useless command taking up a valuable spot in your language's namespace.
Rebinding the symbol breaks backward compatibility and may invalidate existing answers on this site.
That's not the end of the world since we're talking about weird recreational languages, but if it happens frequently, your users will have a hard time keeping up with the changes.
As a hypothetical example, testing whether a given number is prime is probably a good choice for a one-symbol function, since primes come up a lot in golf challenges.
Testing whether it's a square or a power of 2 can be useful, but not as often.
Testing whether it's a perfect number most likely doesn't warrant a one-symbol command.
You'll get a sense of what generally useful things the language is missing by using it.
Minimize the number of incorrect programs
By an incorrect program I mean one that produces any kind of error: syntax error, type mismatch, division by zero etc.
Every error is an opportunity for your language to do something useful instead.
Syntax error due to a missing parenthesis?
Allow it to be implicit in some way (like at the beginning or end of line).
Division by zero throws an error?
Consider having it return infinity or NaN instead, or allow errors to be caught and used for flow control.
A type mismatch is usually a sign of a function that's not generic enough.
Ideally, every function should accept every type of input and do something useful with it, unless there's a good reason not to.
There are several common tactics for this:

Overloading. For example, + can be addition on numbers and concatenation on lists. This seems to be the most popular option.
Vectorization. If + is given lists, it can perform addition element-wise. Jelly uses vectorization extensively.
Coercion. If + is given non-numbers, it can convert them into numbers implicitly. For example, 05ab1e allows numbers and strings to be used mostly interchangeably.
Keep the error if you have a good use for it. In Brachylog, arithmetic operations only work on numeric types. Since it's a logic programming language based on Prolog, they can be used backwards or to generate input-output pairs, and in those cases it's essential that the input can't suddenly be a list or string.

I never created a language myself, but I can partially answer number 3 (I will make this a community wiki, so feel free to add more).
Some tips after the core part of your language is done:

Have a GitHub/GitLab project where you can link to, including a wiki-page/README of your language in general (what it's made for, how to compile and run it locally, etc.), and a short description of each of its builtins.
Ask @Dennis in talk.tryitonline.net chat to add your language to the online compiler TIO.
Add your language to the Showcase of Languages to expose it to the community.
Possibly create a chat room so people have a place to report bugs, discuss improvements, or talk about golfing strategies in your language.
Create a tips page for your language, and perhaps post a few tips as answers to get it started.
Start answering challenges here on CGCC in your language, so people seeing it for the first time might become interested. Answering well-known challenges like Hello World, "Never Gonna Give You Up"; Default Quine; Prime checker; Fizz-Buzz sequence; Odd or Even; etc. are all great challenge to introduce your new language, and let people who see it get a general feel for what's possible in your language.
Apart from those and some other popular challenges, just answering any new challenge is also a great way to expose your language, since people tend to look at new challenges more often than existing ones.

You didn't have to make this CW. I realised that I should have added a part saying You don't necessarily have to have created a golfing language to answer this question.

@Lyxal I made it a CW so everyone can edit it freely and add more points for no. 3. I don't think each of these tips above would need a separated tip, nor any similar ones I might have forgotten. I do am very curious about the no. 1 and 2 of your question though. Some things that come to mind are: what is the underlying compiler/language used to compile/run your language in, and why did you choose that one? What did you do to ensure a good performance? Etc. I'm curious what kind of answers we will get. I'll probably tag some people in chat who I know created a language (after a while). :)

I'm thinking of trying to ask Mego and DjMcMayhem fot tips on discord

Sounds like a good idea. I thought about tagging Adnan, although he isn't very active anymore unfortunately. He started with 05AB1E once (written in Python); then derived 2sable for more flexible implicit input; he later on added this implicit input to 05AB1E as well, making 2sable rather obsolete; and mid-2018 he 'released' a completely rewritten 05AB1E, with new and changed builtins and infinite lists support (written in Elixir) (last two are available on TIO). So lots of experience and history to contribute here.

It strikes me that the most important design decision is what the underlying paradigm of the golfing language is.
Here are some possible types of language:

Stack based
Array based
Object based
Functional
Imperative
Declarative

Indeed you might even have a mixture of these, or something else entirely like a two dimensional language, automata, regex, machine language or a Turing machine and so on.
This is important because it will greatly affect the syntax of the language and in some ways how concisely code can be written.

Edit: Follow Up
I thought that I would show how the design and implementation phases of creating a language actually work in practice. I realise that's it's more than one tip in this answer and it's lengthy I hope that's ok.
Design Considerations
I wanted the following things out of my new language:

Quick to implement (or prototype)
Flexible and concise syntax, perhaps with a view to Golfing
Can do useful things, not just a toy language

I plumped for some version of Forth, because it would satisfy the first two critera. It would also have to be interpreted at least for prototyping, compiling is out because it would take too much development time.
In terms of it doing useful things, it absolutely had to have the following traits:

Ability to call functions
Arithmetic and logic operations
Manipulation of numbers and strings
Loops and conditional structures
Stack manipulation

And because it's Forth I thought the following would be kind of cool:

Multiple data stacks
Ability to 'pass in' function literals to be executed inside functions (kind of functional style)

Implementation Details
Firstly, I would leverage my knowledge and use a language I know well for the interpreter: PHP - at least for the prototyping stage.
Next I needed the interpreter to be able to recognise (tokenise) these four things:

String Literals: 'hello world'
Numeric Literals: 3.1415
Labels (for function names) drop
symbols (representing atomic actions): #@$^

The simplest solution for tokensing the program is to use regex. Also because I wanted concise syntax labels would be strictly alphabetic. I would also need some sort of separator to remove ambuiguity in tokenising, I left a space and comma free for that.
So with all that in mind I could create a fat-free Forth syntax. For example:
1.5,2.7,3,4add add add;

would push four numbers on to the stack, and call a function add three times and then return ;.
Once tokenised the interpreter can then consume tokens one by one and act accordingly.
One consequence of using regex, is that it's unable to handle a nested syntax. So I would need to manage nested loops in some way. The way to do this is to look for the start of loops (token) and find the corresponding end and record somehow in the start token where the end is and vice-versa. That way the interpreter could jump around loops and conditionals very easily. A stack would be needed to know which token closes which opening token.
Functions I would just manage as simply labels, or named positions in the token stream. When a function is executed, the position is looked up and interpretation continues from there. I would return from the function using a ; token. This would also require a function call stack to handle nested function calls - and return back to the calling position in the token stream.
For the fancy stuff, such as passing in function literals, the idea would be to push a string literal containing the code fragment on to the data stack e.g:
'2+;'apply;apply:`;

So to break the above down, '2+;' is a string literal containing the code fragment (push 2 and add to top item on data stack). A function called apply is then called. The function definition begins apply: and a backtick actually pops the string literal and executes it in its own brand new context. Once the fragment has been executed and returns, the function then continues.
The interpreter would handle this by separating out the parsing and tokenisation from the actual execution. That way the literal code fragment can be parsed when pulled off the stack, and that new context passed into the Executing function, using PHP's scoping to handle the new context's scope. The only fly in the ointment is that to be able to call a function from the code fragment, it would need to be able to access the parent's context. For example:
'dotproduct;'walkarray;walkarray:...`...;dotproduct:...;

Next for multiple data stacks that would be easy. I would have just one main data stack where all the action happens and provide atomic actions that can push and pull to other named data stacks. That should greatly simplify operations with vectors or arrays of numbers.
I also wanted conditional loops with the condition either at the beginning or end or just infinite loops. So I chose [...] for an if condition, [...) and (...] for conditional loops and (...) for infinite loop.
Lastly, some features that are missing: general mathematical functions, extensive string handling, goto and breaking out of loops and conditions. Although it is possible to break out by returning in a function by using func:(...[;]...).
Anyway, here's the semi-golfed prototype, and hopefully semi readable, enjoy!
Try it online!

If you want a beginner-friendly golfing language, the stack-based paradigm will suit you most. (Stack-based languages are famously easy to write in.) Also it's the most common paradigm of golfing languages and the easiest paradigm to implement.

Stack based is good because you don't have to have extra syntax to override precedence rules. But stack based require a fair amount of pure stack manipulation and this would add overhead.

Stack-based is also the least original paradigm for golfing, and will therefore probably lead to less adoption by other people, unless it is truely groundbreaking compared to the plethora of other stack-based languages.

@Fatalize Well, there aren't as many good stack-based golfing languages as you think. Most of them were terribly designed (e.g. Neim, Ohm, etc.) I think only 05AB1E and Vyxal stood the test of time. So, if you design your golflang carefully, it would be significantly better than a ton of stack based golflangs already.

Remember to add implicit input/output
In my opinion, a golfing language (whether successful or not) should always have some kind of implicit input/output. This applies to Jelly, 05AB1E, and pretty much every competitive golfing language.
I'll take CJam as an example. CJam doesn't have an all-purpose implicit input; it has input-reading instructions like l and q, and then if the input isn't just a string, it's followed by a ~. That's how Pyth gained the upper hand than CJam.
If you are trying to make a competitive golfing language, try to avoid making your input type-dependent, otherwise you'll be needing type conversion every time you take input (which is pretty wasteful).
Types of implicit input
For my purpose I could only think of two types of implicit input: Taking the whole input as an argument (e.g. GolfScript & Pyth), and cycling the implicit inputs for the operators of the program (e.g. 05AB1E and Jelly). The former is a basic form of implicit input, but still allows you to win some challenges. For the latter, you need to think carefully about how this system works, otherwise it would not help programmers.
Implicit output
Implicit output is another very important design feature of a golfing language. For example, Element isn't very well-designed, as you need a backtick (output the whole stack) every time at the end of the program.
Currently there are only two types of implicit output: full implicit output (the thing that Jelly & GolfScript/CJam uses) and top implicit output (the one that
 Pyth and 05AB1E uses). Both of them are perfectly competive, however under my very unscientific testing, top implicit output languages seem to require extra joins at the end.

I never used Jelly/GolfScript/CJam, but when I compare 05AB1E's implicit top output and MathGolf's implicit full joined output, I personally prefer top output tbh. Many times I have to clean up the stack if I only want to output a single item or single list in MathGolf. Here an example answer. Although I certainly see your point, and in some cases it's indeed useful. Maybe I'm just too used to output top after starting with MathGolf, but I personally prefer just implicit top in most cases. – Kevin Cruijssen

That's how Pyth got shorter than CJam You may be over-simplifying a bit. Pyth programs can be shorter or longer than CJam programs for many different reasons

I never used Jelly/GolfScript/CJam, but when I compare 05AB1E's implicit top output and MathGolf's implicit full joined output, I personally prefer top output tbh. Many times I have to clean up the stack if I only want to output a single item or single list in MathGolf. Here an example answer. Although I certainly see your point, and in some cases it's indeed useful. Maybe I'm just too used to output top after starting with MathGolf, but I personally prefer just implicit top in most cases.

Be a polyglot programmer
If you know 1 language, you can steal the good stuff from 1 language.
If you know 2 languages, you can steal the good stuff from 2 languages.
Likewise, if you know many languages, you can steal the good stuff from many languages.
Therefore, while you are designing a golfing language, it's beneficial to learn a lot of programming languages (which will help you create a good golfing language).

Useful integer constants
Of course your golfing language has syntax that can represent any integer constant, but some integers are more useful than others. You want the useful ones to be available as a single byte. A couple of obstacles to this goal:

With a traditional decimal format, only the numbers 0 through 9 can be represented in one byte. Some non-single-digit numbers, particularly 10 and -1, are very useful.
If you have to put multiple integer literals next to each other in your code, you'll probably need an extra byte for a separator (which doesn't carry any meaning and is therefore a Bad Thing™). I think this problem occurs more often in prefix languages (like Pyth and Charcoal), but I imagine stack-based languages would suffer from it too. In Pip, it crops up when defining a list of numbers.

There are a few strategies to address these issues. Jelly, for example, represents -1 as - and interprets leading 0s as separate numbers. You could even write your integer literals in duodecimal with a signed digit system, which would make -1 and 10 into single-digit numbers. But the most straightforward approach is to have dedicated one-byte builtins for the most useful integer constants. Even some of the single-digit integers can use such aliases, due to the second point above.
Some data
I did a survey of 150 of my Pip golf submissions to see which integer literals or builtins were used most often. Here are the numbers that appeared at least twice:
0    |||||||||||||||||||||||||||||||||||||||||||||||  47
1    |||||||||||||||||||||||||||||||||  33
2    ||||||||||||||||||||||||||||  28
10   ||||||||||||||  14
-1   ||||||||||||  12
3    ||||||||||||  12
8    |||||||  7
9    |||||||  7
4    |||||  5
5    |||||  5
6    ||||  4
26   ||||  4
100  ||||  4
7    |||  3
32   |||  3
64   |||  3
1000 |||  3
16   ||  2
50   ||  2
127  ||  2

This list fits pretty closely with what I would expect (though I didn't think 3 would be so common). It's possible the figures will skew a bit differently depending on the language (for example, 2 will be more common if you need it for operations like "convert to base 2," "modulo 2," etc., and less important if you have builtins for those operations); but I think the overall ranking will stay pretty consistent. So:
Suggestions

These numbers should be representable by some one-byte syntax: -1, 10
Consider adding one-byte aliases for these numbers if numeric literals are likely to occur next to each other: 0, 1, 2, and maybe 3, 8, 9
Consider adding shorter aliases for these numbers if you have codepage space to spare: 26, 100, 1000, and maybe 16, 32, 64, 127

Again, there are a few ways of doing aliases. You can simply have a constant that always evaluates to that number. Pip has variables preinitialized to useful values, which can be updated through the program; for example, i starts at 0, which makes ++i useful for counting things. Jelly has atoms that evaluate to the third, fourth, fifth (etc.) command-line arguments, but if that many arguments aren't provided, they evaluate to useful constants instead.
What about other types?
I've only run the numbers on integers, but here are some gut feelings about strings and lists that deserve golfy syntax:

Should have single-byte builtins: empty string, empty list, space, and probably newline
Should have one- or two-byte syntax: uppercase alphabet, lowercase alphabet, common regex patterns if your language has regex, and maybe some common lists like [0], [1], [0, 1], [1, 0], and [-1, 1]

I've generated a much larger list based on all JS submissions on the site: gist.github.com/Radvylf/1bebd9050ee2d530007bf67d2f325843 (note that it includes negative and floating point numbers)

This relates to the implementation phase
Decide Upon How the Language Will Be Executed
The two most common options to implement your language are a) interpretation and b) transpilation.
Interpretation is where your language is executed step by step. In other words, you write all the processesing logic behind the language.
Transpilation is when you turn your language into another language. This is like translating it into another language.
Transpilation is much easier to implement than interpretation, but interpretation allows for more flexibility.

Can you give an example of interpretation allowing more flexibility?

In what world is compilation easier to implement? It's almost universally more difficult

Ok it makes a bit more sense after the edit but I'd still say interpreting is generally easier, especially for stack based languages as most golfing langs are.

Be patient while implementing your golfing language

This tip might be too obvious for some people, but I see the necessity for posting this tip, since I am surprised to see many golfing language implementors abandon their golfing language long before the language is complete.

If you want to make a good golfing language, you should be patient while you are implementing it.
It usually takes 3-4 years in order to make a good golfing language, adding 500 or so built-ins with lots of trial-and-error. During this period, you must be persistent and resilient, and continue implementing the language anyway. Nothing great happens overnight. You always need a bit of patience while you are implementing your golfing language.
Trust me, anyone can make a good golfing language - it just takes a lot of patience to do so. Besides, other CGCC users will always be excited in learning your golfing language, so don't be discouraged if you feel your language isn't that good yet! It's going to get better as you implement it, so continue implementing your language nonetheless. :P Besides, it's perfectly fine if the language doesn't turn out to be that good, at least you had a good time implementing the language.
Furthermore, after you complete this 3-4 year period, you may still continue maintaining/developing your golfing language, depending on how good you want to make your golfing language.

Not just patience is required. You still need to be a good programmer if you are to make a good golfing language. That way, you will find it easier to factor down the task into a small set of highly-generalized buitins.

Making your language high-level (e.g. starting from Mathematical notation) is probably a good starting point.
Have you heard of APL (which is based on Matrices and its operations)? It's an early target for code golfers to golf in, and it's quite concise.
Mathematics is a formalized system to express stuff in a high-level way. So if you want your language to be easy to use (attracting code golfers) and concise, you should probably find an existing mathematical notation to start with. Also, it will (probably) help users to be engaged with your language (since it's high-level, easy to learn and easy to use).
Examples of golfing languages
For example, Husk is a langauge which incorporates a lot of Haskell elements, like lazy evaluation and function composition; Haskell is a kind of mathematical notation by itself that has evolved from lambda calculus. Husk is very concise and catches up/beats the concise golfing languages, using just a set of 256 instructions.
(Jelly is a language based off APL, and it's quite competitive; I guess it's fairly obvious here.)
Would making the language high-level always attract users?
A counter example of being high level attracting more users is probably Prolog. I don't know exactly why people don't use Prolog, but it might be because people are too used to the mainstream languages and refure to switch. And Prolog is quite concise, due to its functional nature.
The implementation process
Being high level usually means that you have to spend a lot more of your time implementing it, since the higher-level a language becomes, the higher the abstraction level goes. And that usually means a lot of code need to be written for the abstraction.
If you are lazy and don't feel like writing a lot of code just for making your golfing language, you don't have to. Just implement a lower-level language.
How do I design the language though?
You have a plethora of methods of parsing instructions. But the usual method is to parse it as infix/tacit, since Traditional Mathematical Notation is infix.

Make the syntax of your constants short
For strings, you can have implicit quotes or compressed strings. Or even, you can make 2-character compressed strings or directly index into your golfing language's built-in list of common English words.
Or built-ins for common strings (including the empty sting) may be feasible.
For integer arrays, you can create a packed array form (btw Stax has a form like this). For string arrays, you can introduce a special form (Like in Jelly) that introduces compressed strings next to each other.
For numbers, you can do something like 05AB1E's Ƶ, which provides a shorthand on a lot of small integers. Or like in @DLosc's tip, you can add built-ins for common numbers.
The above are merely suggestions.
Some Recommendations

Make sure that the syntactical shortening is appropriate for your language.

For example, the implicit trailing quote is somewhat useful in Jelly. However, in 05AB1E, it is only useful when you print a constant string at the end of execution. SOGL is an improvement of this. Since there are implicit preceding quotes, you can do a lot more things with one less byte.

Another thing about blocks. Most modern stack-based golfing languages already merge them with the higher-order commands that take a block or two as arguments, so this can also be seen as an example of shortening the syntax of your constants.

By the way, you can merge it before the block (like 05AB1E) or after the block (like Stax) and use implicit braces at the start or the end of the program. Which form do you think will be useful in more tasks? ;p
However, you can also attempt to shorten the block syntax. For example, MathGolf has shortened blocks from 1 all the way to 8. And you can also try to implicitly group your blocks (like in Husk; during the parsing process, functions are implicitly grouped into functions with correct types.)

Welcome to Code Golf, and nice tip!

Use the corpus
Credits go to @Lynn for creating this method.
Basically, if you have enough answers in your golfing language on SE, you can use a corpus to analyze your language and optimize its golfiness. Use a SEDE query, and analyze it with a script.
A couple things to note:

1-grams reflect the general usefulness of the 1-byte commands in your language. The higher the frequency, the more useful it is. Basically, if a 1-byte builtin is rarely used, or never used here, then it's better to add it as a 2-byte builtin. A maximum frequency of 15 is a good metric for a 2-byte builtin.

If you leave enough room for your 1-byte builtins, then there would be more room to add more useful builtins in the future.

2-grams are basically golfing opportunities, stuff that you can make into 1 byte. Again, if these occur frequently enough, like more than 15 occurences, for example, it would be nice to add as a 1-gram.
3-grams and 4-grams reflect the parts where most people are wasting bytes on. So if a pattern occurs frequently enough, it would be great as a 2-byte builtin.

Tips on using the corpus

Investigate thoroughly. Understand the exact reason why an occurence is so frequent, when you are in doubt. Read the SE answers involving this occurence.
Consider using the 1-grams list as an insight to the 2-gram occurences.
The number 15 used here is just as an example. The actual number should be determined by yourself, since some languages are not used as often as other languages on SE.
The commands added should make sense to you, i.e. it doesn't look like a random combination that you won't use unless in specific circumstances.

Tips for overloading

Try not to use up every overloading space you have right away (Unless you're really good at overloading). You should be prepared for adding new overloads to your language.
Don't overload if vectorization makes sense. Vectoriation is a really common operation. For example, vectorization is the most common 1-byter in both Jelly and Vyxal, and these two are very different languages. This should show how prominent vectorization is in golfing languages.

For example, + should definitely be vectorized, because it makes sense to do so. If you overload it, you end up wasting bytes in codegolf due to an unnecessary use of a vectorization prefix.

Sometimes, it can be hard to track down your overloads, especially if you have a lot of them. So, it can be helpful to make a table of all of your overloads, to see which instructions could be overloaded, which operations are duplicated, etc.

Another trick when you're designing the language. You can first list every instruction you want to overload (without actually introducing overloads). Then, try to merge all the commands you have into fewer operations (in a way that makes sense to you).

When you don't know what things to overload in your language, generating a 1-gram corpus of a popular golfing language will lead you to some interesting ideas.

Well, I don't think vectorization is that useful except for addition, multiplication, or subtraction. Vectorizing stuff like equality comparison, for example, might warrant a separate builtin for 'exactly equal'. Besides, zipping two lists is not as common as transposing a list, so you may find vectorizing less commonly used builtins cumbersome anyway.

However, vectorization has another definition, which is generating a list of base 10 digits or a 1-range for numbers (like in Jelly). In this case, vectorization would be quite useful, since 1-range and digits are very useful operations.

Length of the builtins: 1 byte vs. 2 bytes
Here, I will attempt to provide some concrete suggestions for @Zgarb's answer upon deciding whether a builtin should be made as 1 byte or 2 bytes.
Maintaining a fairly large 1-byte space is very  important. If you run out of 1-byte opcode spaces, you might find it difficult to add new golfy syntax forms, and 1-byte builtins for frequent 2-byters to your language.
Here are my obsevations on this topic:

If it is a fundemental built-in that is commonly associated with a basic datatype in your language, a 1-byte builtin would be helpful.

For example, a built-in that maps an input list by a block should definitely be a 1-byte builtin.
Similarly, common mathematical operations, like modulus and addition, should be 1-byte as well.
Same thing with list concatenation.

If you find yourself unable to solve some challenges without this builtin, or you think it is cumbersome without it, consider adding it as a 2-byte builtin. Or a 1 byte builtin if you use it frequently enough.
If this is something you would not normally do given the datatypes to your builtin, it should defintely make it a 2-byte builtin. You can always make it a 1-byte builtin, if it is used frequently enough.

For example, converting the input from a unix timestamp to a formatted string probably deserves a 2-byte builtin.

Ideas

If some substring comes up often in a lot of answers, consider first making it a 2-byte builtin.

If it is already 2 bytes, make it 1 byte. The divmod builtin in Jelly is a good example. It combines a pretty common occurence of taking the quotient and the remainder into a single builtin.

If your language uses an ASCII codepage, then you need to be even more careful on builtins. Consider heavy overloading on one-byte builtins, to pack the largest number of fundemental bultins.
A fairly effective method, as mentioned by @mousetail below, is analyzing the frequencies of the builtins of an existing golfing language, and then decide upon the length of the builtin based on its frequency. This would ensure that your built-ins are optimally packed based on the frequencies.

The length of every built in needs to be equal to log8(frequency) if you use full bytes. This can be proved to be optimally efficient. This means sometimes even longer built ins may be worthwhile.

Code it using another programming language you already know very well
You can then create a script in that language to run the programme made using the golfing language you invented.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
WTF.js Obfuscator
Background
One of the commonly meme'd aspects of javascript is its incredibly loose type coercion that allows for +!![]+[+[]] == '10' this technique can also be used to create letters as seen in the following example:
[[][[]]+[]][+[]][-~[]] == 'n'
[undefined+[]][+[]][-~[]] // [][[]] -> undefined
['undefined'][+[]][-~[]]  // undefined+[] -> 'undefined'
['undefined'][0][-~[]]    // +[] -> 0
'undefined'[-~[]]         // ['undefined'][0] -> 'undefined'
'undefined'[1]            // -~[] -> -(-1) -> 1
'n'

Some examples of js coercions:
[][[]] = undefined        // out of bounds array access returns undefined
+[][[]] = NaN             // the unary + operator coerces to numbers +undefined is NaN
+[] = 0                   // empty arrays coerce to the number 0
~[]/[] = -Infinity        // ~ coerces any value to a number then does bitwise negation and / coerces the second value to a number
[]+{} = '[Object object]' // plus coerces both values into strings if it can't do numeric addition
![] = false               // ! coerces empty arrays to false
!![] = true               // negation of previous coercion
+!![] = 1                 // number coercion of true
-~[] = 1                  // ~ coerces [] to 0 and the bitwise negation of 0 is -1, -(-1)=1
true+[] = 'true'          // adding an empty array to a primitive coerces it to a string
'true'[+[]] = 't'         // strings are treated as arrays by js
'true'[-~[]] = 'r'

Here's a reference table of js coercions using different operators
Note: blue shaded cells in the table are strings while yellow cells are literals.
Task
Given a string with only the letters abcdefijlnorstuy , convert it to valid javascript containing only the characters []+-~/{}! that evaluates to the original string. Note that this is not JSFuck but is instead focused purely on a subset of strings that can be (relatively) concisely translated.
Input
Any lowercase string that can be written with the letters abcdefijlnorstuy  (can include spaces)
Output
Valid javascript containing only the characters []+-~/{}! that will evaluate to the original word in a js environment.
Examples
f('u') -> [[][[]]+[]][+[]][+[]]

f('a') -> [+[][[]]+[]][+[]][-~[]]

f('t') -> [-~[]/[]+[]][+[]][-~[]-~[]-~[]-~[]-~[]-~[]]

f('o') -> [[]+{}][+[]][-~[]]

f('l') -> [![]+[]][+[]][-~[]-~[]]

f('r') -> [!![]+[]][+[]][-~[]]

f('defined') -> [[][[]]+[]][+[]][-~[]-~[]]+[[][[]]+[]][+[]][-~[]-~[]-~[]]+[[][[]
]+[]][+[]][-~[]-~[]-~[]-~[]]+[[][[]]+[]][+[]][-~[]-~[]-~[]-~[]-~[]]+[[][[]]+[]][
+[]][-~[]]+[[][[]]+[]][+[]][-~[]-~[]-~[]]+[[][[]]+[]][+[]][-~[]-~[]]

f('aurora borealis') -> [+[][[]]+[]][+[]][-~[]]+[[][[]]+[]][+[]][+[]]+[!![]+[]][
+[]][-~[]]+[[]+{}][+[]][-~[]]+[!![]+[]][+[]][-~[]]+[+[][[]]+[]][+[]][-~[]]+[[]+{
}][+[]][-~[]-~[]-~[]-~[]-~[]-~[]-~[]]+[[]+{}][+[]][-~[]-~[]]+[[]+{}][+[]][-~[]]+
[!![]+[]][+[]][-~[]]+[[][[]]+[]][+[]][-~[]-~[]-~[]]+[+[][[]]+[]][+[]][-~[]]+[![]
+[]][+[]][-~[]-~[]]+[[][[]]+[]][+[]][-~[]-~[]-~[]-~[]-~[]]+[![]+[]][+[]][-~[]-~[
]-~[]]

f('code tennis') -> [[]+{}][+[]][-~[]-~[]-~[]-~[]-~[]]+[[]+{}][+[]][-~[]]+[[][[]
]+[]][+[]][-~[]-~[]]+[[][[]]+[]][+[]][-~[]-~[]-~[]]+[[]+{}][+[]][-~[]-~[]-~[]-~[
]-~[]-~[]-~[]]+[-~[]/[]+[]][+[]][-~[]-~[]-~[]-~[]-~[]-~[]]+[[][[]]+[]][+[]][-~[]
-~[]-~[]]+[[][[]]+[]][+[]][-~[]]+[[][[]]+[]][+[]][-~[]]+[[][[]]+[]][+[]][-~[]-~[
]-~[]-~[]-~[]]+[![]+[]][+[]][-~[]-~[]-~[]]

f('js bad') -> [[]+{}][+[]][-~[]-~[]-~[]]+[![]+[]][+[]][-~[]-~[]-~[]]+[[]+{}][+[
]][-~[]-~[]-~[]-~[]-~[]-~[]-~[]]+[[]+{}][+[]][-~[]-~[]]+[+[][[]]+[]][+[]][-~[]]+
[[][[]]+[]][+[]][-~[]-~[]]

f('obfuscate') -> [[]+{}][+[]][-~[]]+[[]+{}][+[]][-~[]-~[]]+[[][[]]+[]][+[]][-~[
]-~[]-~[]-~[]]+[[][[]]+[]][+[]][+[]]+[![]+[]][+[]][-~[]-~[]-~[]]+[[]+{}][+[]][-~
[]-~[]-~[]-~[]-~[]]+[+[][[]]+[]][+[]][-~[]]+[-~[]/[]+[]][+[]][-~[]-~[]-~[]-~[]-~
[]-~[]]+[[][[]]+[]][+[]][-~[]-~[]-~[]]

Rules
Lowest byte count wins.
The solution can be written in any language, but the generated code must evaluate in either chrome, firefox, or a node.js repl.
Don't abuse any common loopholes.

This is wonderful. Thanks. Are the other letters impossible to get with []+-~/{}!?

Yeah, adding () allows you to get all letters since it allows you to create and call functions to get new strings, this is the concept behind JSFuck. But that becomes even more dependent on JS knowledge than this question already is.

f('js bad') made me chuckle

@begolf123 The link is dead.

@EricDuminil v in native code but require lots of code

JavaScript (ES6),  139  135 bytes
s=>[...s].map(c=>`[{},!![,[][[],![,~[]/[`.split`,`.some(s=>i=~eval(S=`[${s}]+[]][+[]]`).search(c))&&S+`[${'-~[]'.repeat(~i)}]`).join`+`

Try it online!
How?
The following code snippets are used:
 code             | string            | used for
------------------+-------------------+-------------------------------------
 [[{}]+[]][+[]]   | '[object Object]' | space, 'b', 'c', 'e', 'j', 'o', 't'
 [!![]+[]][+[]]   | 'true'            | 'r', 'u'
 [[][[]]+[]][+[]] | 'undefined'       | 'd', 'f', 'i', 'n'
 [![]+[]][+[]]    | 'false'           | 'a', 'l', 's'
 [~[]/[]+[]][+[]] | '-Infinity'       | 'y'

We pick the appropriate character in the resulting string with [-~[]-...-~[]].
We can't access index \$0\$ this way, so we make sure that the snippets are ordered in such a way that this is never required. For instance, 'u' is taken from 'true' rather than from 'undefined'.

I was sure to see your answer! Waiting for explanation

Any other language would be more impressive :p

@JonathanAllan Done. :) But my Python code is probably terribly golfed...

I have a solution which works if you have infinite time and memory. I'm not 100% sure whether that's allowed within the rules here; I searched on codegolf.meta.SE and didn't find anything saying that code-golf answers have to run in a reasonable length of time using a reasonable amount of memory. I also didn't find it forbidden in the "common loopholes" thread. If it makes my solution invalid, please let me know.
JavaScript (ES6), 112, 110, 107 106 bytes
s=>{for(q=[''];;c=q.shift(),q.push(...[...'[]+-~/{}!'].map(x=>c+x)))try{return eval(c)===s?c:d}catch(e){}}

It isn't restricted to string inputs, and can find short solutions in reasonable times, but unfortunately it's not feasible to solve for non-empty strings, even just single-characters like 'o'. Here it is working on some inputs for which it is feasible.
> f(0)
"+[]"
> f(1)
"-~[]"
> f(-1)
"~[]"
> f(true)
"!+[]"
> f(false)
"![]"
> f('')
"[]+[]"

How?
It's a breadth-first search. q is the queue, c is the current string. The breadth-first search algorithm will iterate through every possible string formed from the given alphabet, in order of length, so if a solution exists, it will be found.
We try evaluating c with the eval function, and return it if it evaluates to s. This comparison is done with === to avoid e.g. returning +[] which evaluates to 0 when we're looking for an expression which evaluates to the empty string. The variable c is uninitialised on the first iteration of the loop, but that's OK because it's only used within the try block.
We need try/catch because most candidate strings have syntax errors; as a bonus, instead of guarding the return with an if statement, we can return the non-existent name d because the error will get caught, allowing the loop to continue searching. This saves one byte, but it means the function stops working if you declare a variable named d, which is mildly amusing.

Yeah this is clever. I like it because it doesn't require the knowledge provided in the question of what gets coerced to what. You just brute force the allowed alphabet. You're essentially offloading all js knowledge to be dependant on "eval"

Python 2, 125 bytes
Using a single code snippet.
print[]
for c in input():print'+[{}+!![]+![]+~[]/[]+[][[]]][+[]]['+'-~[]'*(ord('#2??;"?4?9 &?/5%03!$B'[ord(c)%59%21])-31)+']'

Try it online!
Try the output in JS!

Python 2,  167  150 bytes
Saved 2 bytes thanks to @JonathanAllan
print[]
for c in input():i=ord(".@C1A83J42/K70DIY"[ord(c)*91%211%23]);print'+['+"[{} !![ [][[] ![ ~[]/[".split()[i/9-5]+']+[]][+[]]['+'-~[]'*(i%9)+']'

Try it online!
Try the output in JS!
How?
This is based on the same code snippets as my JS answer, but a lookup string is used to retrieve the snippet ID and the position of the character.
Given the ASCII code \$c\$ of the character to be converted, the position in the lookup string is given by:
$$i=((c\times91)\bmod211)\bmod23$$
Given the ASCII code \$n\$ of the \$i\$-th character in the lookup string ".@C1A83J42/K70DIY":

the snippet ID is \$\lfloor(n-45)/9\rfloor=\lfloor n/9\rfloor-5\$
the position of the character is \$(n-45)\bmod9=n\bmod9\$

This is summarized in the following table.
 char. | ASCII code | -45 | //9 | mod 9 | character lookup     | output
-------+------------+-----+-----+-------+----------------------+--------
  '.'  |     46     |   1 |  0  |   1   | '[object Object]'[1] |  'o'
  '@'  |     64     |  19 |  2  |   1   | 'undefined'[1]       |  'n'
  'C'  |     67     |  22 |  2  |   4   | 'undefined'[4]       |  'f'
  '1'  |     49     |   4 |  0  |   4   | '[object Object]'[4] |  'e'
  'A'  |     65     |  20 |  2  |   2   | 'undefined'[2]       |  'd'
  '8'  |     56     |  11 |  1  |   2   | 'true'[2]            |  'u'
  '3'  |     51     |   6 |  0  |   6   | '[object Object]'[6] |  't'
  'J'  |     74     |  29 |  3  |   2   | 'false'[2]           |  'l'
  '4'  |     52     |   7 |  0  |   7   | '[object Object]'[7] |  ' '
  '2'  |     50     |   5 |  0  |   5   | '[object Object]'[5] |  'c'
  '/'  |     47     |   2 |  0  |   2   | '[object Object]'[2] |  'b'
  'K'  |     75     |  30 |  3  |   3   | 'false'[3]           |  's'
  '7'  |     55     |  10 |  1  |   1   | 'true'[1]            |  'r'
  '0'  |     48     |   3 |  0  |   3   | '[object Object]'[3] |  'j'
  'D'  |     68     |  23 |  2  |   5   | 'undefined'[5]       |  'i'
  'I'  |     73     |  28 |  3  |   1   | 'false'[1]           |  'a'
  'Y'  |     89     |  44 |  4  |   8   | '-Infinity'[8]       |  'y'

You can get rid of the print[] and put '[]\n' as an argument for input to save 2 bytes.

How the hell does one come up with such lookup methods?

@RGS I'd be interested too. I suppose brute-forcing is doable since all integers are relatively small, and there aren't many of them. There might be more elegant solutions though.

@RGS This was brute-forced.I tried the following patterns: N*p%m0, N*p%m0%m1, N%m0%m1%m2, N%m0%m1, N%m0, x%N%m0%m1%m2, x%N%m0%m1, x%N%m0 with limited ranges for each parameter.

@Arnauld Ty for your reply, and quite interesting actually!

Prolog (SWI), 269 bytes
It's not a particularly short solution, but made this challenge interesting because it is able to use backtracking to automatically select which string and index into that string to use for each character.
`fals`^`![]+[]`.
`[object `^`[]+{}`.
`und`^`[][[]]+[]`.
`-Infinity`^`~[]/[]+[]`.
`tr`^`!![]+[]`.
[]-`[]`.
[H|T]-S:-B^C,nth0(I,B,H),length(L,I),foldl([_,V]>>append(`-~[]+`,V),L,` +[]`,J),T-U,append([`[`,C,`][+[]][`,J,`]+`,U],S).
S/W:-S+A,A-B,W+B.
A+B:-string_codes(A,B).

Try it online!
Ungolfed Code
% Declaration of strings we can generate with their corresponding JS.
base_str(`undefined`,`[[][[]]+[]][+[]]`).
base_str(`[object Object]`, `[]+{}`).
base_str(`Infinity`, `[-~[]/[]+[]][+[]]`).
base_str(`NaN`, `[+[][[]]+[]][+[]]`).
base_str(`true`, `!![]+[]`).
base_str(`false`, `![]+[]`).

% Construct JS used to index into strings
wtf_index(0,`+[]`).
wtf_index(1,`-~[]`).
wtf_index(N, S0) :-
  N > 1,
  wtf_index(1, S1),
  M is N - 1,
  wtf_index(M, S2),
  append([S1,`+`,S2],S0).

% Construct JS used for single char
wtf_char(C, WC) :-

  % Find known string with desired character at some index
  base_str(S, WS),
  nth0(I, S, C),

  % JS for this index
  wtf_index(I, WI),

  % JS to select index from string
  append([`(`,WS,`)[`,WI,`]`],WC).

% Map wtf_char over string, reducing to single string
wtf_list([], `[]`).
wtf_list([H|T], WS) :-
  wtf_char(H, WH),
  wtf_list(T, WT),
  append(WH, [0'+|WT], WS).

wtf_str(S, W) :-
  string_codes(S, SC),
  wtf_list(SC, WC),
  string_codes(W, WC).

JavaScript (Node.js), 104 bytes
s=>[...s].map(c=>(p=`[{}+!![]+![]+~[]/[]+[][[]]][+[]]`)+`[${'-~[]'.repeat(eval(p).search(c))}]`).join`+`

Try it online!
Explanation
Each letter is converted to a string of the form
[{}+!![]+![]+~[]/[]+[][[]]][+[]][x]

Where x is a number of -~[]
[{}+!![]+![]+~[]/[]+[][[]]][+[]] evaluates to the string [object Object]truefalse-Infinityundefined, which contains all of our letters. We then index into it by using this snippet:
`[${'-~[]'.repeat(eval(p).search(c))}]`

It evaluates [{}+!![]+![]+~[]/[]+[][[]]][+[]] (stored in variable p), then finds the first index of the current letter we are processing. We repeat the string +~-[] (evaluates to 1) that number of times. That is wrapped around with square brackets, and appended to p.
Finally, everything is joined with +.

C# (Visual C# Interactive Compiler), 156 bytes
x=>string.Join('+',x.Select(l=>"[{}+!![]+![]+~[]/[]+[][[]]][+[]]["+new StringBuilder().Insert(0,"-~[]",$"[object {0,8}ru fals{0,9}y nd fi".IndexOf(l))+"]"))

Try it online!
Explanation
Each letter is converted to a string of the form
[{}+!![]+![]+~[]/[]+[][[]]][+[]][x]

Where x is a number of -~[]
[{}+!![]+![]+~[]/[]+[][[]]][+[]] evaluates to [object Object]truefalse-Infinityundefined, which contains all the letters. We index into the string $"[object {0,8}ru fals{0,9}y nd fi", which expands to
[object        0ru fals        0y nd fi

We take the current letter and get the first index of it in that string. We then repeat the string -~[] that number of times, and replace the x with that.
Repeating a string is rather verbose in C#, as there is no builtin for it. Instead, a StringBuilder is created, and taking advantage of the StringBuilder.Insert(int, string, int) overload (which inserts the string n2 times at index n1) to created a StringBuilder containing a repeated string. It is implicitly converted to a string due to the magic of the + operator.
new StringBuilder().Insert(0,"+-~[]",$"[object {0,8}ru fals{0,9}y nd fi".IndexOf(l))

Finally, the converted strings are joined together with +.

You can save 3 bytes by removing the unnecessary +[].

Charcoal, 95 bytes
≔⪪“<≦ω≕ε…(Ｂς´Ｂ⌈ＹWγ№Φξ⌕IY¦l ”,ηＦＳ«≔⊟Φ⁵№§ηκιζ⊞υ⪫[]⁺⁺§⪪“"∧｜⌊AuüQ⁷～⊙<⁷≕u?ψμ”,ζ×+[]][²×-~[]⌕§ηζι»⪫υ+

Try it online! Link is to verbose version of code. Explanation:
≔⪪“<≦ω≕ε…(Ｂς´Ｂ⌈ＹWγ№Φξ⌕IY¦l ”,η

Split the compressed string "\n\nd,\nals,\nru,\\nnfi\n\n\ny,\nobject " on commas. This is the array ["undefined", "false", "true", "Infinity", "[object Object]"] keeping only the space and unique letters and truncated at the last remaining letter to improve the compression.
ＦＳ«

Loop over the input string.
≔⊟Φ⁵№§ηκιζ

Find the entry that contains the current input character.
⊞υ⪫[]⁺⁺§⪪“"∧｜⌊AuüQ⁷～⊙<⁷≕u?ψμ”,ζ×+[]][²×-~[]⌕§ηζι

Split the compressed string "[][[]],![],!![],~[]/[],{}" on commas and take the matching entry, then concatenate it with "+[]][" doubled and a suitable number of repetitions of "-~[]" before finally wrapping everything inside a final set of [].
»⪫υ+

Join everything together with +s.

@Arnauld Thanks for pointing that out; luckily that means that there's some duplication which means it only costs 1 byte.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Jury-rigged Netcat from default Windows
Something unusual: a code golf question with a purpose.
I occasionally find myself in scenarios resembling the following:
Suppose you have two computers, A and B.  Both of them have a fresh copy of Windows 10 installed.  It comes with all the usual stuff, like notepad and paint and a browser, but no extras, like a Linux tools port.  They ALSO have had Remote Desktop and the built in File Sharing removed/disabled.  Computer A has one extra thing - a large-ish file (say, 10 MB) that you need to get onto Computer B.  Computers A and B are connected over a LAN, but they are not connected to the internet.  Their USB drives have been disabled, and they have no other data I/O peripherals.  No disassembling the computers.
In the fewest possible steps, how do you get The File between LAN'd computers A and B, running default Windows 10, with no internet and no external storage devices?
I'm expecting something like "if you type such-and-such line into PowerShell, it takes a pipe and outputs it into a TCP connection", or "if you abuse the browser in such-and-such a way, it lets you host an FTP server".  BUT, I'm open to surprises - as long as they're actually feasible.

What counts as a step?  I think that needs to be resolved for this to be clear.


text:
Super permutations
Super permutations
Input: A string
The program should loop through all lengths of the input (decrementing one each time), generate all combinations with replacement of the string, then make permutations out of  the generated combinations, and display all of the strings.
They can be separated with anything (doesn't need to be a comma)
Example for the string 'abc':
a, b, c, aa, ab, ac, ba, bb, bc, ca, cb, cc
aaa, aab, aac, aba, abb, abc, aca, acb, acc
baa, bab, bac, bba, bbb, bbc, bca, bcb, bcc
caa, cab, cac, cba, cbb, cbc, cca, ccb, ccc

The values don't necessarily have to be sorted.
Avoid any standard loop holes.

Can we also include the empty string as a length zero permutation?

Will the string contain duplicates? If so, do you need the output to be deduplicated?

I tagged this code golf, because all the answers are assuming it is.

I'm finding the talk of permutations and combinations confusing here. The way I'd phrase the task is: output all strings made of characters in the input, whose length ranges from 1 to the length of the input. Related: Output all strings.

Can we take a length argument?

Can we output a list of lists? Like [[a,b], [aa,ab,ba,bb]]? Some answers already assume this, while others flatten the list

Scratch 3.0, 65 blocks / 637 632 bytes

Look at y'all, having fun with your fancy shmancy permutation functions/map tools. Well, not I! No, not I! When using Scratch, one has to do things themselves! You won't find any built-ins around these parts! I'm just glad there still ain't any gotos ;)
But more seriously, the image is split into 4 parts because it's just soooo long
Press space to clear the lists before each run
And finally,
Try it online Scratch!
As SB Syntax:
when gf clicked
set[c v]to(0
ask()and wait
set[L v]to(length of(answer
add(1)to[b v
repeat((L)-(1
add(0)to[b v
end
repeat until<(c)=(1
set[s v]to(0
set[l v]to(1
repeat(length of[b v
change[s v]by(item(l)of[b v
change[l v]by(1
end
if<(s)=((L)*(L))>then
set[c v]to(1
end
set[r v]to(
set[l v]to(1
repeat(length of[b v
set[r v]to(join(r)(letter(item(i)of[b v])of(answer
change[i v]by(1
end
add(r)to[o v
replace item(1)of[b v]with((item(1)of[b v])+(1
set[j v]to(1
repeat(length of[b v
if<(item(j)of[b v])>(length of(answer))>then
replace item(j)of[b v]with(1
replace item((j)+(1))of[b v]with((item((j)+(1))of[b v])+(1
end
change[j v]by(1

-5 bytes due to not being a silly billy and removing extranous spaces

05AB1E, 4 3 bytes
-1 byte thanks to a'_'
ā€ã

Try it online!

I don't know 05AB1E. I just randomly pasted a character inside the program. And it WORKS!?

@a'_' you what? That sounds insanely unlikely lol

@Cruncher I am serious. I thought turning the gL into ã (i.e. a double-cartesian power) would work. It turns out that I copied the wrong character (ā indeed looks very similar to ã)

(And then I feel that pretending that I don't know 05AB1E and saying randomly will make viewers laugh harder.)

Jelly, 2 bytes
ṗJ

A monadic Link which accepts a list of characters and returns a list of lists of lists of characters.
Try it online! (footer formats as a grid)
How?
ṗJ - list, S
 J - range of length of S
ṗ  - Cartesian power (vectorises)

If we must output a flat list of "strings" (lists of characters) we can add Ẏ (tighten) for the cost of a byte.

Haskell, 34 bytes
f s=init$mapM(\_->s)=<<scanr(:)[]s

Try it online!
Here's how it works, using input s="abc":
                       scanr(:)[]s

Produces the suffixes of s, ["abc","bc","c",""], by prepending each character in turn to the front and tracking the intermediate results.
         mapM(\_->s)

Uses the list monad to map each element to s, that is, 'xy'-> ["abc","abc"], and take multiply them as a Cartesian product, here giving ["aa","ab","ac","ba","bb","bc","ca","cb","cc"].
         mapM(\_->s)=<<scanr(:)[]s

Uses =<< as concatMap to take the function above that uses mapM and apply it to each of the suffixes, thereby producing the Cartesian products of copies of s numbering from 0 to its length, in a single list.
    init$

Removes the empty string, produces from the suffix of length 0.
f s=

Declares the function.

What is going on here?

Thanks for the explanation!

05AB1E, 6 bytes
gENIã)

Try it online!
Explanation
gENIã)
 E     # foreach in...
g      # the input
    ã  # find the cartesian product of...
   I   # the input...
  N    # repeat N
     ) # wrap the final stack to an array
       # implicit output of the top element

That looks like genial, which in my (natural) language means brilliant. +1 for that

J, 16 bytes
a:-.~[:,#\{@#"{<

Try it online!

a:-.~ Remove empty boxes from...
[:, The flatten of...
{@#"{ The Catalog (cross prod) of {@...
#\{@#"{<

< The boxed input...
#"{ Copied this many times...
#\ 1, 2, ... N, where N is the input length.  That is, we copy the input once, then twice, ... then N times, taking the Catalog of each of those.

PHP, 176 174 173 171 170 166 bytes
$c=$t=count($u=array_values(array_unique(str_split($argn))));for($s=1;$i<$t**$t;){$i-$c?:[$s++,$c*=$t,$i=0];for($k=$i++,$j=0;$j<$s;$j++,$k/=$t)echo$u[$k%$t];echo',';}

Try it online!
-4 bytes thanks to @Ismael Miguel.
Method: simply count in base N, where N is the number of unique characters in the input string.

You can save 2 bytes by moving $k/=$t; into the for($j=0;$j<$s;$j++), and remove the {...}, like this: for($j=0;$j<$s;$j++,$k/=$t)echo$u[$k%$t];

Didn't think PHP supported the comma operator. But yes, in for loops!

Oh, it works. And here's something else: you can replace your if($i==$c){$s++;$c*=$t;$k=$i=0;} with $i==$c?[$s++,$c*=$t,$k=$i=0]:0;. This will save 1 byte, and work the same. This uses a ternary operator and an array, where the array will be "executed" if the condition is true. However, you need to have a value for the false condition (the 0). What saves the byte is really the array, because you remove the ; after the 3rd assignment, when changing the syntax.

Very clever, I shall use it in future. I switched the condition however, for one extra byte: $i!=$c?:[$s++,$c*=$t,$k=$i=0];

That is actually really clever. I didn't though about it. But hey, 5 bytes shaved from the total is pretty good.

PowerShell, 42 bytes
($a=$args)|%{($p=$p|%{$t=$_;$a|%{$t+$_}})}

Try it online.
Expects input via splatting.

via $null. it's smart!

Husk, 4 bytes
Total Husk novice, there may be better ways to golf this.
Mπŀ¹

Try it online!
Explanation
  ŀ¹ Find the range [1, ..., len(input)]
Mπ   Map with cartesian power of input

Ruby, 60 bytes
->s{a,*z=s.chars,'';z.product(*a.map{a+z}).map(&:join)-z|[]}

Try it online!

Python 3, 95 bytes
import itertools as i;lambda s:[''.join(p)for l in range(len(s))for p in i.product(s,repeat=l)]

Try it online

Using l here made me confuse it with 1 for a second back in the repeat= part... +1!

@ojdo maybe not the best choice on my part :P

Note: you can format your TIO code like this for anonymous lambdas with imports

@JoKing That does look better! Thanks!

Burlesque,  5  4 bytes
sacb

Try it online!
-1 thanks to DeathIncarnate!
sa    # Duplicate the input and get it's length
  cb  # Get all combinations of the input characters up to the length of the input

sa is shorthand for JL[ Try it online!

Python 2, 69 68 bytes
f=lambda s,A={''}:s in A and A or f(s,A|{a+c for a in A for c in s})

Try it online!
Outputs a set; includes the empty string.
Python 2, 71 bytes
f=lambda s,A=[]:s in A and A or f(s,set(s)|{a+c for a in A for c in s})

Try it online!
If empty string is not allowed...

JavaScript (ES7), 90 bytes
Returns a Set.
s=>new Set([...Array(n=(L=-~s.length)**~-L)].map(_=>(g=n=>n?[s[n%L-1]]+g(n/L|0):'')(n--)))

Try it online!
Commented
s => new Set(            // build a set from
  [...Array(             //   an array of
    n =                  //   n entries, with:
      (L = -~s.length)   //     n = L ** (L - 1)
      ** ~-L             //     where L is the length of s + 1
  )]                     //
  .map(_ =>              //   for each entry:
    ( g = n =>           //     g is a recursive function taking n
        n ?              //       if n is not equal to 0:
          [s[n % L - 1]] //         output s[(n mod L) - 1]
                         //         or an empty string if it's undefined
          + g(n / L | 0) //         recursive call with floor(n / L)
        :                //       else:
          ''             //         stop recursion
    )(n--)               //     initial call to g; decrement n afterwards
  )                      //   end of map()
)                        // end of Set()

Charcoal, 17 bytes
ＦＥθＸＬθ⊕κＥι✂⍘⁺ικθ¹

Try it online! Link is to verbose version of code. Explanation:
ＦＥθＸＬθ⊕κ

Loop over the substring lengths and raise the length to each power in turn.
Ｅι✂⍘⁺ικθ¹

Loop from each power to double its value and perform base conversion using the input string as the alphabet, then slice off the first character.

Perl 6, 32 bytes
{flat [\X~] '',|[xx] .comb xx 2}

Try it online!
Anonymous code block that takes a string and returns a list of string including the length zero permutation.

Pyth, 5 bytes
^LQSl

Try it here!

R, 112 bytes
function(S,s=sapply)cat(unlist(s(1:nchar(S),function(X)do.call('paste0',expand.grid(s(rep(S,X),strsplit,''))))))

Try it online!
Things that make you go Argh, strings in R.
Expands out to the following
cat(                                           # output the results
  unlist(                                      # collapse the list
    sapply(1:nchar(S),                         # for 1 to character length of S
      function(X)do.call('paste0',             # for each row from the grid paste characters together
         expand.grid(                          # create permutations
           sapply(rep(S,X),strsplit,''))))))   # replicate the string X times and split.

So we produce a lists of [['a','b','c']], [['a','b','c'],['a','b','c']], [['a','b','c'],['a','b','c'],['a','b','c']].
These are feed into expand.grid to produce the permutations.
Each row of the grid is pasted together with no gaps in the do.call.
As it is still in a list we apply unlist so that cat will be able to output it.

depending on whether you are allowed to output the list directly (it's asked in comments but as yet unanswered) you could replace cat(unlist(...)) with print(...) (maybe show(...) will work also — haven't tried)

I could probably just get rid of them completely.  There could also be an argument put forward to remove the do.call

Perl 5 -lF, 48 bytes
$"=',';map$k{$_}++||say,glob"{@F}"."{@F,''}"x$#F

Try it online!


text:
Narcissistic Quine
Write a program/method that:

Becomes a quine when the input matches the source code;
Doesn't halt otherwise.

This is code-golf, so shortest solution wins. Avoid any standard loopholes.

@PostRockGarfHunter Strengthened the requirements. Now this challenge differs from a cat program.

This is why we sandbox.

Here's a similar question, hopefully the answers can provide inspiration for others!
https://codegolf.stackexchange.com/questions/11370

Possible duplicate of Write the shortest self-identifying program (a quine variant)

Jelly, 14 bytes
“Ṿ;⁾v`¹⁻³$¿”v`

Try it online!
A program taking a single string argument and either printing its source if the string matches its source, or looping indefinitely if not.
Explanation
“          ”v` | Evaluate the following string as Jelly code, using the string itself as argument:
 Ṿ             | - Uneval (effectively wrap the string in “”
  ;⁾v`         | - Append v`
       ⁻³$¿    | - While not equal to the original program argument:
      ¹        |   - Call the identity function

Python 3.8 (pre-release), 67 60 56 bytes
exec(a:='print(s:=input())\nwhile s!="exec(a:=%r)"%a:1')

Try it online!

Python 2, 56 bytes
a='s=input();print s\nwhile s!="a=%r;exec a"%a:1';exec a

Try it online!

Is there anything in 3.8 that this answer relies on?

@Cruncher https://docs.python.org/3/whatsnew/3.8.html#assignment-expressions

GolfScript, 20 bytes
{`".~"+{.2$=}do\;}.~

Try it online!
Explanation
{                }.~ # Evaluate the following string as GolfScript code, using the string itself as argument:
 `                   # - Uneval (effectively wrap the string in ""
  ".~"+              # - Append .~
       {.2$=}do      # - Do While not equal to the original program argument:
                     #   - (Basically do nothing)
               \;    # - If this loop ends, discard the extra copy of the input

What is the relationship between Jelly and GS?

@RGS It's simply because Jelly is (indirectly) based on GS.

why did the GS port of a jelly answer get more votes than the answer it was porting?

05AB1E, 20 bytes
"34çìD«Êi["34çìD«Êi[

Try it online!

Explanation
"34çìD«Êi["           - string literal
           34ç        - push the character "
              ì       - prepend to the string literal
               D«     - duplicate the string (producing the code)
                 Êi[  - loop if it's not the same as the input
                      - else implicitly output

Pyth, 15 bytes
QWnjN B"QWnjN B

Try it online!
Explanation
QWnjN B"QWnjN B
Q                 implicit print input
      B"QWnjN B   evaluates to ["QWnjN B", "QWnjN B"]
   jN             join elements in list with '"' as separator (will be source code)
 Wn               keep looping while input does not equal source code

PHP, 89 bytes
eval($s='$a=chr(39);$b="eval(\$s=$a";$c="$a);";$b.$s.$c!=$argn?:die($b.$s.$c);for(;;);');

Try it online!
This is the best I have found so far, at the beginning it wasn't a port of @Mukundan's answer, but it pretty much ends like it. I will try to improve it later..
EDIT: saved a byte with != instead of == so I can remove the 1
EDIT2: saved 16 bytes using vars for repeated strings

RProgN 2, 17 bytes
«•.x=xe²xw³1#1:?

Explanation
«•.x=xe²xw³1#1:?<SPACE> #
«                       # Push the following function to the stack and execute
 •.                     # Append a space (A non-function character) and stringify
   x=                   # Assign the stringified function to x
     xe                 # Is x equal to the top of the stack?
       ²                # "Double Function" to execute if true
        x               # Push x to the stack
         w              # Output
          ³             # "Tripple Function" to execute if false
           1            # Push a truthy value to the stack
            #1          # A function that just repeatedly pushes true
              :         # While the top of the stack is true. Thus, loop forever
               ?        # If a, than b, else c
                <SPACE> # Used to ensure the function qualifies as a quine.

Try it online!

Funky, 36 bytes
f=s=>{x=`f=[f]`ifx==s x elsewhile1z}

Try it online!

JavaScript (V8), 33 32 31 bytes
-1 byte thanks to Jo King
f=x=>eval(`while(x!='f='+f);x`)

Try it online!

20 bytes, though I'm not sure if exceeding the recursion limit counts as infinite. At the very least, you can get rid of the trailing semicolon

@JoKing Yeah I thought about that but I don't think that really counts, since it's bounded by the size of the stack, thanks for the -1, I did think about something similar with f=x=>x=='f='+f?x:eval("for(;;);") but it's 33 bytes

Another 33 f=x=>eval(\while(x!='f='+f);`)||x`

Perl 5, 50 bytes
$_=q($_='$'."_=q($_);eval";<>eq$_?print:eval);eval

Try it online!

Japt, 29 21 bytes
OvA="Us@¶`OvA=`+Q+A}a

Try it online!
Explanation
OvA="Us@¶`OvA=`+Q+A}a
  A="Us@¶`OvA=`+Q+A}a // Set A to string literal
Ov                    // Evaluate A as japt code
       @              // Function
        ¶`OvA=`+Q+A   //   Check if input equals "OvA" + '"' + A (Q is '"')
                   }  // End Function
                    a // Call function repeatedly until it returns a truthy value
     Us               // Slice off first 0 chars of input
                      // Implicit Output


text:
Simple Circular Words
A "simple circular" word is a word whose chords do not intersect.  The chords of a word may be seen by laying out the alphabet in a circle, and then connecting the word's consecutive letters.
Examples of Simple Circular Words
ROLE

LAKE

BALMY

Failing Example
A word fails to be simple circular if any of its chords intersect:

The Challenge
Write a program or function that takes a word and returns true if it's simple circular, false otherwise.

Code golf, fewest bytes wins.
Standard rules.
You may assume there are no repeated letters in the word.
You may assume every word has at least 2 letters
You may assume the word is all uppercase, or all lowercase, whichever you prefer.
You may output any two consistent values for true and false.

Test Cases
True
ROLE, LAKE, BALMY, AEBDC, ABZCYDXE, AZL, ZA
False
BONES, ACDB, ALBZ, EGDF

After around 1 hour of struggling, I've concluded that this cannot be done visually in Scratch.

@AZTECCO "You may assume there are no repeated letters in the word."

@Kevin Cruijssen ah yes, sorry I skipped that. Although this rule makes the challenge simple it's common for words to have repeated letters, plus ngn answer seems to work for repeated letters too. Maybe we can have a 2nd challenge later based on this..

@AZTECCO I'll be posting a more difficult sequel to this question later this week.  Re: repeated letters specifically, I wanted to avoid dealing with doubles like GOON, where the only sensible interpretation is to add a pre-processing step that removes them, which felt uninteresting to me.  I'll grant it might have been better to prohibit only contiguous repeats, rather than repeats altogether.

Jelly, 12 bytes
O_Ṫ$:Ṫ$¬EƲƤẠ

Try it online!
A Jelly translation of Grimy’s 05AB1E answer; be sure to upvote that one too! A monadic link taking a Jelly string as its argument and returning a Jelly boolean.
Explanation
O            | Convert to Unicode codepoints
         ƲƤ  | Following applied to each prefix:
 _Ṫ$         | - Subtract tail (after popping tail)
    :Ṫ$      | - Integer divide by tail (after popping tail)
       ¬     | - Not
        E    | - All equal
           Ạ | All

Perl 6, 46 bytes
{!/[(.).*]**4<?{[+^] $0 Xeq[...] ~<<$0[^2]}>/}

Try it online!
A regex solution that finds if there are four characters in the string such that the two later characters are in different sections of the circle, as defined by the first two characters.
Explanation
{                                           }   # Anonymous code block returning
 !/                                        /    # If the input does not match
   [(.).*]**4                                     # Any 4 characters
             <?{                          }       # Where
                           [...]                    # The range from
                                 ~<<$0[^2]          # The first character to the second
                        Xeq                         # Contains which of
                     $0                             # The four characters
                [+^]                                # Reduce the list of booleans by xor
                 # Effectively, if only one of the 3rd or 4th character is in that range

K (ngn/k), 26 24 bytes
{&/|/x=&\'x:-:\|26!x-*x}

Try it online!
*x first letter of the argument x
x- subtract it from each of x as ascii code
26! mod 26
| reverse
-:\ make a pair of the list and its negation
x: assign to x
&\' cumulative minima and maxima (max is min under negation)
|/x= boolean mask for where x[i] is the current minimum or maximum
&/ all (and-reduce)

05AB1E, 14 13 bytes
Fixed a bug thanks to NickKennedy
Ç.sεć-ć/ï_Ë}P

Try it online!
Ç               # convert each letter to its codepoint
 .s             # suffixes of this list
   ε       }    # for each suffix:
    ć-          #  subtract first from others: [b-a, c-a, d-a, ...]
      ć/        #  divide others by first: [(c-a)/(b-a), (d-a)/(b-a), ...]
        ï       #  round down
         _      #  compare with 0
          Ë     #  all equal?
            P   # after the loop, product (1 iff the list is all 1s)

I knew a completely different approach would be shorter. Nice answer. Btw, -1 by using ÷ instead of /ï, which you funnily and consequently enough suggested yourself 2 days ago. :)

@KevinCruijssen no, that doesn't work. Try EGDF. ÷ rounds towards 0 while /ï rounds down.

Ah, you're right, due to the -0.5. With the challenge I linked above where you suggested this golf, the challenge didn't cared about how you rounded. Point taken. :) Maybe EGDF is also a good test case for OP, or does it only apply to your formula and not so much to the approaches used in other answers. (PS: consequently=coincidentally in my comment above; I'm unable to edit it.)

@NickKennedy thanks, fixed (i just had to revert my 13 => 12 optimization, which was to use prefixes instead of suffixes).

This is a really nice approach.  Well done.

JavaScript (Node.js), 91 bytes
Returns \$false\$ for simple circular, or \$true\$ for non-simple circular.
s=>Buffer(s).some((o,i,a,j=i)=>a.some(_=>((g=i=>x=(a[i]-o%26)%26)(j)-g(i+1))*(x-g(++j))>0))

Try it online!
Commented
s =>                            // s = input string
  Buffer(s)                     // turn s into a Buffer
  .some((o, i, a,               // for each ASCII code o at position i in a[]
                  j = i) =>     // and starting with j = i:
    a.some(_ =>                 //   for each entry in a[]:
      (                         //
        ( g = i =>              //     g is a helper function taking a position i
            x = (a[i] - o % 26) //       return (a[i] - (o mod 26)) mod 26
                % 26            //       and assign the result to x
                                //       NB: if a[i] is undefined, this gives NaN
                                //           and forces the forthcoming test to fail
        )(j) -                  //     compute the difference between g(j)
        g(i + 1)                //     and g(i + 1)
      ) * (                     //     multiply it by the difference
        x - g(++j)              //     between g(i + 1) and g(j + 1) (and increment j)
      ) > 0                     //     if it's positive, the chords are intersecting
                                //     inside the circle (i.e. s is not simple circular)
    )                           //   end of inner some()
  )                             // end of outer some()

05AB1E, 21 20 bytes
Ask¬-₂%.sD€ß¥s€à¥+ĀP

Port of @ngn's K (ngn/k) answer, so make sure to upvote them!!
Input as a lowercase list of characters.
Try it online or verify all test cases.
Explanation:
A          # Push the lowercase alphabet: "abcdefghijklmnopqrstuvwxyz"
 sk        # Get the (0-based) index of each characters of the input-list in this alphabet
           #  i.e. ["b","a","l","m","y"] → [1,0,11,12,24]
¬          # Push the first index (without popping)
 -         # And subtract it from each index
           #  i.e. [1,0,11,12,24] - 1 → [0,-1,10,11,23]
  ₂%       # Then take modulo-26 to make the negative values positive
           #  i.e [0,-1,10,11,23] → [0,25,10,11,23]
.s         # Take the suffices of this list
           #  i.e. [0,25,10,11,23] → [[23],[11,23],[10,11,23],[25,10,11,23],[0,25,10,11,23]]
  D        # Duplicate it
   €ß      # Take the minimum of each suffix
           #  i.e. [[23],[11,23],[10,11,23],[25,10,11,23],[0,25,10,11,23]]
           #   → [23,11,10,10,0]
     ¥     # And take the deltas (forward differences) of those
           #  i.e. [23,11,10,10,0] → [-12,-1,0,-10]
  s        # Swap to get the suffices again
   €à      # Take the maximum of each suffix this time
           #  i.e. [[23],[11,23],[10,11,23],[25,10,11,23],[0,25,10,11,23]]
           #   → [23,23,23,25,25]
     ¥     # And take the deltas (forward differences) of those as well
           #  i.e. [23,23,23,25,25] → [0,0,2,0]
      +    # Add the values at the same indices in the two lists together
           #  i.e. [-12,-1,0,-10] + [0,0,2,0] → [-12,1,2,-10]
       Ā   # Python-style truthify each (0→0; everything else → 1)
           #  i.e. [-12,1,2,-10] → [1,1,1,1]
        P  # And take the product of that to check if all are truthy
           #  i.e. [1,1,1,1] → 1
           # (after which this is output implicitly as result)

I think you forgot the and wait part. :P

@Lyxal fixed ;p

Well played ;P. I wish I could up vote this twice!

Charcoal, 29 bytes
⬤θ⬤…θκ⬤…θμ⬤…θξ⁼⁼‹ιν‹νλ⁼‹ιπ‹πλ

Try it online! Takes input in consistent case and outputs a Charcoal boolean (- for true, nothing for false). This has a rare use of the p variable. Explanation:
 θ                              Input string
⬤                               All characters satisfy
    θ                           Input string
   …                            Truncated to
     κ                          Current index
  ⬤                             All characters satisfy
        θ                       Input string
       …                        Truncated to
         μ                      Current index
      ⬤                         All characters satisfy
            θ                   Input string
           …                    Truncated to
             ξ                  Current index
          ⬤                     All characters satisfy
                 ι              Fourth character
                ‹               Is less than
                  ν             Second character
               ⁼                Equals
                    ν           Second character
                   ‹            Is less than
                     λ          Third character
              ⁼                 Equals
                        ι       Fourth character
                       ‹        Is less than
                         π      First character
                      ⁼         Equals
                           π    First character
                          ‹     Is less than
                            λ   Third character

For each subsequence of four characters in the input word, the first two comparisons check whether the second character is between the third and fourth while the other comparisons check whether the first character is between the third and fourth. If the results of these comparisons is different then it means that the chord between the first two characters crosses the chord between the third and fourth characters and the whole expression therefore evaluates to false.

This code reminds me of the Phoenix arcade game in the eegs/birds' round

J, 40 36 33 bytes
10(e.,)[:(/:~@,#.@e.])"1/~2]\3&u:

Try it online!
Decided to play my own game.
Still golfing...
But the idea is just to try all possible combinations of pairs of points, and check if their lines intersect, which, if the segements are AB and CD, happens when the letters' numerical values are arranged like:
      _____
     /     \
A...C...B...D
\______/

I recommend holding off for a week before answering your own challenges.

Just FYI for the future.

Haskell, 135 99 bytes
Thanks @JoKing for saving 36 bytes!
Almost certain its not the optimal way to go, so please feel free to improve it.
x(a:b:c:d:_)|s<- \z->min a b>z||z>max a b=s c/=s d;x _=1<0;y s=or$map(x.concat)$mapM(\a->[[a],[]])s

Explanation
However, I loved doing some propositional calculus. First, x tests if a given sequence of four letters form a non-circular word. Let \$I\$ be the interval defined by \$a\$ and \$b\$, so \$a,b,c\$ and \$d\$ form a circular word only if:
$$
p\equiv(c\in I)\iff q\equiv(d\in I)\\
(p\Rightarrow q)\wedge(q\Rightarrow p)\\
(\neg p\lor q)\wedge(\neg q\lor p)\\
\left[(\neg p\lor q)\wedge \neg q\right]\lor\left[(\neg p\lor q)\wedge p\right]\\
\left[(\neg p\wedge\neg q)\lor(q\wedge\neg q)\right]\lor\left[(\neg p\wedge p)\lor(q\wedge p)\right]\\
(\neg p\wedge\neg q)\lor(q\wedge p)\\
\neg(p\lor q)\lor(q\wedge p)
$$
Negating this proposition gives us
$$
(p\lor q)\wedge\neg(q\wedge p)
$$
which is equivalent to \$p\veebar q\$, in haskell p/=q. Finally, y tests if any subsequence with length 4 from the original word is non-circular.
Here's a spaned version:
import Data.List

-- x
cuts (a:b:c:d:rest)
 | s <- \z-> min a b > z || z > max a b
 = s c /= s d
x _ = False

-- y
isNonCircular word = or $ map (cuts . concat) $ mapM (\a -> [[a],[]]) word
```

and gofled to 97 bytes (though I'm no Haskell golfer)

@JoKing how did i not think of that!? I thoutgh about using xor, but didn't find any simple implamentation and didn't even considered using /=, thank you.

@JoKing I tried running your code on my computer, but it didn't compile, even though I see how it would work.

You need the header, with the comment, and I believe that it must be compiled in GHC since -Xcpp is a GHC flag.  Either that or add the v= before the or.  Also lambdas are usually a bad idea.  The lambda in @JoKing's golf can be eliminated for one more byte.

Additionally or + a map is the same as the function any, so instead of or.(x.concat<$>) you can do any(x.concat).

Ruby -nl, 70 bytes
An adaptation of the Perl answer, but Perl is apparently black magic with... whatever they're doing that lets them tersely get any 4 characters.
p$_.chars.combination(4).all?{|*m,c,d|(c=~r=/[#{m.sort*?-}]/)==(d=~r)}

Try it online!

Can you explain the regex part?

@Jonah I take the first two characters selected, sort them, and join them with -. Then this is interpolated into the regex. So if the input is BONES, the program will eventually reach the combination ['B', 'O', 'E', 'S'], so m=['B', 'O']; c='E', d='S'. So it will check if 'E' is in the regex /[B-O]/, and then do the same for 'S', and find that the result for each of them is not the same, so it returns false.

That’s very clever.  Similar idea to my solution but the regex twist is quite fun.

We have to do what's necessary to make things shorter. The next best solution AFAIK a,b=m.sort;(a<c&&c<b)==(a<d&&d<b) is 2 bytes longer.

C (clang), 119 114 bytes
c,n,b,j,o;g(char*w){for(int l[92]={j=o=c=0};n=*w;c=l[*w++])for(b=l[n],o|=b|c-j++&&c+~b&&b-c;n;)l[n--]++;return!o;}

Try it online!

We use an array representing the circle points ( we start from \0 instad of 'A' because it doesn't care)

We increment by 1 each point from current letter to 0.

The next point is valid if
 next == curr or
 next == curr - 1 or
 next == 0 and curr == j( iteration / left value )

LAKE
ABCDEFGHIJKLMN.. j   curr  next
00000000000000.. 0   0     L 0
11111111111*00.. 1   1     A 1
*1111111111100.. 2   2     K 2
3222222222*100.. 3   2     E 2
4333*222222100..

Thanks to @ceilingcat for saving 5