List all the features and aspects you'd put into a programming language of your design

I had a sample code of my fucking network scripting language, but I fucking lost it

It was at networkscriptinglanguage.org but I lost the login info. You could break down a packet into the 7 osi layers, variables with code brackets (stolen by fucking apple), but I want arrays of functions, nsl was a precursor to my work in neural systems

it's so trivially obvious. anyone with more than 1 (one) year industry experience would be able to conclude this:

a statically typed AOT compiled version of Python

it's obvious.

Attached: obvious.png (225x225, 2K)

It would essentially be Haxe but with out of the box support for C for loops and abstract classes.

Attached: mvpkeen.gif (379x213, 1.64M)

Why not BASIC? You know why? Cause bill gates is a FAGGOT, a fucking thief BUTT FUCKER

Dynamic types

1) cool racing stripes (for speed)
2) a beverage holder for my cola
3) kneepads for your mom lol
4) strong static type system

If I design a typed programming language I'll design it so composite types are truly composite, thus passing a String to a function which takes Maybe String is valid, since it will be represented as a Union of a set containing all strings and a set containing Nothing.
Same for Either types.

your unification algorithm would have to be quite clever to accomplish this.

if a function takes in a Maybe but the passed in value is a String, this information might be useful for later optimizations (e.g. omit checks). This means that the implicitly converted type (String -> Maybe) would probably want to carry around the original type or the full type "provenance." It's an interesting problem

Rich Hickey (Clojure's author) mentions there is some language which already does it but its name alludes me at the moment, in this lecture which convinced be union types are done incorrectly in Haskell
youtube.com/watch?v=YR5WdGrpoug
Besides that I'd like ports of Clojure with full interop with the host languages to C, C++, Go and Rust.

There is nothing to talk about

Haskell is already here

the task is to debloat it to something sane like Miranda was in her days

Just cut the bullshit out. Haskell is cannot be improved - it is already a pure applied logic with math notation.

Dotty is cute.

The LLVM backend is what we need. Or at least port to GCC backed.

There were some posts by Joe about Erlang2 or to making it a Lisp.

We should just do it. Erlang needs only some syntax unification and cleanup.

Actually, if one is really into PLs one should pick up on SML and Erlang. They are the greatest. Dotty is also cool.

S-Expressions.

I wrote a lexer for a language but I haven't wrote the parser or anything for it yet. If I finish it I plan on making it sort of like C except with built in utf8 string type, dynamic arrays, hash maps, array out of bounds checking, namespaces, defer keyword from go and python like syntax. I'd also like a better way to do metaprogramming and multithreading but I don't know much about that stuff.
I guess my ideas sound sort of like go without garbage collection so far.

can you show some planned syntax examples, namely functions and data types

emphesize on small simple codebase, compact specs which should be approachable by brighter undergrad
pretty much """better C""" approach
Fixed syntax.
defer, for any scope, statically inserted. not dynamic function-wide like Go.
arrays
multi-file modules, defaul way of compilation is to need all source available thus no header files.
Interpreter for IR. REPL with dynamically loaded environment.
Simple generics. Would probably steal the solution from Zig as it also solves compile time evaluation.
Standard package format and build tool. Might by instructed by the lang itself as it's also interpreted.
Linters, some plugin API for them. Asserts on steroids like invariance checkers for functions.
Most parts of compiler written as library.
Distinguish between arithmetic and logical shift.
No integer promotion. All is type checked.
Enums with namespace by its type. Over any type.
Compile-time type reflection.
Pattern matching or match on strings is nice thing that compiler can handle better that human.
And tons of work on portable standard library.

And you should be able to write kernel and baremetal code in it. That's tier 1 requirement.

Do we really need another programming language though? I can't see that we do, we have tons of them already, and there's one that's going to be pretty good at pretty much any situation in which you might find yourself wanting to write code. A better way to do this would be to just clean up some bits of cruft and misfeatures in existing languages.

Attached: alipa.png (487x487, 280K)

I really want dependent types

>Easily extensible ala haskell
>Clean and modular codebase like dwm or st
I would want myself or people using it to be able to make changes to the language easily without being held back by cruft from the language's early days.
There's too many languages that start of with good goals and design philosophy only to get fucked by bloat over time.

Oh and optionals and tagged unions.

Modesty modifiers, like the ones INTERCALL has.

google isn't being much help. Can you elaborate a bit ?

Bare metal no runtime
Borrow checker like rust
All pointer access is atomic by default, but due to the checker above, it's only applied on shared pointers
simple int i, auto& whatever looping
Erlang esque inter process / inter server communication

COMEFROM instruction. It's so useful, I don't know why more languages don't have it.

?

Datalog, but it's everywhere: the OS shell, RDBMS, email clients, ~ in Quake. Everywhere. I'll be a happier man and computing will stop sucking as much. Alas, in a way this is even harder than inventing a new programming language. It would take years of boring mundane commits to every piece of software I use, of forks and negotiations. Maybe I should build an OS from scratch with Datalog instead.

Are you inspired by D?

Oh, if I could I'd start much lower, with my own CPU. First of all it would be clockless, all instructions are assumed to be parallel(microcode would be probably serial though but it would be possible to compute what instructions don't depend on each other resulting in efficient out of order execution) with linear flow of code being explicitly stated, kinda like in monads. This would solve task scheduling, remove the need for the very concept of cores though I haven't decided yet how to solve task priority. All memory would associative solving register renaming, paging, swapping, position independent code, memory allocation, Numa and garbage collection. The assembly would probably be a high level language, something like Carp, though scope and state passing should be explicit for efficient caching, virtualization, debugging, task suspension and resuming. All peripheral hardware must expose an interface in that language or use a virtual adapter for legacy hardware. DMA and interrupts are strictly forbidden, everything must be handled though the event mechanism. Aside from the minimum instruction set any library functions could be implemented in hardware on demand, for example a GPU could be implemented as the same CPU with SIMD instructions implemented, the same code would seamlessly run on both. Same with priority, haven't decided what's the best way to implement affinity. Operating systems would be basically reduced to libraries and become interchangeable. After that language choice is irrelevant, though using some like C would be simply dumb and masochistic.

