Hack - in the context of code it usually means applying some non-standard or ungraceful solution to solve a problem.

Spaghetti - code that is difficult to maintain because it executes through unorganized and duplicated portions of business logic.

Magic - when there's so much abstraction the code executes and works "like magic".

Bug - cmon you know what this is!

Recursion - typically used when a function calls itself repeatedly to complete a task (this is actually the real meaning, though).

Hook - this could mean a ton of things, but it's basically when one thing "hooks in [or into]" another thing.

Bang - exclamation mark.

Pipe - vertical line.

User - some dumbass whose actions break the application.

Edit: Additions.

Handshake - The data exchange between two or more servers to authenticate the credentials (aka log in) a user.

Endpoint - An individual HTTP or other access protocol on a server, an example being when a browser uses Javascript to request data from a server to update the user interface.

Also on the topic of version control:

commit -- Save into a repository. In most cases, this refers to a local repository.

branch -- You can fork someone's repository, to make your own copy of it. The copy is its own repository, and is often referred to as a branch when it is unchanged from or closely related to the original, or was created for the purpose of pull requests (see below).

push -- Upload changes to a remote repository, such as Github SJWHub or Bitbucket.

pull -- This can refer to pulling changes and updating a repository locally, or to pulling changes from another remote repository.

pull request -- After pushing a commit to your branch of a repository, you can make a pull request: a request to merge the changes you made on your branch into the original repository.

"Big O". Doesn't mean a really great orgasm. Actually refers to the way the time (or occasionally space) taken by an algorithm increases as it has to compute over more data.

PEBKAC - Problem Exists Between Keyboard and Chair (Also applies to tech support and academia)

Overload - means that two or more subroutines are called by the same apparent words/symbols, but they are differentiated by context (e.g. one is fed integers, another text, but they both have the same name).

There are some excellent replies in here. I'll try to summarize them a bit and add on a few more.

First the summary.

• /u/Jeflakra's comment deals with source code management. This is perhaps the single most important thing outside the programming language related to programming.
• /u/whisky_cat's comment is a mixed bag you're most likely to hear programmers use around the coffee machine (mostly though these are tools of the trade).
• /u/Xenoprimate's comment touches upon a bit more abstract concept. This is vital when thinking about a problem, and how and what solution fits best. Remember though that efficiency has two dimensions: time and space and the Big-O analysis can be, and regularly are, applied to both speed and memory usage.
• /u/dast's comment is about types of programming languages.

Other interesting jargon (programming language agnostic):

• Buffer overflow -- accessing more memory than you are legally entitled to
• Infinite loop -- the very definition of insanity, to keep on doing the same thing
• Off-by-one -- typically, a special case of buffer overflow. Accessing just one more element than you can.
• Byte -- minimum addressable unit of memory. Can be 3. 9, 11 or 8 bits (most frequent). The others did exist though.
• Static and dynamic analysis -- code performance, security checks
• Secure coding -- making sure you're not leaving food for the hackers out there
• Tail recursion -- special case of recursion, typically optimized away by compilers. Can be inefficient otherwise.
• Compiler -- the code that turns programs to binaries (simplistic definition)
• Optimization -- time, space or both. Can be at function level, or at the whole program level.
• String manipulation -- dealing with strings. Can be tricky, and wasteful if not done right.

E*: Formatting

• non-trivial: impossible but not provably impossible. If a problem is non-trivial its probably easier to abandon whatever you are doing and try something else
• I don't know: no one knows, this is the age of google if a prepped expert is at a loss it's because mankind hasn't advanced that far yet.
• quadratic: your system is a toy, unless you are printing money capacity costs of your current infrastructure will eat you alive
• no problem: either the code is already written, tested, and shipped or the programmer is lying
• tricky, complex, hmm...: impossible many things in programming are impossible, very few programmers will admit this thus many euphemisms
• impossible, useless, stupid: I am lazy and don't want to do that, except when accompanied by a mathematical proof
• business needs: the user of this phase has no rational arguments however that doesn't mean they are wrong

Common programming paradigms:

Procedural: Code is organized into procedure calls (methods/functions/etc). Code executes one line at a time, and when a procedure call is found, current state is saved to the stack and execution jumps to the code in the procedure. When the procedure is done, the stuff on the stack is popped off and execution jumps back to the line following the procedure call.

Object oriented: like procedural except that methods and state are organized into objects. Each object is responsible for some chunk of functionality and hides the implementation thereof.

Functional: a paradigm in which functions are first class objects, think lambdas, etc. Too complicated to explain here.

In no particular organized manner:

• kludge - Not the most correct way to do something, but it works.
• backtick - the thing below tilde
• grep - find a text pattern in a body of text
• cron - A cronjob is something that can be scheduled to perform at given time or interval. You specify this in crontab.
• userspace - Also known as userland, as opposed to kernel. Kernel interacts with drivers, handles IO with CPU and memory, schedules system critical tasks, and so on. Userspace handles all the application resources, calls and so on. Userland interacts with kernel for hardware IO, interaction with filesystems, etc.
• map - a relationship between key and value. e.g. A map of A to B, A->B
• API - application programming interface, which often provides easy input output relationship in, but not to be used interchangeably with...
• SDK - software development kit, which is a collection of code and examples for developing with particular set of, but not to be used interchangeably with....
• Framework - which is basically a pre-structured way of programming. Sometimes providing a lot of...
• Libraries - which is a set of useful code that is included into the executable or into another library of codes.
• RESTful - something that has representational state transfer quality. Client need not know the structure of API to make REST requests. Simply put, using simple verbs like GET, PUT, DELETE, POST to say what needs to be done and passing parameters either as part of the request or as a payload in text and JSON.
• JSON - javascript object notation. A simple way to group information with curly braces.

• Hash (#)
• Bang (!)
• Shebang (#!)
• Whitespace: tabs and spaces

arbitrary code execution with privilege escalation

Camel Case - Using a capital letter instead of a space when joining words. totalTimeElapsed Pascal Case - Same but also the first word. TotalTimeElapsed.

Mutex - From mutal exclusion. Used in multithreaded applications to prevent two threads from accessing something at the same time.

Reentrant - Used to describe a function that can be called again before it has finished running the first time. Important in multithreaded applications.

Design Pattern - A bunch of ways to solve common requirements. There are to many to go into here but singleton, factory, flyweight, and iterator are some good ones to start looking at.

Alt F4 runs a quick virus scan immediately and removes any recent infections. I use it after any webpage I'm not sure of.