Shill for 'fringe' programming languages

P E R L
- the wizards choice

Nim
nim-lang.org/

Simula

Rust here

Nim a shit.

Discipline yourself into making better software instead of using tools that are just hyped memes.

Ada has always interested me as being both highly readable and in the top tier of high performing language implementations.

I put myself off from learning it though, because I feel the only opportunity I would have to use it, would be for hobbyist projects, and being a complex language, I'm sure it takes a fair amount of time to learn effectively. Some day. Many will say just learn Rust instead, but I'm quite put off by their community, and rust still has yet to prove itself.

Enjoy your shell shock, heart bleed and perpetual Windows patches.

If C devs are so smart, why can't they write good code? Why do they call the users stupid when they were the ones who put the bugs and buffer overflows in the software?

Where did I hear that before ?
Anyway if C was has problematic has you suggest people would have stop using it a long time ago.

Idk user you tell me
Why are more and more devs who goes into Microsoft sponsored schools doing bad code ?
Even MIT has begun to teach shit.

Fringe isn't a synonym for bad.

Can you expound on these choices?

For one.. forum.nim-lang.org/t/2332/1
really dodged that bullet.

second... transpiled to C

and third, it's not rust.

Nice to see these days. Let me guess, the people who showed up demanding a CoC suddenly vanished as soon as they were shut down.

I don't know these class of languages, but I'm amazed when I see example code in APL, A, J, and K. I'd have to look up the differences, but their code examples often seem like random noise to me.

It runs most of the internet except garbage social media sites.

any resources on writing non-shit javascript? the crockford book ? or is that still in the trash category?

I'm keeping my eye on the Julia language being developed at MIT julialang.org. It seems like a very ambitious project:

Why? I mean, they have their reasons, maybe good reasons too, but I can't see why you would need a built-in package manager instead of downloading a library/module and put it in a known directory, like you do for C
Can someone tell me the advantages of a built-in package manager? Julia isn't the first language doing it

le brainfuck XD

If a project I want to install has ten dependencies then I suppose I could download all those ten dependencies and put them in their directories, but if I can just run "pkgman deps-install" and have it all done for me with the correct versions and origins guaranteed and updates of dependencies executed by another single command that's quite a bit nicer.

Fortress was an old chimera hybrid of Fortran fuck all of you Fortran's fun as hell to mess around in and Haskell, but it was screwed over via the office politics clusterfuck between Sun, Oracle, and DARPA. The majority of development stopped in 2012, 5 years ago.

Holy shit, this language is fucking impressive
- Spaces only, no tabs
- No case fall-through
- Operator overloading without class garbage
- Extensive metaprogramming

Unless you're using LFS, your distro has a package manager already. If you use things like AUR anyone can add a package, so even if the lib only has ten users you can find it there. That's much simpler than having to deal with one package manager for each language.

Can you name something like the AUR that's actually cross-platform? If the lib has ten users that might not mean that any of them use Arch. Realistically, even if the lib has a thousand users there's a good chance none of them is an Arch user who cares enough to package it for the AUR.

Exactly this. And unless a library is written in or has bindings or C, it's useless clutter for everyone else not using that particular language.

Any library is useless clutter for things that don't use it. That C-centrism is a ridiculous red herring.

this

why tabs is still an option with other programming languages, I have no idea.

anyone up for DSLs?

Like, Hermetism in programming languages?

i suggest ROS. ROS is a collection of tools and libraries for robotics. it isn't under appreciated but may be less well-known on Holla Forums. if you want to do anything serious in robotics it's industry standard.

ros.org/

you should learn it so you can get a job and stop pajeet from taking the poo to robotics which is a respectable goal.

inane. opinion discarded.

thank you for posting this. i looked at it briefly but had forgotten about it. nim interests me.

This this this this
I was able to create a small PoC in my first day of Nim, something like this for a web framework:
route "/{board}/{thread}": result = Renderer.from_template "board/thread.html" {"board_uri": board, "thread_id": thread}.toTables
it doesn't work but it compiles to this:
proc route_func_8daf2827e(request: Request, board: string, thread: string): HttpResponse = result = Renderer.from_template "board/thread.html" {"board_uri": board, "thread_id": thread}.toTablesroutes.register "/{board}/{thread}", route_func_8daf2827e
which is very nice.

ocaml

It's a functional language (not pure though). The core system is a typed lambda-calculus with Hindley-Milner inference and inductive types (that can be parametrized by other types).
In other words, when you code standard stuff, you don't have to type the types of stuff, ocaml guesses it automatically, and functions can be polymorphic. Inductive types allows you to create all kinds of algorithmic structures easily (lists, trees, hashtables...), and you visit the structure throught exhaustive pattern-matching.

For instance, if you want to code the function that returns the type of a list:
let rec length l = match l with | [] -> 0 | x :: l' -> 1 + (length l') ;;
Here ocaml automatically infers that the type of length is 'a list -> int ( 'a is a polymorphic type, so 'a list is a polymorphic list). Also, ocaml spergs out (muh security) if you don't consider all the cases in the pattern matching, and if the typing is incorrect (the only problem is that it is a chore to mix integers and floats).

