Yxven

The trick to this is to attach a handle to the back of it. I'm using one that telescopes from the "popsockets" brand (I'm unaffiliated and have no idea how it compares with other brands). It makes it possible for me to access all parts of my screen holding it one handed. It should be a standard feature.

Are there any guidelines for what exactly this would entail?

My short term memory is falling off a cliff. What do I need to do to prevent that from getting worse? Are there any other bases I need to cover that I don't know that I'm missing?

You can premove as many moves as you want in a lichess correspondence game. I feel like you can even premove to whatever depth you want, but it has been a while since I've played.

I think this Rust complaint is just inexperience.

You wanted a Map<String, String>, and that's exactly what you should have made. A String is a convenience wrapper for storing a &str on the heap, so storing a String on the heap is redundant. The other options are for performance concerns, which you haven't mentioned any.

Lisp always sounds cool to me until someone starts talking about macros. What's it like inheriting a lisp code base, finding out its full of homemade macros like list comprehensions, and that they're not documented? Inheriting a code base is always scary, but I feel like it kicks it up a notch when your predecessors can customize the language itself. Are my fears justified?

You do realize that "vast selection of easy-to-use libraries" is the most important feature of a programming language. Right? It's up there with, "it's not hard to hire programmers for the language", which Python also benefits from.

Like, I'm partial to Haskell, but if I'm actually trying to get work done, I reach for a language with a robust ecosystem. These days I reach for Typescript, but before then, python was my go-to since it's way nicer to program with than java/c++/c/javascript.

Personally, I would love to ditch python for a language with strong types and type inference, but what is the replacement for django? Where do I find a well-designed, well-documented, battle-tested framework that I can easily hire developers for?

Currently, I think the nearest competitor is node with typescript, and I'd rather stick with python. Please tell me if I'm wrong.

I'm with you.

Haskell's Yesod framework is pretty feature competitive with rails/django, but it doesn't have 1/10th of the community.

I'd love to see Haskell gain wide popularity, but I don't think it's realistically going to happen. People generally travel the path of least resistance, and learning Haskell requires a lot of time and effort before you can be competitively productive with it. Individuals will choose to make that investment, but the masses won't unless they are forced.

I think the closest thing to what we want right now is node with typescript.

I'm not as skeptical of prolotherapy.

The idea is that it acts as an irritant which increases blood flow and other healing responses to that area. Tendons in particular are thought to heal slowly because they don't have great blood flow. This strikes me as similar to the ideas of dry-needling and platelet-rich plasma injections.

Find a newbie, stand behind them, and watch them struggle to use your program. Don't help them at all.

From a web dev perspective, I've heard a lot about React lately, so I learned it. I'm not saying it's bad, but I expected it to do a lot more.

Why did you do that, and what did you replace stock django with?

Would you be more specific as to why you prefer flask to django?

I looked at flask, and the code for views doesn't look much different. It does look like it's missing form and model validation. Do you use a library for that or do you not do that?

As a working programmer that is curious about category theory, I feel like this misses the mark completely. I watched this yesterday, and this is what I remember:

1) I will tell you why category theory is relevant to you, the working programmer.

2) Here are the 2 most important data structures that you don't use in your day job.

3) Look at how they relate in this mathy not applicable way.

4) Conclusion: lambda calculus is awesome.

What I would like to see is:

1) I will tell you why category theory is relevant to you, the working programmer.

2) Here is a realistic but simplified problem and a solution written in python that is obviously the wrong approach to solving the problem. With category theory, we know this is the wrong approach because the math is wrong (and don't go into the math).

3) Here is another example that seems like a decent approach to solving the problem. With category theory, we know this is the wrong approach because the math is wrong (and don't go into the math). Doing it our way has these benefits...

4) Conclusion: learn category theory to become a better programmer.

If you can't do that, find some other way to illustrate the concrete benefits of learning category theory. If there aren't any concrete benefits, it's like telling baseball players they should learn physics to have a better understanding of baseball.

Web development has the most innovation because it is the least entrenched. It is not hard to write a bare-bones web application that produces output that can be read on browsers everywhere.

Compare that to the difficulty of writing a cross-platform GUI framework. It's not even easy to write bindings for existing GUIs because it's hard to wrap C++ in a way that doesn't have you manually managing memory or discarding other language features and philosophies.

This is why we're seeing the Electron approach to GUI apps grow. It's easier to write bindings for chromium and feed it HTML.