Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

In defense of complicated programming languages

viralinstruction.com

Post reply on HN
Print view View original

331–340 of 379 posts

Re: In defense of complicated programming languages

#331

Post by loeg »

AnimalMuppet wrote: post #277
skohan wrote: post #236

Earlier quoted context omitted.

I disagree that you'll be a worse computer scientist. Computer science doesn't happen in Plato's heaven, it happens in real processors and memory. I tend to think focusing on abstractions is almost always the wrong approach. Abstractions should arise naturally as a solution to certain problems, like excess repetition, but you should almost always start as concrete as possible.

I would disagree with where you are drawing that line. I would say that computer science does happen in Plato's heaven; software engineering happens in real processors and memory. But most of us are actually software engineers (writing programs to do something) rather than computer scientists (writing programs to learn or teach something).

Undergrad "CS" education, probably for better (considering the career paths and demand), is more about teaching what you call software engineering than what you call computer science.

Re: In defense of complicated programming languages

#332

Post by cttet »

ncmncm wrote: post #300
cttet wrote: post #62

Earlier quoted context omitted.

I disagree. It is maybe better for the author or you as a beginner, but not everyone. One needs data to support claims like that.

Again, you miss the point. Identically the same person, at different times, is confused by what seems like pointless extra apparatus, and, later, embraces it as solving a problem they have come, after experience, to recognize. "One needs data" is, in this context, nothing better than meaningless bluster.

You can make a general claim like that and sounds true. But I was referring to how your general claim fits to the specific situation.

Conversation is mean to have a deliver and receive end, both side can have problems. "you miss the point" kind of push all the responsibility to the listener. But why you have such a strong confidence about your expression?

Re: In defense of complicated programming languages

#333

Post by mbrodersen »

WalterBright wrote: post #95
LEDThereBeLight wrote: post #90

Earlier quoted context omitted.

I understand this thought process, but in my opinion it's the wrong way to think about software concepts. Understanding what a bridge is doesn't mean knowing how to build one, and in fact tying your understanding to a certain implementation of a bridge just limits your ideas about what is, in fact, an abstract concept. We understood functions as "mappings" between objects for hundreds of years, and when programming c…

I didn't understand how engines worked until I took them apart, either. I was taking things apart to understand them long before computers :-) But the notions of sending a "message" to a "method" just was way way too handwavy for me. I like examining the theory after I learn the nuts and bolts. > Understanding what a bridge is doesn't mean knowing how to build one If you don't know how to build one, you don't underst…

It’s because the “sending message” explanation is BS unless you talk languages like Erlang. The OOP explanations doesn’t make sense because they are BS. In the real world you don’t ask your shoe to tie itself, you don’t ask a tree to chop itself etc. And in OOP languages you normally don’t ask a string to send itself over a socket or draw itself in 3D using OpenGL. The reality is that you have code operating on data. The same way you have an axe operating on a tree, or your hands operating your shoe laces. That’s it. Everything else is BS.

Re: In defense of complicated programming languages

#334

Post by cttet »

xigoi wrote: post #205
cttet wrote: post #70

Earlier quoted context omitted.

But I think that's the exact reason we need to learn simple languages here. So that we know the closed doors first (the abstraction problem), then we will create a key or find a key elsewhere. Otherwise if "Class" is made the part of the language, like Java, you will not appreciate the importance of it to any extent and have a overall bad experience....

You can start with the simple features of a language and use them to introduce the more complex features.

Yep but in this case a language should be bundled with a good tutorial that introduces everything nicely. But if a person wants to just look at the specifications and code examples, the person would be having a lot of pointless keys..

Re: In defense of complicated programming languages

#335

Post by mbrodersen »

LEDThereBeLight wrote: post #192
skohan wrote: post #150

Earlier quoted context omitted.

I agree that everyone shouldn't need to know every implementation detail, but I'd argue there should be more emphasis on the low-level details in CS education. Programming is often approached from a purely abstract point of view, almost a branch of theoretical mathematics, but imho in 99% of cases it's better understood as the concrete task of programming a CPU to manipulate memory and hardware. That framing forces y…

I think that's the difference between computer science and programming. Yes, you'll be a better programmer if you focus on the low-level details, but you'll be a worse computer scientist. I guess, if your goal is to write optimizations, focus on details. If your goal is to find solutions or think creatively, focus on abstractions. Obviously, there’s a lot of overlap, but I’m not sure how else to describe it.

My company fired two Computer Science PhDs because they knew the theory brilliantly but couldn’t turn it into code. That’s the problem with only learning the theory.

Re: In defense of complicated programming languages

#336

Post by cttet »

pjmlp wrote: post #111
cttet wrote: post #64

Earlier quoted context omitted.

To be more concise classes != object systems != polymorphism and dynamic dispatch on data structures The difference between them are important to some people. And that's why they will argue for that.

One thing that is common to many people arguing is that they actually never bothered to read SIGPLAN, or CS type systems. So they argue with knowledge based on Internet facts instead of actual CS literature.

