Alan Kay and OO Programming • Hacker News Board

Re: Alan Kay and OO Programming

#71

Post by ivanhoe » Tue, May 21, 2019, 2:24 PM UTC

cryptica wrote: post #21

>> Extreme late-binding is important because Kay argues that it permits you to not commit too early to the "one true way" of solving an issue (and thus makes it easier to change those decisions), but can also allow you to build systems that you can change while they are still running! >> Binding can also refer to binding a variable type to data. As someone who has over 15 years of experience going back and forth betw…

How exactly types and unit tests stop you from moving around the internal implementation? My impression was always that they help you in exactly that, allowing one to refactor any piece of code without worrying about unexpected side-effects.

Re: Alan Kay and OO Programming

#72

Post by betandr » Tue, May 21, 2019, 2:31 PM UTC

The term object-oriented has often been misinterpreted. Alan Kay explained that "[the term object-oriented] was a bad choice because it under-emphasized the more important idea of message sending".

Re: Alan Kay and OO Programming

#73

Post by TFortunato » Tue, May 21, 2019, 2:42 PM UTC

DSingularity wrote: post #24

slifin wrote: post #16

Earlier quoted context omitted.

Not that I'm advocating the approach but I think the benefit is that if your recipient is out of action then your callee survives In a typical Simula I program (C++ Java PHP C# etc) if you fatal in your recipient's object your callee and the entire program is going to come crashing down, in something like erlang the callee can keep going Before jumping to putting everything on a queue, there are downsides like you've…

Why better without async? You feel the same about std::async?

As parent mentioned, there is overhead to using async: both in actual execution (e.g. likely spinning up another thread, plus creating a future object) and cognitively (in terms of following control flow, and knowing when exactly things are happening).

It's not that it isn't great when you do need it, but there are also plenty of cases where you don't need it and it's just unnecessary overhead.

Re: Alan Kay and OO Programming

#74

Post by cryptos » Tue, May 21, 2019, 2:48 PM UTC

What Alan Key describes reminds me of actor systems like Akka. Each actor is like a "cell" isolated from other "cells". An actor receives messages of arbitrary types ("messaging" and "late binding") and can do what it wants and whenever it wants. Actors can form a hierarchy to handle errors. This again is much like how cell handle injuries.

