Software Engineering Concepts & Keywords
Software Engineering / Microprocessors, Embedded Software, Firmware DevMobile-Handheld, Palm OS / ActionScript 3.0, MXML, Flex 4.5 SDK, Image Effects / AS 3.0 Polymorphism
jQuery, PHP, Database, MySQL / Dreamweaver, HTML, CSS, XML, Photoshop / Forex Trading Systems
| Introduction: | I'm familiar with these concepts and have worked with many of them with varying levels of expertise. There are mostly only keywords and sentence fragments below. Just look from one concept to another and notice the ones you know and make a note of ones you don't. |
| Software Engineering: | Definition of requirements, mapping requirements to functionality, structured analysis: data flow, message flow, entity relationship, timing and state transition diagrams, state machines, user interaction scenarios (use cases), object oriented, class, interface, abstract class, concrete class, front-end/back-end class, encapsulation, inheritance, polymorphism, composition, object oriented programming (OOP), programming to interfaces vs. sub-class polymorphism (inheritance), design patterns: singleton, strategy, model-view-controller, information hiding, separation of concerns, module coupling and cohesion, functional strength, YAGNI (you aren't gonna need it), the 80/20 rule, time/data synchronization requirements, naming conventions, namespaces, mythical man-month. Agile and Extreme programming methods I think are an attempt to avoid building something that is not wanted, and to provide an opportunity for stakeholders to stay on-board as the project develops and the existing design becomes locked-in.
For some projects, there may be too much uncertainty about requirements to lock in a design up front. For those designs, development can benefit from verifying incrementally what is wanted during development, creating the possibility of altering the design when the cost of change is lower. The suitability of these methods then will depend on how fluid the requirements are. |
| Microprocessors: | Central Processing Unit (CPU), CPU programmer's model, memory map of input/output devices and peripherals, Complex Instruction Set Computer (CISC), Reduced Instruction Set Computer (RISC), program counter, stack pointer, frame pointer, status register, data registers, address registers, general purpose registers, supervisor mode, user mode, opcode, mnemonics, instruction set, instruction alignment, instruction addressing modes, instruction pre-fetch, tracing/single-step, immediate, direct and indirect addressing, signed and unsigned arithmetic, read-modify-write cycle, level 1 cache (on-chip), shared memory, nested vectored interrupt controller (NVIC on ARM), exception processing, reset exception, vectored interrupt, software interrupt, non-maskable interrupt, exception vector table, bus error (access to non-existent address), exception stack frames, floating point co-processor, memory mapped peripherals, macros, in-line assembly, shadow the ROM or FLASH containing the exception vector table to location 0 during reset, JTAG, In-Circuit Emulator (ICE), big endian, little endian, binary, octal, base 10, hexadecimal, 1's and 2's complement, ASCII character set, subtract 0x40 from lower case char to capitalize, 0x0A (LF, Unix EOL), 0x0D 0x0A (CR, LF, DOS/Windows EOL) |
| Embedded Software, Firmware Dev: | Real-time operating system (RTOS), microkernel, soft vs. hard real-time, simple control loop, interrupt driven foreground/background system, cooperative vs. preemptive multitasking, round-robin with time slicing, task context, context switch, critical section, interrupt latency, preemption granularity (dispatch latency), intertask communication: mailbox, message queue, event flags, semaphore, mutex, priority inversion, priority inheritance, race condition, pre-allocate resources to prevent deadlock, release resources in reverse order that they were allocated, deterministic, fixed size blocks prevent fragmentation, mutual exclusion, atomic operation, test and set instruction (read-modify-write cycle), reentrant, interrupt service routine (ISR)... ... Pace yourself, keyword lists are far more information dense than sentences... EABI (Embedded Application Binary Interface: defines CPU register usage, parameter passing, and stack frames, etc), l-value, r-value, static vs. dynamic linking, position-independent code, arrays in C are never the same as pointers but pointers can be the same as arrays, a compiler generated stack is a LIFO (last-in first-out) queue that grows downward in memory for each function that is called, function activation record (data structure that supports the invocation of a function), stack overflow, a definition can occur only once (int x), but a declaration can occur many times (extern int x), a definition defines the type for an object and reserves storage for it, but while a declaration describes the type of an objects, it is used to refer to objects defined elsewhere, "Some authorities recommend that there are only two precedence levels to remember in C: multiplication and division come before addition and subtraction. Everything else should be in parenthesis. We think that's excellent advice." p. 47 ("Expert C Programming", by Peter Van Der Linden). Memory map, firmware, makefiles, start up/boot code, relocatable code, checksums, cyclic redundancy check (CRC-16), volatile keyword, real-time clock, watchdog timer, static initialized data section, interrupt and exception vector table, interrupt mask, non-maskable interrupt, debounce push button hardware, the bounce duration of typical button contacts is about 8 msec, Motorola S-Record and Intel Hex record binary data formats, tasks are infinite loops, using test points, chip selects, LEDs to debug with a logic analyzer, detect errant pointer self-modifying code bugs using checksums, measuring code execution to the microsecond using the stop watch in your wrist watch. UART (Universal Asynchronous Receiver Transmitter), RS232, RS485 (differential balanced line over twisted pair), parallel port, PLD, FPGA, Flash (nor), ROM/PROM/EEPROM/NVRAM, ADC (Analog to Digital Converter), DAC (Digital to Analog Converter), programmable interrupt controller, I2C, SPI, LCD display, keypad, printer, plotter, digital thumbwheel, rob-bit signalling (in-band) on 24-channel T1 line (1.544 MHz), second derivative for calculating change in rate of change, hw/sw serial flow control (RTS/CTS, DSR/DTR, XON/XOFF: Ctrl-Q/Ctrl-S), oxygen sensor, shaft encoder, strain gauge, thermocouple. NOR Flash supports full random-access and execute-in-place access and is a drop-in replacement for ROM, but has longer erase and write times, NAND Flash supports much greater storage density with reduced erase and write times, but data can only be accessed a block at a time (no random access) and it suffers from read disturb errors where reading one location can alter the contents of nearby cells (ECC-error correcting codes are used to manage this). NAND Flash is best suited where high capacity data storage is required. Flash operation in general is hindered by a finite number of program-erase cycles, but this can be improved through wear leveling and bad block management techniques. "The precendence rule for understanding C declarations is the one that the language lawyers like best. It's high on brevity, but very low on intuition. The Precedence Rule for Understanding C Declarations A. Declarations are read by starting with the name and then reading in precedence order. B. The precedence, from high to low, is: B.1 parenthesis() indicating a function, and B.2 the postfix operators: - parenthesis () indicating a function, and - square brackets [] indicating an array B.3 the prefix operators: the asterisk denoting "pointer to". C. If a const and/or volatile keyword is next to a type specifier (eg. int, long, etc), it applies to the type specifier. Otherwise, the const and/or volatile keyword applies to the pointer asterisk on its immediate left." ("Expert C Programming", by Peter Van Der Linden, p. 74.) |
|
Mobile-Handheld, Palm OS Dev: |
Zen of Palm design philosophy, limit feature breadth of apps to prevent the usability death spiral, handheld usage profiles are the opposite of laptops or PCs, design for small memory constraints, design apps to wait on input (and therefore sleep) to extend battery life, leave the heavy cpu utilization for the PC and laptop apps, Palm apps are event-driven and they implicitly quit when the user starts another app, simplify user interaction required to access the most used features, Palm OS is based on a real-time kernel, but apps have no access to multithreading and so are single-threaded, Palm OS uses the sub-launch to simulate cooperative multi-tasking in Palm OS, Palm OS 5 introduced multi-tasking app development, but only for native ARM apps, not for standard 68000-based apps, Palm OS Emulator (POSE) and Palm OS Simulator for debugging, Palm OS 80/20 rule: 80% of the users will only use about 20% of the features, short history of Palm Unfortunately, Palm's engineers were prevented from taking their next operating system, webOS fully into the market. The technical problems looked short-term and solvable. webOS is very innovative in that apps are webpages incorporating HTML, CSS and JavaScript code based on the Mojo and then Enyo Frameworks. webOS uses open source WebKit for its browser and has the Linux kernel at its core. HP then bought Palm and has since decided to (mostly) cancel webOS and instead open it up to outside developers. So HP is keeping webOS alive, but won't be building any products with it. Update 1: "LG Acquires webOS From HP To Use In Smart TVs" (2/25/13) Update 2: What LG's Acquisition of webOS Means for Its Open Source Projects (2/26/13) (HP isn't completely abandoning webOS.) |
|
ActionScript 3.0, MXML, Flex 4.5 SDK: |
Flash Builder 4.6 (Eclipse IDE), Flex SDK 4.5-4.5.1, (dnlds) (4.5 Rel Notes) (4.5 Info), (4.5.1 Rel Notes), (Flex SDK 4.6 dnld), (4.6 Rel Notes) (4.6 Info), Flex Developer Center, Vizzy Flash Tracer (Adobe) (Git),
Flash Player 9,10,11, swf file, Apache Flex (Wiki info), Flex LiveDocs (1-4), Flex Docs, Flex 3, Flex 4, MXML (Macromedia XML-based markup language), Spark and MX components, Spark components, Adobe AIR ( Wiki info ), Adobe Flash Platform, ActionScript 3.0 API Reference (AS 3.0), ActionScript 3.0 Syntax, was first available in Flex 2, then was incorporated into Flash CS3. Both ActionScript 3.0 and JavaScript are ECMA-script languages and both are event-driven, script cdata tag, timers, easing, tweening, skinning can be done using in-line CSS, by calling the setStyle() method, and by using CSS either from external files or within an embedded style using the <mx:Style> tag, call the ExternalInterface() API to call JavaScript code from Flex, use Embed keyword to embed an image into the program swf file, use Bindable keyword to bind a data value to a Flex control, Flex 3 and 4 offer quick prototyping of UI for controlling sophisticated event-driven algorithms in the background via ActionScript, and then CSS styles and skinning allow designers to take customization of the UI to the next level, when invoking a bound method, we need not specify the object on which the method should execute because the bound method will automatically execute on the object through which it was originally referenced (see Colin Moock, "Essential ActionScript 3.0", pg 67 for more), AS 3.0 does not support abstract classes or abstract methods (see Joey Lott's compile-time workaround in his book, "Advanced ActionScript 3 with Design Patterns"), for a more flexible polymorphism code to interfaces (says Joey Lott), avoid "stranded listeners" (registered anonymous functions that can't be unregistered since there is no reference to them), reuse objects if possible rather than "dispose" of them... ... Your favorite background music might help you relax and concentrate here... The Flex Image component works with the ActionScript BitmapAsset object (not Bitmap, not BitmapData), while the Flex Image component works directly with an Embedded image declared as a Class (eg: flexImg.source = embedImg; or in Flex: <mx:Image source="{embedImg}"...), to work with an Embedded image in ActionScript using non-Flex objects, instantiate the same embedded image using 'new', eg: var bmap:Bitmap = new embedImg(); and this will return a reference to a Bitmap object, be sure to initialize all BitmapData objects with 'transparent' set to true and use a 32-bit ARGB color initializer constant that includes an 8-bit alpha value (eg: 0x00000000, transparent black or 0x00FFFFFF, transparent white) or alpha transparency won't work on the object. |
| ActionScript 3.0 Image Effects for Flash Player: | Flash Player uses pre-multiplied alpha to optimize for speed but at the cost of performing lossy image transformations affecting R,G,B channels as well when modifying the alpha channel (extremely lossy for small alpha values), using the BitmapData method colorTransform(), ActionScript 3.0 (AS 3.0) APIs support Flash Player's adjustment of an image's red, green, blue and alpha channels, the ColorMatrixFilter() class supports general matrix operations on an image that permits implementation of filters such as adjustment of an image's brightness, contrast, saturation and hue as well as sepia tone and inverting an image, the built-in blur filter approximates a Gaussian Blur at the high quality setting, built-in perlin filter useful to create clouds/fog, tweening, easing... ... The AS 3.0 image manipulation APIs are really quite impressive. Read on ... Any filter can be partially applied to an image by writing AS 3.0 code to carefully mix images using an alpha channel containing the mask that identifies the partially selected pixels, the convolution filter API supports effects that modify the current pixel based on the value of adjacent pixels, such as sharpening, blurring, and embossing, the histogram API supports creating a visual histogram of an image's channel data, other APIs support filters such as bevel, drop shadow, glow, gradient and displacement maps, threshold as well as scaling and rotating an image, transformation of an image's palette map makes implementation of "levels and curves" possible (sophisticated curve-fitting code required for curves), and the following blend modes are directly supported between 2 images: darken, multiply, lighten, screen, overlay, hardlight, difference, add, subtract, and invert. |
|
ActionScript 3.0 and Polymorphism: Subclass Polymorphism vs Programming to Interfaces |
Polymorphism occurs when multiple types of objects might work in a given situation.
Two major ways to achieve polymorphism in ActionScript 3.0 are by Subclass Polymorphism (via inheritance)
and by Programming to Interfaces (via "contract"). Adobe provides
this excellent discussion
to distinguish between these two ways. Note that ActionScript 3.0 does not support multiple inheritance, so the "Diamond Problem" where a method with the same name is defined by two different super classes that are both inherited, thus creating ambiguity, is avoided completely. Wikipedia describes the diamond problem as "an ambiguity that arises when two classes B and C inherit from A, and class D inherits from both B and C. If there is a method in A that B and C have overridden, and D does not override it, then which version of the method does D inherit: that of B, or that of C? It is called the "diamond problem" because of the shape of the class inheritance diagram in this situation. In this case, class A is at the top, both B and C separately beneath it, and D joins the two together at the bottom to form a diamond shape." ActionScript 3.0 does support classes to implement multiple interfaces. Interfaces can't have concrete implementations, and are only "contracts" or "promises" that you will implement all the methods (enforced by the compiler). Since ActionScript 3.0 guarantees that there is only one implementation of any method in any level in the inheritance chain, the Diamond Problem doesn't occur in ActionScript 3.0, even when classes implement multiple interfaces, because there's never any ambiguity about which method to run. 1. Subclass Polymorphism
Subclass polymorphism is achieved via inheritance. Any object in the inheritance chain can stand in for any other type of object up and down the inheritance chain as long as the object at least inherits from the expected class. The idea is for the code working with the objects to not have to know about any details about the objects, especially the type of the object and what its varying capabilities may be. If a method can accept the object (the object inherits from the specified, expected super class), then that object will work at run-time and an exception will not be thrown. One major limitation though of subclass polymorphism is as follows. Consider the restriction that you can only substitute a super class with its subclasses. That is, anywhere the super class is expected, its subclasses can be used too. However, the limitation is that the inverse is not true. You cannot substitute a subclass with its super class if the subclass is what is expected. That is, anywhere a subclass is expected, the super class cannot be used there as well. Only the expected subclass will work (along with its own subclasses, if any). For example, suppose subclass C1 extends super class C. Subclass C1 likely has other public methods specific to the subclass that super class C doesn't have (which was probably why subclass C1 was created). Since subclass C1 is a C, but super class C is not a C1, C cannot stand-in for C1. Using Interface terminology, super class C cannot be substituted for its subclass C1 because super class C doesn't fulfill the same contract as its subclass C1. However, the contract that subclass C1 fulfills is a superset of what C fulfills. Subclass C1 does all that super class C is required to do and more, so subclass C1 can stand-in as a substitute for super class C. 2. Polymorphism by Programming to Interfaces
ActionScript 3.0 supports the ability of a class to implement one or more interfaces, with or without inheritance. An interface specifies the methods (and their signature), that the class must implement or the class will not compile. If a class implements two interfaces that both define the exact same method, this will not cause a problem because the required method will be implemented only once in the new class, and both interfaces will be satisfied with regard to that required method. Also, the limitation that you cannot substitute a subclass with its superclass, if the subclass is what is expected, is now removed if we're implementing interfaces rather than using inheritance. One class can substitute for another class if they both satisfy the same interface requirement of a method argument, for example. That is, if a method's argument is defined as requiring an object of type I-interface-name, then only objects that at least satisfy that interface will work at run-time and an exception will not be thrown. Likewise, assigning an object's reference to a variable of type I-interface-name will work only if the object at least satisfies that interface, otherwise an exception will be thrown. (Of course, if we're not inheriting, then we're not reusing existing code either.) As Adobe says, "Programming to interfaces instead of implementations provides for future expansion as well as flexibility in the way you construct the objects in your applications. Further, it forces you to consider the actual function of each of your classes. These techniques form the basis of the largest and most maintainable applications." |
| jQuery Dev: | jQuery and $ (optional) are identifiers and only these two are added to global namespace, functions are first-class objects, 'this' is determined by how a function is invoked, not by how its declared, a function can have different contexts depending on how its called, functions as first-class objects have methods, a function is not a method of an object, instead a function acts as an object's method only when that object serves as the context for the invocation of the function, a function closure is a function instance including its context, create a single global variable for your application to reduce your global namespace footprint to a single name, variables that evaluate to true are called truthy, variables that evaluate to false are called falsy. JavaScript, although widely used across the web, "is not deeply used" by developers, says Bear Bibeault (jQuery in Action). Javascript "is Lisp in C's clothing", says Douglas Crockford (JavaScript: The Good Parts). Both JavaScript and ActionScript 3.0 are ECMA-script languages and are event-driven. |
| PHP Dev: | Personal Home Page (PHP) Tools v1.0 (1995), PHP is a dynamically typed, interpreted language, php.ini, pass by reference is done using the ampersand operator (&), type juggling, silence operator (@), GD graphics, associative arrays, key value pairs, variable expansion within double-quoted strings, heredoc format for literal strings, nowdoc format when you want the text as-is without variable expansion, sessions, cookies, clean all input vars using isset(), trim() and htmlentities(), validate all input vars (use regular expressions), turn off magicquotes (magic_quotes_gpc = Off), disable register globals, copy data from the superglobal arrays $_GET and $_POST and work with cleaned and validated local copies rather than work directly with the $_GET[] and $_POST[] arrays, developing secure UI/forms by filtering all input (regular expressions), escaping all output using htmlentities(), use GET for read only access to data (GET is intended to be idempotent), using POST rather than GET, RESTful services (GET, POST, PUT, DELETE), using form tokens (prevent cross-site request forgery), using bound parameters so that the context of data use prevents SQL injection, prevent SQL injection also by properly filtering and escaping all data used to create the query, salting user passwords and cleaning all tainted data... ... Reward yourself at this point with a nice cool glass of water with a slice of lemon... Defense in Depth, grant only least privilege, complication breeds mistakes, mistakes can create security vulnerabilities, no data contained in an HTTP request can be trusted (anything in an HTTP request can be faked by someone using Telnet), configure Apache to reject accesses to certain file types, default maximum PHP script execution time: 30 seconds, Client URL Request Library (Curl), PhpED, Eclipse, Dreamweaver, Smarty templates, Zend framework, CakePHP, RSS, Simple XML, PHP Data Objects (PDO: a lightweight DBMS connection abstraction library). |
|
Relational Database and MySQL Dev: |
Relational database, relation refers to a database table and the relatedness of the fields or columns (attributes) to each other in a record or row (tuple), relation does not refer to relationships between tables, primary key, secondary key, foreign key (field that matches primary key in another table), non-key attributes, functional dependencies, tuples, records, b-trees, packing databases, unique, redundant, duplicates, insert, modify and delete anomalies, referential integrity, one to one, one to many, many to many, MySQL, SQLite, Clipper RDMS, phpMyAdmin, fixed size records, variable size records, CRUD (create, read, update, delete), schema, table (relation, which is a set of tuples that have the same attributes), row (tuple or record), column (attribute or field), index, create, drop, insert into, replace into, delete from, select, from, where, like '%$fieldFilterString%',
order by, auto-increment, $res = mysql_query( $sql, $conn), joins (inner, outer, see here and here). Use 1st, 2nd and 3rd normal forms to eliminate anomalies (there are actually 7 normal forms): - 1st Normal Form: All attributes must depend on the primary key. The primary key is composed of the minimal set of attributes which can uniquely identify a record. No multivalued or composite attributes are allowed. No nested relations are allowed (non-atomic values), that is, each table cell must be single-valued. All entries in a column must be of the same kind. - 2nd Normal Form: All attributes must depend on the whole key. Must also be 1NF. - 3rd Normal Form: All attributes depend on nothing but the key. No attribute may be transitively dependent on the primary key unless the intermediate dependency is a secondary key. Must also be 2NF. Although accurate, the above description is typical of so many computer science texts in that after learning (or maybe memorizing) the material, six months later you'll probably have forgotten the concepts. For example, consider the definition of Second Normal Form (2NF) above. Before knowing what 2NF is, it's not intuitively obvious at all that, "all attributes depend on nothing but the key" (2NF above), is the same as saying that (see below), 2NF is all about redundancy across multiple rows and that columns that contain data that repeat in different places should be removed to their own tables. Once someone understands 2NF, they'll see that they are the same, because data in columns that repeat across multiple rows are attributes that don't depend exclusively on the key. However, the above description absolutely does not make that clear, except to those that already know (and maybe not even then). It's only useful as a reference check. It's rare when you come across a description of complex concepts that are accurate, accessible, understandable and memorable. I came across just such a discussion of database normal forms in an excellent book by Robin Nixon, "Learning PHP, MySQL & JavaScript" (2009). Read the excerpts from this book below and see if you agree this is a noticable improvement over the terse definitions of normal forms above. - "The process of separating your data into tables and creating primary keys is called Normalization. Its main goal is to make sure each piece of information appears in the database only once.", p. 203. - "First Normal Form. For a database to satisfy First Normal Form, it must fulfill three requirements: 1. There should be no repeating columns containing the same kind of data. 2. All columns should contain a single value. 3. There should be a primary key to uniquely identify each row.", p. 204 - "Second Normal Form. The First Normal Form deals with duplicate data (or redundancy) across multiple columns. The Second Normal Form is all about redundancy across multiple rows. In order to achieve Second Normal Form, your tables must already be in First Normal Form. Once this has been done, Second Normal Form is achieved by identifying columns whose data repeats in different places and then removing them to their own tables.", p. 206. - "Third Normal Form. Once you have a database that complies to both the First and Second Normal Forms, it is in pretty good shape and you might not have to modify it any further. However, if you wish to be very strict with your database, you can ensure that it adheres to the Third Normal Form, which requires data that is not directly dependent on the primary key but that is dependent on another value in the table should also be moved into separate tables, according to the dependence.", p. 208. - "When Not to Use Normalization. Now that you know all about normalization, I'm going to tell you why you should throw these rules out of the window on high-traffic sites. That's right - you should never fully normalize your tables on sites that will cause MySQL to thrash." - "Normalization requires spreading data across multiple tables, and this means making multiple calls to MySQL for each query. On a very popular site, if you have normalized tables, your database access will slow down considerably once you get above a few dozen concurrent users, because they will be creating hundreds of database accesses between them. In fact, I would go so far as to say you should denormalize any commonly looked-up data as much as you can." - "You see, if you have data duplicated across your tables, you can substantially reduce the number of additional requests that need to be made, because most of the data you want is available in each table. This means that you can simply add an extra column to a query and that field will be available for all matching results. Of course, you have to deal with the downsides previously mentioned, such as using up large amounts of disk space, and ensuring that you update every single duplicate copy of data when one of them needs modifying." .... - "However, until you are very experienced with MySQL, I recommend you fully normalize all your tables, as this will instill the habit and put you in good stead. Only when you actually start to see MySQL logjams should you consider looking at denormalization.", p. 211. I found the complete lack of technical jargon in the above discussion refreshing. See also this classic paper on relational database design for foundational concepts: - Fundamentals of Relational Database Design, by Paul Litwin (1994) |
|
Dreamweaver, HTML, CSS and XML: |
HTML, CSS, XML, templates, editable region, CSS style sheet, quirks mode vs. standards mode, document flow, block vs. in-line elements, liquid layouts, div, float left/right, clear float, layers, behaviors, library items, tables, colspan, rowspan, frames, rollovers, slices, image maps, style elements using CSS instead of embedding attribute tags within the HTML code, CSS rule hierarchy, descendant or compound selectors, element specificity (a-b-c-d: in-line, id, class, elements) resolves conflicting CSS rules, absolute vs. relative links, FTP, form hidden field, GET vs. POST form action, target blank/parent/self/top, named anchors, CSS Class (.) vs. Id (#), tag selector, tracing image |
| Cascading Style Sheets: | Use Cascading Style Sheets (CSS) to support the separation of presentation from content and behavior, Class and ID selectors, descendant or compound selectors, use only old C-style matching comments in CSS style sheets (no HTML or HMTL comments or // comments), the last rule for an element in a stylesheet 'wins', when an element is affected by more than one CSS rule, CSS element specificity resolves the conflict (see Dreamweaver above for more), element selectors (eg: p, a, table, or img), class selectors (prefix with dot, eg: .myContentDivs), ID selectors (prefix with hash, eg: #specialDiv), pseudo-class selectors (eg: a:link, a:hover), child selectors (div > a, only direct child elements selected), media queries, responsive web design (great examples). ... CSS is cool... time now to take a deep breath to prepare for the home stretch... Adjacent selectors (h2 + p), attribute selectors (eg: div[class="myContentDivs"], img[alt], a[title], li[class="vcard"], div[id="content_main"], pseudo-element selectors (eg: li:last-child, p:first-line, p:first-letter) (called pseudo because they aren't nodes in the document), combined selectors, for example: descendent + id + child + attribute: #nav-main ul > li > a[title] { /* rules */ } - in this example, we're targeting all anchors that have titles, which are direct descandants of list items, which are themselves, direct descendents of unordered lists, which themselves sit inside some element which has a unique ID of "nav-main" |
| Photoshop: | Layers, channels, RGB, CMYK, LAB, greyscale, plug-ins, resolution, alpha channels (white selects, 0xFF), masks, clipping mask, interpolation, image resampling using bicubic vs. nearest neighbor, aliasing (jaggies), JPEG, BMP, PNG, GIF, transparency, loss-less vs. lossy data compression and image file formats, scale, rotate, distort, perspective, unsharp mask, gaussian blur, levels, curves, white point, black point, remove color cast with grey point, opacity, histogram, blend modes, layer mask, adjustment layers, s-curve for contrast, selections, feathering selections, partially selected pixels, quick mask, clone, pen, paths, stroke, slices, Image Ready for animated GIFs, high-pass filter sharpens with overlay blend mode, use measure tool and rotate-canvas-arbitrary to straighten an image, aspect ratio, TWAIN, posterize, threshold, high key, low key, clipping, polygonal lasso, out of gamut warning, ppi and dpi, rasterize, merge visible (use Alt key), drop shadow, creation of a favicon image file (.ico) for a website, brightness = 0.3*R + 0.59*G + 0.11*B |
| Forex Trading Systems: | Forex low leverage, low frequency trading, MQL4 language for the Metatrader 4 platform, indicator, expert advisor (EA), currency pair, bid, ask, spread, price tick, pips, back-testing, multiple entry risk diversification, cutting your losses and letting your profits run versus cutting your profits and letting your losses run, margin requirements, edges, the incredible danger of excessive leverage, pair correlations, risk-on, risk-off, volatility generators, trending vs ranging vs choppy price action, grid based trading, thinking in probabilities, psychology of trading, recent price level bias, near term price action bias, recent trade bias, hindsight bias, law of large numbers, we need to understand and someone is always ready to provide an explanation, hearing what you want to hear, believing what you want to believe, the power of "as if" when dealing with uncertainty... |
