I used to be a hardcore functional programming weenie, but over time I realized that to do high-performance, systems programming in an FP language means writing a bunch of non-idiomatic code, to the point that it's worth considering C (or C++ for STL only, but not that OOP stuff) instead unless you have a good reason (which you might) for a nonstandard language.
The problem isn't Python itself. Python has come a long way from where it started. The problem is people using Python for modules where they actually end up needing, say, manual memory management or heterogeneous high performance (e.g. Monte Carlo algorithms).
No, I think it is fair to call out mediocrity, even when it tries to pull the "disclaim exactly the set of specific applications it gets called out on" trick.
Sure, pandas often beats raw python by a bit, but come on, there's so much mediocrity between the two that I doubt they even had to cheat to find a situation the other way around.
People create accidentally quadratic code all the time. It's even easier in pandas because the feature set is so huge and finding the right way to do it takes some experience (see stackoverflow for a lot of plain loops over pandas dataframes).
I can't even see what the reason for making an LSP implementation proprietary would be other than lock-in. The argument seems to be "we make it closed so that it can't connect to other things that are closed", which feels pretty silly. Being closed is bad when other people do it, but good when you do it?
I'm having a hard time finding the flaw with this logic, I use pyright but not pylance every day in Neovim and am not locked in at all.
Making "the LSP sever that leverages pyright" closed source sucks but is far from the end of the world. If the complaint is that pyright could eventually become non-OSS well that's true of everything.
It's about the VSCode ecosystems becoming more and more close source to accomodate the dev env as a service strat while using the FOSS root of vscode for PR that deserved to be underlined.
I noticed vendor lock in. He answered "we only lock the easy bits", which is already a weird idea. Like saying we are only not transparent on the small spending on our IRS declaration.
I then question the easy part by asking, tongue in chick, to tell me how I can do the same with FOSS easily. It's freedom I am talking about, not price. Indeed, the proprietary work in question is available without payment already.
We are warning people to not consider this platform the same way they consider fully free ones, despite the obvious wish of MS that they do so.
This platform comes with invisible strings attached, some of them will likely turn into chains in the future.
And it's MS new marketting strat to say they are open now for everything, so it's only fair we point out that the player matters. You are not dealing with the LSF or the PSF, but with MS.
MS has a long history of taking something (a tech, a concept, etc), playing fair for years to attrack people, then add more and more little details that in the end, lock you in into their ecosystem.
In this particular instance, MS has been pushing the "dev env in the cloud" commercial strategy for some times, using the openess of the VSCode ecosystem as on of the bait.
Don't get me wrong, I think VScode is a good product, and I can see the value of a dev env in the cloud that matches your local setup.
But given MS track record, I expect this to be likely a way to take control of your dev env: once it mostly resides on their server, you are locked in.
Parts of VSCode being not free are one of those little details I talked about. They hint at the direction MS is likely going to follow, as it used to do in the past.
Most authors at some point write about their process. I've read many accomplished, experienced authors' takes. Authors seem to agree that there's a struggle at the beginning to figure out a process that works for them, and do in fact take the time to tell others what worked for them to help ease the discovery process for new writers.
Here's some examples of famous, accomplished and prolific writers doing what you claim they won't do:
> Most experienced writers don't stop to tell people how to write.
That's not true. Anyone who masters any kind of craft sooner or later feels compelled to teach it to others. Humans are biologically driven and evolved to share knowledge. Many well-known writers wrote about writing. There are tons of different books about writing.
If it's only technical, then bots can implement it too.
If it's not only technical (e.g: you must be a verified token provider), then it will stop Linux/BSD communities, just like it's today near impossible to open a community mail server.
I believe it's the same with animal consciousness and intelligence.
It should be self evident.
Not that it mirror ours, but that they have something of a similar nature.
You have to remember that centuries ago, some humans assumed black people where, in fact, not human. Not having a soul. Not feeling pain as we do.
I remember the testimony of a person stating he once saw an African white master asking her black servant to check if electricity was on... by touching the wire. To her, they were not sensible enough to care.
This advice works only if 5 prerequisites are met:
- the coder is fluent in programming. Beginners will not know how to architecture things, and need to fiddle way more. It's impossible for them to create a doc that will make sense from the top of their head.
- The coder understands the problem well, and it has a known solution. Many problems are better understood when trying to solve them, by exploring its space while programming. It's impossible to start documenting something you don't know very well. It's espacially true if you have to come up with a novel solution.
- The problem is well defined. Unlikely. Clients don't define their problem well, and it's half our job to extract the information from their brain. However, while it is sometimes possible to get that on paper, and formalize it, most of the time, programming an incorrect PoC and iterating on it is a better interface to communicate with the client: they have a visual result to discuss. Writting a doc that you trash down every day would be a waste.
- The coder understands the field well. I'm currently working with a Bank, and I don't know the field. Many algo I must implement are in the head of my clients, and the quickest road to understanding them is to peer code them. They attempted to make a formal doc first of course. After 6 months, they still don't agree on how to do some things. One week of coding with me forced them to confront reality, and take concrete decisions.
- The coder has the big picture. Starting with a doc assumes you know what your API should look like. I would recommand that you do know, if you don't, you are probably in trouble. But it's a fact of life that sometimes you can't figure it out, and starting from something incomplete and coding it will make the big picture clearer.
That's a lot of pre-conditions.
My experience is that most teams starting with the doc (or tests) don't ship, or end up shipping only once they start fiddling. Those who do are excellent teams, the best ones, and I love working with them. But they are a rare bread. We are usually an average team, not ticking all pre-conditions, and not composed of only very skilled or experienced professionals. We fiddle a lot.
And unless you have a great team leader, taking such an ordinarity team and making it write the doc first will result in a terrible doc that doesn't match the solution to the problem, that you will rework again and again, while nothing is getting in the hand of the client for concrete feedback.
I favor a middle ground: start with paper, but don't pretend you are going to have a full spec.