Is the world ready for a system based on the ideas of smalltalk and Xerox Parc? We have the technology now. The tech community basically reinvented every from Xerox Parc in a shittier way by sticking with Unix derived systems and Windows. Computing needs to grow up.

Other urls found in this thread:

I've been getting good enjoyment out of my Pepino board running Project Oberon. This was originally written as a cheaper/cleaned up version of the Alto workstation. There are emulators to get started without spending money but you'll need to read the book & docs, it's quite different to other OSes to use.

Probably not, people who hold power want world to go towards "easy to use" and "everyone is programmer" route so they can reduce wages of great programmers.

How is it different?

Even good OOP is bad.

What do you mean? I've have seen huge projects written in OOP but not in C.

Pajeet pls

Xorg? Linux kernel? 90% of linux apps? faggot

C is a mess that no longer works in the modern world. Generation after generation of programmers keep making the same mistakes, buffer overflow errors. C is a security disaster.

Object-oriented programming is fine when you're working with things that are, essentially, objects. I've accidentally written a more-or-less object-oriented program without using OOP language features (although the language I used offered a lot of them) and it wasn't pretty.

Java-style OOP is bad, but that's not all there is to OOP.

How is that relevant to this particular discussion?

Some details are in

It's similar to acme on Plan 9 (or its clone wily on UNIX). You can type text into any frame, then middle-click a string like Missile.Launch to call a procedure "Launch" inside a module "Missile". All code is dynamically linked, like Inferno, there are no libraries/main programs but it works better than you'd imagine. Relies on language design rather than hardware features like an MMU for reliability/safety--I'm unimpressed with Rust's complexity when they try to do the same.

The system is very simple, it's intended for teaching. Slightly reminiscent of an ST or Amiga IMHO. A2 is supposed to be an extended descendant usable for real work, but I haven't got that far yet. I'm still happy enough working on the simple version.

Please explain further

Java is bad because it runs an entire environment for every single program that Java executes in, designed to let the same exact code work on all platforms because they all just get their own version of JRE. When you boil it down you're not running the Java program, you're running a Java VC that runs a Java program. The overhead this cases is totally out of control and represents everything bad with programming today.

And that's how it's been for the last 20 fucking years with Java.

Java's gospel of OOP is that there is "Inheritence, Encapsulation and Polymorphism". There are many counterexamples.

Inheritence is now often considered bad style, delegation may be easier to maintain. There are lots of languages (like the most common runtime on the planet, Javascript) that don't inherit classes at all but clone prototypes.

Encapsulation is better done by a module system, which is totally orthogonal to OOP. For example, SML has one and is functional.

Polymorphism, in particular ad-hoc has always been in Java. The parametric type, like generics, isn't particularly OO but was relatively recently added too.

I've seen arguments that OO is so poorly defined that the only thing you can rely on is late binding. I guess Java does a particular interpretation of that, but I wish it didn't force 10 other design choices on me at the same time.

Also, even if you limit yourself to class-based OOP, I forgot to mention the split between CLOS-like defmethod and "put your methods in the class definition" like Java.

Also, Common Lisp and some other languages like Perl 6 have a Meta-Object Protocol. Personally, I think publishing this for programmers to use is a bad idea for maintenance, but it's intellectually impressive. You could appreciate Kiczales book the same way you might appreciate a theorem.

I just want a modern LISP machine.

GNU Emacs (^:

Dynamic typing is shit. You'll get your wish when they make you write your programs in JavaScript.

Dynamic typing is fine, at least for interpreted languages. Javascript's style of weak typing (which is not the same as dynamic typing, C has static weak typing) is a problem.

Dynamic typing is when a variable can be any type. If performance isn't very important that is nice, because it means you can write very generic functions.

Weak typing is when types are implicitly converted. C does this a lot - you can treat a character like an int, or a memory address of a float like an int, or a long long like an int, and it will convert it for you. It's the programmer's responsibility to make sure it won't blow up.

Javascript does a "smarter" kind of weak typing where it automatically converts strings to ints. That makes sense for small webpage manipulation but is awful for many other things.

Me I don't even care about the hardware, I want a decen lisp OS, something like a port of Genera to x86, native.
Or even better a modern Lisp OS based on Genera
Why is life so cruel?

I want no typing. Instead you declare a size when instantiating a variable. After all memory is just bits. You can toggle between float and int math at will. If you want to convert data from the IEEE 754-2008 standard to an integral complying with the ECMA-372 standard you will have to say so explicitly. If you want to do int math on two 32 bit variable and then use a float interchange to convert it to halve the values memory space you should be able to do that easily, or to treat some data as chars. Merging data and splitting it up should also be easy its all just bits.

I want sections of code in the ide to change colors based on the number of cycles they are expected to take. We have the horsepower, just compile and run as frequently as possible in the background.

There needs to be easier ways to generate useful self modifying machine code. I am of the opinion that the majority of clock cycles spent executing code are redundant and if programs were more aware of themselves as they ran you could easily get tremendous performance boosts.

Part of me hopes mores law will fail hard and soon so people can again focus on software performance instead of just throwing more cpu at the problem until it goes away.

This is the way of proprietary software. The owners of Genera do not want just anybody to use it, they want to control exactly who is allowed to use it. It's obvious that other people didn't care about Genera as much as the alternatives.

What did he mean by this

These words have different meanings in the Lisp school and the math school.

You're using the Lisp school meanings.

In the math school, dynamic typing is when there is only one type and weak typing is when the same underlying object can be reinterpreted as a different type.

That webm is beautiful holy shit.

No, it's a curse. It cripples their performance and massively increases debugging work in larger programs. There's no reason interpreted languages have to be slow, but when built around dynamic typing and GC they have to be.