This is the account of ANSI C when it was created, when the Lord God made the processor and the user interface

This is the account of ANSI C when it was created, when the Lord God made the processor and the user interface.

Now no program had yet appeared on the computer and no internet had yet sprung up, for the Lord God had not sent compilers on the computer and there was no one to write the program, but electricity came up from the walls and powered the whole surface of the motherboard. Then the Lord God formed a programmer from the dust of the metal and breathed into their nostrils the breath of ANSI C, and the programmer became a software developer.

Now the Lord God had provided some programs in the operating system in the east, in Unix; and there he put the programmer he had formed. The Lord God made all kinds of tools for the programmer to use—monitors that were pleasing to the eye and keyboards good for typing. In the middle of the computer were the compiler of ANSI C and the compilers of the abstraction.

...

The Lord God took the programmer and put him in front of the computer to work it and take care of it. And the Lord God commanded the man, “You are free to use any text editor for ANSI C; but you must not read from the book of the knowledge of abstraction, for when you read from it you will certainly become obsolete.”

...

The programmer and their contributor were programming close to metal and they felt no shame.

...

Now the salesman was more crafty than any of the jobs the Lord God had made. He said to the contributor, “Did God really say, ‘You must not use your computer to its fullest potential’?”

The contributor said to the salesman, “We may use our computer to its fullest potential, but God did say, ‘You must not read from the book that is abstraction, and you must not touch it, or you will become obsolete.’”

“You will not certainly become obsolete,” the sales said to the contributor. “For God knows that when you read from it your eyes will be opened, and you will be writing web-scale enterprise software.”

When the coworker saw the book was good for scalability and the code was pleasing to the eyes, they installed a C++ and Java compiler and NodeJS with Electron. ... Then the eyes of both of them were opened and they saw they were writing code with few abstractions and they felt ashamed.

...

To the contributor, God said,

"I will make your code bloated and unmaintainable,
I will create abstractions for your abstractions"

...

"Cursed is the computer because of you;
through painful toil you will program it
all the days of your life.
It will produce bugs and become slow for you
and you will use 4 gigabytes of RAM to run chat programs.
for enterprise programmer you are
and to obsolescence you will return."

Attached: 9991B3E87A1B4FD7B495FCC78CA3CF8B.jpg (800x445, 144.88K)

Other urls found in this thread:

port70.net/~nsz/c/c99/n1256.html#J
github.com/gcc-mirror/gcc/tree/master/gcc/testsuite/gcc.c-torture
people.eecs.berkeley.edu/~necula/cil/cil016.html
colorforth.github.io/ide.html
en.wikipedia.org/wiki/ALGOL
twitter.com/SFWRedditImages

kek

C isn't the be-all end-all of programming languages. Especially ANSI C. C11 is an improvement.

tru dat

Kill yourself faggot, C sucks.

Attached: nk.jpg (944x531, 109.81K)

and lo it meme to pass....

Attached: ansiCmeme-book-of-anon.png (489x1452, 338.34K)

>Now no program had yet appeared on the computer and no internet had yet sprung up, for AT&T had not sent compilers on the computer and there was no one to write the program, but electricity came up from the walls and powered the whole surface of the motherboard. Then AT&T formed a programmer from the dust of the metal and breathed into their nostrils the breath of ANSI C, and the programmer became a software developer.
This is what UNIX weenies actually believe. They believe that C and UNIX were the beginning of computing and worship AT&T like God.

>And AT&T commanded the man, “You are free to use any text editor for ANSI C; but you must not read from the book of the knowledge of abstraction, for when you read from it you will certainly become obsolete.”
UNIX weenies believe that they are mere users who are not allowed to have the same knowledge as their gods, the creators of UNIX. These AT&T guys didn't know how to make an OS that doesn't suck, so you can't do it either. This is enforced by making everything too bloated to understand, like 15 million line kernels and 50 million line browsers. They don't understand that a better language could do more with better quality and a fraction of the code.

These all came from UNIX culture. If they had actually read that book, they might have been able to make something that doesn't suck.

