6 ms·
This is the first time I'm hearing about Tandem. Are there any other noteworthy, older computer technologies that are in some ways superior to current technolo
by adamnemecek 10y ago
This is the first time I'm hearing about Tandem. Are there any other noteworthy, older computer technologies that are in some ways superior to current technologies?
- nostrademons 10y agoSome examples I can think of: - Burroughs B5000. Designed from the start to be programmed solely with high-level languages. Supported type-tagging directly in the hardware. All code was automatically re-entrant; problems like PC-lusering, interrupt handling, concurrent execution, and unsafe accesses to globals simply didn't exist. All of this in 1961. - SmallTalk, Interlisp, and the Lisp Machine development environment (late 70s). All of these had the property that you could modify & customize your IDE as it was running - it's sorta like Eclipse or Emacs on steroids, but rather than a plugin architecture where you have to wade through megabytes of docs to figure out how to write some code, the IDE was just written in itself and open for re-use and modification. Smalltalk in particular was very good about letting you inspect & pull up documentation on any object inside the running system, seeing the runtime values of its fields. - SmallTalk also let you search by example, eg. you could type in the inputs and the outputs of a function and it would suggest which function you were thinking about. - The Common Lisp condition system (mid 80s) is way more thorough than any error-handling system used today. A key feature was that error-handlers could run in the stack frame that caused the error; thus, they could inspect the code and data that caused it, and attempt to correct the problem, letting the algorithm run uninterrupted. If the handler couldn't do this, you had the option of dropping into an interactive debugger, fixing the code, and continuing where you left off. - Multics (1964) did away with the distinction between files and memory. It was as if every file was implicitly mmapped, or alternatively, the processes's memory was just another file. - The capability security model (late 90s) fixes many of the security problems that most systems today have. The key idea is that instead of letting each subsystem (remote node, process, library, function call, etc.) know about every other node in the system and then force them all to check whether each request is authorized from an intended sender, each subsystem can only communicate to subsystems which have explicitly delegated a capability that they may perform. For example, instead of every process having access to the open() system call and then the syscall checking the process's uid against the ACLs for the file, each process would be passed in a list of file descriptors on which they could operate and no mechanism would exist for accessing something outside of that set. - Exokernels (late 1990s) were a reformulation of the role of the operating system such that the OS is responsible only for securely multiplexing the hardware, and any abstraction mechanisms are delegated to userspace libraries. They've been undergoing a bit of a comeback under other names lately, with virtualization hypervisors like Xen being basically an exokernel, and unikernels being the libOS.
- nostrademons 10y agoOh, and some examples of things that were largely considered dead & unknown relics when I first started programming in 2000, but have since undergone renaissances and are now quite mainstream: - Lexical closures were largely unknown to working desktop programmers. They've been around since Algol in 1960, but Assembly/C/C++/Java don't support them and those languages had "won" in 2000, so they were quite unknown to programmers first encountering them in Perl, Python, Ruby, or JS (the first three of which have strange variable-capture behaviors). Now basically everyone knows about them. - Erlang-style distributed programming was also a lost art; I remember coming across some mailing list posts by Joe Armstrong c. 2003 where he described Erlang's strategy as "wait for everyone else to realize this is important." Now that future is here, and we get articles like this one. - Type inference has been around since the 80s, but it was missing from virtually all mainstream languages, which either had manifest static typing or dynamic typing. Almost all languages released since 2009 have been type-inferenced. - map/filter/fold functions were also something commonly known to Lisp/ML/Haskell programmers, but unknown to working C/C++/Java software engineers. Now they're fundamental to many programming languages, and the basis for MapReduce (which itself was revolutionary in bringing functional programming ideas to a mainstream audience).
- fanf2 10y agoProper lexical closures were a prominent feature of Perl 5 in the mid 1990s - hardly unknown! Type inference dates from 1969 (Hindley) and 1978 (Milner)
- sedachv 10y ago> - Multics (1964) did away with the distinction between files and memory. It was as if every file was implicitly mmapped, or alternatively, the processes's memory was just another file. Don't forget IBM System i (AS/400), which has a single persistent address space for everything. Frank Soltis' Inside the AS/400 is an interesting read.
- adamnemecek 10y agoThanks for the info but I think that I was looking for something more obscure :-). Smalltalk, Lisp, and Erlang are all pretty much household names on this site.
- nickpsecurity 10y agoI have a list here with at least one example from numerous styles: https://news.ycombinator.com/item?id=10957020 https://news.ycombinator.com/item?id=10957020
- kragen 10y agoIn some ways? That's easy. Aside from the ones nostrademons points out: The Transputer: a CPU architecture centered on communication. Maybe the Forth machines like the Novix and the MuP21, currently in the form of the GreenArrays chips: very simple, performance-competitive with much more complex concurrent alternatives, but harder to program. The F-83 Forth system, which also had an IDE you could modify and customize while it was running, but ran comfortably on an IBM PC without a graphics card. The Alto that Interlisp and Smalltalk ran on, which ran user-defined microcode in order to allow you to customize the machine for your language. The AS/400. Pick. APL. The CM-4. The Cytocomputer, although I think modern technologies caught up with it a few years back. HP programmable calculators, starting from the 9100, had their CPU instruction set as their user interface, making them relatively easy to program. Unfortunately, as with TECO, this involved compromises both as the UI and the instruction set. The IBM SP2 high-speed switch with its buffered cut-through wormhole routing for super-low latency. Oberon: a full-stack computing system including its own compiler and novel, customizable GUI, within a single book's worth of code. Pad++, the canonical zooming user interface prototype. Lotus Improv, reportedly. Sketchpad, which was the first graphical user interface and the first constraint-programming system — arguably an enormous improvement not only on its predecessors but also most of it successors. Augment/NLS; seen the Mother of All Demos? Usenet, though it couldn't survive spam — censorship-resistant, peer-to-peer, super-low-bandwidth, fault-tolerant, and with superior threading mechanisms and UI to a lot of what we use now. I saw a talk a few years back by someone who'd set up a private Usenet server to sync sensor data from an intermittently connected polar weather sensing platform.
- protomyth 10y agoOpenVMS and its file system were amazing for clustering. Amazing how HP owns all the cool always on technology.
- fit2rule 10y agoRetrograde degression is a thing in computers. Those who fail to read the code, re-invent the code.