I find a lot of people's political arguments wouldn't compile because of basic logic errors, and I try to point this out. But not many people are interested in this kind of analysis, they instead prefer the tribalist point-scoring like the OP mentions.

I dream of a world where political debates can be syntax-checked. I'm sure you could do it with AI today.

But in the end its all about feelings.

I can't describe how many times I will just go along with someone's passionate ranting on something I disagree with and egg them along because its makes them happy. This is tribalism. I will disagree with the group, and if you saw me you'd think I was the strongest supporter, but I actually vehemently disagree with everything.

There are very few people it's worth having a real discussion with these days.

I don't change my opinion of people for what they think, but it's very rare to find people who reciprocate this.

I think your use of the word "world" is telling.

Trump, the Republicans, and the global right are focused on their citizens.

The Democrats and the global left are more focused on the world and their role in it.

It's no longer just two approaches on how we can have the strongest economy. Each party has a weighting for how much to consider every issue across the world.

For example, there are people who would be happy with less growth, lower income, but more action on climate change.

- You cannot shift+click select to easily add playlists into a folder.

- Any podcasts you follow cannot be moved into folders to tidy things up. They just clutter the sidebar.

- You have to click on a tiny arrow to expand a folder. Clicking on the folder navigates inside the folder.

The fact that podcasts are in the same Spotify mega-app is terrible too. And the podcast experience is a complete mess.

I listened to an interview with the head of Spotify product, and he talked about how great it was to have everything in this mega app. I just feel the opposite of everything he said.

It's one of the most popular services in the world, but has one of the worst user experiences of all the apps I use.

And they actually think they are doing a good job at it.

Comments URL: https://news.ycombinator.com/item?id=39775011

Points: 73

# Comments: 81

Would be interesting to see how the interpreter works actually...

I would guess it checks what `defun` is, which is a macro...then expands it, and the expansion should ultimately result in an s-expression, which is then parses? Is this right?

https://lispcookbook.github.io/cl-cookbook/clos.html:

> arguably one of the most powerful object systems available in any language.

https://en.wikipedia.org/wiki/Common_Lisp_Object_System:

> Another unusual feature is that methods do not "belong" to classes; classes do not provide a namespace for generic functions or methods. Methods are defined separately from classes, and they have no special access (e.g. "this", "self", or "protected") to class slots.

Love this.

And the multiple dispatch.

> :before, :after, and :around

Guess these are similar to aspect-oriented programming. Maybe useful for plugin systems.

> change-class

This looks pretty cool for GUI apps. So many times you want to change a component to something else.

I thought everything would just be s-expressions, and be consistent, so it would be easy to read to figure out what is going on.

But it seems like there are so many special constructs and macros, that make it hard to read. And behind the scenes of these macros it gets really complicated. Whereas in other languages its readable the whole way down.

E.g. How am I suppose to read this? How does it de-construct to s-expressions...and does it even? What is implemented natively in the interpreter? Does that language have built-in keywords?

I thought everything was suppose to be like: `(left . (left . right) )`.

    (loop for i in '(1 2 3)
        when (> i 1)
        return i)

Like maybe there is some simplicity at the very bottom, but that doesn't seem to matter in day-to-day programming.

Another example, the first think I see when I look at the language basics of how to make a function:

https://lispcookbook.github.io/cl-cookbook/functions.html:

    (defun  (list of arguments)
      "docstring"
      (function body))

Comments URL: https://news.ycombinator.com/item?id=37209654

Points: 7

# Comments: 17

There is a ton of code out there, and also blog posts, but I find it especially motivating if there is someone to discuss/debate with.

Sometimes there are great discussions on HN about such things when the right article surfaces.

What are the best places for this?

Comments URL: https://news.ycombinator.com/item?id=37074313

Points: 4

# Comments: 0

Would anything be that different today?

Comments URL: https://news.ycombinator.com/item?id=37045687

Points: 1

# Comments: 2

Computer graphics in films gives people an unrealistic expectation of what we can do. I would think a lot of people look at this CGI and then think such things are possible in real-time gaming/simulation.

Comments URL: https://news.ycombinator.com/item?id=36974184

Points: 4

# Comments: 6

I look at React from a Backbone lens. In Backbone, you had view with a model that managed a dom element tree. You could render whenever you wanted and exactly when needed.

> functional components...reducing development complications

Hooks and the like just feel like an entirely different programming language. It's impossible to trace what is actually going on. Yet, everyone ends up having to learn all the nuances and rules and know somewhat how they are working under the hood, and then also contort their code to work with hooks too.

React and these big frameworks draw people in because under the hood they are so damn complex that people feel like they could never write something like this themselves. But they don't realize that the code they actually need is extremely simple and something they can easily step-through with their debugger.

> we got directed data flow

We kind of didn't need it though. Think about your SQL database backend. It's a big ball of mutable state, and people get by fine with it. If I have an object, and just listen to changes to it, and re-render, its much easier than having some complicated event-sourcing thing going on.

So much of React's design is chasing this functional-programming purity kind of thing. Contrived examples can be made to look super elegant and clean, but then there are all these edge cases and the realities of interop with a big ball of DOM state. Instead of chasing these kind of concepts, the goal should rather be day-to-day developer experience. Which mostly involves debugging and tracing through code.

> Flow

Ocaml was a terrible choice. Things moved so slowly. No one could contribute. There were just so many usability issues and waiting for things to compile. Just an excuse to use shiny tech. And oh boy did they tell you often about how Ocaml was a great choice for such a project.

...

The peeve I have is the distortion of the ecosystem. For many years to come, no one can stray too far for React to innovate because of the familiarity and risk. Look at projects like Solid, Qwik, etc. It's not Meta's fault but more the community hype machine.

It really feels like Meta has led us on a shitty frontend path for the past 5+ years that we need to leave behind.

- Flow

- Jest

- Metro

- React

- React Native

- GraphQL

- Flux/Redux

Everything they do is just so overly complicated, and so many layers of abstraction rolled up in a messy ball of mud.

Letting such a large company lead the frontend space is a bad idea, because if they make a bad architectural decision they have to just keep rolling with it because they roll it out so widely internally, and improvements are very slow because of the business impact.

Simplicity in my book comes down to how comprehensible is your stack trace. A few lines of code calling into a giant magical function is not simple.

Comments URL: https://news.ycombinator.com/item?id=36958442

Points: 27

# Comments: 15

There is so much content I would block if I actually could. Completely disable YouTube Shorts on mobile. All snarky/sarcastic/political/ad-hominem takes filtered.

Devs are gatekeeping way too much. More no-code/low-code is the way forward. It's always just a balance of how much abstraction to add.

It feels like it's kind of assumed a founder would be a CTO/manager type. But usually you take the role of an individual contributor, and act as a product manager, engineering manager and senior dev and have to manage yourself. This kind of setup is actually rare out in a lot of later stage companies.

I find myself wishing I had a manager above me, rather than me becoming a manager and hiring someone else. But it seems wrong if I'm the founder.

Anyone else?

Comments URL: https://news.ycombinator.com/item?id=36724528

Points: 2

# Comments: 1