It's right between Haskell autism and normal programming because you can also put imperative blocks in your code.
Also it has an OOP thing, a module system (a bit like Java interfaces, but more autistic), exceptions and such.

ROS is the thing spamming the gentoo package feed with thousands of entries, that's what it is to me.

Does it have a parallel computation thing? It's 2017;)

What's the big selling point of Ocaml vs something like Rust?

"it's not rust" is a big selling point on its own :^)

Well, it exists since the 80's, it does not try to mimic C, unlike Rust which tries to glue C, ocaml and haskell together.
As for parallel programming, it has POSIX threads and all the unix stuff, but there's nothing ocaml-specific.

See realworldocaml.org/v1/en/html/prologue.html#why-ocaml

Thanks I'll take a closer look at this. I studied Haskell quite diligently a few years back, so curious to see a more "real world" ML type language.

Still going to look into OCaml more, but there's some criticisms pointed out here that make me less enthusiastic. For my particular use case, Julia is probably more appropriate.
reddit.com/r/ocaml/comments/3cwn7i/ocaml_for_scientific_compution_why_not/

Sounds neat. Is it easy to pirate without ending up with malware?

Impressive. I had to fuck a Latina to create a small PoC, and it took 9 months.

>I'm keeping my eye on the Julia language being developed at MIT julialang.org. It seems like a very ambitious project:

So was the Third Reich. And look how that turned out. You might want to read this before investing a lot of time in Julia:

zverovich.net/2016/05/13/giving-up-on-julia.html

It certainly used to be. I pirated it for years before I started earning a nice living.

It has to go back.

Right in the feels. Yeah that does sound disappointing, and I was a bit suspicious when I saw that list of goals.

Perhaps you should interpret that as a polite suggestion to stop larping as tech and start programming. Only YOU can prevent pajeets turning tech into a designated shitting street.

Scheme. A lot of people know about it, some know it, and hardly anyone really uses it for serious programs, or even popular hobby-projects. Of course a big part of the problem is that every implementation differs so much, but it wouldn't even matter to me whether Chicken, Chez, Guile, or whatever would be the one to get a huge following, (though Chez is best :D) but I'd really like there to be a more active community around the language.

Of course there's also a purely functional Scheme, Owl. I'd really like to see more usage of it but I'll have to be honest in that the only reason I know about it is because I was searching for a purely functional Scheme.

i haven't used scheme but i used common lisp (ecl) when i was doing sicp and enjoyed it.

from the zverovich article
THIS
i messed around with julia a year or two ago but she doesn't offer much i can't get from a python + numpy + scipy combo. python + numpy + scipy should be your default when considering numerical and scientific computing. use julia, or octave as a last resort if for some reason you can't go with python. fuck matlab, proprietary language, avoid at all costs.

Ada: I have no experience in this language, but the examples I've seen make it look very attractive: rosettacode.org/wiki/Category:Ada With performance up there with C and C++, except with much better safety, it would likely be well suited for things I want to write. The downside is that it doesn't seem popular outside of defense dept affiliated companies, although PHP is popular and look how shit that is. Rust seems like a modern alternative, but it is still unproven and even if avoiding SJW were the ONLY reason to avoid Rust, I'd still take it.

I'm also going to shill Ada.

Ada is a very big language and you probably won't use all of it in one program. Ada is designed to prevent buffer overflows, dangling references, and memory leaks, and has many features that help you write secure programs. Ada can also be used for systems programming and supports low-level features like inline assembly and address arithmetic.

Ada has many kinds of numeric types and enumeration types, which you can define specific to your program. You can use the hardware standard types, but you can also define your own. Enums can include characters, so you can define your own kinds of strings. There are integer ranges, fixed-point, floating-point, decimal, modular, and more. If you want an array that wraps around, you can use a modular type for the index and don't have to worry about overflows. If you only need digits and a few other characters, you can tell the compiler to pack them into 4 bits or whatever the minimum is. Ada supports multi-dimensional arrays with any discrete type as an index. Arrays can be returned from functions without allocating them on the heap.

Ada has packages, generics, classes, tagged records, interfaces, and a lot of other features which help organize your program and libraries. Packages also show you what parts of the language a program uses. Unsafe features are in separate packages than the safe parts. Tagged records are for method dispatching. Maps, vectors, sets, and math features like matrices and complex numbers are part of the standard library.

Almost every error in Ada has throws exceptions, like array indexing, stack overflow, running out of memory, and numeric overflow, unless you specifically turn them off.

This is so nice. I'm really fussy about standard libraries, and it pisses me off that in C++, their standard is often bemoaned by its users, leading to a reliance on boost. Working through the Ada2012 book at the moment, I think I'll write a simple shell as a first project.

Rust, though it's becoming kind mainstream, which is good. It's not perfect but it comes damn close in my opinion.
Idris, it's shaping up to be basically rust if the default was a gc instead of ownership. It also supports unique types and borrowing, like rust. In principle this allows the GC to stop during sections of the program because no allocations are performed, and so on, which may relieve some of rust's most annoying parts if it works out. Based on haskell though.

