Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon. Entire thread

UNIX the Ultimate: standing on the shoulders of midgets

Name: Anonymous 2017-07-07 1:47

Name: Anonymous 2017-07-07 3:54

Text is the universal interface. Dont parse la though.

Name: Anonymous 2017-07-20 14:51

« ISO C++11 Published
2000 Interview: Dennis Ritchie, Bjarne Stroustrup, and James Gosling »
Dennis Ritchie

2011-10-12 by Herb Sutter

dmr (Dennis Ritchie)

What a sad week.

Rob Pike reports that Dennis Ritchie also has passed away. Ritchie was one of the pioneers of computer science, and a well-deserved Turing winner for his many contributions, notably the creation of C — by far the most influential programming language in history, and still going strong today.

Aside: Speaking of “still going strong,” this is a landmark week for the ISO Standard C Programming Language as well. Just a couple of days ago, the new C standard passed what turned out to be its final ballot,[*] and so we now have the new ISO C11 standard. C11 includes a number of new features that parallel those in C++11, notably a memory model and a threads/mutexes/atomics concurrency library that is tightly aligned with C++11. The new C standard should be published by ISO in the coming weeks.

[*] ISO rules are that if you pass the penultimate ballot with unanimous international support, you get to skip the formality of the final ballot and proceed directly to publication.

Bjarne Stroustrup made an eloquent point about the importance of Ritchie’s contributions to our field: “They said it couldn’t be done, and he did it.”

Here’s what Bjarne meant:

Before C, there was far more hardware diversity than we see in the industry today. Computers proudly sported not just deliciously different and offbeat instruction sets, but varied wildly in almost everything, right down to even things as fundamental as character bit widths (8 bits per byte doesn’t suit you? how about 9? or 7? or how about sometimes 6 and sometimes 12?) and memory addressing (don’t like 16-bit pointers? how about 18-bit pointers, and oh by the way those aren’t pointers to bytes, they’re pointers to words?).

There was no such thing as a general-purpose program that was both portable across a variety of hardware and also efficient enough to compete with custom code written for just that hardware. Fortran did okay for array-oriented number-crunching code, but nobody could do it for general-purpose code such as what you’d use to build just about anything down to, oh, say, an operating system.

So this young upstart whippersnapper comes along and decides to try to specify a language that will let people write programs that are: (a) high-level, with structures and functions; (b) portable to just about any kind of hardware; and (c) efficient on that hardware so that they’re competitive with handcrafted nonportable custom assembler code on that hardware. A high-level, portable, efficient systems programming language.

How silly. Everyone knew it couldn’t be done.

C is a poster child for why it’s essential to keep those people who know a thing can’t be done from bothering the people who are doing it. (And keep them out of the way while the same inventors, being anything but lazy and always in search of new problems to conquer, go on to use the world’s first portable and efficient programming language to build the world’s first portable operating system, not knowing that was impossible too.)

Thanks, Dennis.

Posted in Opinion & Editorial | 79 Comments

Name: Anonymous 2017-07-20 18:55

>>3
C — by far the most influential programming language in history

There was no such thing as a general-purpose program that was both portable across a variety of hardware and also efficient enough to compete with custom code written for just that hardware.

How silly. Everyone knew it couldn’t be done.

go on to use the world’s first portable and efficient programming language to build the world’s first portable operating system

It's one thing to praise someone for their accomplishments and another thing to lie.

Name: Anonymous 2017-07-20 20:44

"(\.|[^"])*"

Name: Anonymous 2017-07-21 5:36

>>4
You seem to be missing the
>and also efficient enough to compete with custom code
Portable code was doable, but platform-specific code always beat it.
C was dominating all platforms because it beat their compilers at their own turf:speed and memory use. Back in 70's/80's this was the ultimate argument and platform-specific stuff slowly died with new standards and x86 processors getting to the top(486 was a breakthrough processor that made performance affordable for the average joe. I still remember playing Red Alert on it).

Name: Anonymous 2017-07-21 11:38

