381–390 of 519 posts
strace. Even after having learned many programming languages and contributed to various projects, it was only when I started using strace that I felt like truly, efficiently understand what any program does, and can reliably write programs that do things fast. I believe that "syscall oriented programming" (making your program emit exactly and only the right syscalls) results in clean, understandable software. Now I u…
Earlier quoted context omitted.
Seconded, although to be fair the choice of IDE doesn't really matter as long as it's relatively good. When I moved from vim to Jetbrains, one of the biggest things was seeing all the small errors including spelling mistakes. Being able to easily see and fix minor syntax errors or things like missing variables etc really makes a difference, especially when you are working on a codebase where that was missing for a lo…
The arrival of Language Server Protocol is going to make IDE-like functionality more evenly spread across traditional text editors, "modern" text editors and "IDEs". In Emacs I recommend eglot: https://github.com/joaotavora/eglot
LSP is decent, but I've yet to see any languages with the depth and quality of Jetbrains IDE support, by a fairly large margin. I've had to fight VSCode settings many, many times in to world of Go, but Goland "just works" for the essentials - intellisense and code navigation is just so much better. Python and Typescript are probably the best-supported in VSCode, but they still don't meet the mark. Rule applies doubly so for languages that aren't strongly typed. Breakpoint debugging for code and tests is similarly hands off.
They add all sorts of ecosystem-specific know how to make the experience smooth, e.g. Rails, Rspec in RubyMine.
I still use command line tools for every other part of my workflows, e.g. Ripgrep, git, dependency management, but I haven't found anything else that compares for coding with really excellent intellisense and code nav, other than Visual Studio proper for C#.
Earlier quoted context omitted.
My life was also improved with some additional aliases in my git config: [alias] dfif = diff idff = diff grpe = grep
Nice! I create two-letter aliases, it truly helps: gc = git checkout gs = git status etc...
And then define one and two letter aliases for the things you do often:
st=status
l=log --with-prettiness
ap=add --patch
shit=reset
co=checkout
Earlier quoted context omitted.
For a very long time I didn't use anything besides just plain vim, 2 biggest things to add to your vim use is undodir and YouCompleteMe. Crazy that I didn't have either of these for so long, undodir I wish was part of the default.
I've been using vim for 20+ years and have never been into extensive customizations. That was part of the attraction, because I had to deal with a lot of remote servers, often off-shore. With out-of-the box vi/vim I could get the most done with the least number of keystrokes. Someone made a comment above about IDE editors with vim emulation. Wish every IDE would do that. RStudio for example is not exactly vim, but I…
Jupyter Notebook: https://github.com/lambdalisue/jupyter-vim-binding Jupyter Lab: https://github.com/jwkvam/jupyterlab-vim
- no “intellisense“, only word completion
- write down my operative “what do I do now” stack on paper (helps to not lose yourself in a forest of thoughts and fixes)
The second one I found very effective, because instead of guessing what function or method does or how many of them are there, you go to man/html docs and read on what it really is, how it works, and what its error modes are. This way I learn much more about APIs that I use, read rationales, caveats and more.
Also, intellisense when done wrong (and it often is) gets in your way and creates non-deterministic time-dependent modes for your input, even worse than vim-anxious people usually criticize it for.
Earlier quoted context omitted.
> I recommend starting with a gentle approach that doesn't require picking up a new language Disagree. This is likely to 'dilute' the lessons of functional programming, as it were. If you learn to program in idiomatic Clojure/OCaml/Haskell/Scheme, you can be relatively sure you really have picked up the principles of functional programming. If you merely attempt to apply new principles in an environment you're alread…
Some people say learning Latin makes you a better writer, smarter, etc. even if you're unlikely to directly use it. Dubious claims but it feels like FP can be like that.
For a simple example, val newList list.map(function Call(_))
Instead of val1 = functionCall(1) valN = functionCall(N)
2) Scheme. It started with writing plugins for GIMP in its embedded Scheme in the 90s, then I moved on to Guile -- but Scheme not only made programming fun, it put solving a greater class of problems within my reach, especially when I had to solve them quickly. When I need to explore an algorithm or rough out a prototype for how a system might work, I reach for Scheme -- and even when I'm not working in Scheme or another Lisp, I bring its lessons with me.
3) Darcs. This was my first DVCS, before git, and it enabled me to more easily use version control on my own independent projects and prepared me for a git workflow.
4) Linux, and open source in general -- for providing me with a free OS, free tools, and lots of code to examine for ideas and inspiration. Back when I was faffing about with Windows programming as a teenager, this was a real game changer.
Earlier quoted context omitted.
I upvoted the parent and want to emphasize vim key bindings. This is not necessarily vim the editor, it's your editor of choice in vim mode. Learning to use vim is like learning to touch type: it's initially a pain, but it's hard to ever go back once you've mastered the basics. If you haven't learned to touch type (it happens, I didn't learn until I was 22), then first learn that, then learn vim. FYI: Remap your caps…
I recently had a revelation: When typing longer shell commands it can be time-consuming to go back and make changes, turns out you can use Vim style cursor movements within the Fish: https://stackoverflow.com/questions/28444740/how-to-use-vi-m...
- Solid editor: I've used a few editors and IDEs in the past. I think a learning to use a programmable editor is a better investment than learning to work with an IDE. IDEs are generally single purpose: working very good for a limited selection of languages, platforms, etc. Having a good editor at your disposal allows you to manipulate any text oriented (and sometimes binary) format. When your editor is programmable…