Detour from collaboration to analysis tools

For effective collaboration (or knowledge production or publishing efforts), relatively elaborate and detailed requirements must be met which can be quite specific to the arrangement of people and the nature of the tasks and the content.  These requirements may well change over time, with limited time window to meet them before collaboration participants (or clients or customers) lose interest.

Of course, there’s quite a spectrum of online applications or services which attempt to cover different parts of this territory:  wikis, email, forums, IM, task trackers, Google docs/calendar/sites, Basecamp and Confluence and similar, blogs, content management systems (CMSs) and so on.  But inevitably it’s only practical for these services to offer limited configurability, using which you can only achieve an approximate fit to ideal requirements.

This prompts us to look to open source packages, in hopes that we can achieve a better fit through modification of source code if need be (without writing an app from scratch), and by taking advantage of the customizations and add-ons that other participants often contribute to open-source packages.

Open source increases the necessity to interact with source code, both to understand the product (and add-ons) in the first place, and to implement initial and subsequent customizations of our system, not to mention deal with subsequent versions of the adopted open-source package.

But interacting with source code is hard, and can easily become the bottleneck to progress on the original quest — the collaboration or publication effort.

So we are quite interested in tools that might digest source code and transform it into summaries or diagrams that we could understand vastly more rapidly than reading reams of text.   By the same token, these kinds of tools might help actual open source contributors to work more effectively, something we’d like to encourage if we want to enjoy the product of such labors.

This is certainly not the first time I’ve found myself traveling approximately this same path of reasoning.  This time I’m persuaded me to take a detour for a closer look at the state of these tools, to identify key obstacles, and consider how these tools could be brought to bear better than they are currently.

Tools for analyzing and summarizing  a software system

A very broad-brush breakdown of a software system distinguishes between what the system knows, and what the system does.  In a typical online system, what the system knows (at least for the long term) corresponds to the data it stores in a database, while what it does corresponds to the functionality implemented by the program source code.  Each of these can be examined to gain an understanding of the system as a whole, and each sheds some light on the other.

The tools for examining, digesting and summarizing each of these aspects of a system are at quite a different states of usefulness:

• Database tools
• Source-code analysis and summary tools

Database tools

(“Database diagrammer”, “Entity-relationship tool”, “database modeling tool”) There are numerous tools in this category, and many do a good job of reading an existing database and summarizing this into diagrams that you can read quickly to learn most of what’s significant about the database coarse and detail structure — elucidating what the system knows.

It would be useful to attach additional information to this kind of diagram, but most such tools don’t provide any facility to merge in and visualize additional information.  I’ve been helping to encourage richer database diagrams, by contributing to the ModelRight effort, which I describe in more detail here [link to come].

Source-code analysis tools

Compared to database structure, source code is a much more complex material to analyze, so the tools in this area are in a correspondingly less satisfying state. Though there is a variety of tools which programmers use to help work on the detail level of source code, there is a dearth of tools capable of providing intelligent and rich summaries of the important structure and relationships of source code.

Yet some of the obstacles to advancement in this area appear to be relatively mundane,  raising hopes that progress might be encouraged.  A major obstacle has been the relative awkwardness of just parsing source code (successfully!)  to derive reliable raw data as a basis for analysis. This, I suspect, has been a substantial deterrent to developers creating ad hoc analysis when they need it, which might have snowballed into more elaborate tools.

However, I’m encouraged that the basic parsing tools are getting more capable and domesticated.  In this vein I’ve been working to get a better grasp of ANTLR, and making some modest contributions to that effort, as I describe here [link to come].

Of these topics, currently the area I’m most active in is assembling tools for some software analysis capability that I want to have at hand.

I describe what motivated this direction in My foray into software analysis tools.

I made some contributions to database analysis tools, discussed here [link to come].

I am also chewing away on some source-code parsing tasks, and discuss some of that here [link to come].

For everything else… see the sidebar to visit posts by Categories or by date.

Printing code from Eclipse

Story currently (Eclipse 3.4.1) seems to be that printing in Eclipse is primitive — no control over fonts or page margins.  That leads to a desire to print via some other tool that does provide that level of control.  One possibility is MS Word.  Going down that path means one wants to know:

• How to copy and paste with the syntax highlighting intact
• How to fix up any tab/space issues

… which is what the next to blurbs are about

Copy syntax-highlighted text