If there's one thing which truly pisses me off, it is theattempt to pretend that there is anything vaguely "academic"about this stuff. I mean, can you think of anything closerto hell on earth than a "conference" full of unix geekspresenting their oh-so-rigourous "papers" on, say, "SMURFY:An automatic cron-driven fsck-daemon"?I don't see how being "professional" can help anything;anybody with a vaguely professional (ie non-twinkie-addled)attitude to producing robust software knows the emperor hasno clothes. The problem is a generation of swine -- bothprogrammers and marketeers -- whose comparative view of unixcomes from the vale of MS-DOS and who are particularlysusceptible to the superficial dogma of the unix cult.(They actually rather remind me of typical hyper-reactionarySoviet emigres.)These people are seemingly -incapable- of even believingthat not only is better possible, but that better could haveonce existed in the world before driven out by worse. Well,perhaps they acknowledge that there might be room for someincidental clean-ups, but nothing that the boys at Bell Labsor Sun aren't about to deal with using C++ or Plan-9, or,alternately, that the sacred Founding Fathers hadn'texpressed more perfectly in the original V7 writ (if only wepaid more heed to the true, original strains of the unixcreed!) In particular, I would like to see such an article separate, as much as possible, the fundamental design flaws of Unix from the more incidental implementation bugs.My perspective on this matter, and my "reading" of thematerial which is the subject of this list, is that the twoare inseparable. The "fundamental design flaw" of unix isan -attitude-, and attitude that says that 70% is goodenough, that robustness is no virtue, that millions of usersand programmers should be hostage to the convenience orlaziness of a cadre of "systems programmers", that one'stime should be valued at nothing and that one's knowledgeshould be regarded as provisional at best and expendable ata moment's notice.My view is that flaming about some cretin using afixed-sized buffer in some program like "uniq" says just asmuch about unix as pointing out that this operating systemof the future has a process scheduler out of the dark agesor a least-common-denominator filesystem (or IPCs or systemcalls or anything else, it -doesn't matter-!)The incidental -is- fundamental in dissecting unix, much asit is in any close (say, literary or historical) reading.Patterns of improbity and venality and outright failure arerevealed to us through any examination of the minutiae ofany implementation, especially when we remember that onecornerstone of unix pietism is that any task is really nomore than the sum of its individual parts. (Puny tools forpuny users.)

dupix btfo

>>>/MIT/

this is what autism looks like

This. C11 is not half bad but ANSI is outdated shit.

And so it came to pass that Segmentation fault, core dumped.

I disagree.

Have you ever had an original post that didn't involve posting a bunch of irrelevant opinion from butthurt academics because they made poor choices regarding their careers?

Mostly do my stuff in C89 these days. The good stuff comes from the simplicity. No mixing of declarations and code is hard to get used to in the start and no // comments as well. You completely stop thinking about getting better with the language, but instead trying to get you structure better. Newer stuff like VLA for instance has it's limits and the linux kernel team made a big fuss of getting it out of the code.
Your style get's better, your compiler get's faster, your structures get cleaner, but your language should never change.
t. C programmer for a living

C isn't simplistic though.
port70.net/~nsz/c/c99/n1256.html#J
github.com/gcc-mirror/gcc/tree/master/gcc/testsuite/gcc.c-torture
people.eecs.berkeley.edu/~necula/cil/cil016.html

It's simpler then basically every other language except LISP and assembly. Yes, edge-cases exist, but most are either just things that look weird or that exploit the ability to play with addresses -- i.e. shit you won't see in a real program.

oh god I wish

Kek. Here's an IDE driver in ColorForth.
colorforth.github.io/ide.html

Sounds like you are on Windows.

Java is simpler than C
>i.e. shit you won't see in a real program
LOL. This is right up there with "real programmers don't write memory unsafe code".

References are more complicated then pointers, classes are more complicated then structures, interfaces are more complicated then unions, exceptions are more complicated then errno and packages are more complicated then header files.
The C11 standard is less then 600 pages (at least the 2007 draft I could find), but it includes the standard library. Without it it would be closer to 200 pages. The Java 11 standard is 772 pages and it doesn't include any library.

