Sign into an existing account

https://flix.dev/

It has all the features other languages can only dream of.

Including:
- extensible records (doesn't exist in almost any other statically typed language)
- algebraic effects (to capture IO and other side effects by the compiler)
- type classes (like in Haskell or Scala)

Sadly I don't have time to write wrappers for the hundreds of libraries I use already with my current language of choice to consider switching to it, but looks interesting.

Standard ASCII is one byte per character, ending at 0x7F, which gives just about enough space for control bytes, spaces, punctuation and uppercase/lowercase Latin.

Extended ASCII uses the upper half to include some accented letters, and there have been attempts to use dreaded "code pages" for switching alphabet entirely, but Unicode is the proper international solution... in return for accepting that the character encoding is no longer one byte each, and moreover may be variable width.

UTF-8 is proudly variable-width, matching ASCII in most documents while using only those upper half byte values to encode non-ASCII, a robust system which reduces impact when an unaware program reads it as ASCII. The variable width is an issue for a few types of program such as word processors, though most operations (copying, sorting, searching) need not care.

Then some butthurt happened in the early 1990s, and someone just had to insist on fixed byte width, and out popped UTF-16. Two bytes per character, costing a load of extra storage for most files, and absolutely no plan for what happens when we reach 0xFFFF. Java, C# and JavaScript all signed up to it for their fixed width string storage.

The Unicode character space started getting flooded with every alphabet in existence with all the durka durkas and the ching chang chongs, and symbols for mathematics, music and such. It looks to me that they got up to 0xD000 before admitting that it is going to run dry.

The solution? Reserve 0xD800 to 0xDFFF... for using pairs of characters in that range to represent 0x10000 and above. So, a variable width encoding.

This is indeed literally as retarded as having to use a gas-powered generator to recharge an electric car.

Even worse, the UTF-8 system could store Unicode up to 0x7FFFFFFF, but that UTF-16 extension only takes it up to 0x10FFFF, and now Unicode itself specifies 0x10FFFF as the limit just to appease UTF-16.

UTF-16 has fucked everything up for zero benefit in return. Even C++ has an entire wide-string type and string library suite for it which is widely known as a massive trap to avoid and put UTF-8 bytes inside normal strings instead. Windows purports to use wide-strings for files, but it is broken.

Python (a.k.a. programming for niggers) 2 tried to "help" with Unicode in the same way that cats "help" ensure that everything is knocked successfully onto the floor. Python 3 sort of behaves itself, while in the background it insists that if a single string character would be multi-byte in UTF-8 then the entire fucking string gets converted to a fixed width encoding big enough for that. Actually that is really a different manifestation of insistence on fixed width rather than UTF-16 specifically, but that type of thinking is still the problem.

UTF-16 must be destroyed.

using System;

namespace EventDelegates
{
public delegate void DelItemProduced(int item);

public class producer{
public event DelItemProduced onItemProduced;

public void produceItem(){
Random r = new Random();
for (int i = 0; i < 10; i++){
onItemProduced( r.Next(1,10) );
System.Threading.Thread.Sleep(1000);//wait
}
}
}//end class producer
public class consumer{
public void consumeItem(int item){
Console.WriteLine("item produced: " + item);
}
}//end class consumer
class Program {
static void Main(string[] args)
{
producer p1 = new producer();
consumer c1 = new consumer();

p1.onItemProduced += new DelItemProduced(c1.consumeItem);
p1.produceItem();
}
}//end class program
}

All of my contact with Python is to fix broken stuff, where most of the time the fix is to start over with a better platform. Every time I end up having to use it, I find new failures in its design which are even more mentally retarded than the time before.

Reliance on white space is colossally retarded and it imposes the need for a `pass` keyword. Anyone who thinks it is possible to force programmers into writing legible code that way is a colossal retard.

Like most pretentious garbage it changes many classic reserved words, just enough that the number of complainers does not rise above half the users. `throw` is `raise`, `catch` is `except`, `null` is `None`, `true` is `True`, `false` is `False`. So much for keeping to a lowercase style when you can use capitals just because those are constants rather than keywords.

Inconsistently, it retains `==`, `!=` and `^` but changes `&&` to `and`, `||` to `or` and `!` to `not`.

Despite being popular for data processing, it cannot thread. It has something called threads, but this is only useful for I/O, because its "global interpreter lock" fundamentally can only run one line at any time. The autistically screeched response is to run extra processes, but its attempt at shared memory is also total ass. All the data popularity comes from being a front end to NumPy, which is written in C.

Lambdas? Only if the result can be written in one expression, no statements allowed.

Class constructor? Some nigger decided to name that `__init__`.

Anonymous object? It was supposed to work but doesn't, but you can `import types` and use `types.SimpleNamespace` instead, that works. Unless you want methods with statements in, then you need to use `def` and pass in all scope variables.

No pre-increment or post-increment. `+=` works, but you can't use it within a comparison test, because fuck you.

No `switch`, get used to `elif` nigger.

No do-while, make a flag or copy the fucking loop code.

No labels for `continue` and `break`, no numeric argument option, not even a fall-back `goto`. Guido himself said that this type of code is too complicated, by which he means he is too retarded to understand it, so fuck off and make a load of complicated flags and tests instead.

It doesn't even have the `===` operator like other languages with dynamic types, you have to test the types yourself... using `__class__` like a nigger.

No `static` keyword, but you can make a static method if you put `@staticmethod` on the line before. Genius.

You can have the ternary operator, but you have to put the test condition in the middle instead of at the front. Also `if` and `else` are reused for doing that, just in case you missed having a horizontal scroll bar.

That much is only what I have learned while otherwise trying to avoid Python.

Fuck

How they presented themselves: https://www.thetapestryhouse.com/media/transfer/img/william_embarks_bayeux_tapestry_metth005.jpg

How Jews present them: https://thunderclam.files.wordpress.com/2011/10/1.jpg

"Most people in the Middle Ages wore woollen clothing, with undergarments (if any) made of linen. Among the peasantry, wool was generally shorn from the sheep and spun into the thread for the cloth by the women of the family. Dyes were common, so even the lower class peasants frequently wore colourful clothing."

They had better clothes than we do.

wouldn't it be nice to be able to run some basic pre os kernel api before your computer started no matter what BIOS and without suffering through terrible documentation.

https://pic8.co/sh/oEnnlL.gif
Hehehe. Programming's COOL!

https://news.ycombinator.com/item?id=37955264

@system might be worth a read