• Beej Jorgensen
    link
    141 year ago

    I was taught obsolete things in college in the early 90s. But FORTRAN wasn’t the useful part of the class–problem-solving and broader language exposure was.

    People focus on random technologies that are being used in class as being obsolete, but that’s not the point of college. You can learn technologies on your own, and if you have trouble with that, maybe practicing it in college is a good idea.

    Basically we’re going to drill on technology-agnostic fundamentals for 4 years, and use a wide variety of technologies and languages as vehicles for that so you get a good breadth of experience.

    • @ribboo@lemm.ee
      link
      fedilink
      English
      21 year ago

      So much this.

      People want more “real world usage” in college and school overall. Teach kids how to do taxes, teach engineers how to use X and Y software.

      Well, in 10 years there’s a new software that does your taxes in another way, and plenty of laws have changed and there are new stuff to consider. And those software the engineers were taught, they are obsolete.

      That’s why focus should be on getting people to a place where they themselves can acquire the skills needed to do those things by themselves.

    • AggressivelyPassive
      link
      fedilink
      11 year ago

      Exactly. Whether you’re learning fortran, C or python doesn’t really matter. The core concepts are almost the same.

        • AggressivelyPassive
          link
          fedilink
          21 year ago

          Comprehensions are just shorthands, nothing more. You can unroll into loops on a syntactical level.

          But the fact that you think like that, shows to me, that you actually don’t understand the core concepts behind languages.

          At the end, each language compiles to assembly, and all the fancy features are just different ways of encoding assembly.

          • xChaos
            link
            fedilink
            -2
            edit-2
            1 year ago

            @agressivelyPassive ok, comprehensions are just syntax, but still, they still allow producing new arrays directly from iterable objects, without need to store them in temporary arrays, which counts as added abstraction.

            Basically I agree, that there are concepts which are simply not available in certain runtime libraries/interpreters, like multithreading or lazy evaluation. So I more or less agree, that syntax is not so important and we should categorize the underalying abstractions, accessible by syntax (or whatever).

            But at least memory management abstractions of Python are very different from Fortran or C (ok, you can use many different libraries for that in C, but you will hardly get reference counting and automatic clenaup of unreferenced objects and so, and this not just syntax issue… it is automation issue…)

            • AggressivelyPassive
              link
              fedilink
              31 year ago

              And nothing of that has anything to do with understanding core concepts. Threads are native CPU constructs, they don’t just exist because of a library. Memory management is nice, but also not arcane knowledge that can only be learned by going to a university.

              A C dev learning dependency injection and a Java dev learning manual memory management will both have to learn something new, but for neither it should fundamentally change how they think about computers.

              Again, you seem not to understand what’s actually going on under the hood. There is not a single language concept that a regular dev in another language couldn’t understand. It’s all just “make compiler write assembly so computer go brrr”. That doesn’t mean it’s trivial to be proficient in a new language, but that was never the goal of any higher education. It’s called computer science, not advanced button pressing.

        • Beej Jorgensen
          link
          11 year ago

          Compensations are light years behind whatever’s coming next. 🙂 And I don’t think of them as “core”. They’re practically syntactic sugar. If you can write a comprehension but can’t write a loop with a conditional in Python or FORTRAN, you’re missing the core.