The natural language is evolved by people saying what they what and the majority became the language. Not defined by some elites or some authority.

Classes binds data and functions together, and object systems supports inheritance. These are some of the things that some people don't really like, but you may not care. People sometimes care about syntax as well, writing "Class" is also part of the experience of using the language.

We have different words in the language for a purpose, that's my opinion.

Re: In defense of complicated programming languages

#337

Post by cttet »

Zababa wrote: post #80
cttet wrote: post #56

The definition of "simple" and "complex" is very vague here. If we use Clojure's philosophy of simple, Python is by no means a simple language, even without classes. There are a lot of special syntax like `with` `as` `elif` `for .. else` and concepts such as `nonlocal`, not even mention generators, decorators and lots of fancy stuffs, although it is easy to learn... I don't agree with the author that static type make…

> If we use Clojure's philosophy of simple, Python is by no means a simple language, even without classes. There are a lot of special syntax like `with` `as` `elif` `for .. else` and concepts such as `nonlocal`, not even mention generators, decorators and lots of fancy stuffs, although it is easy to learn... Beware of the Turing tarpit where everything is simple but nothing is easy! Python is by no means perfect, but…

Yep, so as I said the definition of things like "simple", "complex" are super vague.

| but using different syntax when doing different things can make a lot of sense.

For C users yes, if we step back a little bit, for English users yes, but for people with other language background it may not hold. Every pieces of added syntax will utilise some human priors that may be specific to someone. But some really minimal systems can be grasped by every background, albeit taking a very long time.

Re: In defense of complicated programming languages

#338

Post by cttet »

IshKebab wrote: post #74
cttet wrote: post #56

The definition of "simple" and "complex" is very vague here. If we use Clojure's philosophy of simple, Python is by no means a simple language, even without classes. There are a lot of special syntax like `with` `as` `elif` `for .. else` and concepts such as `nonlocal`, not even mention generators, decorators and lots of fancy stuffs, although it is easy to learn... I don't agree with the author that static type make…

Static types are definitely make the language more complicated. It will have a bigger specification and more complicated implementation. You could even argue it makes writing programs more complicated. But they definitely also make writing programs much much easier. Kind of like how algebra is more complicated than basic arithmetic, but good luck proving Pythagoras's theorem without algebra.

What I meant is that the word "complicated" is vague. Even if you a using a language with dynamic type, it just hides the unavoidable complexity behind. All the problems with types will resurface at the run time. The language by itself allows very complex interactions with types, just that the user not specifying it. For me I would add the behaviour of the language as part of the language complexity, not the written part only.

Re: In defense of complicated programming languages

#339

Post by cttet »

jakobnissen wrote: post #104
cttet wrote: post #56

The definition of "simple" and "complex" is very vague here. If we use Clojure's philosophy of simple, Python is by no means a simple language, even without classes. There are a lot of special syntax like `with` `as` `elif` `for .. else` and concepts such as `nonlocal`, not even mention generators, decorators and lots of fancy stuffs, although it is easy to learn... I don't agree with the author that static type make…

Author here. Indeed, when I tested off my idea on a friend, his first response what "But what is complexity? Is J a complex language? What about assembly?". It can get tricky once you get into the weeds. But from the comments here, it looks like most people got what I was trying to express. W.r.t whether types makes Python more complex - my point was that a type system makes the _language_ more complex, but it makes…

The big or small language problem have been debated quite a long time, for what I know especially in the scheme community. There are a lot of insightful discussions about R6RS, which you may find interesting.

Re: In defense of complicated programming languages

#340

Post by lispm »

ncmncm wrote: post #330
lispm wrote: post #318

Earlier quoted context omitted.

Example: GNU Emacs comes bundled with 1.5 million lines of Lisp code. How was that possible, given that Emacs Lisp has macros?

You have maybe noticed that Emacs is a single program? (OK, two or three, historically.) Emacs Lisp code that doesn't integrate with the rest of Emacs just doesn't work.

What I have noticed is that GNU Emacs is an application development platform for various programs.

Example: Org mode. 133 k lines of Emacs Lisp code.

https://orgmode.org

Org mode then is also used by other tools.

Somehow these 'Lisp macros' seem to integrate, even though they are written in different times (GNU Emacs started in the mid 80s) by many different authors, for different programs on top of GNU Emacs.

That GNU Emacs is a program itself is not different from, say, CPython. That's also a program itself, used to run other code. GNU Emacs has 'packages' and an online archive for that. Developers publish libraries (which other use) and whole solutions, like Org mode.

That 'Lisp' itself doesn't have an 'eco system' is no surprise, since Lisp is not a single language, but a family of dialects, developed over the last almost 64 years - either similar ones like Autolisp and Emacs Lisp or different ones like Logo and Racket. Thus these dialects tend to have their own eco-systems. Like Java and C each have their own eco-systems.

Post reply on HN