erlich

The library tree view is so terrible.

- 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.

I thought Lisp was suppose to be simple in that: it's all just lists.

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)

It seems as if there are actually a ton more special case primitives I need to know, when I could get away with a lot less syntax in other languages to be productive.

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 <name> (list of arguments)
      "docstring"
      (function body))

How do I read this as an s-expression?

I find it really useful to learn about programming by discussing code examples.

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?

It feels like a technology that didn't have such a resource-intensive tech-tree leading up to its discovery, so someone could have just discovered Transformers and Attention back then.

Would anything be that different today?

There are so many naysayers out there, but you have to admire the amount of free publicity he has generated.

I was just thinking the other day how everything Meta has put out on the frontend, I felt compelled to use it because of the hype. But I've ended up being frustrated by almost all of it.

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.

Technical founders usually have deep conviction behind an idea and need to build the proof-of-concept themselves.

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?

Especially in computer programming, I find that you really can take as much time as is given. You often can see people spending weeks on something that could be done in under an hour. The scope seems to grow with the amount of time you have, and the difficulty in asking for more time. Sunk costs also factor into requesting more time - if you have already spend a long time on something, its easier to get more time.

*The idea is to perform a task and produce a demo-able deliverable as quickly as you can in 30 mins. Then 1 hour. Then a day. Then a week.*

The idea is to force people to explore the fastest possible solution first.

I think this can help:

- analysis paralysis - you have to pick your library/framework/technology/approach super fast. There is so much choice and this can help force a quick decision and accelerate the learning by doing rather than by reading. - motivation - you feel the rush of a deadline in the first day...instead of the "I wish I had more time" feeling just before the deadline. - "it couldn't be that simple" - sometimes things can be really simple...especially if you step outside of your existing tech stack / process. There might be a library out there that does everything for you...but you embarked on a roll-your-own approach that has taken you months. This forces you to explore the quickest modern solution that you might have disregarded.

I haven't tried it yet, but was interested if anyone has tried something similar.

There is so much churn in software. For new kids its easy, you just pick up the latest thing. But for older folks, over the years you've placed bets on longevity of stuff, invested in the ecosystem, only to see those replaced overnight by new projects. It's despairing.

At every point, you felt like the tech was good enough, but then the community and ecosystem just packed up and left somewhere else - to something that is not debuggable, and has crappy IDE support, and is slow to compile (e.g. Rust) or even run (e.g. React). And this is going to keep happening.

Does anyone see this changing anytime soon? I just want to have one stack and master it.

I want to use TS/JS for computer vision stuff.

What is the best approach? Any good ports of opencv? Is WASM a possibility?