>>6
Early C compilers were not efficient. C originally didn't do any optimizations (see arguments about i++ vs ++i) and hardware was different. Unix was originally written in assembly and rewritten in C in 1973. Unix was not ported from the PDP-11 until 1977. Writing an OS in a high-level language was not a new idea anymore. C became important later, in the 1980s, because of Sun, which created the first Unix workstation, and Windows. That explains the huge gap between C's creation and standardization.

Name: Anonymous 2017-07-21 12:09

>>7
>Early C compilers were not efficient.
Nope. They were small, efficient, portable and really fast(10times faster than GCC)
https://en.wikipedia.org/wiki/Portable_C_Compiler
>C originally didn't do any optimizations
https://en.wikipedia.org/wiki/Portable_C_Compiler#Features
The first C compiler, written by Dennis Ritchie, used a recursive descent parser, incorporated specific knowledge about the PDP-11, and relied on an optional machine-specific optimizer to improve the assembly language code it generated.
and hardware was different.
But the C code was portable and fast.
>Unix was originally written in assembly and rewritten in C in 1973. Unix was not ported from the PDP-11 until 1977.
Thats right, but C itself spread beyond Unix.
All software stacks today begin at C layer.
>Writing an OS in a high-level language was not a new idea anymore.
Writing in fast, efficient language that was also portable unlike asm was new.
C became important later, in the 1980s, because of Sun
Nope. Its the K&R book that made C mainstream.
https://en.wikipedia.org/wiki/The_C_Programming_Language
>which created the first Unix workstation,
Which was a niche commercial product for the elite few owning expensive workstations.
>and Windows
At the time, DOS was the more dominant system.
>That explains the huge gap between C's creation and standardization
C was built and designed by hackers, they didn't like standards and bureaucracy.

Name: Anonymous 2017-07-21 13:17

>>8
You're arguing that it was PDP-specific and portable. Make up your mind.

Name: Anonymous 2017-07-21 13:44

>>9
The distinction between an implementation and language is lost on you?
A C compiler could be non-portable, but C as language will be portable.
Imagine Intel C/C++ compiler. Its obviously x86-Specific.
It has tons of optimizations and will compile only to x86 code.
ARM platform has its own C compilers(gcc among them).
Brian's early compiler=>Intel C/C++ today with PDP=x86
PCC=>GCC today
AlmondsActivate()

Name: Anonymous 2017-07-21 13:59

*correction: Dennis Ritchie's compiler

Name: Anonymous 2017-07-21 14:01

LJ: What was your part in the birth and destiny of the C language?

BK: I had no part in the birth of C, period. It's entirely Dennis Ritchie's work. I wrote a tutorial on how to use C for people at Bell Labs, and I twisted Dennis's arm into writing a book with me. But, if he had been so motivated, he certainly could have done it without help. He's a superb writer, as one can tell from the C reference manuals, which are his prose, untouched. I've profited a great deal from being part of the book, and I treasure Dennis as a friend, but I didn't have anything to do with C.

Name: Anonymous 2017-07-21 15:20

There is not a single non-trivial portable C program in existence.
Note: portable as long as you have … ≠ portable.

Name: Anonymous 2017-07-21 15:29

portable = able to be ported

Name: Anonymous 2017-07-21 15:59

>>13
That was solved ages ago with preprocessor defines
#if defined(WEIRD_AS_FUCK_OS) && defined(COMPILER_IS_X)
/*Something contrary to common sense, logic and sanity*/
#else
/*standard stuff*/
#endif
Tada, its now portable

Name: Anonymous 2017-07-21 16:27

>>15
what if WEIRD_AS_FUCK_OS isn't defined?

Name: Anonymous 2017-07-21 16:53

>>16
It depends on the compiler. Before that line it could try
#if defined(COMPILER_Y) && defined(SOME_OBSCURE_FEATURE_THAT_ONLY_WEIRD_OS_HAS)
#ifndef WEIRD_AS_FUCK_OS
#define WEIRD_AS_FUCK_OS
#define AND_ITS_LEGACY_FEATURES_
#define COMPILER_IS_SHIT_
#endif
#endif
At least one of the compilers is detected and based on its defines the code path is chosen.
M

