In their definition of programming languages types, I'm not sure I see how SQL which they cateogrize as declarative really differs from FP, especially with lazy evaluation. Both are a succession of functions applied onto a previously declared variable : just think of a long SQL query with many ctes modifying the previous ones; each of them can be thought of as a variable which takes its value from the application of a function on other variable (a bit like the let function in ocaml).
I always thought of LaTeX as being the prime example of declarative programming.
Yes Excel lately is turning into a really compelling product, using functions such as sequence (dynamic arrays), lambda (pure functions) and let (defining sub-variables). You'd think you're coding in a pure functional language, and that's great! Now, ff only Excel had a convolution function! But nonetheless it's a great GUI, everybody knows how to use it and sharing it is dead simple.
The one downside I can find is the lack of a good plotting library. And yes comments as well is something I miss a lot.
Interesting. I heard many good things about Pycharm, but it kind of looks bloated? How does it compare to VS Code (which is quite good (notebook and repl support mostly), but not great, in particular regarding the debugging experience)?
People always use bloated as an argument against something. Bloated framework, bloated linux distro, bloated ide…
What really is the problem with having all “the plugins installed”/features, nicely integrated, always compatible, reasonably configurable, maintained and with support vs inflating a minimal editor (framework, *) yourself, without all the advantages mentioned earlier.
Yes it may cost some cheap memory, vs costs of fixing plugins yourself.
My advice: Embrace it. Everything just works. Bloated in many cases is a non argument.
Disclaimer: long time bloated fan. Pycharm, django, monoliths. I rather spend time fixing things that matter.
That's... That's a huge stretch. I've been on an outdated version of pycharm for nearly a year now because they broke support for docker-compose in a pretty huge way. Moreover, I have yet to have a pycharm project where I didn't need to create my own docker override file.
Interesting, i recall doing that in the early days of the docker integration. It is pretty solid now. Also might have been the weird way that project was setup, but i do not remember the specifics.
Also cannot judge it because you gave no examples.
PyCharm has a great debugger. I am a longtime Pycharm user and have used VScode from time to time for python, and it seems like only now VSCode is catching up.
Pycharm is still better though in the general language support department. However I feel that if you were already a VSCode user, VSCode has become good enough. Pycharm like other IntelliJ based IDEs has many other QoL features which I can't find anywhere else. But if you haven't been using them already I doubt they would seem to make a difference.
The VSCode add-on manager also discriminates against users using VSCodium (The open source build of VSCode without Microsoft's proprietary "telemetry"). They simply will not let you install certain add-ons.
For large codebases PyCharm is superior, as VS Code usually chokes in its JavaScript memory usage before PyCharm's Java. You need to load large symbol datasets in the memory and VS Code seem to be struggling with this.
PyCharm autocompletion, autoimport, red underline errors and type hinting tools are also better than in VS Code.
VS Code Jupyter Notebook integration as better. PyCharm tends to do very badly with complex notebooks.
A VS Code setup with all the plugins required to make it do all the things I use daily in PyCharm is far more bloated. The debugger (including REPL) in PyCharm is phenomenal, the way Docker and other integrations work is almost seamless, the git GUI is way better (smart merge!)...
Yes, the memory usage is higher, but spending like 50 € on an extra RAM stick to run the program I spend 70 % of my work (and often free) time in seems pretty reasonable.
I use PyCharm for my job as well as for personal projects, and it handles large codebases with type annotations very well. I would compare it to Visual Studio (not Code) in the sense that it’s a batteries included deal, which means larger initial size but I use maybe two plugins.
To be honest I don’t use the type annotations given by the IDE that much, and I also only encounter them in my work code base (pymongo), so I can’t comment on that part. I was mainly commenting just on its ability to handle large code bases.
The IntelliJ git interface makes a lot of sense, and makes many helpful operations easy, like “compare what I have now to this particular commit”. The VSCode git interface, even with plugins like GitLens, seems to make these operations hard to get to, and how VSCode manages diffs with the staging area involved is totally bananas.
Aside from that, PyCharm has a slightly better debugging interface but otherwise it’s quite close to VSCode for Python development. Sane version control is a bit aside though.
I think that while it takes forever to boot up from cold, those monolith-style classic IDEs with their centralized caching (and most important, centralized AST caching) outrun (by a lot) those Language Server Protocol based text editors when you're jumping around and editing code.
Going around code is faster. Global search is faster. Autocomplete is faster. Refactoring is faster.
Using the Java Language Server Protocol in VS Code was very painful even for very trivial Java Spring Boot projects.
Granted, their boot and first pass of project analysis is really slow.
That being said I still use VS Code very often (as a cool text editor, not as IDE), and I have no clue how VS Code boots and feels so snappy when most other Electron apps that I use feel like unresponsive slow garbage.
VS code support for multiple Python environments and dependency handling (be that requirements.txt or pyenv or…) is really quite terrible compared to Pycharm.
VS:Code is not bloated yet. With all plugins accumulated for a certain project type it might be more bloated the visual studio memory wise. So the bloatedness deepends on what one is doing with it
Jetbrains IDEs are an industry standard, and has a quantified ROI on time saved.
First thing to think about: Pycharm is an IDE, VSCode is an editor. You're going to bloat VSCode to get anywhere near the functionality of Pycharm.
I believe jetbrains products have made me a better developer as it should provide more context and intellisense to give you guidance away from code smells and bad practices, without becoming a crutch (moreso for statically typed languages).
Also, very fond of the keybindings on macos as they mirror chrome, os, and electron applications.
This. As someone living in Japan, I would love an option to drop a dollar to read the economist or such for a day.
I rarely subscribe as, between work and a new son, rarely have time to keep up to date on a particular site, and the background stress of paying for something I'm not using is frustrating.
Recently stumbled upon this quite good YT channel, which also brands itself as aimed towards beginners, although in my opinion both the Susskind lectures and these 'physics mini lessons' would be best appreciated with at least some prior knowledge of undergrad physics.
Well you can manage to run the Wolfram Engine through a jupyter kernel directly in VS Code. Although, I believe when I set it up the output was an image, no matter the object being returned (for instance 2+3 would return an image of 5 black on white).
Totally unrelated since I can't access the website, but one thing that I'd like to see in a typing system used in data analysis is to be able to see the dimension of the data structures used. For instance, to be able to tell at compile time if a matrix multiplication is going to crash due to dimension mismatch.
So far, in Python at least, at best I can tell that it's a float array, without specifying the dimension (for example 2d for a matrix) or better, specifying its dimension is (n,p) where n and p are both type variables.
Kinda did, but mostly the first chapters, actually up to CNN chapter (where real modern DL start). But so far, I really liked what I read. It has a very good blend of code and theory, with hands on applications throughout the whole book. Most importantly, all those applications could perfectly be copy pasted into your own environment. So it actually reminded me of a very thorough tutorial on a framework, more say than a regular textbook, although the authors don't compromise on mathematical arguments (but don't get lost in it either, they skimmed pretty fast on regularization theory imho). If you've had previous exposure to classical ML, I think it's a fantastic introduction to DL, enough to get started.
I always thought of LaTeX as being the prime example of declarative programming.