Eclipse (or at least the Java editor) has the capability to copy syntax-highlighted text in RTF format (so the formatting can appear for example in Word).

However, turns out that this feature is disabled if code-folding is enabled.  So you have to disable code folding:

Window > Preferences > Jave > Editor > Folding > uncheck “Enable Folding”

References:

• http://denverdev.blogspot.com/2009/01/developer-syntax-highlighting-for.html
• http://dev.eclipse.org/newslists/news.eclipse.platform/msg25833.html
• https://bugs.eclipse.org/bugs/show_bug.cgi?id=64498

Show and fix up tab/spaces:  AnyEdit tools add-on

Available here:   http://andrei.gmxhome.de/anyedit/

Minor note:  Follow all the install instructions including the preferences settings, because some of the functionality does not appear in the UI otherwise.

JVM  1.6.0_14, _15 bug causes breakpoints to fail

In Eclipse, running one of the recent JVMs causes breakpoints to stop working soon after an app is started in the debugger (though some may work initially).

References

• Eclipse bug report:  Breakpoints fail to hit under JDK 1.6.0_14
• Sun bug report: JDWP threadid changes during debugging session (leading to ignored breakpoints)
• Ubuntu forum: Eclipse: Java is not stopping at breakpoints

Collection of JVM Options

http://blogs.sun.com/watt/resource/jvm-options-list.html

Desired features

• Platform(s): Must run on Windows.  If the editor is available for other platforms, that’s helpful.
• Speed: Must respond “immediately” in almost all situations.
• File Size: Must not have a problem with large files (say a million lines of text).
• Line-length: Must support long lines (preferably arbitrarily long).
• Tab/space handling: Must be able to have tab key insert spaces (to next tab position), and be able to set the spacing of  tab stops
• Auto-indent
• Block indent/outdent
  
• Tab/space/newline visibility: Should be able to enable visibility of special characters such as these. (And maybe separate schemes for different file types.)
• Brace/bracket matching: Position the cursor on one bracket, editor highlights the matching one.
  
• Multi files/windows: Able to have multiple files open at once in separate tabs OR separate windows and these separate windows should NOT be stuck within a %^$# parent MDI window!
• Multi view of same file: Must be able to allow view/ edit of multiple locations in the same file — split window layout would be good here.
  
• Newline handling and conversion: Able to detect,  retain and optionally convert a file’s newline convention.
• Behavior around end-of-line:
  • Allow cursor placement beyond end-of line (and auto insert spaces if user types anything there)
  • Moving the cursor vertically doesn’t cause cursor to jump around to follow line-end!
  • Trim trailing spaces on save
• Multiple undo
• Rectangular block selection: Essential, and must have convenient key bindings
• Unicode handling and conversion: Not needed yet, but I can see this is coming
• Macros: Need simple ones for ad hoc repetition. Probably don’t need full-blown macro language, especially if it’s custom to the editor (VBA or one of the existing scripting languages would be OK.)
  
• Search/replace:
  • understand regex, and begin/end line etc
  • would be nice if search was immediate/live
• Bookmarks: Must be easy to set and jump to multi bookmarks
• Quasi-IDE features
  • Nice, but it seems to be a trade-off between benefit vs how involved they are to set up.  I’m currently pursuaded that syntax highlighting is feasible for an editor vendor to supply in a low-hassle way. I’m less pursuaded on intellisense (autocomplete based on libraries of known functions and other identifiers.) This seems more of a job for a real IDE that understands a complete project.
  • Syntax highlight
  • Code folding: Assuming that it understands the syntax
  • Able to run external tools: And maybe understand error line/col so it can position the cursor on return from compile
  • Version control integration: Not sure if this is an exciting or even practical feature.

Editors noticed

…. and my reactions…. For anyone dropping in: this is just notes for me — it’s not intended to be comprehensive or fair.

• EditPad: EditPad Lite is my current editor, when I’m not using an IDE.  But I’m missing the features that at in Pro, so one option is just get the Pro version. Regarding Pro:
  • Only multi-edit capability is tabbed.  No split. Can open new instance, but it’s not synchronized with the first.
  • Cannot set my preferred beyond-end-of line cursor movement behavior.  This is probably the feature that most makes this editor uncomfortable to me.
  • Number gutter is distractingly indistinguishable from the main text.
  • Search opens non-modally as part of window border (OK), but occupies too much space.