Why does Ada attract so many LARPers? Sour grapes over Rust TBHWY

Julia is promising but has not been proven... at all.

Sounds like you're bitter that Ada is still well above Rust in the TIOBE index.

Sour grapes? Ugh, let me know when Rust is powering aircraft control systems and not "safe spaces". Ada is a proven technology, time will tell how Rust fares.

Tabs can be adjusted to any width by other people. What's the point of indentation if you're going to use 2 spaces or 3 spaces, and as a result have your code look like badly structured sideways mountain of spaghetti.

Julia

It's not finished (or at least doesn't feel like it is), but I believe it has potential. Right now I only use it as interactive shell as my calculator, which it's perfect for.

D
It's C++ without the BS.

...

It was hard but not impossible, they've made it easier now.

But the stdlib still has it enabled. Until the gc is rewritten to get rid of it (never ever, they've been trying forever), it's still forced gc.

I came here to shill D as well.

Why? Because it's like C, but fixes most of C deficiencies, at the expense of backwards compatibility.

C++ expanded on C, but kept all its flaws and added a metric shitload of its own. D first fixed C then it started to augment it.

dlang.org/ctod.html

I'm also gonna shill D. It's just so fun to code things in. It's so nice and easy to express things in, you can honestly use it as a scripting language. I use it in any programming competition I can. ranges, slices, powerful template stuff...

tour.dlang.org/tour/en/gems/uniform-function-call-syntax-ufcs
p0nce.github.io/d-idioms/

What are you even doing that's too realtime for a GC?

Take your pick.

#define ARRAY_LENGTH 17
int array[ARRAY_LENGTH];
for (i = 0; i < ARRAY_LENGTH; i++)
array[i] = value;

versus

int[17] array;
array[] = value;

Holy shit, this D thingy that wumyn always talk about seems like the real deal all of a sudden!

...

Well, luckily for you, you can just not use it, or turn it and druntime off entirely. For math, you can use the -betterC flag and the Mir libraries (github.com/libmir). Benchmarks are showing these to be insanely fast in their field, apparently (I don't know anything about heavy math programming).

The way the GC works, if you never allocate on the heap using it, you'll never get pauses. If you want to keep druntime but still stay away from the GC, you can just use custom allocators. Games, kernels, and Android apps have all been been written in D (though, with the GC off for the first two).

Not this user, just having more remarks on D language, and also being interested in the "better C" aspect of it.
In my experience D has a bad shared library support. Contrary to what's documented on the site, "shared static this()" in libraries does not work, at least not right away. Shared libraries which are dynamically loaded from C programs must initialize the D runtime themselves.
But if it's Linux in particular, shlibs rely on the same instance of druntime, and need special care not to get in each other's feets.
Look for instance what gymnastics and crappy workaround the dplug framework has to go through to get its initialization working.
github.com/AuburnSounds/dplug/blob/master/core/dplug/core/runtime.d

Now if the requirement for druntime and GC can be eliminated (I wouldn't consider this a big lack myself), the problem is also eliminated. I should try this, but I hope that doesn't break thread local storage, which relies on druntime to my knowledge.

With that said, I'm also disappointed in D as a "better C" language because its type system allows null references.
But on the other hand, CTFE, bounded genericity, etc..

Hm, that stinks. I'd hate to get rid of the druntime and GC in my own code. It's all just so... nice. I don't do much of anything that's realtime so I very happily use the GC because of how easy it makes things.

They do seem to be trying to make D more and more betterC friendly. The guy behind the Mir libraries pushes it really hard lol.

Any of you D fans tried using it for web development?
vibed.org

Are there any plans for D to get keyword arguments in the future?

Yes but not much more than Hello world.
I have to applaud Vibe.d devs for being among those who get template systems right, and by that I mean AOT compilation.

I used it for my group project for my Databases class! We had to host a web server that would be able to perform SQL queries, display results on the webpage, etc. Diet templates are really cool. Our professor recommended we do our projects with XAMPP but you'd sooner find me dead than doing anything in PHP. It's a pretty neat library, I'd say. No idea how good it is for professional use, but it was pretty pleasant to work with.

If PHP is something people consider "professional use", anything that prints text and performs SQL queries is no less "professional" than it is.

Forth. I think it's a good hobby programming language because it's minimal so doesn't require a massive time investment. The gforth implementation is very popular now, and runs on UNIX & Windows. Like learning a lot of languages, even if you never use it commercially it may make you a better programmer--Forth should teach you how you don't need a lot of the features that are considered "essential".

Also, unlike the similarly minimal Oberon & Scheme, there are commercially-supported compilers if you want to try make some money.

Clojure
It's functional, dialect of lisp, dynamic, immutable with repl driven development and can interop with anything in its host language

You forgot to mention that this is all meaningless without rewriting a stdlib that doesn't use the gc. Also mir is crap (both in features and especially performance) compared to c and c++ options, which most even otherwise very slow languages (such as python) use either as binding or as ad-hoc fast backends.