10 ms·
What's worked in Computer Science: 1999 vs. 2015 (2015)
- Byamarro 3y ago"Fancy type systems" What about TypeScript? I've literally implemented snake game using types alone, it's quite powerful.
- devjab 3y agoThe phone networks and basic infrastructure for the internet in many countries wouldn’t work without Erlang. Which is functional… but maybe that doesn’t count?
- caditinpiscinam 3y agoOn the other hand, the banking infrastructure in many countries wouldn't work without COBOL, scientific research wouldn't work without MATLAB, and healthcare wouldn't work without MUMPS. Many languages and paradigms, good and bad, end up entrenched within an industry.
- jnxx 3y ago> COBOL > MATLAB > MUMPS One of each uglier than the one before. But: Is there something we can learn from these examples? Are there good reasons for these languages being adopted? And are the Racket designers with their approach of "a language to define interoperable DSLs" up to something?
- caditinpiscinam 3y agoI think programming languages are more like spoken languages than we give them credit for. Their design is more intentional, but the processes by which they spread, compete, and evolve is similarly difficult to pin down.
- simne 3y agoYou forget FORTRAN (was very popular for scientific computing, and nearest neighbor with COBOL in S/360 environment) :)))
- deleted 3y ago[deleted]
- blt 3y agoThe link to "Microsoft's driver verification tool", which "has probably had more impact than all formal chip design tools combined", is broken. Does anyone know which tool this meant?
- nequo 3y agoThat link is archived here: https://web.archive.org/web/20160416132849/http://research.microsoft.com/pubs/70038/tr-2004-08.pdf https://web.archive.org/web/20160416132849/http://research.m...
- eimrine 3y agoThe document is still searchable: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-2004-08.pdf https://www.microsoft.com/en-us/research/wp-content/uploads/...
- skybrian 3y agoFancy type systems have come a long way since then. (TypeScript, for example.)
- pyuser583 3y agoTS really stands out as amazing. It’s realized a lot of the promise of strong typing.
- malcolmgreaves 3y agoI agree that TypeScript is quite amazing. And that it's indeed improved the programs created that run in the browser or on `node`. However, I wanted to point out something that I think often gets overlooked when folks talk about TypeScript. I'd argue that TS has realized it for the web programming masses, who usually don't have any computer science education and thus are unaware of computing fundamentals such as types. TS hasn't realized the promise of strong typing only because it has been quite late to the game, so to speak. I do think I understand where you're coming from. Web programmers are the largest group of programming-related professionals. Bringing CS wins to this large group absolutely does bring the largest gains and impact to industry. There have been many programming languages created decades before TypeScript that have realized the promise of strong typing. Unfortunately, I think this road took too long. Collectively, people have known about these ideas since John Backus's 1977 Turing Award Lecture [1] -- "Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs" Anyways, I digress. Hopefully this was insightful! Have a great day :) [1] https://dl.acm.org/doi/pdf/10.1145/359576.359579 https://dl.acm.org/doi/pdf/10.1145/359576.359579
- anthk 3y agohttps://hypercubed.github.io/joy/joy.html https://hypercubed.github.io/joy/joy.html
- cgh 3y agoHow so? It looks a lot like a less-rich Java, whose type system has existed for literally decades. In fact, the generics syntax and type erasure was directly influenced by Java.
- ipython 3y agoFascinating about how ARM has made tremendous strides in the “high end” market since 2015. I would argue that I would categorize RISC as a “yes” with its absolute dominance on mobile and now moving into data center not to mention all the embedded use cases.
- t43562 3y agoI think the battle between RISC and CISC is overshadowed by the battle between non-x86 and x86. On average are new designs more RISC than CISC? I don't know but that's different from numbers of chips of a certain type sold. RISC showed what you could do with a clean sheet and the battle has really been about whether we can afford the cost of changing to a new instruction set just because it's better by a bit.
- zer00eyz 3y ago>> by the battle between non-x86 and x86. 68000 -> PowerPC -> x86 -> arm Apple has been through 4 architectures in 30 years. Given enough money and tyranny (as in "were doing this" kind of leadership, vs committee) its apparently not that terrible.
- simne 3y agoAnd rumors said, they even considered IBM RS-6000, but pushed to make simplified PowerPC, and IBM had not very good times, so agreed.
- peterfirefly 3y agoAdd the transition to "32-bit clean" on 68K (and some trouble with caches) + 32-to-64-bit transitions on PPC and x86.
- bdw5204 3y agoAt the moment, x86 is mainly hanging on in legacy spaces because of backward compatibility. Everything new is RISC including Apple's newer Macs. Windows computers still run on x86 because people buy Windows to run legacy code. Playstation and Xbox run on x86 because that makes porting games from Windows more convenient. My view, even when I was studying RISC V in grad school around 6 years ago, was that RISC is clearly superior technically and this would only become more obvious with Moore's Law dying. I think subsequent events are only confirming this view. The strongest evidence for it is that nobody would even think about making a new CISC architecture that isn't x86.
- deleted 3y ago[deleted]
- sampo 3y ago> Fancy type systems We are taking steps to this direction. By adding optional typing to dynamic languages Python and JavaScript/TypeScript. And then type checker tools and local programming style guides are making using these maybe less optional, and more mandatory.
- t43562 3y agoIMO the day python types become mandatory there will be a fork. It would be such a total betrayal of it's reason for existing that we would have to invent another untyped or duck-typed language again.
- sampo 3y agoI mean, your company or your project may require you to write type hints and use a type checker tool. Not that Python the language makes typing mandatory.
- chasd00 3y agonagware like Typescript have turned type bolt-ons into a religion almost. It has its place but really gets in the way in others. Hence, the reason untyped languages exist in the first place.
- kfajdsl 3y agoFor me the primary purpose of TypeScript is to give my editor information about interfaces so I don’t have to do the menial back and forth of accidentally making a typo in a function name, object param, etc. I find myself using less type hints in Python because the story for REPL driven development is so much better than JavaScript, and that takes most of the pain away.
- datavirtue 3y agoGiving the editors hints in this case is very expensive.
- 3y ago
- aleign 3y agoWhat is "capabilities" supposed to mean?
- jayd16 3y agoProbably Capability based security https://en.wikipedia.org/wiki/Capability-based_security https://en.wikipedia.org/wiki/Capability-based_security
- jnxx 3y ago> What is "capabilities" supposed to mean? "Is this app allowed to read your contacts?"
- mike_hearn 3y agoIt means that the permission (capability) to do something is encapsulated into an unforgeable bearer instrument that can be stored, passed around and so on. An open file handle (descriptor on UNIX) is a capability, because if you have it you can use it to read and maybe write to the file, and because you can send it to another process, at which point that process also has the capability to read and write that file. Capabilities are one of those concepts that's a bit like FP or RISC. It sounds elegant but in the real world experience is mixed, so it's rare for a system to rely on it purely. Most real security systems today are built on semi-static permissions granted to domains defined by some third party identity system. Capabilities do get used, but mostly in the sandbox context and mostly as a detail. So I think Dan is not quite correct that mobile platforms use capabilities. Users assign permissions to specific apps semi-statically there. The lowest levels of the OS may use a small set of capabilities as part of the implementation, but granted permissions are not generally easy to send around to other apps.
- stevefan1999 3y agoI would like to suggest that the classical taxonomy of RISC/CISC dichotomy is basically non-existent nowadays -- namely because both sides have influenced each other. It is well known that CISC has taken a lot of inspirations from RISC designs (such as having a lot more registers in x64), and RISC designs also taken some inspirations from CISC (such as having SIMD/vectorization units). In other words, the line between RISC and CISC has been very fine lately. Also, at the end of the day, they all turned into μops. If I remember Jim Keller correctly, ARM and x86, they are basically the same in the back nowadays, its just the frontend and their decoding units are different. And that's why he strongly suggested AMD to also adapt Zen design with ARM ISA during his tenure there, oh I think it is called K12. I think there is another blurry line between superscalar and VLIW architecture, too.
- Apofis 3y agoWith all of the sanctions China is really starting to push RISC forward, challenge ARM, and they are starting to find success. That "No" has absolutely changed to a "Maybe". https://www.prnewswire.com/news-releases/global-and-china-automotive-risc-v-chip-industry-research-report-2024-customized-chips-may-become-the-future-trend-and-risc-v-will-challenge-arm-302089267.html https://www.prnewswire.com/news-releases/global-and-china-au...
- fulafel 3y agoI don't know if a reduced instruction set can "take inspiration" from a big one, it just becomes a non reduced one. Also these examples don't feel right for me: x64 has the same number of registers as CISCs traditionally did (eg m68k, z/architecture, vax). 32-bit x86 was just an exceptionally register-starved CISC. And SIMD postdates RISC vs CISC divide for a long time, both schools of architecture got SIMD around the same time. But the divide has become less relevant because originally instruction set affected chip area a lot, and there were big gains to be had by the quantitative approach of benchmarking compiled apps with different proposed instruction sets and seeing what runs fastest when transistors are spent on hot instructions vs execution engine resources. Nowadays we have more transistors than we know what to do with, and just put in lots of cores that end up sitting idle because of diminishing returns trying to speed up cores with more transistors.
- hosh 3y agoDo GPUs and TPUs for AI count towards parallelism?
- deleted 3y ago[deleted]
- sophacles 3y agoI don't think so, they still tend to fall into the "Lampson further remarks that to do parallel programming, what you need to do is put all your parallelism into a little box and then have a wizard go write the code in that box." statment, for the most part.
- jnxx 3y agoWhat could be a different case is Clojure. But I am not sure, and the performance characteristics of Clojure make it well-suited for server-style concurrency, but not so much for high-performance parallelism.
- deleted 3y ago[deleted]
- silvestrov 3y agoI'd say that "pure Functional programming" has become a no. But "Functional programming approach" has been subsumed into existing programming languages, e.g. records in Java. You get most of the benefit of FP while keeping all of the other good stuf from an imperative language.
- unregistereddev 3y agoI'd agree with this and add that pattern matching and functional interfaces are additional examples of tools from the FP toolbox being subsumed into existing programming languages. Pure functional programming seems tempting. In small projects it can produce beautiful, readable code. In large projects I've only seen it result in messes, and I still haven't decided whether that's due to limitations of functional purity, due to the team (and myself) misusing features that we don't understand, or both.
- ildjarn 3y agoWhat mainstream languages have a good suite of FP features though? If you try to write mostly pure code in Java I’m afraid you’re in for a bad time, despite the (big!) improvements of records and lambdas. Minimum viable FP starts at OCaml, F#, Scala and Closure, yet none of these are mainstream.
- AS37 3y agoI code in C# and use a ton of LINQ when writing business logic. It's FP-ish enough to avoid logic mistakes. The mediator design pattern, which is kind of bringing another FP paradigm to the OO world, also features heavily.
- ska 3y agoI think this is the point really, not that mainstream, "general purpose" languages support FP well, but that FP ideas and aspects have been adapted into many of them.
- ildjarn 3y agoC# LINQ, being a round-about implementation of do-notation, is a pretty advanced FP feature, and beyond most mainstream languages. C# is certainly a step up over Java etc. However, most developers wouldn’t understand, say, a result monad implemented via LINQ, so you’re still fighting the ecosystem somewhat.
- sys_64738 3y agoFormal Methods was for people who didn't want to write any code.
- deleted 3y ago[deleted]
- jayd16 3y agoI guess from some sense, all web apps and all GUI apps using the GPU are using parallelism. That's almost everything. Those are both leveraging shared-nothing type architectures so you can think in a single thread and apply it to concurrent work loads for parallelism. Does that not count? What would satisfy this category?
- dehrmann 3y agoI think the dream of parallelism in 1999 was that CPUs aren't going to get much faster in terms of clock cycles, so how will algorithms run on more data. This is a bit dumbed-down, but things like sorting in parallel. It turns out that local data didn't quite scale like that, we got more ram and SSDs, and that coordination usually makes small-scale parallel algorithms prohibitively expensive. Where parallelism does work today is some flavor of SIMD like vector instructions, parallel matrix multiplication on a GPU, or map-reduce.
- IshKebab 3y agoInteresting how much has changed since 2015. Apple's M chips have made RISC is a clear yes now. Rust has a pretty fancy type system. Not Haskell-fancy but still. Functional programming is pretty much an expected feature now.
- aleph_minus_one 3y ago> Apple's M chips have made RISC is a clear yes now. ARM is not a pure RISC architecture (even though its instruction set is somewhat inspired by those ideas behind RISC that stood the test of time).
- IshKebab 3y agoWhat counts as "pure RISC"?
- SV_BubbleTime 3y agoAsk the Scottish. Elsewhere in the comment section is describe the question isn’t RISC/CISC, it’s x86/Nonx86. And far more interesting since those lines are still fairly well established.
- simne 3y agoGood question. Now things are complicated. When all beginning, CISC CPUs was not one chip but board or even cabinet (like IBM S/360), and they featured customizable microcode, so you could even load different microcode on different CPUs in system. As I know, very powerful feature of S/360 series was to supply custom microcode to make machine compatible with older IBM hardware, like 1401 series or 7xxx series (or to make your own architecture if you wish and if you have enough money). I have not hear about customizable microcode in RISC (to be honest, I hear, it exists in ARM, but it is rare used option, if compare with IBM 360).
- keybored 3y agoWhat can you do in Haskell that you can’t do in Rust with macros and elbow grease?
- Legend2440 3y agoNeural networks: 1999 - No 2015 - Not really 2024 - Yes?
- Calavar 3y agoI'd say 2005 to 2010 is probably more probably more appropriate for not really. By 2015, neural networks were already a really hot research topic. Just off the top of my head, the seq2seq paper was published in 2014 and U-Net and ResNet were published in 2015.
- ska 3y agoThis is eliding most of the history of neural networks as a hot reasearch topics. Since the late 50's early 1960s they've had several resurgences in interest, e.g. 80s RNNs, 90s stuff around several centers. Hell people were doing interesting things with them commercially in the 90's. The late 90s and early 00's had a lot of other interest (kernel methods, SVMs) but NN folks kept plugging, and the hardware to hit the next level was just around the corner. The resurgence you're noting are papers with a 10 year tail before them (hell, most of the deep concepts were initiated decades before but lacked both the data sources and efficient hardware to really work them out). This stuff has a long and deeply connected history.
- deleted 3y ago[deleted]
- Divver 3y agoI wish this was updated for 2024 His RISC being “No” most would agree is somewhat incorrect though it seemed correct back in 2015. But it kinda goes to show how these yes/maybe/no things can evolve unexpectedly over time and not be to taken as gospel that will stand the test of time.
- tptacek 3y agoGood 'jcranmer on the RISC-CISC thing: https://news.ycombinator.com/item?id=39481940 https://news.ycombinator.com/item?id=39481940
- vanderZwan 3y agoI just want people to start doing interesting things with stack machines again. Like, hardware ones, not VMs (plenty of interesting stuff happening there). But that's the concatenative language lover in me wanting to see more interesting things happen, not some zealot claiming we all should switch to it.
- keybored 3y agoYes Maybe Firefox Reader Mode CSS
- MattGrommes 3y agoAlso, Reading Mode in the sidebar of Chrome. The days of square monitors and wall-to-wall text have been over for a while.
- oconnor663 3y ago> Lampson further remarks that to do parallel programming, what you need to do is put all your parallelism into a little box and then have a wizard go write the code in that box. Not much has changed since 2009. I would like to see a reevaluation of this take with respect to Rust. When we're talking about Rust's safety features, we usually focus on memory safety, because that has the biggest impact on security. But there are lots of memory safe languages, and I think it's actually Rust's thread safety features that are the most unique. (Lots of shared type system machinery between both sets of features.)
- simne 3y ago> That Intel ceded the low end of the market might seem ironic considering Intel's origins, but they've always been aggressive about moving upmarket Will see. Intel after 2023 is not like before 2023, when it lost its dominance to AMD and partially to Nvidia and ARM (Apple-M2). Now lowest end CPUs become RISC-V and ARM pushing to become one of leaders. x86 is strong, but who knows, how long it could dominate under pressure. And if we count not desktops but all personal devices, ARM is already won (on just smartphones, now more ARM CPUs than people on Earth, and Data Centers share of ARM CPUs growing). Only one final thing I could copypaste from "X-files" - "truth is out of there".
- simne 3y agoAfter digest information about IBM 360, I decided, we lost CISCs. One of most important feature of 360 was customizable microcode, which you could load on system boot and got effectively different hardware (like with FPGA emulators of Amiga's). It was widely used to emulate old hardware, like IBM 1401 or IBM 7xxx series. But I have not seen this feature in 390 documentation, so looks like their 360 emulation become just software (and with achievements of semiconductors in 1990s it looks like adequate, to switch to software emulation). This was not only feature of 360th, for example Xerox Alto, also have documented feature to alter microcode when need (as I hear, they have special framework to work with it, just like we now work with Assembler when need), and I hear rumors that something similar was shipped with DEC mini-computers, but for micro-computers, this feature practically disappeared. Even when we have "microcode update" feature in many modern CPUs, but it is usually undocumented feature, to which nobody have access outside CPU manufacturers (only could upload encrypted binary, supplied by manufacturer to fix bugs). As I said, in 360th, this was documented standard feature, you could use if need. I must admit, ARM marketed feature of customized microcode, to add new instructions (they have standardized place in instruction set, named "custom coprocessor instructions", so if you have enough money, you could make special ARM with your additional instructions, you could even order some additions on die), but it is nothing if compare to 360. And I could tell from FPGA cooking, not all things implemented in FPGAs as hardware logic pipelines. When speed accepting, many people using in FPGA practically microcode engines (very common thing is 1-bit CPU, which is very similar to CISC microcode engine, and programmed in Assembler, very similar to early 8-bits; some people prefer full-featured CPU, like 8048 or even more).
- dang 3y agoRelated: What's worked in Computer Science (2015) - https://news.ycombinator.com/item?id=15796515 https://news.ycombinator.com/item?id=15796515 - Nov 2017 (62 comments) What's Worked in Computer Science - https://news.ycombinator.com/item?id=10623600 https://news.ycombinator.com/item?id=10623600 - Nov 2015 (63 comments)
- xorvoid 3y agoFancy Type Systems is indeed vague, but I’d disagree with No in 2024. They are slowly winning. Definitely a Maybe to a Yes. E.g. Rust is hugely popular/successful and has brought a much more sophisticated type system to system programming.