HNHacker News
TopNewBestAskShowJobs

tgbugs

1,061 karma · joined April 11, 2019

submissionscomments
tgbugs··on Nicomachean Ethics
Another way I like to phrase this thought (without getting into the details about whether Aristotle and Nietzsche agree or disagree), is that morality is a system of rules for making decisions. Turing machines and computation more generally allow for the implementation of arbitrary decision procedures. However, if you want that those decision procedures to be consistent, you need something else, namely a set of axioms. Goedel, Turing, Church, etc. have proved (more or less) that there is no set of axioms that gives universally true answers for all decisions, so there can be no provably objective system of morality. Thus, we must choose our axioms, if we do not, we usually choose implicitly (which I think is related to Nietzsche's abhorrence of slave morality). Aristotle represents a set of axioms that are practically applicable to many human relations, representing a pretty good default, if you have to choose one. Nietzsche says, (to use the words of another) 'choose again.'
tgbugs··on Prefer associative ontologies to hierarchical taxonomies
In general I agree with the sentiment expressed in TFA and generally try to follow it when building new ontologies because asserted subClassOf hierarchies create a huge impedance mismatch between how the computer interprets them and what the designer thought they meant (e.g. I've seen people use subClassOf hierarchies to represent a partonomy, but more subtle variants in what "is a" means within a single hierarchy can wreak havoc on usability). It also allows you to defer the deeper modelling until a use case presents itself and build your hierarchies from the underlying structure of the domain (with data) rather than trying to impose an almost surely incorrectly hypothesis about the structure of the domain from the top down (without data).

That said, there are a number of cases where hierarchical taxonomies are vital in building information systems. Some examples.

A use case where you need a way to guarantee that a space is completely covered without duplicates (important for accounting, or creating menus). Having a single non-overlapping reference space (like a map) is critical for clear communication.

A use case where you need to capture some semi hierarchical knowledge from domain experts, e.g. an org chart, or the parts of a car, or the parts of the brain.

Org charts are the perfect example of the tradeoff. Consider the US Department of Defense (don't actually do this you will loose your mind). The chain of command is famously a single parent hierarchy, and if it is not, it is a sign that something can go wrong due to conflicting orders. However, let's say I wanted to know which branch of the military funded a certain research project based on the office that wrote the RFP. This question is pretty much impossible to answer for an arbitrary RFP, and the time and effort needed to maintain the full associative ontology and keep it up to date is stupefying huge, AND it is not even clear that such an ontology would actually be pointing to anything that was actually meaningful in the real world (beyond ill defined social and economic relationships between arbitrary groups of primates).

Hierarchies are an effective way to collect knowledge from domain experts in a systematic way that does not require them to know that they are writing down a bunch of axioms, but instead can just draw a diagram -- multiple hierarchies are very important here, because hierarchies from different experts usually agree at a high level, and then differ in the details, often due to the use case for the knowledge or from the experimental perspective, not because there is some fundamental ontological difference. In this sense having multiple hierarchies is a way around the problem of ambiguity in the meaning of "is a".

tgbugs··on We have to talk about this Python, Gunicorn, Gevent thing
Python pretends to be a nice homogeneous "everything is at run time" language, but it is all a big lie and there aren't big flashing letters saying "you really probably shouldn't do this" when you start solving a problem in a certain way. For example, it is almost certainly best practice to _never_ call a function, class method, or static method inside a module that is going to be imported, and certainly never instantiate a class. However, there are certain patterns that almost necessitate it if you don't want to write loads of boiler plate or deal with the performance overhead of metaclasses. There are also a bunch of nice hacks like using `object()` at the top level as an instance distinct from everything else, but I'm sure there is a way that `MYTYPE = object()` will come back to absolutely ruin your day if you have to compare two `MYTYPE` instances in two different dicts derived from a parent process and a subprocess.

I have personally made this mistake on two or three occasions where I conflated file/module behavior with class behavior because I wanted a python file to act like it was a bit more declarative. Unfortunately this leads to a world of eternal pain. You can work around it, but you should have made everything a python class and pretended like the files/modules don't exist or at least have staggeringly different semantics hiding behind that innocent little `.` operator. Python simply cannot support the desire to solve a problem in a certain way because of the structure of the problem and forces you into using its happy path patterns if you want it to work in slightly different run time contexts.

Two relevant posts from instagram engineering on the subject which suggest that best practices for avoiding these kinds of issues are non-obvious and easy to miss.

https://news.ycombinator.com/item?id=20708889 https://news.ycombinator.com/item?id=21284669

tgbugs··on We have to talk about this Python, Gunicorn, Gevent thing
This is a great review of what is going on "behind the scenes."

As the maintainer of about 5 little services with this structure I have vowed never to write another one. The memory overhead alone is a source of eternal irritation ("Surely there must be a better way....").

Echoing other commenters here, the real cost isn't actually discussed. Namely that there is a solution to some of these problems (re long running tasks?), but it carries with it a major increase in complexity. Its name is Celery and oh boy have fun with the ops overhead that that is going to induce.

A while back I did some unscientific benchmarking of the various worker classes for python3.6 and pypy3 (7.0 at the time I think?). Quoting my summary notes: 1. "pypy3 with sync worker has roughly the same performance, gevent is monstrously slow gthread is about 20 rps slower than sync (1s over 1k requests), sync can get up to ~150rps" 2. "pypy3 clearly faster with tornado than anything running 3.6" 3. "pypy3 is also about 4x faster when dumping nt straight from the database, peaking at about 80MBps to disk on the same computer while python3.6 hits ~20MBps"

I won't mention the workload because it was the same for both implementations and would only confuse the point, which is that there are better solutions out there in python land if you are stuck with one of these systems.

One thing I would love to hear from others is how other runtimes do this in a sane and performant way. What is the better solution left implicit in this post?

tgbugs··on The Need for Data Engineers
So many posts in this thread are spot on. I've heard descriptions of some tech positions being equivalent to 'internet plumbers,' well, having spent a two week rotation shadowing plumbers in my youth, I have come to think of what I do as more akin to being an 'internet garbage man.' I deal with the shit the no one else wants to deal with, or maybe more like an e-waste manager. There is gold in the shit, but no one wants to actually do the dirty work of building the system to move all the nasty sharp PCBs to somewhere that the precious metals can be extracted in a way that that delicate workers won't cut themselves to pieces.

No surprise, it is hard to find people who want to do this job and are good at it. I see the demand in the academic world ('scholarly infrastructure' is a very niche place) where it is nearly impossible to hire someone who can do this work, so hearing that it is also impossible in industry means I guess it is time to start training the undergrads :/.

I have an idea for a curriculum that could teach some of the principles for this kind of work (give them the gentoo handbook for a start, and see if they can follow it to get a database up and running from a box of parts), but I suspect that mostly it would act as a way to filter out people who simply don't like the activity, and you also have to have some amount of interpersonal skills in order to understand the use cases of your colleagues ....

Anyone who cracks this problem will have solved a far more general one in the process.

tgbugs··on The missing semester of CS education
In my graduate program (Neurosciences) the students with a computational background usually realize after about two years that all of our colleagues desperately need a basic orientation for how to actually use a computer to do real work. The only institutions that I know of that teach the kinds of courses we need are community colleges.

The curriculum presented here is an enormous community resource and I hope the other institutions recognize the desperate need for a course like this and allocate the resources to teach it.

tgbugs··on Emacs Lisp Animations
It merely subsumed it. https://github.com/pft/gimpmode

No need to be better than your competitors when you can simply eat them and steal their powers!

tgbugs··on This Page is Designed to Last
If it is for blocks of text then you could use #+BEGIN_VERSE in combination with #+ATTR_HTML, or possibly create a custom #+BEGIN_FRENCH block type, but I suspect that you are thinking about inline markup, in which case you have two options, one is to write a macro {{{lang(french,ju ne parle frances}}} and the other would be to hack the export-snippet functionality so you could write @@french:ju ne parle frances@@ and have it do the right thing when exporting to html. The macro is certainly easier, and if you know in advance what languages you need it shortens to {{{fr:ju ne parle frances}}} which is reasonably economical in terms of typing.
tgbugs··on This Page is Designed to Last
The issues outlined here are one of the reasons that I am moving as many of my workflows to org-mode as possible. Everything is text. Any fancy bits that you need can also be text, and then you tangle and publish to whatever fancy viewing tool comes along in the future.

I don't have a workflow for scraping and archiving snapshots of external links, but if someone hasn't already developed one for org I would be very surprised.

In another context I suggested to the hypothes.is team that they should automatically submit any annotated web page to the internet archive, so that there would always be a snapshot of the content that was annotated, not sure whether that came to fruition.

In yet another context I help maintain a persistent identifier system, and let me tell you, my hatred for the URI spec for its fundamental failure to function as a time invariant identifier system is hard to describe in a brief amount of time. The problem is particularly acute for scholarly work, where under absolutely no circumstances should people be using URIs or URLs to reference anything on the web at all. There must be some institution that maintains something like the URN layer. We aren't there yet, but maybe we are moving quickly enough that only one generation worth of work will vanish into the mists.

tgbugs··on Cyc
Amusingly, or sadly, depending on your perspective, in practical settings the default behavior of that question depends on exactly what you want human to mean in the vocabulary of the local use case, because continuants are a very leaky abstraction if they are used to type biological systems, and while to our 'common sense' the type of human and human shaving should obviously be the same, when you get to questions about whether seemingly insignificant numerical differences in rates of catalysis constitute differences in type, then suddenly the distinction between "protein" and "protein wiggling slightly faster than usual" or "protein binding molecule a" (think "human holding shaver") becomes very much not obvious depending on exactly what question you want to answer. In the protein example if you black box the system, they can be fundamentally different. If human means predator, and your question is how dangerous is this human, then "human" and "human holding razor" becomes "agentous thing" and "agentous thing with sharp edged object" practically different things in very important ways if you are trying not to be filleted.
tgbugs··on What Kind of Problem Is Climate Change?
One phrase that seems to be missing from the article is is larger category of problem -- a collective action problem. The public good framing has to do with a citizen/state relationship. The collective action framing reflects a state/state relationship. A number of the more technical terms throughout the article imply this, but I was surprised that the term itself was left out because including it immediately tells us that certain solution simply will not work.

Further note (edit). I think it is unlikely that a single state will ever be able to mitigate alone unless all other states stop or drastically reduce CO2 release. Maybe one state could threaten to set off a bunch of nukes in the upper atmosphere to destroy electronics and power grids around the world as a threat to encourage compliance, but that seems extremely far fetched.

tgbugs··on Racket2 Possibilities
Having followed this fairly closely, I will drop a though here while it is in my head. Surely there would be no obstacle to supporting s-expression syntax and allowing additional syntax around it. Everyone seems to see this as either-or, but is it really truly impossible to have a set of rules that say "you can't start a valid sexp with `(4` so this must be the start of an infix expression" and "you can start an sexp with `(add1` so I'll keep going"? Yes there will be a cost in the reader, but moving away from sexps is already going to be costly in that sense. Further, if we are going to incur the cost of a major complication of the parsing implementation, then why not go all out and allow interleaved expressions? What are the ambiguous cases that make this impossible?
tgbugs··on Writing a Ph.D. thesis with Org Mode
I wrote a docs api v1 -> org converter in python. I just pulled it into its own repo and it still has a bunch of dependencies related to how I handle auth for other projects, but if you want to take a look it is at [0]. There is an example of how I use the Docs class in an org source bock in the readme (note that I use evil mode, and that you need to view raw to see everything that is going on with the headers). It currently requires a little dance to get everything in the right place at the right indent level, but it could be fully automated. I'm in the process of writing a converter going the other direction in elisp, and I will probably rewrite the python into elisp at some point as well, but for now, following the keystrokes is faster for me than trying to reimplement it to integrate with the org-mode api.

As an overview I use the heading level in the google doc as the corresponding * level (e.g. h1 -> , h2 -> *, etc.). Nearly every construct in the google doc has a 1:1 mapping with some org mode convention (there are some things that I still write in org-syntax in the google doc, such as figure captions and stuff like that.

If I need to export to markdown from org I usually try pandoc (I very rarely do this though). Importing from markdown I use pandoc as well, newer versions do a pretty good job and only need a few tweaks from time to time. Latex export is straight forward using org-mode's built in exporter [1] via the export dispatcher. For full pdf export I use lualatex via texlive with all the pain that that entails.

0. https://github.com/tgbugs/gdocorgpy 1. https://orgmode.org/manual/LaTeX-export.html 2. https://orgmode.org/manual/The-Export-Dispatcher.html#The-Ex...

tgbugs··on Writing a Ph.D. thesis with Org Mode
I have been writing my thesis as an org-mode file in git that is automatically published [0] as a pdf every time I commit using a bash script tangled as a commit hook. Figures are (or can be) computed from live data, and org-ref can automatically manage and format all my references as I go without the insanity inducing workflows that one usually has to resort to. Another amazing thing about org-mode is that I can write a code block to hit a remote api (e.g. google docs) and fill and format entire chapters from a collaborative editing source that my advisor is comfortable using, C-c C-c and it is embedded in the document. Perfect for stitching papers together from a variety of sources.

While there is a learning curve, the peace of mind of having a single tool that enables me to use any tool I need to use was such a relief after years of other painful writing and publishing workflows.

If you are starting a PhD today and are going to do anything at all with code, I seriously suggest you learn org-mode. By the time you finish, not only will you have a PhD, but even if you don't you will have the power of one of the most amazing authoring tools under your command! (I would say, "Learn org-mode, simplify your life!" but emacs tends to lead to other complications).

0. https://orgmode.org/manual/Publishing.html

tgbugs··on Why Lisp Failed (2010)
Most of my day to day work is in python, but I have a number of projects in Racket and have been dabbling with common lisp. I think the author is simply incorrect here. Other algol like languages offer the illusion of understanding, but then you get things like 'patterns' where even though in principle you know what the atomic elements of the language mean you are confronted with an undocumented 'pattern' that you have to puzzle out to understand what the code is actually trying to do. Lisp provides structure for these patterns in the form of DSLs, and if that means someone has to confront that they don't know something, at least it whacks them in the face rather than giving them the illusion of understanding. More importantly lisps provide a way to formalize, specify, check, and document the pattern.

So if lisp failed for some internal reason then I don't think it was for the reason the author specifies. What should worry people more is that a language that is better in 99% of cases can fail for reasons that have nothing to do with its technical merits, but purely by accident of history or as a result of politics unrelated to those technical merits.

Trilobites were the most diverse clade in the history of the earth. Trying to rationalize why they went extinct by studying their anatomy is going to be fruitless. Same with LISP.

tgbugs··on Tagsistant: A Semantic Filesystem for Linux
Not quite. xattrs are not indexed, so if you want efficient retrieval by xattr tags you have to build/maintain your own inverted index. xattrs are good if you have a file that you want to store metadata about, but not so good if you want to use that metadata for discovery (at least in my experience, maybe I'm missing something, but I've implemented a remote file syncing system using xattrs and I never came across a tool in the unix arsenal beyond find + getfattr which is painfully slow).
tgbugs··on Major mode for editing SEML (S-Expression Markup Language) files
I've been using SXML [0] for all my sgml needs in Racket and the quality of life improvement from having a sane and regular syntax for everything is hard to overstate. seml looks like it might have the same kind of quality of life improvements for some of my elisp-only code. I'm not sold on the way that missing attributes are handled using nil, that seems like a design decision that was made to simplify parsing at the expense of making the representation more cluttered.

https://docs.racket-lang.org/sxml/

tgbugs··on Rethinking Files
In the context of http, we have HEAD, but we don't have something DATAHEAD, or METADATA, which would ask the server to provide you what _it_ thinks is the relevant metadata for the endpoint in question. You can fake this by streaming data, or using something like `Content-Range` _if_ you already know what _you_ think the incoming data is, but this means that the consumer has to already know what it is expecting, which kind of defeats one of the purposes of metadata. For example it would be great to be able to send a METADATA request to a url for a zip file and have the server send you back just the central directory (why did they put the central directory at the _end_ of the file?? -> edit: answer: because it was created at a time when you wanted to write the zipped data to disk in a stream so you wouldn't actually know what you had until the end, optimized for writing, duh).
tgbugs··on Rethinking Files
I've done some silly things [0] with python's pathlib recently that seem related to the issues discussed here. Given that smalltalk message passing finally clicked for me durnig the process, I am attracted to an object-like solution for everything (or a file-object-like solution for everything, since the practical performance advantages are undeniable). That said there are some considerations both for the low level implementation, and for high level things like affordances for 'file' operations.

In direct response to the suggestion about file paths for verbs. Allan Kay says in one (possibly many) of his talks something along the lines of 'every function should have a url.' The one of surely many challenges is how to ensure that the mechanism used to populate file system paths with nested functionality (e.g. /usr/bin/ls/all to `ls -a`) don't trigger malicious behavior during service/capability discovery. Being able to more deeply introspect file data and metadata as if the file were a folder could potentially be implemented as a plugin, and I worry about the complexity of requiring a file system to know about the contents of the files that it hosts, or that the files themselves be required to know about how to tell the file system about themselves. Existing file systems adhere to a fairly strict separation of concerns, since who knows what new file format or language will appear, and who knows what file system the file will need to exist on.

Said another way I think that the primary issue with the suggested approach is that it is hard to extend. The file system itself needs to know about the new type of object that it is going to represent, rather than simply acting as an index of paths to all objects. If there is a type of object that is opaque to the current version of the file system that object either has to implement a file-system-specific discovery protocol (which surely would have fun security considerations if it were anything other than a static manifest) or the user has to wait for a new version of the file system that knows what to do with that file type.

Some thoughts from my own work. (partially in the context of OJFord's comment below)

Treating files and urls as objects that have identifiers, metadata, and data portions and where the data portion is treated as a generator is very powerful, but the affordances around the expression local_file.data = remote_file.data make me hesitate. When assignment can trigger a network saturating read operation, or when setter doesn't know anything about how much space is on a disk, etc. then there are significant footguns waiting to be fired and I have already shot myself a couple of times.

The more homogeneous the object interface the better. However, this comes with a major risk. If the underlying systems you are wrapping have different operational semantics (think files system vs database transactions) and there is no way to distinguish between them based solely on the interface (because it is homogeneous) then disaster will strike at some point due to a mismatch. To avoid this everything built on top of the object representation has to be implemented under the assumption of the worst case possible behavior, making it difficult to leverage the features of more advanced systems. As with the affordances around local.data = remote.data, if I have a socket, a local file, a remote web page that I own, a handle to an led, a handle to a stop light, a database row in a table that has triggers set, the stdin to an open ssh session, and a network ring buffer all represented in the same object system, I have as many meanings for file_object.write('something') as I have types of objects, and the consequences and side effects of calling write are so diverse (from flipping bits on a harddrive to triggering arbitrary code execution) that it is all but guaranteed that something will go horribly wrong. At the very least there would need to be a distinction between operations where all side effects could be accounted for beforehand (e.g. writing a file of known length to disk has the side effect of reducing free disk space, but that is known before the operation starts), and operations where the consequences will depend on the contents of the message (e.g. DROP TABLES), with perhaps a middle ground for cases with static side effects (e.g. the database trigger) but that would not immediately visible to the caller and that might change from time to time.

The distinction between files and folders is quite annoying (non-homogeneous), especially if you want to require that certain pieces of metadata always 'follow' a file. This is from working with xattrs that are extremely easy to loose if you aren't careful. Xattrs are a great engineering optimization to make use of dead space in the file system data structure, but they aren't quite the full abstraction one would want. It is also not entirely clear what patterns to use when you have a file that is also a folder -- do you make the metadata the outer file and the data the inner file? Or the other way around? Having the metadata as the outer file means that you can change the metdata without changing the data, but that the metadata will always 'update' when its contents (the data) changes. However, when I first thought about using such a system, I had it the other way around, and a system with that much flexibility I suspect would have even more footguns than the current system.

Another issue is the long standing question around what constitutes an atomic operation. Everything is simple if only a single well behaved program is ever going to touch the files, but trying to build a full object-like system on top of existing systems is a recipe for leaky abstraction nightmares.

While I was working on this I came across debates from before I was born. For example hardlinks vs symlinks. There are real practical engineering tradeoffs that I can't even begin to comment on because I don't understand the use cases for hardlinks well enough to say why we didn't just get rid of them entirely.

0. https://github.com/SciCrunch/sparc-curation/blob/master/spar...

tgbugs··on Racket 7.3
For Racket specific macro tooling syntax-parse [0] in combination with syntax classes is usually the suggested starting point. Hygenic with pattern matching and a bunch of other features for parsing s-expression grammars. As mentioned down-thread Greg Hendershott's Fear of Macros [1] is a good starting point for a number of folks. The curriculum for Racket School 2018 [2] also has exercises that help introduce the syntax-parse tooling.

0. https://docs.racket-lang.org/syntax/Parsing_Syntax.html 1. https://www.greghendershott.com/fear-of-macros/ 2. https://summer-school.racket-lang.org/2018/plan/

tgbugs··on PySnooper: Never use print for debugging again
I have to say sometimes I do find it much easier to read logs than to muck about in an interactive interpreter. That said I did just add `export PYTHONBREAKPOINT=pudb.set_trace` to my bashrc and am slowly going through and removing all my old `from IPython import embed` lines. A much simpler workflow that doesn't incur major runtime costs.
tgbugs··on The Web is missing an essential part of infrastructure: an open web index
For many use cases I would imagine that an index that was a bit delayed might actually be preferred. I'm not entirely sure what you meant to imply by 'research purposes' but many of the use cases I imagine are scholarly use cases where something a more stable would be preferable. That said I seem to recall Henry Thompson telling a story about trying to do a study of the statistics of the net using common crawl. By the time he was done he ended up being less certain of the results, the understanding, and the methodological validity of anything related to trying to measure the internet by looking at a single snapshot of a subset of the link structure. Too hard to understand what you are actually counting.

edit: yep here it is https://doi.org/10.1145/3184558.3191636

tgbugs··on Applied Category Theory
When I saw the title I suspect that this would be David Spivak, and happily it is, I am also please to learn that he now has a new co-conspirator in the form of Brendan Fong. I first encountered Spivak's work via Category Theory for Scientists [0] which inspired me to try to come up with ways to use it for documenting scientific protocols. My chief complaint at the time was that someone had not already implemented many of the ideas expressed in his work. Despite the usual treatment of category theory as something mystical and opaque, I find Spivak's work to bring such clarity to communicating complex ideas. Those ideas are always going to be complex, but the way we communicate about them does not have to be. From a quick skim Sketches will provide further inspiration.

0. http://math.mit.edu/~dspivak/teaching/sp13/CT4S.pdf

tgbugs··on Research as a Stochastic Decision Process
This is a fantastic perspective on managing ignorance. It is told from a personal perspective, but there are fascinating applications of this at an organizational scale.

My initial thought was that the primary challenge here (which the author addresses in part) is in estimating the time it takes to complete a task. If you already 'know' how much time something is going to take then is there really uncertainty? How much uncertainty? The author seems to be going in the right direction, but there seems to be something more here about sources of ignorance that touches on the number of special cases in the problem space, or something of that nature. I wonder if there is any work trying to infer the number of special cases, or 'practical realities' of a problem space (maybe a kind of roughness, inhomogeneity, or irregularity?) that will ultimately be the major time cost.

Another thought is that 'bad' negative results don't have the provenance required to rule anything out, but if you know exactly what was done then you have much stronger evidence about where the problems might lie.

Finally this is deeply connected to another issue which is that sometimes we don't have the resources to devote to solving the really big problems so we never even try. The economics of cutting edge research only serves to drive us further from the hardest questions because we don't have anywhere to start because we haven't the faintest idea why we fail.

Somehow this reminds me of my first play-through of Darksouls -- the only thing that kept me going was the belief that it could be completed. My repeated failures were required for me to slowly gather enough information to see where I was going wrong. Funding basic research that is truly at the edge of the unknown is like only funding noobs that have never played before, or maybe more like funding good players from one game that come to another, they'll get there eventually, but they have to be able fail, and if you make them play Ironman mode then we might as well give up -- the game is too hard.

tgbugs··on Setting Up a Pi Hole Made My Home Network Faster
I run ublock, privacy badger, and noscript in firefox in addition to my pihole. Unlike the local in browser solutions pihole will sometimes cause extremely long hangs on poorly engineered sites that are hard to distinguish from network connectivity issues (because in a sense they are intentional network connectivity issues). For example, the chrome web store hangs because google essentially requires you to allow ssl.google-analytics.com and has a multi-minute timeout set (just checked and it is 140 seconds when trying to retrieve ga.js). After a while you learn to recognize when a site is having pihole issues and you go check the log.
tgbugs··on Emacs 26.2 Released
I 'switched' to evil mode about 2ish years ago and ported my entire .vimrc and all its quirks with no problem. There are some rough edges with some other modes not supporting evil by default where hjkl muscle memory can trigger functionality unexpectedly, but that is usually easy to fix. The only other thing you have to watch for is that emacs is overly strick about C-a b vs C-a C-b and this manifests painfully when using C-w l and friends to switch buffers. The easiest fix is just to bind C-w C-l as well so that you don't have to slow down your typing.

I have actually found it hard to go back to vim because emacs has been much easier to customize and many of the features I use routinely are no longer in my vim config.

← PreviousPage 9 of 9