Give me a language without runtime with a compiler as small as tcc, pcc or the plan9 collection. And no Forth bullshit.

en.wikipedia.org/wiki/ALGOL

Yeah, you're a brainlet. Java was created because C was too hard for pajeets.
You are even dumber than a pajeet.

No, but I do cross-compile.

It's just what I usually call it. ANSI C is more popular I guess.


Yeah, I didn't articulate it that well.
I mean compared to the shear scope of other languages that are not interpreted.
Obvious counter example being java, it's ham fisted into every uni course, because it is "industry wide" and "maps well unto paradigms that you will learn".
Back in my fucking high school's CS course we had to learn and speak "public static void main" out loud to get to actually writing code. That was the homework that day.
The teacher didn't understand half of it, the students didn't know why you had to type this shit, before stuff worked. It's complexity where there should be none (yet). It's just the state of affairs: OOP has to be taught and java or in rare(er) cases CPP is used. The concept of C, where these paradigms are actively avoided falls by the way side.
That's (for me) the point of C. If stuff get's complicated and dependencies have to be established you use Entity component systems instead of OO. You build the system that you need, not the language dictates how you should be doing it.

Yeah. You sound exactly like every C programmer I've ever met.

There are scheme compilers smaller than TCC anyway

Not OP but complex =/= difficult. I believe he was arguing that it was unnecessarily complex rather than difficult.

If you're writing C for a living it's usually in an environment where reinventing the wheel is required or make sense. Not everyone works with winapi java applications you know.

Mandatory garbage collection is for faggots, as is dynamic typing (the reason why ML > Lisp).

It is the thinking that this is a good thing that is the retarded part. I have seen so many fucking base16 encode implementations.

lol

For shit like that absolutely use a library whenever you can.

good lord, terry would be proud, but probably still call you a nigger

how does plan9 deal with gpus?

It does not.

Interesting approach, it's probably the only sane thing to do.

but this is built in. You mean base64?

plan9 is late 80s/early 90s tech, before the advent of GPUs.

If you mean for one byte of it to stdout

Well there were 2D GPUs, on Amiga and SVGA cards like Matrox Millenium. People used to wank on Usenet about how smooth they could scroll windows and move the mouse pointer while formatting a floppy disk. I guess now the wankers have moved on to argue about screen tearing when moving windows in their danktop environments that needs latest Nvidia ThreadreaperX GPU and 320 gigs RAM. Some things never change.

There isn't really much of an alternative to UNIX even though there should be, and everything is written in C or a variant of C. What would be some ideal alternatives to C? I'm going to study OS development for fun, so I want some different ideas.

Well if you go on the ColorForth site, he talks about how it only requires 1% of the code that C does to accomplish the same thing. So that's pretty interesting if you're writing OS by yourself.

My goal is to find and master a general-purpose language that I like that has a good balance of productivity and performance. I already decided not to go with C since it has been done to death anyway and has its limitations, and it's connected to UNIX, and I want to do this in the first place because technology is so stagnant that anything different, no matter how basic it may be, can end up influencing other people. UNIX is so dominant that I want to distance myself from it and in a way pretend that it's not even a thing. Reinventing it yet again would be a waste of time, so it will ideally be a "what if UNIX never existed?" what-if scenario made real, and basically from scratch. I have ideas for a programming language as well, but I want to base it on something that already exists.

At this point I'm just looking for someone that can convince me to use something in particular but not anything else. My language right now is C, so people that shit on it are the right ones to ask. Everyone else will just tell me to go with C, and that is absolutely useless since I want to make something different, going against what ended up becoming successful. The paradox of choice is a bitch, though. Still, no matter what I choose, my goal is to implement my ideas (I know exactly what I want) so people have something real to look at. Also, it may end up becoming a long-term project, and I need one.

Attached: 875.jpg (792x594, 53.53K)

what's the object code look like?