Name: Anonymous 2017-07-21 18:18

>>10
A C compiler could be non-portable, but C as language will be portable.
The C language is far less portable than traditional high-level languages like Fortran, Algol, and Basic. These languages can run better on tagged architectures and high-level computers. C can't compile to more advanced hardware, so people stopped building it. If you're wondering why OSes have separate address spaces and no orthogonal persistence, it's because we use C.

The real point in what he said is in a way is even more powerful: C was/is good enough that basically every processor these days is a “C machine” — byte addressable, 8 bit bytes, sizeof (char *) == sizeof (int *) etc. Anybody who started programming after the early 80s probably can’t imagine programming anything else. Essentially, C fit _a lot_ of the hardware (basically, IBM-style hardware, though it was developed for the PDP-11) so people stopped building hardware that didn’t look like a PDP-11. A virtuous network effect.

Name: Anonymous 2017-07-22 4:13

>>18
Simple cheap hardware and simple languages with free compilers
won over complex expensive hardware and proprietary compilers.
Must be a conspiracy.Jewish

Name: Anonymous 2017-07-22 4:16

>>19
At last I truly see..C is made to dumb down programmers, software and hardware.

Name: Anonymous 2017-07-22 4:57

>>20
Smart people were saying that about Unix and C for years[1].
Modern Unix is a catastrophe. It's the "Un-Operating System": unreliable, unintuitive, unforgiving, unhelpful, and underpowered. Little is more frustrating than trying to force Unix to do something useful and nontrivial. Modern Unix impedes progress in computer science, wastes billions of dollars, and destroys the common sense of many who seriously use it. An exaggeration? You won't think so after reading this book.

We are academics, hackers, and professionals. None of us were born in the computing analog of Ken Pier's East Africa. We have all experienced much more advanced, usable, and elegant systems than Unix ever was, or ever can be. Some of these systems have increasingly forgotten names, such as TOPS-20, ITS (the Incompatible Timesharing System), Multics, Apollo Domain, the Lisp Machine, Cedar/Mesa, and the Dorado. Some of us even use Macs and Windows boxes. Many of us are highly proficient programmers who have served our time trying to practice our craft upon Unix systems. It's tempting to write us off as envious malcontents, romantic keepers of memories of systems put to pasture by the commercial success of Unix, but it would be an error to do so: our judgments are keen, our sense of the possible pure, and our outrage authentic. We seek progress, not the reestablishment of ancient relics.

[1] http://www.art.net/~hopkins/Don/unix-haters/preface.html

Name: Anonymous 2017-07-22 7:00

>>15
What if a new compiler enters the stage?

Name: Anonymous 2017-07-22 10:43

>>22
The UNIX is force the new compiler to support legacy defines until the compiler becomes legacy enough that it itself forces C code to check for its presence

Name: Anonymous 2017-07-22 12:56

>>22
Makefiles that deduce what system features are presents, what compiler builtins exists, what parts of C library it supports, etc. C code will be portable due combination of makefiles, ifdefs >>23 and not depending on machine-specific values like sizeof(int) sizeof(void*)

Name: Anonymous 2017-07-22 13:23

>>24
None of this is standardized, so all of it must be written by hand every time or autogenned by crap like autotools which inserts 7000 lines of unmaintainable and unauditable crap to your program. Meanwhile, a portable program (i.e. one that doesn't depend on non-portable features) doesn't have to do any of this because it is portable. The degree to which cetards debase language to make their shitheap look better is incredible. You can't switch implementations without serious work, but it's totally portable; it never recovers from errors, but it totally works; it doesn't map well to machine features, but it's totally close to the machine; and so on.

Name: Anonymous 2017-07-22 14:33

>>25
The only objection to makefiles i have is that testing for features requires generating and running hundreds of tiny C programs. Otherwise they're quite slim, fast and portable.
Compared to Java build systems, they're practically instant.

Name: Anonymous 2017-07-22 16:10

>>26
Nothing wrong with makefiles except that fucking tab rule, I only have a problem with the way C programmers do what they call portability.

Newer Posts
Don't change these.
Name: Email:
Entire Thread Thread List