I have to check D. There are way tooany things I dislike on C++ (many core designs, majority of stdlib apis) and am afraid that D have copied them, I might have too many misconceptions about it.

And I thought I was too radical with dreaming about Mill.

Does that wall of text actually make any sense or it's just noise?

You can indicate flow control from an arbitrary point. Say you have one routine that adds one to the X register and it has a label ADDONE. Well in another routine you can issue a COMEFROM ADDONE and add one more to the X register (or do whatever you want) then jump back to ADDONE+1 when your done. Anyone who jumps to ADDONE will end up calling your COMEFROM routine, effectively patching ADDONE without reorganizing any code.
It's essentially GOTO in reverse.

So, function hooks?

It can allow the user to talk to God

Much more powerful than that, but the same concept.

Elaborate

I'd like a regexp that isn't sensitive to whitespace so I could properly fucking format it.

Good thread

that exists though

Give it a shot, read the docs.
I like the language a lot personally, but I mostly just wanted C++ but less fuck-retarded, and D delivers there.
It's very much seems like designed by people who sat down with a list of things they didn't like about C++ and gave their own effort at fixing it, but they also wanted something comfortable and familiar.

The fewest number of keywords possible

Piet.

swift?

I'd love to have more good reasons to use python now that I've started learning shell script. It would need to have all the syntax and useful features of Python but with the speed and system integration of POSIX shell script (so still not that fast)

en.wikipedia.org/wiki/INTERCAL#Details

>INTERCAL has many other features designed to make it even more aesthetically unpleasing to the programmer: it uses statements such as "READ OUT", "IGNORE", "FORGET", and modifiers such as "PLEASE". This last keyword provides two reasons for the program's rejection by the compiler: if "PLEASE" does not appear often enough, the program is considered insufficiently polite, and the error message says this; if too often, the program could be rejected as excessively polite.

so exactly what Nim is
nim-lang.org/

Sql syntax

blowjob

>A better way to do this would be to just clean up some bits of cruft and misfeatures in existing languages.
There are multiple widely-believed fallacies that make that impossible.
>muh backwards compatibility
For some weird reason, it's easier to sell an entirely new programming language that "doesn't have all the bad stuff the old ones did" than a new version of one of the old languages that drops a bunch of useless shit because refactoring is scary, even though rewriting from scratch in a new language usually takes more effort.
>b-b-but that shitty feature can be useful sometimes
People who spout this don't realize that there is a certain cost associated with adding a new feature, and this cost becomes greater the more features you already have. If a certain feature isn't able to offset this cost, it should not be added/should be removed/replaced if it's already present.

stricter-than-strict typing in the form of "promises", which can narrow down the return value of something into specifics, potentially allowing runtimes and compilers to look in advance at what is expected of it and jumping to conclusions

How do you do this without a bunch of null pointer exceptions? Stuff like optionals seems like it would be a violation of a stricter than strict typing system.

LINQ in dotnet basically does this already.

copy c++ but unfuck the build/link process and redo the syntax of template metaprogramming

Sounds like Swift has all this desu. Functions are just closures (named anonymous functions), has protocols and extensions, and you can map and filter to your hearts content. The only thing it's missing imo is a good way to write async code.

you must define in the promise that it can be null
just simple modifiers like that can be shorthands (like ?)

simple and consistent c-inspired syntax
channels
preemptively scheduled green threads
closures
defer
slices
bounds checking
multiple return values
named return values
hash tables
interfaces
explicit fallthrough
name before type
type assertions
trivially easy cross-compilation
fully featured standard library
good tooling

Looks like just noise to me.

I don't understand how an object type isn't a promise. I get the nullable types though.

Every statement should have a valid and logical evaluation. Like if statements should work like a ternary operator and for loops should become arrays

x := if y then 5 else 8

array := for x in for y in z{y}{x}

well for example "string?" would get exploded into this promise (pseudocode):
{
return is string ||
return is null
}
in that sense, type definitions are just stackable shorthands for parts of promises

you're describing static typing

This, except Ruby instead of Python. That is to say: Crystal.

well no, promises can also have more specific rules (e.g. "return > 10"), exception types must also be part of promises (like Java), method parameters also have promises of their own (as they, too have types), etc.
that way, code essentially documents itself

Swift and kotlin already has this

i'm more of a chan int guy myself

You want monade and powerful type system.
Basically, you're asking for Haskell

I'd make it so black people could use it as easily as white people could, for equality

literally signal handlers (also Lisp condition)
also just pass in a function pointer

en.wikipedia.org/wiki/COMEFROM
Proves that lisp is a joke.

Anything different that has a pratical use.

I don't a sollution to a problem. I want something I didn't knew I needed.

Attached: sample_9b3b4db972c684a82cd58f0f03cf17e27a320ce7.jpg (850x1038, 137K)