Genre not found
Artist not found
Album not found
Song not found

javascript void;
Richard Berry Lyrics


We have lyrics for these tracks by Richard Berry:

At Last At last, my love has come along my lonely days are…
Hey Henry You couldn't dance at all But now you're over ball The way…
Louie Louie Louie, Louie, oh, oh, me gotta go Louie, Louie, me gotta…
The Wallflower (Hey Baby, What do I have to do,) (To make you…
Visiteur La première fois d'sa vie qu'un homme a le bonheur D'entrer…

The lyrics can frequently be found in the comments below, by filtering for lyric videos or browsing the comments in the different videos below.
Most interesting comments from YouTube:

Heater

@Dirk Knight Don't get me wrong. I love C.
It's one of the smallest, simplest, high level languages that compiles to native code worthy of the name.
It allows one to do most of what would otherwise have to do in assembler. But portably.
A C compiler can be written by one person in a not unreasonable amount of time.
C compilers can run on very small machines.

As such I'm prepared to accept all the problems that can arise through use of pointers, endianness, etc, etc.

The syntax of C is mostly great. Which is why so many other languages today look like C. Java, C#, Javascript, Rust etc, etc...

However, C's syntax for declarations can very tortuous. So much so that people have written programs to decode C declarations into something human readable.
See: https://cdecl.org/

Hence I tend to agree that ""C declarative syntax" was an experiment that failed.



Joe Larson

This was interesting, but... I have to disagree with some of the most basic premises. Maybe that disagreement is based on lack of supporting conversation that addresses my thoughts, and I could come around.

Let's start with the idea that OO didn't solve complexity. Okay, that's fair. FP doesn't, either. Both are tools that don't solve complexity, but they also both make it possible to address more complicated problems. We are now solving significantly more complicated problems than we were back in 1980. OO combined with modularity have made it possible to not even think about huge parts of what we do. Back in 1980, the state of the art in display was using an ncurses library on a VT-101 terminal. How the world has changed.

To say OO "didn't solve the complexity problem" is basically moving the goalposts by about 6 football fields.

I also am not on board with some of the other "conclusions" some people have come to regarding things like inheritance. Inheritance is a tool. Composition is also a tool. The problem is when you use the wrong tool for the problem space.

There was a lot of interesting perspective in this talk. I'm not sure I agree with some of the broad arguments, but still, interesting.



Joe Larson

@Jessica Sunlight It solves one class of complexity, but it does it on top of a pretty strong source of already-solved complexity from garbage collection.

And it doesn't do a thing about networking complexity or a bunch of other things.

It solves one problem: data access in a multi-threaded (but not multi-process) environment. That's a nice problem to solve, and there are some specific problems where that's a REALLY nice problem to have been solved.

But it's one class of problem, and it doesn't have remotely the impact garbage collection had -- which is effectively on every single program written, where you can still have MT programs that don't worry about data access across threads.

I'm not trying to take away from that. It's a useful tool, one of many tools. It's not the be-all and end-all.

And it in no way solves all complexity. It solves one specific type.

But I've admitted I'm not a hard-core functional programmer. If there are OTHER problems it's solving, feel free to explain.



Joe Larson

@Jessica Sunlight It's unclear what you're replying to when you say, "Actually it does". What does what? I scrolled back, but couldn't guess what you were replying to, but it probably wasn't my most recent comment nor my original comment.

My best guess is your argument that FP solves complexity. But that's not really true. It solves one class of complexity, which you then talk about, and I never argued it didn't.

But that's only one class of complexity. It doesn't solve all the other classes of complexity. I'd suggest it solves approximately the same amount of complexity that garbage collection solves. I use the word "approximately" very deliberately and wouldn't care to get into an argument over semantics and don't know how you'd actually measure it, either.

But there remain huge complexity issues associated with (for instance) networking, microservices, and just the general difficulty of so many things we do. It's not like FP is a sudden cure to any of that. It eliminates the need to mutex lock in the same fashion that garbage collection eliminates the need to manage calls to delete and pay attention to who owns the data.

I agree with you that "doing everything in OOP is kinda a joke". But I've said that above. I'm not a purist. I'm a pragmatist, and I've repeatedly said to use the tool that makes the most sense at the time. I have little patience for purists. Maybe that's sloppy on my part. On the other hand, my employers have always seemed pleased with the amount I get accomplished. I must be doing something right.

Your statement about oop eternally fxing bugs while func is healed -- that's partially fair, although clearly a gross over-generalization. After all, eternal / 2 is still eternal.

I will probably never have the opportunity to become a hard-core functional programmer. I'm an old fart (58), and so I only have so many years left in my career. We aren't using functional languages at my current employer, and I'm too busy bringing in other tools to take the time to even think about this any time in the next 3 years. But it is interesting to see the discussions. 58 may not seem that old. There are probably a few people reading this thread that are older. But I can start collecting social security at 67, at which point I can become a full time author, if I want, and ditch programming entirely. That's only 9 years. Who knows what will happen in that period? 9 years is a long time in this industry. But can someone really be considered a master at any of this with, say, 5 years of total experience in it? It takes at least two (IMHO) to really make it through the paradigm shift, and there's still more time really getting into the groove. It doesn't help that I hate pretty much all weakly-typed languages.



Joe Larson

@Jessica Sunlight It's unclear what you're replying to when you say, "Actually it does". What does what? I scrolled back, but couldn't guess what you were replying to, but it probably wasn't my most recent comment nor my original comment.

My best guess is your argument that FP solves complexity. But that's not really true. It solves one class of complexity, which you then talk about, and I never argued it didn't.

But that's only one class of complexity. It doesn't solve all the other classes of complexity. I'd suggest it solves approximately the same amount of complexity that garbage collection solves. I use the word "approximately" very deliberately and wouldn't care to get into an argument over semantics and don't know how you'd actually measure it, either.

But there remain huge complexity issues associated with (for instance) networking, microservices, and just the general difficulty of so many things we do. It's not like FP is a sudden cure to any of that. It eliminates the need to mutex lock in the same fashion that garbage collection eliminates the need to manage calls to delete and pay attention to who owns the data.

I agree with you that "doing everything in OOP is kinda a joke". But I've said that above. I'm not a purist. I'm a pragmatist, and I've repeatedly said to use the tool that makes the most sense at the time. I have little patience for purists. Maybe that's sloppy on my part. On the other hand, my employers have always seemed pleased with the amount I get accomplished. I must be doing something right.

Your statement about oop eternally fxing bugs while func is healed -- that's partially fair, although clearly a gross over-generalization. After all, eternal / 2 is still eternal.

I will probably never have the opportunity to become a hard-core functional programmer. I'm an old fart (58), and so I only have so many years left in my career. We aren't using functional languages at my current employer, and I'm too busy bringing in other tools to take the time to even think about this any time in the next 3 years. But it is interesting to see the discussions. 58 may not seem that old. There are probably a few people reading this thread that are older. But I can start collecting social security at 67, at which point I can become a full time author, if I want, and ditch programming entirely. That's only 9 years. Who knows what will happen in that period? 9 years is a long time in this industry. But can someone really be considered a master at any of this with, say, 5 years of total experience in it? It takes at least two (IMHO) to really make it through the paradigm shift, and there's still more time really getting into the groove. It doesn't help that I hate pretty much all weakly-typed languages.



DanteNotAvailable

9:20 - We even have "`Considered Harmful` considered harmful" so there's that. One historical note: According to ESR's jargon file, while the article itself was definitely written by Dijkstra, the title was apparently supplied by Niklaus WIrth.

25:35 - I think there's the crux of my minor rumbling disagreement with "6/10 languages are C++ or C++ descendants" whereas I'd be totally on board with "6/10 languages are C or C descendents" (and i'd probably argue the number is higher). I really don't consider Java to be a descendant of C++ but a descendant of C and SmallTalk (all the C++-ish bits come from SmallTalk). Also, while Objective-C is different it's still a little similar because it started life as a C pre-processor. Funnily enough it's sort of got the same ancestry as Java but loved SmallTalk a little more than C(which is fair... SmallTalk was pretty interesting). To give Stroustrup his due, He was looking at the "C Experiment" from a different perspective than basically everyone else. C didn't solve the "program organisation" problem so therefore it failed.

Also a side note: It's funny that Swift is listed as being C-like (not inappropriately i'll add) because one tag line for Swift was "Objective-C without the C".

36:16 - But a huge part of the reason why distributed systems are so frightening is because of the tools that are available to us. Joe Armstrong wasn't afraid of distributed systems programming because his toolset was designed for building reliable distributed systems. I also think Alan Kay's world has, in some ways, come to pass since so much software these days is microservices all the way down. The key feature that took much of the industry decades to appreciate was isolation (not without reason... serious performance dragons lie here). If i am forced to assume that that other "object" is on a different computer then there's nothing i can do to alter or inspect it's details, i HAVE to use it's provided interface. in C++ (or Java or C# or...) it's difficult to enforce that outside of running it in a different process.

44:25 - Erlang, a language built explicitly for building distributed systems, is a functional language. Joe Armstrong(one of the creators) had as part of his thesis that share nothing immutability was a necessary precondition to a reliable distributed system. I don't think there's as much daylight between "build it like a distributed system" and "functional programming" that you think there is. Having said that, i agree that our implementations of OO and FP are diametrically opposed to one another but to me that says more that our implementations of OO fail at "build it like a distributed system".

49:20 - In fairness I think this is as much a sign of the hardware at the time as anything. The LGP-30 with it's 4096 word (about 15kb in modern parlance) drum memory was state of the art at the time. When swapping out parts of the operating system to get access to enough memory is a reasonable strategy, GCs are a waste of time because you're going to need to manually massage your data into place anyway. Garbage Collection became a reasonable general strategy when the amount of memory that could reasonably be expected to be available went through the roof (by contrast, a modern server machine with 15gb would be considered fairly small). This is still somewhat the case in the embedded and (in some cases) mobile spaces. These days of course the common complaint about GC is latency spikes (see https://blog.discord.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f ).



Peer Reynders

@Vladimir Kraus
> Does this really make sense to anybody else than FP freaks? LOL

Heraclitus: "Ever-newer waters flow on those who step into the same rivers."

i.e. functional programmers create a new river for every new observation.

"The Value of Values"
https://youtu.be/-6BsiVyC1kM

Functional programming is value-oriented - your mindset seems to be limited to "place-oriented programming" (i.e. imperative programming).

The Elm Architecture (TEA) - which specializes on web applications and therefore is UI-centric - is based on this principle:

* Model - the state of the application
* View - view = fn(state), visualization as a function of state
* Update - state = fn(state, action), i.e. functions that transform the old state to the new state based on an input.

Performance-wise Elm beat out Vue, React and Angular in the "A RealWorld Comparison of Front-End Frameworks".

So from that perspective "getting a new widget after passing the old widget through a transform" makes perfect sense because the old widget is part of the old state while new widget is part of the new state. That is less wasteful than it sounds because thanks to persistent data structures "new state" and "old state" can share the data that is common between them - thanks to immutability.

> But on the other hand OOP is very natural for human brain.

Richard Fabian: What's wrong? - Mapping the problem

"Object-oriented development is good at providing a human oriented representation of the problem in the source code, but bad at providing a machine representation of the solution. It is bad at providing a framework for creating an optimal solution."

> The problem with data oriented programming is that it is optimal for hardware but quite hard for human brain.

Richard Fabian: Data is not the problem domain

"When we consider the data from the data-oriented design point of view, data is mere facts that can be interpreted in whatever way necessary to get the output data in the format it needs to be. We only care about what transforms we do, and where the data ends up."

i.e. Data-Oriented Design doesn't concern itself with a representation of the problem domain but instead is entirely focused on delivering a solution that transforms data from one form into another. Much like RDBMS organize data for efficient storage and retrieval, Data-Oriented design seeks to structure and layout data for efficient transformation by the appropriate systems.

> And the problem of FP is that is is both unnatural for human brain.

That's an issue of familiarity. Familiar things seem easy, unfamiliar things seem difficult even when they are simple.

"Simplicity Matters"
https://youtu.be/rI8tNMsozo0

A pure function is much simpler than a stateful object. A system that does something "useful" is often implemented via an "imperative shell with a functional core", i.e. the side effects are pushed to the edge of the system.

> Hence FP is not the correct way.

Immutable values can be shared without issue across threads or even cores which can't be said for mutable values.

The interesting thing is that both data-oriented design and functional programming focus on the transformation of data - the big difference is that DOD does it in a "place-oriented" fashion for performance reasons while functional programming does it in a "value-oriented" fashion to gain the benefits of immutability.

From that perspective the design of Rust is interesting:
* It's an imperative language
* But it keeps an extremely tight leash on mutability by controlling exclusive access via unique references.
* So in many cases it leans heavily on FP idioms for "value-oriented programming".
* But it's perfectly OK with local mutability, i.e. "place-oriented programming" as it's needed for data-oriented design.
* As it's a systems language, memory layout can be controlled which is essential for DOD.
* It doesn't bother with OO features because if you value performance you shouldn't be using OO anyway.

As a result FP-style is quite common in Rust but the path to DOD is open for optimization purposes.



Vladimir Kraus

@Pisarenco Gheorghe Thank you, you gave me the best argument I could wish for. Does this newObject = setWidth(width, object) feel right and appropriate in your brain? So if you want to change some property of a certain widget, you take your old widget, then you pass it to some transformation function and get a new widget... so now you have two widgets... well... really? Is this really what you consider correct programming style? Does this really make sense to anybody else than FP freaks? LOL

The problem with OOP is that it is not optimal for hardware. Another problem with OOP is that some people get it wrong and tend to create complicated inheritance graphs which results in tight coupling. Not cool. But on the other hand OOP is very natural for human brain. We as humans are naturally used to think about things and problems as objects with properties interacting to each other. That is why OOP is so popular and languages which support OOP are among the most prevalent (except C which is prevalent because other reasons - hardware).

The problem with data oriented programming is that it is optimal for hardware but quite hard for human brain.

And the problem of FP is that is is both unnatural for human brain (like in your example newObject = setWidth(width, object) ) and inconvenient for hardware (immuatble copies everywhere).

Hence FP is not the correct way. It is good for academics and for a few freaks who love to fight their holy wars against other programming styles, which makes them feel somehow "elevated".



John Weiss

6:20 The code syntax and execution order are two different things!

I really like the implied conditional code syntax! The conditions <0, ==0, >0 are implied by position. Sparse! Love it.

But not a fan of code that's not broken into separate functions.

A language could conceivably combine an implied syntax with functions. Hypothetical example:
IF (BOATS - 1)
PROC1, PROC2, PROC3



Jeff McClintock

"Functional programming makes our programs less like distributed systems"

WRONG. Here's an example of a functional-style 'pipeline in C++. ('|>' is a pipeline operator that passes the output of one function into another, like a flow-chart).

auto e = str |> views::reverse() |> ranges::find_if(isalpha) . base();

If one is prepared not to take things too literally, this is so very very similar to what Alan Kay was talking about when he said it's a "bit like having thousands of computer all hooked together by a very fast network", because each function is like a highly modular self-contained 'computer' that communicates with the other over a 'high-speed network' (the pipeline). Conceptually Alan Kay was very close to the modern 'Reactive/Functional' style.

Apart from this niggle, I really enjoyed this talk BTW.



All comments from YouTube:

Jay Wilkins

He said C declarator syntax was a failure and indeed a lot of languages, like Java and C++, which directly borrowed from C/C++ abandoned it.

Richard Bloemenkamp

Instead of saying the best language has these features, I think we have come to a point where we should say: "If you are working in this domain and your task is to develop this or that, with these people in this existing environment, then the most interesting languages, development environments and archiving systems are these and for these reasons"

SimGunther

"Next paradigm shift" (functional programming) starts at 41:51

SimGunther

@Jonathan Higgs I hoped for the same thing, but now I'm just gonna use FP/DoD/procedural/declarative/reactive code by default and move to imperative/OO code when the default mode is inconvenient.

Jonathan Higgs

I was hoping for something interesting not another functional evangelist

Michael Weaver

Slight correction at 52:05, OO was very much a product of acedemia : https://www.google.com/url?sa=t&source=web&rct=j&url=https://medium.com/javascript-scene/the-forgotten-history-of-oop-88d71b9b2d9f%23:~:text%3D%25E2%2580%259CObject%252DOriented%2520Programming%25E2%2580%259D%2520(,his%2520Sketchpad%2520Thesis%2520in%25201963.&ved=2ahUKEwjEyLnAidHsAhU2_XMBHdoSAxgQFjABegQIARAE&usg=AOvVaw1V9uojy62DUR7Mh6laDk_T&cshid=1603675178267

Euquila

CPUs are not functional. They are procedural. If you need to make abstractions, write some declarative code with some good documentation. Otherwise, write well structured code where functions cut across data structures (not the other way around like in OOP).

sidekick rida

Could've avoided this video if it was titled "Functional programming: the next paradigm shift"

Heater

Bjarne did not say that C syntax was an experiment that failed, curly braces, parenthesis, semicolons etc.
What he said was that the "C declarative syntax" was an experiment that failed.

A view I can sympathize with.
Much of the rest of C surface syntax for conditionals, loops, functions, etc, lives on in C++, Java, Javascript, the new kid on the block Rust, and many others. Where it works very well.
Far from a failed experiment.

CARP

I agree. The speaker commenting on Stroustrup's "failed experiment" comment was criticizing a comment he never made! Typical Straw Man fallacy. Stroustrup was not talking about blocks or curly braces, semicolons or any of the stuff other languages retained, but of C's byzantine declarative syntax (declarations) which can get pretty hairy.

More Comments

More Videos