Well put. I wonder if a lot of this comes from classical piano players (which there seem to be a lot of, proportionally?) assuming that everyone who learns piano is necessarily aspiring to play those super difficult classical pieces one day. I've started picking up the piano with jazz in mind and it's hard to tell if a lot of the advice out there is spot on and I'm worse off for ignoring it, or if it's really just not relevant to me because I don't intend to play Bach or Mozart. A lot of it _feels_ irrelevant, but I hesitate to dismiss it when it's coming from people who are clearly a lot more experienced than I am.
This brings to mind something Ira Glass said about "the gap":
> Nobody tells this to people who are beginners, I wish someone told me. All of us who do creative work, we get into it because we have good taste. But there is this gap. For the first couple years you make stuff, it’s just not that good. It’s trying to be good, it has potential, but it’s not. But your taste, the thing that got you into the game, is still killer. And your taste is why your work disappoints you. A lot of people never get past this phase, they quit. Most people I know who do interesting, creative work went through years of this. We know our work doesn’t have this special thing that we want it to have. We all go through this. And if you are just starting out or you are still in this phase, you gotta know its normal and the most important thing you can do is do a lot of work. Put yourself on a deadline so that every week you will finish one story. It is only by going through a volume of work that you will close that gap, and your work will be as good as your ambitions. And I took longer to figure out how to do this than anyone I’ve ever met. It’s gonna take awhile. It’s normal to take awhile. You’ve just gotta fight your way through.
Couldn't this same reasoning be used to argue that we don't need for loops or functions because we have GOTOs? Boilerplate is tedious and error-prone to write and to read/understand in my experience.
It cannot. The syntax bloat forces structural cleanliness.
A lower level problem is addressed with a higher level fix. It would be better of course to not have bloated syntax, but not at the cost of better program logic.
As for tedium: Java programmers rely heavily on IDEs to "write" most of the boilerplate for them. The IDE fills in tokens automatically, and hides them visually with +/- boxes to the side.
Personally I don't hide it, and I do type each token by hand. Since the parent brought up tedium, I wanted to mention that there are solutions to it. IDEs hide bloat, but code review and other tools often don't.
Yep, then spend 2 years in pain from the tendonitis and ligament damage. Those tissue have a lot less blood flow than muscle so they can't keep up with stupid fast growth. Good form to prevent injury takes practice too, years of it! But I suppose if you are taking steroids you might heal faster in the short term.
Or just gain a pound a month and talk to a therapist about your body dysmorphia. A therapist is way cheaper than a surgeon. You'll also learn a lot about the limits of your body and learn a sustainable way to build strength and muscle.
For anyone else who happens by and has the same issue, vim had (has?) substandard syntax highlighting for javascript. Pulling in pangloss's vim-javascript (https://github.com/pangloss/vim-javascript) fixed that up for me. If you write JSX, you can pull in https://github.com/mxw/vim-jsx to get great highlighting for that too.
I wonder why text editor preferences are so personal. I use the same editor and probably 90% of the same config as this guy and was nodding along until I saw he remapped B and E. Horrifying! Those are fundamental motions.
I’m always surprised at the number of people who recommend mapping `,` as their Leader key; it’s almost as useful as its counterpart, `;`. I suspect that such people never learned vanilla Vi and use `f`, `t` and related line movement commands.
When I learned Vim, I started with the `vimtutor` tutorial. At the end of the tutorial, it suggests Learning the Vi Editor - by Linda Lamb (O’Reilly)[1] for further reading. I found this book to be excellent for providing a solid grounding on Vi – and its descendants such as Vim. For a while, I constrained myself to using Vim in Vi-compatibilty mode before using the many wonderful features provided by Vim.
I try to keep my vimrc as lean as possible so that I’m not reliant on having it available (even though I have it in a Git repository on my VPS) and it’s only in the last couple of years that I’ve started adding plugins to it (Syntastic and Unicycle).
"I’m always surprised at the number of people who recommend mapping `,` as their Leader key; it’s almost as useful as its counterpart, `;`. I suspect that such people never learned vanilla Vi and use `f`, `t` and related line movement commands."
I've been using vim for years, but I completely disagree with your statement. I rarely find the "," key useful, so to me it was a no-brainer to switch to using it as the leader. I just have ",;" mapped to the functionality that "," used to do.
I use ";" all the time, but searching backwards just barely comes up. Usually, I'll hit "home" and then repeat my "f" search if I need it.
Thanks for different perspective (and to otterpro and tasuki). I use `;` much more often than `,` but I still find the `,` useful when I’ve gone past the position I want to go to, e.g., typing `5fx` when I should really have have used `4fx`.
I agree that we shouldn't use "," or ";". I prefer to use SPACE as the leader key, as it is probably the most prominent key and also easiest to reach, but I can understand why some would use "," or ";" because of it's easy reachability and the fact that those keys aren't as used as often (at least for novice users). Perhaps it should be part of "best practice" in Vim.
> I’m always surprised at the number of people who recommend mapping `,` as their Leader key; it’s almost as useful as its counterpart, `;`. I suspect that such people never learned vanilla Vi and use `f`, `t` and related line movement commands.
I use `,` as Leader, as well as to search back if I happen to `;` over something I was looking for. I don't mind waiting 400ms (my `timeoutlen`).
I was listening to a recent TalkPython podcast with Dougal Matthews titled "Effective Code Reviews". Host Kennedy asks every interviewee what is their favorite editor. Dougal's answer: (44:35-44:48) "I use Vim all the time. Yeah, I work in so many remote servers and VMs that I have some scripts to kind of set up my Vim environment on that machine, and then it's just great."
Who knew it would be that easy to switch to your own personal VIM setup?
Does learning about the Lambda calculus have any take-aways for programming in modern languages, or is it more of a cool toy/mostly of interest for language designers and academics?
The lambda calculus teaches you how to build computation from a very simple evaluation rule called "beta reduction" which is just a fancy name for "search and replace" with function parameters. If you can find a system that can rewrite terms in such a fashion, you can compute whatever you want using the tricks you learn in lambda calculus.
For example, C++ templates were not meant to be Turing-complete, but they work by rewriting terms [1], so you can encode lambda calculus in it, and run arbitrary programs at compile time.
Philip Wadler does a better job than me at getting excited by lambda calculus. He calls it "the omniversal programming language", and claims that aliens will probably have discovered it [2].
I've found understanding the lambda calculus goes a long way to understanding functional programming—in particular, it does a wonderful job demonstrating just how simple the core ideas underlying languages like Haskell are, contrary to their reputations.
It's also a great way to get a deeper understanding of computation and how it relates to logic. The lambda calculus is special for being an incredibly minimal model of computation that's still expressive enough to write programs (albeit a little awkwardly). Expressing something you care about in lambda calculus is way easier than using a Turing machine directly or even programming in assembly!
I think lambda calculus encodes computable functions, but not algorithms, because changing evaluation order can make you go from O(n) to O(n^2) etc. To define time and space complexity, you need to assume something like Haskell's graph reduction. That's more complicated than starting with assembly and counting steps.
It gives a pretty facinating point of view onto computation in general.
You only the ability to define and call functions. Functions can only recombine their input. And somehow it is still as powerful as, say, python!
Don't need some built in math , invent numbers using function definitions. Don't need built in recursion, just implement it using functions as the y-combinator!
There are also some practical usages of the whole implement-data-as-functions idea. There are some libraries in haskell that do this, for instance, which means that the compiler can optimize dsl's.
I actually found myself factoring my code differently after learning lambda calc. It at the very least seemed to result in better code (c#) so I would say there is practical benefits.
Besides the uses of the lambda calculus for functional programming, Church Encoding is also a powerful tool for algorithmics, program architecture, and performance improvement.