Interesting is that the Akka community put a lot of effort in implementing statically typed actors. But as far as I know (I'm not quite up to date) there is no final solution to it. It is controversial if it is even the right thing to do.

Re: Alan Kay and OO Programming

#75

Post by PunchTornado » Tue, May 21, 2019, 2:48 PM UTC

jompe wrote: post #29

cryptica wrote: post #21

>> Extreme late-binding is important because Kay argues that it permits you to not commit too early to the "one true way" of solving an issue (and thus makes it easier to change those decisions), but can also allow you to build systems that you can change while they are still running! >> Binding can also refer to binding a variable type to data. As someone who has over 15 years of experience going back and forth betw…

I'm a fresh graduate from uni so I'd say that I don't have that much experience. My last years working on the side of studies using Python really made me prefer strongly typed languages like Haskell, Rust, Elm etc. My experience is that the compiler almost always finds my small errors and would-be-bugs which Python exposes at runtime (crashes with e.g. None-type errors). What would you say the benefits are with dynam…

I think you're confusing strong and dynamic. It's static vs dynamic and strong vs weak.

Re: Alan Kay and OO Programming

#76

Post by Zelphyr » Tue, May 21, 2019, 2:52 PM UTC

cryptica wrote: post #21

>> Extreme late-binding is important because Kay argues that it permits you to not commit too early to the "one true way" of solving an issue (and thus makes it easier to change those decisions), but can also allow you to build systems that you can change while they are still running! >> Binding can also refer to binding a variable type to data. As someone who has over 15 years of experience going back and forth betw…

I think our industry has become rife with people who don't know its history. So we get people "discovering" new ways of doing things that were known decades ago. Take for example "JAM stack", also known as basically the way web development was done 20 years ago. It is touted it as something new and exciting when it's only so if you don't understand the history of web development. Sure, JavaScript is used more now than it was back then but that doesn't make Jam Stack altogether new, does it?

Likewise, statically typed languages aren't new and refreshing. They're just another way of solving a problem. Note I said they're "another way", not a "better way". They have their place (right tool for the job, etc...) but I think OP's point is that too many people think statically typed languages are better for everything and that's simply not the case. But one needs to understand the history of languages and programming in order to better appreciate the distinction and, more importantly, know which tool is the right one for the job.

Re: Alan Kay and OO Programming

#77

Post by potta_coffee » Tue, May 21, 2019, 2:55 PM UTC

armitron wrote: post #57

cryptica wrote: post #21

>> Extreme late-binding is important because Kay argues that it permits you to not commit too early to the "one true way" of solving an issue (and thus makes it easier to change those decisions), but can also allow you to build systems that you can change while they are still running! >> Binding can also refer to binding a variable type to data. As someone who has over 15 years of experience going back and forth betw…

We need to acknowledge that this particular field of, let's be generous and call it engineering, we are talking about is, for the most part, slow-moving and rather backwards to begin with. It's also shaped by forces and concerns that are suboptimal. As I wrote in the past: "Software Engineering must be the only engineering discipline where mastery of tools and barrier to entry in terms of skills are in many ways inve…

You sound like a really fun guy to hang out with. Also, a lot of those "clowns" are building things that make a lot of money and serve a lot of customers.

Re: Alan Kay and OO Programming

#78

Post by peterwwillis » Tue, May 21, 2019, 2:56 PM UTC

Some interesting points:

- One cell has protein molecules with 5,000 atoms each; 30% of cell is 120 million components that transmit information; About 100GB of state.

- The internet is the only successful OO program

- Your program should be able to change its code as it runs

My own interpretation of the "messaging" paradigm is this: you send 100 people a letter with some random symbols in it and say, "I would like a pony." Over time you will get letters back, and eventually you will get a response which is basically what you were looking for. Then you send more letters.

Also I'd mention that based on the bugs in the erlang code I've seen, it should stop being used as some kind of holy savior of the unscaling mess of OO code out there. I don't find it any better than C code.

Re: Alan Kay and OO Programming

#79

Post by munificent » Tue, May 21, 2019, 3:07 PM UTC

cryptica wrote: post #21

>> Extreme late-binding is important because Kay argues that it permits you to not commit too early to the "one true way" of solving an issue (and thus makes it easier to change those decisions), but can also allow you to build systems that you can change while they are still running! >> Binding can also refer to binding a variable type to data. As someone who has over 15 years of experience going back and forth betw…

> As someone who has over 15 years of experience going back and forth between statically typed and dynamically typed programming languages

I have >20, in a mix of dynamic and statically typed languages. I've even designed a few of both including some that straddle the line.

> It's a shame to see the new generation of developers moving back to statically typed languages

It's only a shame if you presume to know better than all of those developers. If dynamic typing was what they wanted, they wouldn't have added TypeScript to their existing JavaScript code. Personally, I trust that in the aggregate, developers aren't dumb and do understand their own pain points and solutions even when the pain and solutions aren't obvious to me.

> Many of the people who came up with or promoted the idea of dynamically typed languages had decades of experience working with punchcards, assembly code and statically typed languages; they were onto something.

Most of the designers of the initial statically typed languages came from that same era and technology background, so I don't think this argument carries much weight.

Neither dynamic nor static typing supplanted the other. They are parallel tracks and have been for virtually all of computing history (see BASIC and FORTRAN). Both branches are still going strong, so anyone on one branch isn't discarding the wisdom of the other, they're simply choosing their preferred path. If I use a hammer and you use a screwdriver, I'm not "discarding the vast amount of screwdriver wisdom", I simply know that I have a nail and not a screw to deal with.

One of the real problems I see with advocates of dynamic typing is that we for the most part, we have lost a dynamic code editing experience. Without something like Smalltalk's "open a code editor when an error occurs" live debugging/editing experience, you'll never get the real benefits of dynamic typing.

Editing dynamically typed code in a textual static user experience seems like the worst of both worlds to me.

Re: Alan Kay and OO Programming

#80

Post by zwieback » Tue, May 21, 2019, 3:13 PM UTC

jasode wrote: post #18

>, he realized that while software routinely has trouble scaling, cells can easily coordinate and scale by a factor of over a trillion, creating some of the most fantastically complex things in existence, capable of correcting their own errors. By comparison, the most sophisticated computer software programs are slow, tiny, bugfests. Kay's conception of OOP starts with a single question: how can we get our software t…

Yes, so true. I grew up with stacks of floppy disks with huge statically linked applications. The whole era was preoccupied with basically one massive problem: how to achieve modularization and some degree of reuse.

Now these issues are still important but cheap storage and fast, always available communication has changed software development to the point where Alan Kay's points sound a bit like misplaced puritanism. I respect him but I don't think his views have the relevance they once did.