• UltraEdit:  Looking pretty good on most of the feature list
  • Main deficiency: MDI (or tabs).
    • However, does have split,
    • Minimizing the surrounding parent window clutter, and launching multi instances, could be workable
  • Can set my preferred cursor behavior, including trim right whitespace on save.
• Zeus:
  • MDI, no free-floating edit window. Has 2-way split.
    • Can launch more instances. Other instances looking at same file sync on save (not live).
    • Semi-fatal flaw: In split mode, the left gutter info disappears (line numbers, bookmarks), which is where they are most needed.  This is a known issue, apparently “will not fix”.
    • Can set my preferred cursor behavior, including trim right whitespace on save.
  • Has active forums.
• EditPlus:
  • MDI only (but can run multi instances).  No tabbed arrangement of windows. Does have usable 2- or 4-way split.
  • Mouse can place cursor after end of line. However, cursor keys cannot. On cursor up/down, cursor leaps to existing line ends. (For me, editor disqualified on this feature alone.)
• SlickEdit :  Looks feature-packed, cross platform, interface to version control, build system etc. But $299.
  • MDI window. Manual describes various splitting arrangements.
  • 1300 page manual.  Maybe too much of a good thing?
• Crisp: Skipped trying this one due to $275.  Appears to use MDI, or tabs. Does have split, I think, or maybe it’s just borderless MDI windows. Seems to expose a little too much complex internals for my liking. (We still need a “buffers” paradigm?)
• Multi-Edit:
  • Website rather frustrating — much rhetoric, not much description of features, nor screenshots.
  • Full and Lite versions
  • MDI windows, optional tabs. Split = create new window. Window management seems pretty clumsy
  • Can be config’ed to my preferred cursor behavior
  • Within minutes I discovered that undo didn’t work properly.  Then it allowed files to be closed without saving edits.
  • Shows edited lines with marker in margin — that seems desirable!
  • There seems no way to mark columnar block with mouse
• NotePad++:  A sourceforge-hosted project.
• CodeWright: Was a Borland product, but discontinued
• VEdit
  • Probably powerful for specific tasks (like editing huge files) but the UI and options philosophy comes across like it’s a Windows 3.1 app written by a brilliant assembler programmer.  Eg: Starts with crazy looking DOS-esque fonts. Some options must be configured using bit masks that user has to figure out from docs.
  • Split = make more MDI windows.
  • Cursor moves with scrollbar! Arrrg! Maybe there’s an option to disable this, but manual has almost 600 references to “cursor”, so I didn’t find the way forward on this.
• Emacs
• Textmate:  This is Mac only, but well liked
• E Text Editor: Claims to have the “power of TextMate on Windows”. “Unix at your fingertips” (if you have cygwin installed!).  Site has no description of feature set. (But does have a wiki for docs)
• Intype: Something that might be interesting in the future
• vi or anything like it:  Not compatible with my brain due to vi’s reliance on multiple modes and multi-keystroke commands combined with lack of prompts and affordances.
• Comparisons
  • Zeus, UltraEdit, EditPadPro circa 2005-2007
• Oh great….
  • http://en.wikipedia.org/wiki/List_of_text_editors
  • http://en.wikipedia.org/wiki/Comparison_of_text_editors

So in this post I’m recording some notes on a number of finer points of PHP syntax which seem to be undocumented. In particular:

• Rules for composing a valid variable or function (or object…member variable/function) identifier “path”.
• Variable names — not limited to simple strings
• Variable names can be reserved words
• The supposed “reference operator”
• Can some statement keywords (like print) use function syntax?

Preliminaries

• Based on PHP 5.2.x (ie: pre 5.3). I think 5.3 is mostly (entirely?) a superset of 5.2.x

Accessing variables, functions, objects, methods in PHP

The following table shows a variety of variable, function and member cases. Blue brackets show the precedence order and association of the parts of the expression. (See key below for italicized words.)

	Global or local	Object member
Constant [Note 1]		Not applic
Variable
Variable; name from expression. [Note 2]
Variable; name from variable
(…equivalent to…)
Function
Function; name from expression	(Not possible: illegal syntax)
Function; name from variable
(…equivalent to…)	(Not legal syntax)
Function; name from variable twice
(…equivalent to…)
Array element [Note 3]
Variable; name from array element
Array element; array name from variable
Function; name from array element		Ordinary function selected by array in object
		Method in object selected by ordinary array
