SoylentNews

What's Worked in Computer Science

posted by cmn32480 on Monday November 30 2015, @08:19AM   
from the thought-provoking dept.

Phoenix666 writes:

In 1999, Butler Lampson gave a talk about the past and future of "computer systems research" [PDF]. Here are his opinions from 1999 on "what worked".

Yes

Virtual memory
Address spaces
Packet nets
Objects / subtypes
RDB and SQL
Transactions
Bitmaps and GUIs
Web
Algorithms

Maybe

Parallelism
RISC
Garbage collection
Reuse

No

Capabilities
Fancy type systems
Functional programming
Formal methods
Software engineering
RPC
Distributed computing
Security

Basically everything that was a Yes in 1999 is still important today.

The article is a current snapshot on those issues. Do you agree?

---

Original Submission

• Re:RPC Re:RPC (Score: 2, Disagree) by maxwell demon on Monday November 30 2015, @08:43PM

  by maxwell demon (1608) on Monday November 30 2015, @08:43PM (#269900) Journal

  Your function can be simplified to:

  def fact(number):
     if number >=1:
        return 1
     else:
        stackoverflow()

  SCNR

  --
  The Tao of math: The numbers you can count are not the real numbers.

  Parent

  Starting Score:	1		point
  Moderation		0
  Disagree=1, Total=1
  Extra 'Disagree' Modifier		0
  Karma-Bonus Modifier		+1
  Total Score:		2

• Re:RPC Re:RPC (Score: 3, Informative) by Marand on Monday November 30 2015, @09:15PM

  by Marand (1081) on Monday November 30 2015, @09:15PM (#269911) Journal

  Sure, if your language of choice doesn't optimise tail call recursion. In the context of functional programming languages, this is a common form of recursion that is optimised to not blow the stack, even in languages that can't do more general tail call elimination (such as JVM-based functional langs like Clojure and Scala). Bad tail recursion in one can cause an infinte loop, '10 goto 10' style, but won't overflow.

  As this is a core concept of most functional programming, you apparently tried to be witty about a topic you don't know much about because you're used to imperative languages and assumed all languages have the same limitations of your preferred one(s).

  Parent

  • Re:RPC Re:RPC (Score: 0) by Anonymous Coward on Tuesday December 01 2015, @10:33AM

    by Anonymous Coward on Tuesday December 01 2015, @10:33AM (#270116)

    Sure, if your language of choice doesn't optimise tail call recursion.

    The language he used was very obviously Python. Python does not do tail recursion elimination.

    As this is a core concept of most functional programming, you apparently tried to be witty about a topic you don't know much about because you're used to imperative languages and assumed all languages have the same limitations of your preferred one(s).

    You apparently like jumping to conclusions.

    1. As I wrote above, the code was very obviously Python code, which implies having no tail recursion elimination.
    2. Contrary to your assumptions, Python is not my preferred programming language. It is, however, the language used in the post I replied to.
    3. Contrary to your assumptions, I do know about tail recursion elimination. Indeed, initially I did indeed put an infinite loop there; but as I said, Python does not do tail recursion elimination, and therefore I did change it to stack overflow before posting.
    4. I'm not sure what to make of the fact that you, of all the possibilities, chose to use "10 goto 10" to describe an infinite loop, but it certainly doesn't speak for you. I would have chosen something like while (true) {} or, keeping in the Python language, while True: pass — but actually I would not have written explicit code for the loop at all, as I assume everyone here knows what an infinite loop is.
    5. What I intended to be witty about was that the function as given obviously does not calculate the factorial (which I assume was intended, given the name). All that tail recursion elimination talk is actually a red herring.

    Parent

    • Re:RPC (Score: 2) by Marand on Tuesday December 01 2015, @11:46AM

      by Marand (1081) on Tuesday December 01 2015, @11:46AM (#270130) Journal

      I probably shouldn't even respond considering the above post reeks of all kinds of mad, so you likely won't take any further response civilly either, but here goes anyway...

      1. AC never specified a language and was talking about functional programming in a general context, so I treated the snippet as pseudocode. It's written in a generic enough way (and Python has that generic psuedocode look to it in small chunks) that, without mentioning Python explicitly, it shouldn't really be assumed either way.

      Likewise for the followup that had a call to "stackoverflow()", since that reads more as pseudocode than as a commonly implemented call in any language. (Does Python actually have a stackoverflow() function? I've never heard of such.)

      2. See #1

      3. See #1

      4. Was there something incorrect in my statement about the infinite loop? I was describing a process, not writing Python code, so I chose the simplest construct/example possible with the intent of being understandable to anybody. It's basically a jump, sharing some similarity to what happens to recursion after TCE. It also had the benefit of being short to type, which is always a bonus when using a tablet touchscreen. All I see here is nitpicking with a vague insinuation that my statements aren't valid because I mentioned the dreaded goto.

      5. It's not a red herring. Nobody explicitly mentioned Python, the only discussion was "functional programming" in a general sense, and your response -- assuming you're the same poster but using AC to avoid a potential karma hit for the combative response -- as a followup gave the impression that you were implying tail recursion in FP is problematic because of overflows.

      Maybe it's all just a communication issue because of a lack of clarity and not enough thought about how it would read to others. Though, the AC response afterward makes it look more like an attempt to save face after a mistake by arguing and insinuation, if it's really the same person.

      Still, I have no way to verify that the AC post is maxwell demon posting anonymously, so I'll take the charitable option and assume it's all a communication problem for now.

      Parent

• Re:RPC (Score: 0) by Anonymous Coward on Monday November 30 2015, @09:33PM

  by Anonymous Coward on Monday November 30 2015, @09:33PM (#269916)

  Oops, that else return should be:

  return number * fact(number - 1)

  You also need to keep in mind that elementary students have no concept of negative numbers.

  Parent