Terminology Dictionary
Defensive Programming is a philosophy which anticipates errors and handles them in the code by never assuming a particular function call or library will work as advertised. When reusing legacy code and APIs, deprecated logic and validation patterns which may not account for contemporary security vulnerabilities are evaluated before adapting it for a modern application.
Technical Debt is unnecessary code developed in the process of rapid prototyping in the design phase to determine the scope of a project. The design should be refactored shortly after release to consolidate the excess code. This will the prevent the accumulation of redundant and obsolete code that will make maintenance more costly than anything. It will also balance the short-term convenience of rapid prototyping with the long-term need for minimalist code which is documented, well organized, and maintainable
Literate programming is an explanation of the program logic in a natural language, such as English, interspersed with snippets of macros and traditional source code. These macros are similar to the algorithms in pseudocode typically used in teaching computer science. These arbitrary explanatory phrases become precise new operators, created on the fly by the programmer, forming a meta-language on top of the underlying programming language. Literate programming forces programmers to explicitly state the thoughts behind the program, making poor design decisions more obvious. It provides first-rate documentation that allows authors to restart their own thought processes at any later time, and allows other programmers to more easily understand the construction of the program.
anonymous fuctions are used to assign a block of code as the value of a variable by storing it as an inline function without a name.
first-class functions are modules that can be passed as variables
overloaded functions have the same name, but accept different parameters
method signature is the list of arguments passed into the function of an object
Parsing is splitting strings into pieces
A procedure is a module that does not return a value
ODBC is open database connectivity
An iterator, which is sometimes known as a cursor or enumeration, is an extremely powerful interface for accessing items from a collection one item at a time. The word “iterate” means “repeat or do many times.” An “iterator” is therefore “something that repeats or does the same thing many times.” Basically, it is a looping construct where you don’t need to know the data structure in order to loop over it. The collection may store its internal data as a list, array, or query. It also takes the responsibility for traversal through collections of data away from the collections themselves and puts it into a standard iterator interface. Because it is separate from the collection itself, it also allows more than one iterator to exist at the same time. Additional iterators can be implemented that filter collections against certain criteria. An example of this may be an iterator implementation that only displays news articles based on defined preferences or one that filters corporate documents based on security level.
WSGI is an API for creating decoupled filters to transfer data between different protocols such as XML, SOAP, JSON, YAML, etc. A web service based on the WSGI spec can be used by any filtering application run by any framework
Named vs positional notation
Servers are computers hooked up to the internet via wired or wireless network connections. They store web content and listen for requests by web browsers or other clients asking for web pages. Upon receiving requests, they usually run scripts, query databases, or open files before responding to clients. If the server finds the requested page, it sends it back and the browser displays it. Otherwise, it sends back an error in the form of a numeric code, such as 404(not found) or 403(access denied).
A protocol is the language used by a client and server to negotiate the transfer of data, such as http, ftp, or tcp/ip (tcp disassembles data into packets, ip handles addressing and routing of the packets).
A clickjacking attack can be used to direct seemingly benign mouse clicks to these privileged buttons. For example, you may think you’re playing a game, when you’re actually starting a webcam recording. Using only CSS and HTML, an attacker can create a transparent IFRAME of a victim web page that contains privileged buttons. Underneath this transparent IFRAME, the attacker puts content, like a game, that entices the user to click. Although the user only sees the game, the mouse clicks are delivered to the transparent buttons, since they are on top of the game.
The buttons that the clickjacker directs clicks to are privileged buttons that require the user’s authority to work. Typically, this authority is expressed in the form of cookies, derived from the user’s password. Whenever the browser sends off an HTTP request, it includes all the corresponding cookies for the request target. This model for using authority is called ambient because the requestor doesn’t explicitly specify what authority should be used. Instead, the execution environment automatically adds all possibly relevant authority to every request. From the programmer’s perspective, things automatically provided by the execution environment, like CPU time and memory, seem to be part of the ambient environment in which they work, never explicitly mentioned, but there when you want them.
The most popular counter-measure for CSRF is to embed an unguessable secret in the legitimate HTML FORM element. Since the attacker doesn’t know the secret, he is unable to create a FORM that generates a POST request the server will accept. This use of an unguessable secret for access-control shifts the web-application from an ambient authority model to an explicit one. The unguessable secret embodies the authority to perform the request and it must be explicitly provided when making the request. A similar technique can be used to protect against clickjacking.
If the URL for a page containing privileged buttons included an unguessable secret, the attacker would be unable to create an IFRAME element that refers to the page. Similarly, the attacker would also be unable to navigate the web browser to that page at an unexpected moment. By taking away the attacker’s authority to display the privileged buttons, we take away the opportunity to play tricks with the timing and positioning of their display.
currying is the process of making a function call with multiple arguments split between callbacks. One argument is passed to an anonymous function. This function returns a function callback. The remaining arguments are passed to the callback as an array of the concatenated argument list. This is useful to avoid repeatedly passing in static parameters into a function. If you have a function which expects only one argument, you can use currying to extend it by returning a function which expects one argument, then returning the expected result. The closure scope retains the arguments from the parent function in order to reference them in the child functions, but.
/*
Inside the function curry is defined another function accumulator, which does the very obvious thing of accumulating the arguments.
The central thing, is the array sa, which contains the arguments so far (saved arguments), and then the function accumulator, which if called again, with not enough arguments, will collect the new arguments into the array sa, and then return, as the result, itself, so that the next call, will also collect arguments. If enough arguments have been collected, the function executes. Notice, that the apply uses the closure space to execute in, this is very important, as we shall see in a moment.
Also of importance, is how the arguments array is passed as an argument, to the new accumulator. Using closures, there is no real need to pass it, but using a closure, all curried functions, created like this, can only share the same arguments array! This is obviously not optimal, and there is no real solution I can see on this, which is why a copy of the array is passed instead of using closures.
In my old example, there was a bug in the code. After enough arguments had been accumulated, the function was executed, just as desired, but afterwards, the given arguments were not forgotten. The new lines nPrev, and saPrev resets to the originally captured values whenever the function has gotten enough arguments. This returns the arguments to its pre-not-enough-arguments-yet, each time it gets enough.
*/
function curry(curried_function, args_array, space)
{
// subtract the number of arguments passed to the function
// from the number of arguments the function is defined with
var num_args = curried_func.length - args_array.length;
var saved_args = Array.prototype.slice.apply(args_array); // saved accumulator array
function accumulator(more_args ,saved_args, next_arg)
{
var saved_args_prev = saved_args.slice(0); // to reset
var num_args_prev = num_args; // to reset
for(var i = 0; i < more_args.length; i++, num_args--)
{
saved_args[saved_args.length] = more_args[i];
}
// if not enough arguments where passed, then curry
if ( (num_args - more_args.length) <= 0)
{
// apply uses the closure space to execute in
var reset = inner_function.apply(space, saved_args);
// reset vars, so curried function can be applied to new params.
saved_args = saved_args_prev;
num_args = num_args_prev;
return reset;
}
// Curry the of the arguments
else
{
return function (){
// arguments array is passed as an argument instead of using closure scope,
// since all curried functions can only share the same arguments array
return accumulator(arguments, saved_args.slice(0), num_args);
}
}
}
return accumulator([], saved_args, num_args);
}
lazy loading is overloading a function within its definition using conditional statements. This is useful to avoid checking conditions each time a function is called by changing the logic of the function once a condition is met and implicitly caching the state
memoization is a technique for caching previously calculated values so that they need not be recalculated. To speed up the caculation of a collection of values, we save each value in a cache data structure. Later, if we use a function to compute the values, the function looks in the cache to see if it already knows the values. If it finds them there, it returns them immediately, avoiding the lengthy calculation. If not, it computes them, adds them to the data structure, and returns them to the caller. Memoizing trades space for time, since a memoized function may run faster than its non-memoized version, but it uses up more memory. Memoizing can be used to create a persistent cache in the file system, profile functions in order to see which ones can be sped up by optimization. It is not useful for functions that depend on utilities outside the argument list, such as the system clock, or functions that need to be run every time in order to perform exception handling. It is also not useful for return values that need to be mutable or cause side-effects, because multiple changes will reference the same cached value. The basic strategy looks like this:
var cache = [];
memo_function(callback_function)
{
var query_val = arguments[0];
if (query_val in cache)
{
return cache[value];
}
else
{
var func_val = callback_function(query_val);
cache[] = func_val;
return func_val;
}
}
Referential transparency means that a function always returns the same result if it is provided the same input. Arithmetic operations are referentially transparent: 5*5 can be replaced by 25, for instance. In fact, all functions in the mathematical sense are referentially transparent: sin(x) is transparent, since it will always give the same result for each particular x.
Reflow is the process generating objects using the layout engine of a web browser. HTML uses a flow based layout model, meaning that most of the time it is possible to compute the geometry in a single pass. Elements later in the flow typically do not affect the geometry of elements that are earlier in the flow’, so layout can proceed left-to-right, top-to-bottom through the document. There are exceptions to this rule: most notably, HTML tables may require more than one pass.
The XUL box layout model, on the other hand, is constraint based, meaning that geometric preferences and constraints of neighboring elements are taken into consideration before the elements’ final geometry can be computed. The box is the geometric primitive for the XUL layout model.
All HTML reflow, including the initial reflow, begins at the root frame, which corresponds to the element of the HTML document. Reflow proceeds recursively through some or all of the frame hierarchy, computing geometric information for each frame object that requires it. Reflow may have the side-effect of creating new continuation frames, for example, for a text frame when the text must be wrapped. Some reflows are immediate in response to user or script actions; for example, resizing the window or changing the document’s default font. Other reflows are incremental and are dealt with asynchronously; for example, when content streams in from the network. Incremental reflows are queued by the presentation shell for batched dispatch. Dirty reflows are a series of incremental changes to one part of the page which are combined into a single event.
A side-effect is a statement that causes a state change within a program, such as the assignment of a value to a variable.
lazy evaluation is executing an expression only after there is a call to return its value, rather than as soon as it is bound to a variable. You can potentially generate infinite output without exhausting memory using lazy evaluation, since no more values will be computed than the program requires.
dynamic programming is a variation on recursive programming combined with memoization to eliminate repetitive execution by caching previous results if some recursive calls occur more than once
Object Relational Managers provide an object interface to your database, with tables as classes, rows as instances, and columns as attributes.
A context object is a pointer to the parent of the current variable or function. In JavaScript, this is the context object for the element that invokes a function or has a function attached to it, such as this.id=’subnav’ in a DOM mouseover
recursion is the idea that a function can come to an answer by repeatedly calling itself with new arguments until a “base case” or “end condition” is met.
ex. pseudocode
function F with arguments
if end condition is not met
return F called with new set of arguments
else
return end condition value
information architecture is a diagram of the conceptual structure and organization of content. The objective of the information architecture diagram is not to provide a full-blown navigational specification; this level of detail is best kept in other documents, where it is less likely to confuse and distract.
strong typing is locking the type of a variable to the type of its initial value
weak typing is changing the type of a variable whenever its value changes
A cursor object acts as a handle for a given SQL query. It acts as a record counter which retrieves every row of the result, until all the matching rows have been processed.
Keyword density refers to the percentage rate that a particular keyword is used. If your article is 100 words total and the word ‘car’ appears ten times, then the keyword density for ‘car’ is 10%. Generally, SEO copywriting seeks to create keyword densities between 3-8% for keywords.
SERP stands for search engine results page. The list of results for a keyword that are returned after a search by a search engine such as Google.
RDFa is a set of naming conventions to define HTML content as a certain type of data through appending semantic values to specific class names in HTML
A constructor performs default actions, such as setting local variables based on function arguments, for every instance of an object
A callback is a function that is sent as an argument to another function. This is useful to apply a generic function to different data types. An example of a callback usage is a search filter which dynamically generates a sublist of items based on criteria checked against each item in the main list.
A functor is an object of a class type that implements the function-call operator, allowing the object to be used within expressions using the same syntax as a function call. Functors are more powerful than simple function pointers, being able to contain their own data values, and allowing the programmer to emulate closures, among other uses.
An internal iterator is a Higher Order Function (HOF) that takes a collection(array, struct, hashmap, list) and a function and applies the function to every element of the collection. Usually the Internal Iterator is a member function of the collection and therefore does not require a specific collection parameter.
Polymorphism means that the same method signature can have different implementations in each child class or interface which defines the method.
Auto Vivification is implicitly creating data structures accessed via name when explicitly creating their data, such as intializing a hash upon assigning the first key/value pair, or creating a folder upon saving a file in a new path.
An idle process generates output without any input, such as the top command in Unix
Algorithmic complexity refers to the time it takes to execute a function measured by big O notation. If something takes O(n) time to execute, its complexity is linear relative to in the size of data set. If it takes O(n^2), its complexity is quadratic. Using this notation, you should know that searching a list is O(n), a binary search through a sorted list is log(n), and sorting of n items takes n*log(n) time.
A closure is an anonymous function that shares the scope arguments and local variables of its calling function. In other words, the inner function contains the scope of the outer function. You write a function that contains a function. The inner function is a template for the functions that you’re writing over and over again, but with variables in it for all the things that vary from one case of the function to the next. The outer function takes parameters that have the same names as those variables, and returns the inner function. Then, every place where you’d otherwise be writing yet another function, simply call the outer function, and assign the return value to the name you want the “duplicated” function to appear. It can be passed around as a value and executed on demand by anyone who has that value, at which time. Now, if you need to change how the pattern works, you only have to change it in one place: the template. The inner function can be accessed only from statements in the outer function. The inner function forms a closure: the inner function can use the arguments and variables of the outer function, while the outer function cannot use the arguments and variables of the inner function. Closures can contain multiple scopes, and they recursively contain the scope of the functions containing it. This is called scope chaining. When no one refers to the closure anymore, it’s garbage collected, and the local variables go away.
A domain specific language is an abstraction of an existing programming language to make it possible for stakeholders to read code and facilitate communication between business and engineering. Design patterns are encapsulated as objects given semantic names. Relationships between these objects are created using intuitive logic to supply context missing from the abstract base language. This gives developers a universal way to describe different approaches to achieving similar goals. The essence of a DSL is building the semantics of the business into a mini-language, so the business people can read the code.
Language-oriented programming is a development style focused increasing the readability of code by simplifying the grammar used to connect objects and functions
Serialization is converting a language specific data structure into a binary string format so it can be transferred between file systems and servers or read by other languages. This is a good way to pass data without converting it to XML.
Higher-order functions are functions that operate on functions instead of commands or variables
A namespace specifies the scope of a set of elements and attributes that are in a document
An enumerated type is a data structure that has a specific number of string values which are mapped to an integer list for sorting purposes, such as a deck of cards (i.e. King, Queen, Jack, Joker, Ace, Deuce, 10, 9, 8, etc.)
Functional programming is a style of programming that emphasizes “first-class” functions that are idempotent. It was inspired by ideas from the lambda calculus. State is maintained in the values of function parameters saved on the stack (often placed there by recursive calls) rather than in global variables saved on the heap. This allows functions to be executed repeatedly without affecting global state (an important characteristic to consider when transactions are discussed later). It also opens the door for smart compilers to improve performance by automatically reordering and parallelizing code, although the latter is not yet common.
First-class functions have the ability to be assigned to variables, passed to other functions and returned from them. The ability to return a function supports selection of behavior to be executed later. Functions that accept other functions as arguments are called “higher-order functions”. In a sense, their operation is configured by the functions that are passed to them. The functions passed in can be executed any number of times, including not at all.
A side-effect is any command that changes the value of an assigned variable, which can cause unexpected bugs. Functional programs bypass this particular issue by simply not assigning values to variables at all. In practice, applications need to have some side effects. Simon Peyton-Jones, a major contributor to the functional programming language Haskell, said the following: “In the end, any program must manipulate state. A program that has no side effects whatsoever is a kind of black box. All you can tell is that the box gets hotter.” The key is to limit side effects, clearly identify them, and avoid scattering them throughout the code.
A monad is a function that does nothing, and has a side-effect such as opening a file, printing, or sending email.
Event Driven Programming is the execution of a queue of events that are triggered by user input. Callback functions only create event objects and add them to the queue so state remains unchanged.
Aspect Oriented Programming is the expression of event-driven programming through the use of callback functions or other means to respond to a local event that has global consequences without going through repetitive conditional checks or creating uneccessary dependencies between objects or subroutines
A subroutine (procedure or subprogram) is a portion of code within a larger program, which performs a specific task and can be relatively independent of the remaining code. The syntax of many programming languages includes support for creating self contained subroutines, and for calling and returning from them. They are in many ways similar to functions, but usually have side-effects outside of the simple “return value” that functions return. Some programming languages make very little syntactic distinction between functions and subroutines.
irb stands for interactive ruby. It’s a command line debugger built in the language.
Meta-classes are classes that contain information about class definitions. Each function in a class has a meta-class that defines the attributes for that function. Each attribute corresponds to a property in the meta-class. The values of each property in the meta-class correspond to the values of each attributes in the associated function. Meta-classes enable introspection of class definitions.
Classes may also be used as objects in their own right, as instances of a metaclass, the class MetaClass by default. When you declare class Dog, you’re actually calling a metaclass class method that constructs a metaclass instance (i.e. the Dog class) and then calls the associated closure (i.e the body of the class) as a method on the instance. (With a little grammatical magic thrown in so that Dog isn’t considered a bareword.)
The class Dog is an instance of the class MetaClass, but it’s also an instance of the type Class when you’re thinking of it as a dispatcher. If you treat the Dog object as an instance of Class, the user thinks the class is there to dispatch the user’s own Dog class methods. However, if you treat the Dog object as an instance of MetaClass, you get access to all its metaclass methods rather than the user-defined methods. You can get from the ordinary class object to its corresponding metaclass object via the .meta method, which every object supports.
In Python,special/reserved names are keywords which map to global functions, but these functions can be explicitly redefined(overloaded) for a specific class by assigning these names to a class function. __init__ gets run automatically when a class is first created. __str__ is run automatically when an class is output as a string. __repr__ is run automatically whene a class is output as a list, dictionary, or tuple. __call__ is called when a class instance is called as a function. __new__ is called to create a new instance of a class. __dict__ is called when you reference the key/value pairs defined in a class.
Scaffolding is a meta-programming method of building database-backed software applications. It is a technique supported by some model-view-controller frameworks, in which the programmer may write a specification that describes how the application database may be used. The compiler uses this specification to generate code that the application can use to create, read, update and delete database entries, effectively treating the template as a “scaffold” on which to build a more powerful application.
A ternary operation is a boolean conditional statement that evaluate a variable and returns one value if true or another if false. It can be used to create as a conditional jump or an alternative switch statement
ex.boolean variable ? value if true : value if false
Reflection is the process of assigning objects and functions to string variables to create pointers to them. This allows you to write code that generates code by evaluating a variable at runtime.
Homoiconicity is a programming language feature which treats the executable statements as first class data structures that can be used in variable assignments or executed at runtime without implicit interpretation or explicit compilation. For example, the “eval” statement in Lisp calls itself instead of an internal algorithm, and XSLT can be used to transform XSLT.
A persistent data structure is both dynamic and immutable since it creates a copy of itself each time its state changes and preserves the previous versions with either read-only(partially persistent) or read/write access.
A tuple, like a struct, is a collection of items of any type delimited with parentheses. Unlike structs, however, tuples are immutable.
The arguments property is an implicit array of all variables passed to a function. The primary use of the arguments property is to create functions which can dynamically change the number of arguments expected from each call.
An interface is like a class whose functions are not defined, which forces polymorphism when used
Refactoring involves rewriting or moving functions so that they are more reusable and follow coding standards and style guidelines
Coroutines are subroutines that allow multiple entry points and suspending and resuming of execution at certain locations. Coroutines are well-suited for creating iterators, and pipes. Subroutines can return only once; in contrast, coroutines can return (yield) several times. Yielding returns the result to the calling coroutine and gives it back control, like a usual subroutine. However, the next time the coroutine is called, the execution starts just after the yield call.
Continuations are functions that call other functions instead of returning values. When a function calls another function, that is the last thing it does. We add an extra argument to every function, which will be used to pass the function’s continuation. Instead of waiting for the called function to return, it puts any work it wants to do afterwards into a continuation, which it passes to the function. Essentially, this involves breaking up the code into a collection of callback functions.
Traditional control flow occurs when user procedures call library procedures. Library procedures may call other library procedures, but they never call back into the user code.
Inversion of control is a design pattern in which the flow of a program is determined by user input, as opposed to traditional flow in which user input is determined by the flow of a program
Generators are coroutines in which subsequent calls yield additional results. Generators are also a generalisation of subroutines, but with at first sight less expressive power than coroutines; since generators are primarily used to simplify the writing of iterators, the yield statement in a generator does not specify a coroutine to jump to, but rather passes a value back to a parent routine.
Encapsulation is consolidating a difficult procedure into an easy process by automating repetitive steps and only requiring manual input when necessary
Field encapsulation is sending a form field value to a function instead of writing repetitive regexp validation and type conversion code for each field
A foreign key is the primary key of another table that is used in joins or as a unique constraint. It should always be not null to avoid outer joins
Recursion is the process of calling a function within its definition. Recursive data structures are partially composed of smaller and simpler instances of themselves. For this reason, they are best applied to objects which fit this description, such as nested trees, multi-dimensional arrays, and multi-level hash tables such as the DOM. Nested lists are often searched using recursion as a substitute for loops. The definition is not circular, since at some point we will reach the root node, which does not have any children. The design pattern is such: if done, do base case; else, do this element, then the rest of them.
A model is the database API, like an active record pattern, which abstracts CRUD operations into universally used objects or functions. It is a collection of SQL functions used to access all tables.
A view is the event delegation API, which encapsulates validation and read/write functions. It is the HTML page with embedded server side variables.
A controller is the user interface API, which includes dynamic templates and effects libraries. It is like an action page in Coldfusion which verifies user input and calls the database API or the HTML page to insert or retrieve data while hiding the queries or absolute paths to secure data. In a switchboard framework, each module’s index.cfm page is a controller which uses a static URL parameter as a switch statement variable. Each case statement of the switch includes or redirects the appropriate view file to generate content.
Immutable data structures are those that cannot be changed after initalization. Data in functional programming languages is typically immutable. This allows data to be accessed concurrently from multiple threads without locking. There’s no need to lock data that can’t be changed. With multicore processors becoming prevalent, this simplification of programming for concurrency is perhaps the biggest benefit of functional programming.
A class is a collection of related logic and information used to generate copies of unique object which perform redundant tasks and communicate the results
Inheritance is copying data and actions from a specific class to a dependant class which has unique functionality
A mixin is the dynamic addition of functions to an existing class by either calling a standalone function or a function within a class. This can be done easily with standalone functions by using an include statement which calls the function’s file name in the object initializer or body of any class. This gives much of the benefit of multiple inheritance, but without destroying the simple model of single inheritance. There are object-based and class-based mixins, with the former being more complex than the above example but allowing for runtime extension of classes.
Lexical Scoping is using the latest value of a variable that is expressed before the reference is reached in a top down interpretation of the code
Dynamic Scoping is using the latest value of a variable that is expressed anywhere within the function where the reference is called
An object initializer is a list of zero or more pairs of property names and associated values of an object, written in object literal notation. These hashes are assigned at the creation of the object and for each subsequent instance.
A vector is an array that can grow as needed.
A binary tree is an ordered hash with multiple levels of inheritance
A hashtable is an associative array that uses a hash function to map items to pseudo-random slots in an array. With a good hash function, a hashtable can give fast, O(1) access for key-value lookups for mapping from names to particular values. You can also use hashtables to implement “sets”, which are useful to check if a tag is a member of the defined group of HTML inline elements, for example. Hashtables are also good for caches to map inputs to the already computed output.
A generator is a subroutine which is called like a function, but returns a “new” value every time it is called (i.e., it is emphatically not a mathematical function). The “random number generator” is prototypic of a generator.
A linked list is an array with next and previous node information
Bottom-up design is a philosophy of changing the language to suit the problem. You don’t just write your program down toward the language, you also build the language up toward your program. You may think “I wish I had such-and-such an operator.” So you go and write it. Afterward you realize that using the new operator would simplify the design of another part of the program, and so on. Language and program evolve together, because the code complexity tells you what ideas are easy to implement, what needs to be fleshed out or generalized, and what is too complex to pull off.
Top-down design is a philosophy of working around the language to solve your problem. You anticipate all the major functions you will need, then write down the requirements of each of those functions and repeat the process for defining child functions. These compartmentalized sub-routines eventually will perform actions so simple they can be easily and concisely coded. It provides guidance to request new functionality, try out new prototypes, and attempt to combine resources in more creative ways to achieve the design goals.
A method is a function associated with an object. You define a method the same way you define a standard function. Then you use the following syntax to associate the function with an existing object:
object.methodname = function_name
Data URI is a way of holding an embedded object in the current page so it is retained offline as bytecode instead of a reference. So embedded pages, images, plugins, data, etc. can all be embedded into the page, without needing to reference external files. The same can be done with images in stylesheets. This way, you can make a completely self contained page that you can pass to other people.
It also makes page maintenance much more easy. Say you are restructuring your site. You move files from one directory to another. So you have to find every occurence of the image tags, and rewrite them. With Data: URIs, the page with images would be completely self contained. To move the page, you just move the page, and the images move with it.
A union operator will combine the result-sets of multiple queries. each query in a union statement must have the same number of columns.
Monkey patching is modifying objects or classes at runtime to extend their functionality
A package is a namespace that organizes a set of related classes or functions.
A good package encapsulates the solution to an abstract by making the details transparent, such as converting a URL into an anchor tag with the proper hyperlink and title from the document itself.
A framework is a package which provides services and interfaces to fill the application-specific gaps with plug-ins and custom implementations of base functionality
A stack is a set of components which provided the basis for deploying applications. Building applications on top of a stack save time usually spent recreating common functionality and tedious utilities.
An application is the top layer of a stack that connects the services, enforces security policies, and integrates plugins to create a usable product.
An expando attaches additional properties to an object
An inner join defines a relationship between two tables where one or more key-fields are in common. In order for a record from the two tables to be returned, every described key field must match.
An outer join defines a relationship between two tables where all records from one or both tables are returned regardless of the existence of a matching key-field in the other table. A full outer join combines the results of both tables, filling in NULLs for missing matches on either side. A left or right join returns all the records from the first or second specified table, respectively, filling in NULLS for missing matching on the other table. A self-join compares a table to a copy of itself, and is useful for filtering out a specific subset of records from within a single table without returning duplicate or similar rows.
An intersect operator returns rows that are common between two tables without duplicate rows
An intersect all operator returns the same result as intersect, but includes duplicate rows
An except operator compare two tables and returns the rows that appear in the first but not the second result set without duplicates.
An except all operator returns the same result as except, but includes duplicate rows
An except distinct operator is equal to the minus operator in Oracle
Parameterized queries are SQL statements in which each variable used to query or update a table column is statically typed
Prepared statements are SQL statements that separate data binding from execution. Separating statement preparation from execution can be more efficient for statements that are executed multiple times, because the preparation phase need be done only once. For example, if you need to insert a bunch of rows, you can prepare an INSERT statement once and then execute it repeatedly, binding successive row values to it for each execution. A prepared statement can contain placeholders to indicate where data values should appear. After you prepare the statement, bind specific values to the placeholders (either before or at statement-execution time), then substitute the values into the statement before sending it to the database server.
The static keyword makes class methods accessible via the class prototype (using the :: scope resolution operator in PHP) instead of through each instance of the class object
The private keyword limits visibility only to the class that defines the item. That means child classes do not see the private methods of the parent class and vice versa.
The protected keyword limits visibility only to the base class and its child classes derived from it.
The final keyword prevents child classes from overriding a method by prefixing the definition with final. If the class itself is being defined final then it cannot be extended.
The this keyword allows you to reference private and protected data through public methods of the same class
The interface keyword defines an object interface, which allows you to create code which specifies which methods a class must implement, without having to define how these methods are handled. Classes that implement interfaces define their methods. All methods declared in an interface must be public, this is the nature of an interface.
The abstract keyword creates a class defining an interface only, so they cannot define the implementation of its methods. Classes that inherit from them must define the implementation. Any class that contains at least one abstract method must also be abstract. When inheriting from an abstract class, all methods marked abstract in the parent’s class declaration must be defined by the child; additionally, these methods must be defined with the same (or a less restricted) visibility. For example, if the abstract method is defined as protected, the function implementation must be defined as either protected or public, but not private.
Overloading is having more than one function with the same name in the same scope or having more than one operator with the same name in the same scope. It is not possible to overload across different scopes. Overloading in PHP provides means to dynamically “create” members and methods. These dynamic entities are processed via magic methods one can establish in a class for various action types.
Type hinting binds function arguments to specific objects or strongly types them
as array objects
Late static binding uses the keyword static to change the
context of a static reference to the calling object, instead of the prototype, which allows child classes
to inherit static methods which reference themselves rather than their parents.
A correlated sub-query is a sub-query that uses values from the outer query in its WHERE clause. It is an alternative to using an outer join.
A union all statement is taking two of the exactly same structured tables and making them into one table. For example, if tables named CompanyA and CompanyB had the same columns, you could run a UNION ALL query to make them appear as one table. For example, this allows us to see each employee who is in a department and each department that has an employee, but also see each employee who is not part of a department and each department which doesn’t have an employee.
Idempotence means that every time you make a same request, the same action occurs. In the HTTP protocol, the GET, HEAD, PUT and DELETE requests share this property. Functions that always return the same result when passed the same arguments are idempotent, as opposed to being dependent upon the state of the arguments which can change with time. This makes them much easier to understand, debug and test. They have no side effects such as changing global state or performing any kind of I/O, including file I/O and database updates.
ACID is a set of guidelines for guaranteeing the integrity of database transactions. It consists of the following principles:
Atomicity Atomicity states that database modifications must follow an “all or nothing” rule. Each transaction is said to be “atomic.” If one part of the transaction fails, the entire transaction fails. It is critical that the database management system maintain the atomic nature of transactions in spite of any DBMS, operating system or hardware failure.
Consistency states that only valid data will be written to the database. If, for some reason, a transaction is executed that violates the database’s consistency rules, the entire transaction will be rolled back and the database will be restored to a state consistent with those rules. On the other hand, if a transaction successfully executes, it will take the database from one state that is consistent with the rules to another state that is also consistent with the rules.
Isolation means that data is locked during a transaction. This is required to maintain the performance as well as the consistency between transactions.
Durability refers to the guarantee that once the user has been notified of success, the transaction will not be lost. This means it will survive system failure, and that the database system has checked the integrity constraints and won’t need to abort the transaction. Many databases implement durability by writing all transactions into a transaction log that can be played back to recreate the system state right before a failure. A transaction can only be deemed committed after it is safely in the log.
cross-cutting concerns are functions of a program which affect other functions. Since they cannot be completely modularized in both the design and implementation, the resulting code will either be scattered throughout different modules that generate necessary data or tied to specific modules that perform dependant operations. Logging changes to the a database is an example of a cross-cutting concern since it involves checking and updating multiple tables.
A caching proxy server keeps local copies of frequently requested resources to significantly reduce bandwidth usage and increase server response times.
pub/sub is an event-driven design pattern for getting notifications whenever an update happens within a data structure. An object subscribes to a data structure, establishing a link to receive the content of any status updates from then on. If any object publishes a data structure that matches that signature, then it will receive the data. If the subscription happens after the publication, any previous updates will be missed unless they are saved in a global archive which the object can check upon subscription
As opposed to event delegation, error handling for failed event targeting has to be custom built, and storage of past events is a must. In addition, scalability is a concern since the publishers may be overwhelmed by bandwidth limitations as subscriptions rise, especially if content is encrypted. Concurrency to handle multiple publish actions in parallel must be designed at the beginning to prevent throughput issues as well.
decorators are a metaprogramming technique use to dynamically redefine an algorithm by passing the existing object itself as a parameter to one or more alternatives the reimplement it. It is useful for things such as recursively searching for all instances of an object and dynamically wrapping them with extra functionality such as memoization, argument type checking, or return value validation. In Python, décorators are instead use to redefine functions instead of classes. It is similar to currying, but redefines the function logic rather than the function return value.
REST is a methodology of offering data through a web service which uses URIs to uniquely address resources, HTTP methods (GET, POST, PUT, DELETE) and content types (text/html, text/plain, text/xml, etc.) provide a constrained interface, all transactions are atomic, and HTTP provides cache control. GET: Read(Copy); PUT: Update(Overwrite); POST: Create(Append); DELETE: Delete(Cut);
Each client request to the server must contain al information needed to understand the request,
without referring to any stored context on the server.
Behavior Driven Development(BDD) is a variation of Test Driven Development(TDD) in which requirements are stated in Given/When/Then conditional logic scenarios which determines the development of a module, as opposed to turning them into true/false unit test assertions. The form of those requirements is fairly rigid, allowing them to be interpreted by a tool that can execute them in a manner that is similar to unit tests.
ex.
GIVEN an employee named Bob making $12 per hour.
WHEN Bob works 40 hours in one week;
THEN Bob will be paid $480 on Friday evening.
Unit testing is like giving a separate bill to each couple or individual at dinner. Each person knows only their total plus the tip, and don’t care about the cost of the total meal. Integration testing is giving one check to the entire group, and asking everyone to calculate how much they owe. Sometime it works well, but other times you come up short and people start complaining about giving their fair share towards the total.
BDD leverages the concept of cause and effect and associates it with the software concept of input/process/output. The Given/When/Then convention stimulates better thought processes than the AssertEquals(expected, actual); convention. Given/When/Then is very similar to If/And/Then; a convention used to read state transition tables. One of the problems in BDD and TDD knowing that you have written enough scenarios (or tests). If you can enumerate the states, and events, then you know the number of paths though the system. So if Given/When/Then statements are truly nothing more than state transitions, all we need to do is enumerate the number of GIVENs and the number of WHENs. The number of scenarios will simply be the product of the two.
TDD was adopted as a way to describe low level requirements and drive the development of software based on those requirements. BDD was created to better analyse high level requirements, and drive the development of systems using a language better than unit tests. BDD is a variation of Finite State Machine specifications, and FSMs can be shown, mathematically, to be complete. Therefore, there may be a way to demonstrate that requirements are complete and consistent using BDD.
Continuous Integration is the process of automatically merging code revisions and building
testable packages to identify issues such as missing dependencies, path changes, and size limitations during development before the QA stage has begun. It requires a unit testing framework and configuration of the revision control software in order to be usable
GUI Pipelines are a functional programming style design pattern. Rather than providing a save dialog box containing a file manager to let the user specify where a program should write data, provide a save dialog box containing an icon (and a field to specify the name). The destination is specified by dragging and dropping the icon. The user can drop the icon anywhere an already-saved file could be dropped, including onto icons of other programs. If the icon is dropped onto a program’s icon, it’s loaded and the contents that would otherwise have been saved are passed in on the new program’s standard input stream.
For instance, a user browsing the world-wide web might come across a .gz compressed image which they want to edit and re-upload. Using GUI pipelines, they could drag the link to their de-archiving program, drag the icon representing the extracted contents to their image editor, edit it, open the save as dialog, and drag its icon to their uploading software.
Conceptually, this method could be used with a conventional save dialog box, but this would require the user’s programs to have an obvious and easily-accessible location in the filesystem that can be navigated to. In practice, this is often not the case, so GUI pipelines are rare.
A Storage Area Network is a network of storage disks. In large enterprises, a SAN connects multiple servers to a centralized pool of disk storage. Compared to managing hundreds of servers, each with their own disks, SANs improve system administration. By treating all the company’s storage as a single resource, disk maintenance and routine backups are easier to schedule and control. In some SANs, the disks themselves can copy data to other disks for backup without any processing overhead at the host computers.
References
Glossary of Programming Concepts
Code Examples of Programming Terms
WhatIs Technical Definitions Search
Blog at WordPress.com. | Theme: Pool by Borja Fernandez.
Entries and comments feeds.