Element of array returned from function. (Apparently not available.)	Not legal syntax

Key

Notes

1. PHP semi-allows unquoted strings. That is to say, if PHP sees a bare series of characters, it attempts to look up a constant by that name. If not found, PHP will “assume” the series of characters into a string (apparently single-quote style). If error_reporting(E_ALL) then PHP issues a warning (“Notice: Use of undefined constant xxx – assumed ‘xxx’ in [...]“).

2. Curly braces enclose expression to be evaluated first, with the resulting string then used as part of the identifier. (But see also braces used for subscript, next Note.)

3. Array index(es):

• Array index may be enclosed in either square brackets [ ] or braces { }, though the former is more widely used (are braces deprecated?).
• Multi-dimensional array access: Use multiple sets of brackets/braces: $multiarray[1][4] etc
• If the variable is a string rather than an array, then the square brackets or braces can be used to access a single character in the string. (Ie: the string is treated in this case as an array of characters).

Possible misunderstanding involving { } and unquoted strings

The { } braces used to enclose expressions (as shown above) appears to be undocumented on php.net. Consequently there are opportunities for it to be misunderstood. This is especially the case when one experiments and sees that:
$a = $blah->afunc();
$b = ${blah}->{afunc}();
… results in $a and $b getting the same result. Perhaps, one might infer, the braces in this context are some sort of grouping mechanism for pieces of an identifier path. What is missed in this scenario is that in the first statement, PHP sees the identifiers $blah and afunc, while in the second statement PHP sees blah and afunc as unquoted strings, and internally revises it like this:
$b = ${'blah'}->{'afunc'}();
Now we can see that { } perform their function enclosing an expression, in this case a couple of simple strings. (This revision process is reported as a warning note if error_reporting(E_ALL) is in effect.)

Additional use of curly braces in string interpolation

In double-quoted strings PHP is able to “interpolate” variables — recognize a variable and substitute its value in its place in the string. This can be invoked using one of two syntaxes, “simple” and “complex”, as described here: http://www.php.net/manual/en/language.types.string.php#language.types.string.syntax.double. The simple case looks like this:
$a = "This is a string with $b in it";
The complex syntax requires curly braces around the section of the string to be interpolated, like this:
$a = "This is a string with {$b} in it";
This is useful if placing the variable directly in the string can’t be parsed properly, for example:
$a = "This is the $nth item"; // $n next to th, won't parse
$a = "This is the {$n}th item"; // better
Note that the syntax that PHP recognizes in this case is actually {$ … }. That is to say, the curly braces are only recognized as interpolation if the opening brace is immediately followed by the dollar sign prefix of a variable.

