shadowofneptune

Has anything changed since about David Bowie playing a piano?

The article raises a good point about object files and binary compatibility being neglected in more recent languages.

The more 'objectively' is used here, the less meaning it seems to have. If people have trouble using the notation, it's a subjective issue that cuts into the utility of the language. Even after getting used to it myself, I sometimes get tied up translating infix formulas to RPN or PN. There doesn't need to be one notation/language to handle everything.

Ah, this is what I was thinking of when I said other Vi's. Did not realize it's a fork of Vim.

This was not my experience with Emacs, oddly enough. I started using it because it was the only editor that both supported a terminal and had a top bar. Like a windows program, pressing F10 gets you a File, Options, etc. menu that helped me get through that first session. Emacs (and other Vi's, I should note) has made a nod towards accessibility that Vim has not.

That's what I meant by keeping a list, didn't expand on that much. It's something that needs to be configured per-program, which is an issue.

With the Emacs shell, this goes a step further. Emacs functions and /bin/ commands are put in the same namespace. '+' is now a command that can be run at the command line, while 'grep' can have its output redirected to a buffer instead of a file (Sadly no input redirection). This, all while itself being a buffer.

It doesn't work well with full-screen programs, or ones that use escape sequences. Sadly there's no away around that besides keeping a list of those programs. Unix programs have never needed to say to the OS "I am a fullscreen program" due to how little a traditional shell actually interacts with a programs.

Emacs is my login shell now. I feel however that other, more pure attempts at this like the Canon Cat and Plan 9's text editor were smothered by the Mac/Windows interface of GUI programs which rarely interact. A more evolved shell never had the chance to arise.

For civil purposes, I feel the second still makes more sense as 1/86400 of a solar day. Unless you have an atomic clock, you cannot accurately keep to the SI unit over weeks or months anyway, let alone the time between leap seconds.

Of the features to selectively take from Lua, the syntax is one I like. Pascal-style syntax does not have the statement separation issues a more expression-rich language like JavaScript has. It not only does not have statement separators, it is almost completely whitespace agnostic.

As a strategy to get adopters, it could also have value. There's a small but widely spread group of people who have been exposed to Lua in various games and programs.

The potential population for that footgun is compiler writers, who should safely fall into 'know what they are doing' territory.

This might be the finest criticism I've seen of attempts to extend the Christian epoch forward or backwards.

LEA only got more powerful in later models as the restraints on registers were removed and more addressing modes got added. Now it can do several additions and a multiplication in a single operation. Reusing that memory hardware/instruction format is a clever ISA decision.

Micheal Abrash's book covers this. May just be better to swap out the segment registers at that point though.

Have address calculations been covered yet? Those are pretty complex on the '86.

Alternatively, the 'rep' prefix would be interesting.

I have to admit you're right there, now thinking about how I would explain games I play, approaches to tasks, etc.

The mind itself, perhaps. The person in possession of it though usually does have a conscious strategy to play a game once they are proficient, and can happily explain it to you.

Yeah, the literal meaning sounds absolutely disastrous and I'd love/dread to see it.

Yes, it is a loophole, but just in one law, not in the constitution. Congress delegated to the Treasury the right to mint coins of any denomination, even if the intent was different.

I must admit that the separation of powers issue had not quite occurred to me, since the entire scheme is self-defeating and would scare holders of the US debt anyway. People would be (and are right now!) worrying a lot more about a credit rating downgrade or a default than a separation of powers concern.

Hardly. It's just a particular mechanism to print more money that got created inadvertently . A really silly and dumb route to that, but no different in effect. That it's no different from printing more money to pay the debt is part of why it's unlikely to avoid a credit scare.

> If an object that has automatic storage duration is not initialized explicitly, its value is indeterminate. If an object that has static storage duration is not initialized explicitly, then:

• if it has pointer type, it is initialized to a null pointer;

• if it has arithmetic type, it is initialized to (positive or unsigned) zero;

[end quote]

—C99 Standard, §6.7.8

EDIT: That said, it can only relied upon to be zero at the first call of the function.

There's also the X Bitmap format: https://en.wikipedia.org/wiki/X_BitMap

GIMP outputs it, which means you can make much any image embeddable into a C source.

The most famous book title I know with that format is Frankenstein, or The Modern Prometheus. It's so old a style that I find it funmy that it could be seen as a fad.

Bill Joy, maker of Vi, was rather impressed by Emacs's input model in fact:

> I think one of the interesting things is that vi is really a mode-based editor. I think as mode-based editors go, it pretty good. One of the good things about EMACS, though, is its programmability and the modelessness. Those are two ideas which never occurred to me.

https://web.archive.org/web/20060701083055/http://web.cecs.p...

I am used to Emacs's parallel universe of keyboard shortcuts now, but I think you could make a good Emacs using standard Windows keybinds.

It at one point was an illustration of how large and ponderous operating systems felt back then compared to most other programs.

https://pbgalvin.files.wordpress.com/2007/03/scan0001.jpg

A nice touch that got dropped was that the minicomputer and microcomputer OSes were smaller, more evolved beasts.

The issue is that the one-dollar bill is still being printed. Decades of inflation has made dollar bills much more common, which means they come out of pockets more, which means they wear faster. I expect once the penny finally goes out of use, dollar bills will as well, and you'll see a lot more dollar coins.

Official Intel program to detect the current processor (starts on page 16): http://kib.kiev.ua/x86docs/Intel/AppNote485/241618-005-mn.pd...

I'm looking at it myself from the other end: one of the most interesting ideas from Smalltalk, Oberon, Plan9, etc. was having text be executable as programs in a text editor. It's to a visual editor as a command line shell is to a line editor.

I've heard it called an 'integrating development environment,' a system where all the tools to use it like an IDE are there.

EDIT: OP has a blog post showing the similarities between the mentioned systems: https://www.multicores.org/blog/what-have-i-been-up-to.html

That is accurate, yes. Borland C++ and Delphi share the same component library and are interoperable.

Object Pascal has two magic types, dynamic arrays and AnsiStrings. These are automatically reference counted. Objects and classes have to be managed by hand, yes.

In general, expect a lot more compiler magic out of Pascal, a lot of concepts were hacked into the Borland compilers over time.

Enough with this 'emulating a PDP-11' cliche (never seen it quoted as the PDP-7 before). Explicit instruction-level parallelism has its own issues that make it difficult to use effectively, precisely because it must do statically what out-of-order processors do dynamically.

The use of C as a scapegoat is odd. What alternatives would have led to a different world of processors? Pascal? PL/I? Experiments in parallelism at the time like Erlang are about process-level parallelism, not the kind of instruction-level parallelism this line of argument calls for.

You absolutely can have simpler systems than we use today, but let's not fool ourselves about how we got here.