This gets potentially puzzling if a user sometimes sees something like this:
$a = "This is a string with ${b} in it";
In that example PHP sees the curly braces as enclosing an expression (in this case a bare string, which could be a constant, but if not then PHP “corrects” it to ‘b’ as described above in “Possible misunderstanding involving { } and unquoted strings”.

In short, within a double-quoted string, {$b} and ${b} employ curly braces in two quite different ways. The first encloses an expression for interpolation, the second encloses an expression which will form a variable name. And they could be used together:
$a = "This is a string with {${b}} in it";
… though there’s not much point in this example.

Variable names: Not limited to simple strings

The standard description is here: http://php.net/manual/en/language.variables.basics.php

“Variable names follow the same rules as other labels in PHP. A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thus:”

[a-zA-Z_\x7f-\xff] [a-zA-Z0-9_\x7f-\xff]*
Ie: first letter must be in [A-Z] , [a-z], underscore or characters 0x7f-0xff , and subsequent characters can be from that same set or digits. Note no spaces or punctuation, for example. However, this is really just a limitation on what PHP will digest in the form: $myvarname and related.

If instead you write:
${'my evil %^&# varname'}
PHP will happily digest pretty much any string as a variable name (or member variable name). (There may be a way to employ evil function names also, but I’ve not seen a way to create the evilly-named function in the first place.)

Variable names: Can be reserved words

Despite the warning here: http://php.net/manual/en/reserved.php

“None of the identifiers listed here should be used as identifiers in any of your scripts. These lists include keywords and predefined variable, constant, and class names. These lists are neither exhaustive or complete.”

… in actuality some (perhaps most or even all) these reserved words can be used as variable names (and member variable names), without PHP objecting. This seems to be because there is no difficulty distinguishing the reserved usage from the variable name usage (due to the dollar sign etc). However, the reserved words trigger an error when code uses them to declare or call a function or method.

References and the reference “operator”

There is much discussion on php.net about PHP “references”. Some of this discussion is quite confusing because the syntax and behavior for references was considerably revised between PHP4 and PHP5, with the latter taking a more straightforward approach.

Manual pages starting here: http://php.net/manual/en/language.references.php, at least as of early 2009-08, are a muddle in this respect.

In PHP, “reference” means what other languages call “alias”

PHP’s reference idea is not what other languages (C++, Delphi etc) call a reference. Instead, the PHP reference is more like what others call an “alias”. It is not a variable that points to another variable, instead it’s a completely interchangeable second (or subsequent) name for the same variable, or rather for the memory slot where the variable’s value is stored. (This is described more fully as a “symbol table alias”.)

Thus:
$a = 57;
$b =& $a; // create a reference (alias) to $a
$b = 25; // the memory slot referred to by $a and $b now contains 25
$c = $b; // The value of that slot is copied to $c
Now both $a and $b have the value 25, because both $a and $b refer to the same memory slot. At this juncture, $a and $b are completely equivalent, there’s nothing special about the one introduced first, or last for that matter.

Because this idea is really that of “alias”, there’s no syntax to “de-reference” such a variable. In addition, ordinary assignment ($c = $b;) simply copies the value as usual, because there’s nothing special about $b — it’s just a variable.

Relationship between PHP objects and references

Somewhat confusingly, it is sometimes said that variables holding PHP objects operate as references. To clarify, in PHP 5, they operate like references in other languages, but not like the PHP references (aka aliases) just discussed. Example:
class G {
var h$;
function f( ) {...}
}
$j = new G( );
$k = $j; // second variable refers to same object
$m = clone $k; // $m gets a copy of the object
In actuality, a variable referring to an object contains a flag to tell that it’s an object, and its value is an object id, by which PHP can find the object in memory. In the sample code, the new function passes such an object id to $j (with no “&” required). Similarly, in ($k = $j) the object id is copied, so that $k now refers to the same object, and the object itself is not duplicated. To create an actual copy, one can use the clone function.

In PHP 4, matters were more convoluted; PHP 4 objects involved using the “reference” idea, and the “&” operator was involved in awkward ways. In short, PHP 5 made a substantial improvement, no longer entailing the “&” operator. So one must avoid being thrown off by outdated documentation that harkens back to days of 4.

Back to the main point: where do references, and “&”, occur?

We can concern ourselves only with how references are involved in ordinary variables (ie: not object variables). In this realm, references, and the ampersand, appear in three different roles:

• Create a references (alias) of an existing variable
  • $a =& $b;
• Declare that a function’s argument(s) should be passed by reference (and can thus also return a value)
  • function myfunc(& $anarg, $otherarg) {...}
    Here $anarg is to be passed by reference, that is to say $anarg is an alias to whatever variable is passed in.
• Declare that a function returns a reference (alias) to a value.
• • function & myfunc() {...}
$x =& myfunc();
    Here myfunc() is declared to return a value by reference. If the invocation receives the return value using the reference “operator”, then the receiving variable becomes an alias to the value from the function. (Here $x becomes an alias to the value created within myfunc()).

Is “&” an operator?

Though “&” is often referred to as the reference operator, I claim that it is not really an operator. Where it is used in function declaration, it is simply an additional flag on the function or argument specification, so not an operator there. But is it an operator in the “=&” cases?

On the one hand, it is possible to write:
$a = & $b;
The separation of the & with whitespace perhaps gives the impression of it being a separate element. However, if this:
$a = (& $b);
… results in an error message. That is to say, there does not appear to be a separately available “result” from the application of the “&” by itself. So in my view, the combination “=&” is best thought of as a single “assign alias” operator, regardless of any whitespace between the two characters.

Can some statement keywords (like print) use function syntax?

It may be noted that a that the print statement returns a value and behaves something like a function:
print 'something'; // normal usage
print('something'); // usage that looks like a function
$x = print('something'); // Returns a value ($x = 1, not sure what it means).
$x = print 'something' ; // Perhaps unexpectedly, does the same thing without "function syntax"
Here’s the doc on php.net: http://us.php.net/manual/en/function.print.php

However, the line of thinking displayed above and implied by the docs is very misleading. So far as I can tell, there is no version of the print statement that incorporates the brackets in the function syntax. Instead, if brackets are used they merely act as enclosing brackets around the expression provided as an argument to print — an entirely different meaning, and misleading to boot.

Here’s a case where this makes a big difference:
$x = print('something') + 37;
If print( ) was a function, then this should print the string ‘something’, and give $x the value 1+37 =38. Instead, the “+ 37″ causes PHP to interpret (‘something’) as a number, having value zero. So the expression provided to print is 0 + 37, causing print to print the number 37. The result value from print is 1 as usual, assigned to $x.

The example’s likely intended effect could be achieved with this syntax:
$x = (print 'something') + 37;
Now print will print ‘something’, and the result, 1 gets added to 37, giving 38 to $x.

———————–

Id for monitoring cherch is GW20090805PHP

Relevant to the motivation for visualization

… in thinking or communication.

The primacy of Objects – Attributes – Relationships, and from there Types etc.

• Semantic networks
• Entity-Relationship analysis
• Alfred Korzybski: Science and Sanity. Not entirely sure this is on topic for the current purpose, but there it is:
  • At google books
  • OCR’ed: http://www.rodsmith.org.uk/alfred-korzybski/
  • PDFs: http://esgs.free.fr/uk/art/sands.htm
  • Questia: http://www.questia.com/PM.qst?a=o&d=55309160

Attempts to motivate from neuroscience

… which I think it a weak approach, since not enough is known about how knowledge is represented in the brain at a neuroscience level to extrapolate much about how to use the brain better. Most literature in this area seems oriented to speculating on how the brain might be employing neurons based on observed coarse-level behavior. Extrapolating from these speculations thus results in a circular argument.

• Edward de Bono: The Mechanism of Mind 1969.

Ontologies per se

• BIRN Project
  • Ontology effort: http://www.nbirn.net/research/ontology/index.shtm
• Larry Swanson
  • Larry Swanson home page at USC
    
  • Frontiers in Neuroinformatics profile:  larry w. swanson
  • Brain Architecture Management System (BAMS)
    • A paper: BAMS neuroanatomical ontology: design and implementation
    • BAMS home: http://brancusi.usc.edu/bkms/

Brain Atlases

Some key atlases

Mai, Paxinos, Voss: Atlas of the Human Brain (Spiral bound) ISBN: 012373603X

Woolsey, Roberts, Gado, Hanaway: The Brain Atlas: Avisual Guide to the Human Central Nervous System (spiral bound) ISBN: 0471430587

Brodmann’s Localisation in the Cerebral Cortex.  ISBN: 0387269177

Schmahmann: Fiber Pathways of the Brain. ISBN 0195388267 (Note: for rhesus monkey)

Links

• Marks and Meaning, Dave Gray and related:
  • http://www.marksandmeaning.com/ blog
  • http://groups.google.com/group/marks-and-meaning/web/tracking-dave-gray-and-m-m Dave Gray venues
  • Don Moyer
    • http://www.thoughtformdesign.com/web/site/ thoughtform
    • http://www.flickr.com/photos/36106576@N05/sets/72157615206414468/ Don Moyer’s HBR info graphics
• http://simplecomplexity.net/ An information visualization blog
  • http://innovatechinc.com
• http://www.wallstats.com/ Wall stats (Jess Bachman)
  • http://www.wallstats.com/deathandtaxes/ US budget poster and others
  • http://www.wallstats.com/blog/interview-with-a-pentagon-graphicsbudget-expert/ DoD Engine Room

MRI

• Marty Sereno’s Neuroimaging course (with links to PDF notes):  http://www.cogsci.ucsd.edu/~sereno/276/
• Joseph Hornack’s online book “The Basics of MRI”. Very step-by-step explanations, with many illustrations and animations: http://www.cis.rit.edu/htbooks/mri/inside.htm

FFT (Fast Fourier Transform)

• Brainflux (Jason Gallicchio) 2D FFT Java Applet: http://www.brainflux.org/java/classes/FFT2DApplet.html
• 1-D FFT Demo (using audio examples): http://www.ling.upenn.edu/~tklee/Projects/dsp/FFTDemo.html
• INTRODUCTION TO FOURIER TRANSFORMS FOR IMAGE PROCESSING: http://www.cs.unm.edu/~brayer/vision/fourier.html
  
• http://www.developer.com/java/other/article.php/3457251