Softpanorama

May the source be with you, but remember the KISS principle ;-)
Contents Bulletin Scripting in shell and Perl Network troubleshooting History Humor

FrontPage Regular Expressions

News Frontpage Recommended Books Recommended Links Examples Search and Replace Best books about Regular Expressions Javascript Regular Expressions
Microsoft Articles and How-to documents Macros
by Stephen Travis
Finding and replacing text FrontPage SDK Tips History Humor Etc

Introduction

FrontPage2003 added regular expressions to its Find and Replace tool. This is a big improvement and allows for more powerful code editing. Also it does not corresponds to classic Perl regex syntax and for those who know Perl regex well have troubles adapting to it.

There are four key differences:

  1. : is used to define metasymbols, for example :b, :w, :d instead of \b \w, and \d. For example :d is equivalent to \d in Perl. Usage of : allows closing HTML tags into regex without changes.
  2. In addition to standard Perl-style regex metacharacters such as +, *, -, colon, # and @ need to be escaped as they are used as metacharacters
  3. Non greedy + is represented by #.
  4. Non greedy * is represented by @. For example
    <a.#href=\"http{s@}\: -> <a target="_blank" href="http\1:

Unfortunately the Frontpage regex engine used was borrowed from some God forgotten Microsoft project done by people who never used Perl and is buggy. Nor just buggy, but seriously buggy.

Unfortunately the regex engine used in Frontpage was borrowed from some God forgotten Microsoft project done by people who never used Perl. Some metasymbols are different. And worse it is buggy. Nor just buggy, but seriously buggy.

Some bugs are really nasty and suggest compete incompetence of designers:

{[a-z]}{[A-Z]} matches aa and Aa and AA (case insensitive matching)

The same effect on case insensitive matching is observed for

{[abcdefghjiklmnoprstuvwxyz]}{[ABCDFGHJIKLMNOPRSTUVWXYZ]}

It requires a lot of trial and error to figure out its regular expression syntax which differs from UNIX style syntax. And even with a lot of trial and errors it not always works properly because of bugs. Shame on Microsoft.

As far as I know FrontPage2003 regular expression capabilities remained in unmodified form in Expression Studio/Web (see for example Regular expressions for finding text).

Note: the :b white space matches any white spaces in code or text within a single line.

Tips

Examples

Replacement of time

   

Replacement of  multiple tags between <a and href with target="_blank"

<a.#href=\"http{s@}\: -> <a target="_blank" href="http\1:

Replacement of time in format 12:00 followed by <br> with the same time plus <blockquote> tag

{:d:d\::d:d} <br> -> \1 <blockquote>

Replacement of "tail string"

/ref\={.+}\" => /ref=nikolaibezroukov"

[Jan 04, 2013] Bug -- case insensitive classes

{[a-z]}{[A-Z]} matches both aa and Aa and AA

[Jan 04, 2013] Replacing two dots between letters with blockquote tag

{:a}{\.\.}{:a} -> \1<blockquote>\3

[Jan 03, 2012] Replacing font with kbd tag

<font color="\#0000FF" face="Fixedsys">:a+</font> -> <kbd>\1</kbd>

More general "Compressing" tags regex: replacing one tag with a simpler tag:

<font color="\#0000FF">{.#}</font>    ->    <kbd>\1</kbd>

Same idea but sequence of two tags

{<b>:b*<font color="\#0000FF">}{.#}{</font>:b*</b>}

Find two duplicate, consecutive words and replace them with a single word. To search, use the following expression:

{.#} \l

Frontpage regex metacharacters

Expression Syntax Description
Any character . Acts as a wild card to match any single printing or non-printing character with the exception of the newline (\n)character.

For example, the regular expression c.t matches the strings cat, c t, cot, but not cost. In this example, the period (.) is a wild card for a single character. It appears between the letters 'c' and 't', so any single character between the characters 'c' and 't' will match the expression — even if it is a space.

Maximal — zero or more * Matches zero or more occurrences of a character that precede the expression, matching as many characters as possible.

The regular expression .* matches zero or more occurrences of one character.

For example, the regular expression b.*k matches book, back, black, blank, and buck. In this example, we combine the period (.) with the asterisk (*) to make one syntax. The period (.) appears immediately before the asterisk (*) expression. The asterisk (*) matches zero or more occurrences of any character between 'b and 'k'. The period (.) acts as a wild card for the characters between 'b' and 'k'. In this example, it means that any character between 'b' and 'k' can be repeated.

Maximal — one or more + Matches one or more occurrences of a character that precede the expression, matching as many characters as possible.

The regular expression .+ matches one or more occurrence of one character.

For example, the regular expression bo+. matches bob, book, and boot. In this example, we combine the period (.) with the plus sign (+) to make one syntax. The period (.) appears immediately after the plus sign (+) expression. The plus sign (+) matches one or more occurrences of the letter 'o'. The period (.) acts as a wild card for the last character of each word, which, in this example are 'b', 'k', and 't'.

Minimal — zero or more @ Matches zero or more occurrences of a character that precede the expression, matching as few characters as possible.

The regular expression .@ means match zero or more occurrences of one character.

For example, the regular expression a.@x matches 'abx' within 'abxbxb' and 'acx' within 'acxcxc'. In this example, we combine the period (.) with the at sign (@) to make one syntax. The period (.) appears immediately before the at sign (@) expression. The at sign (@) matches zero or more occurrences of any character between 'a and 'x'. In this example, the period (.) acts as a wild card for the characters 'b' and 'c' between the characters 'a' and 'x'.

Minimal — one or more # Matches one or more occurrences of a character that precede the expression, matching as few characters as possible.

For example, the regular expression si.#er matches 'sicker' or 'silkier'. In this example, we combine the period (.) with the sharp sign (#) to make one syntax. The period (.) appears immediately before the sharp sign (#) expression. The sharp sign (#) matches one or more occurrences of any character between 'si' and 'er'. The period (.) acts as a wild card for the characters 'c' and 'k' in the word sicker, and 'l', 'k', and 'i' in the word silkier.

Set of characters [ ] Matches any one of the characters within the brackets ([ ]). You can specify ranges of characters by using a hyphen (-), as in [a-z].

Examples:

  • The regular expression c[aou]t matches cat, cot, and cut, but not cet or cit.
  • The regular expression [0-9] means match any digit.
  • You can specify multiple ranges of letters as well. The regular expression [A-Za-z] means match all upper and lower case letters.
  • [^ ] means any character not in set
Beginning of line ^ Anchors the match to the beginning of a line.

For example, the regular expression ^When in matches the any string that begins with "When in" and that also appears at the beginning of a line, such as "When in the course of human events" or "When in town, call me". Whereas, this regular expression does not match "What and when in the course of human events" if it appears at the beginning of a line.

End of line $ Anchors the match to the end of a line.

For example, the regular expression professional$ matches the end of the string "He is a professional" but not the string "They are a group of professionals".

Beginning of file ^^ Anchors the match to the beginning of a file. Works only when searching for text in source code or in text files.

For example, to match the first HTML tag at the beginning of a file, use the following regular expression: ^^<html>

End of file $$ Anchors the match to the end of a file. Works only when searching for text in source code or in text files.

For example, to match the last HTML tag at the end of a file (with no spaces following the tag), use the following regular expression: </html>$$

Or | Indicates a choice between two items, thereby matching the expression before or after the OR symbol (|).

For example, the regular expression(him|her) matches the following occurrences:

  • "it belongs to him"
  • "it belongs to her"

but it does not match the line "it belongs to them."

Escape special character \ Matches the character following the back slash ( \ ). This allows you to find characters that are used in the regular expression syntax, such as a left curly brace ({) or a caret (^) or some other special character.

For example, you can use \$ to match the dollar sign character ($) rather than implementing the regular expression to 'anchor to end of a line'. Similarly, you can use the expression \. to match the period (.) character rather than match any single character, which is what the period (.) regular expression does.

Tagged expression {} Tags the text matched by the enclosed expression. You can match another occurrence of the tagged text in a Find expression or insert the tagged text in a Replace expression using \N.

For example, suppose you are looking to find two duplicate, consecutive words. To search, use the following expression: {.#} \1

With the assumption that the consecutive words are separated by a single space, you'll want to add a space between the right curly brace (}) and the back slash ( \ ).

In this example, we combine the sharp sign (#) and the period (.) with the curly braces ({}) to make one syntax. In this expression, .# represents any consecutive characters. Since this portion of the expression is surrounded by curly braces ({}), the consecutive characters will be tagged and can be referred to as \1. This expression will find any consecutive characters followed by a space, followed by those exact same consecutive characters.

Nth tagged expression \N In a Find expression, \N matches the text matched by the Nth tagged expression, where N is a number from 1 to 9.

In a Replace expression, \N inserts the text matched by the Nth tagged expression where N is a number from 1 to 9. \0 inserts the text matched by the entire Find expression.

For example, suppose you want to find two duplicate, consecutive words and replace them with a single word. To search, use the following expression: {.#} \l

With the assumption that the consecutive words are separated by a single space, you'll want to add a space between the right curly brace (}) and the back slash ( \ ). In this example, we combined the sharp sign (#) and the period (.) with the curly braces ({}) to make one syntax.

To replace, use the following expression: \l

\1 represents what was found in the first pair of curly braces in the find string. By using \1 in the replace action, you essentially replace the duplicate, consecutive words with a single copy of the word.

Group expression ( ) Marks the beginning and end of a subexpression.

A subexpression is a regular expression that you enclose in parenthesis ( ), such as the expression that follows: (ha)+ In this example, we combine the plus sign (+) with the parenthesis ( ) group expression to make one syntax. The subexpression is (ha) because it is encapsulated within the parenthesis ( ). When you add the plus sign (+), the expression enables you to find repeating pairs of letters. The plus sign (+) represents one or more occurrences of 'ha'.

This expression matches the following occurrences 'haha' and 'hahaha'.

Prevent match ~x Prevents a match when x appears at this point in the expression.

For example, the regular expression real~(ity) matches the "real" in "realty" and "really", but prevents the match to "real" in "reality".

Line break \n Matches a new line in Code view, or a <br> in Design view.

The syntax (\n), is a shorthand approach to enable you to match all line breaks.

Tab \t Matches a single tab character.

For example, if you want to find all single tabbed characters at the beginning of a line, the regular expression would look like the following:

^\t+

In this example, we combine the caret (^) and the plus sign (+) with the tab (\t) to make one syntax. The caret (^) that precedes the single tab character expression, anchors the match to all tabbed characters at the beginning of the line. The plus sign (+) represents the matching of one or more tab characters.

Any one character not in the set [^] Matches any character that is not in the set of characters that follows the caret (^).

For example, to match any character except those in the range, use the caret (^) as the first character after the opening bracket. The expression [^269A-Z] will match any characters except 2, 6, 9, and any upper case alphabetical characters.

Repeat expression ^n Matches n occurrences of the expression that precedes the caret (^).

For example, with n equaling 4, the expression [0-9]^4 matches any 4-digit sequence. In this example, we combine the set of characters ([ ]) syntax with the repeat (^n) syntax to demonstrate a more realistic use of regular expressions.

Alphanumeric character :a Matches the expression [a-zA-Z0-9].

You can use the following expression: [a-zA-Z0-9] to match one occurrence of a letter (upper case or lower case) or number. Also known as alphanumeric occurrences. You can use the shorthand expression :a for all instances of [a-zA-Z0-9].

White space :b Matches any white spaces in code or text.

For example, to match a single white space character at the beginning of a line, use the following regular expression:^:b

Alphabetic character :c Matches the expression [a-zA-Z]When you use this expression, it enables you to match all upper or lower case letters.

You can use the shorthand expression :c for all instances of [a-zA-Z].

Decimal digit :d Matches the expression[0-9]This expression enables you to match any digit.

For example, suppose you want to find a social security number in a text file. The format for U.S. social security numbers is 999-99-9999. :d^3-:d^2-:d^4 or, by using [0-9], the same resulting expression:[0-9]^3-[0-9]^2-[0-9]^4]

You can use the shorthand expression :d for all instances of [0-9].

Hexadecimal digit :h Matches the expression [0-9a-fA-F]+

Use a this expression when you want to match a hexadecimal combination of any upper or lower case letters between 'A' and 'F', and any numbers.

For example, suppose the pages in your Web site have multiple different background colors and you want to change the color of those pages to black, such as 000000. However, you do not know what the hexadecimal numbers are for the existing colors. Use the following regular expression to find all existing hexadecimal numbers:

\#:h

You could use [0-9a-fA-F] to search, but in this example we combine the back slash (\) and the sharp sign (#) with the hexadecimal digit (:h) syntax. \# matches a non-expression sharp sign (#) and :h matches any sequence of hexadecimal characters.

To replace the existing hexadecimal numbers, type the hexadecimal number of the background color that you want: 000000

Identifier :i Matches the expression [a-zA-Z_$][a-zA-Z0-9_$]*

When working with code, if you want to match all program identifiers, you can use the shorthand expression :i to replace having to type the lengthy expression above.

Rational number :n Matches the expression ([0-9]+\.[0-9]*)|([0-9]*\.[0-9]+)|([0-9]+)

If you want to match all whole numbers that contain a decimal point, you can use the shorthand expression :n to replace having to type the lengthy expression above.

Quoted string :q Matches the expression ("[~"]*")|('[~']*')

If you want to match all quotes surrounded by quotation marks, you can use the shorthand expression :q to replace having to type the lengthy expression above.

Alphabetic string :w Matches the expression [a-zA-Z]+

This syntax is a shorthand approach to enable you to match one or more alphabetical characters, either lower case or upper case.

Decimal integer :z Matches the expression [0-9]+

This syntax is a shorthand approach to enable you match any number from zero or more.


Top Visited
Switchboard
Latest
Past week
Past month

NEWS CONTENTS

Old News ;-)

the-visual-studio-ide-and-regular-expressions

God forbid we all learn one standard* regular expression dialect.

At any rate, some of the Visual Studio IDE regular expressions look awfully similar to standard regex:

Visual Studio IDE Standard
Any single character . .
Zero or more * *
One or more + +
Beginning of line ^ ^
End of line $ $
Beginning of word < (no equivalent)
End of word > (no equivalent)
Line break \n \n
Any character in set [ ] [ ]
Any character not in set [^ ] [^ ]
Or | |
Escape special char \ \
Tag expression { } ( )
C/C++ identifier :i ([a-zA-Z_$][a-zA-Z0-9_$]*)
Quoted string :q (("[^"]*")|('[^']*'))
Space or Tab :b [ |\t]
Integer :z [0-9]+

But they certainly don't act related when you try to use them. For example, try something simple, like finding "[A-Za-z]+". That's all occurrences of more than one letter in a row. When I try this via the Visual Studio find dialog with the regex option checked, I get positively bizarre results. It finds a word made up of all letters, true, but as I click "Find Next", it then finds each subsequent letter in the word. Again. What planet are these so-called "regular expressions" from?

The semi-abandoned Microsoft VSEditor blog has a three part tutorial (part one, part two, part three) on using the crazy Visual Studio dialect of Regex. There's a lot of emphasis on the strange < and > begin/end word match characters, which have no equivalent that I know of in the .NET and Perl dialect of regular expressions.

You might say that searching with regular expressions is such an extreme edge condition for most developers that it's not worth the Visual Studio development team's time. I won't disagree with you. It is rare, but it's hardly esoteric. Every developer should be able to grok the value of searching with the basic regular expressions that are a staple of their toolkit these days. Heck, some developers are so hard core they search through their code with Lisp expressions. Basic regex search functionality is awfully mild compared to that.

To be honest, searching with regular expressions isn't a common task for me either. But I'd be a lot more likely to use it if I didn't have to perform a lot of mental translation gymnastics on the occasions that I needed it. Don't make me think, man. But there is hope. There's a free add-in available which offers real regular expression searching in Visual Studio.

* well, mostly standard, anyway. Certainly JavaScript regex syntax could be considered standard these days.

Selected Comments

foxyshadis:

It could be worse. Imagine if they'd chosen POSIX regexes, or old VB's Like operator (shudder).

Beginning of word: \W\w
Vice versa for end.

Here I'm going out on a limb and trusting the internet that .net syntax is at least pcre-compatible.

Foxyshadis on July 14, 2006 6:31 AM

david_avraamides:

But Vim's regex search and search/replace, especially combined with really easy macro recording/playback, is so powerful and easy to use (once you've got an idea of the syntax), I find myself using it fairly often. When I'm forced to use VS for work, there are times when the lack of a good regex search really jumps out at me.

Vim is free. Why not use it at work when you need it?

This is the reason I always keep GNU Emacs handy on any machine I do coding on. I always run into cases where the power of a really good editor is needed. Vim, Emacs and the like have decades of experience behind them, by people who will get it right if it isn't already.

It appears that VS.NET's FR was built by people who have time to read blogs, but not to use the very code library that they are asking everyone else to use.

David Avraamides on July 14, 2006 7:45 AM
Jeff Atwood

you can get something at the beginning or end of a word by putting a \b in the right spot

Right, \b is very handy, but not quite the same thing as the explicit "beginning of word" or "end of word" characters. I did a search on these characters and I got hits on egrep and emacs. So I guess that does exist in some flavors of regex.

Jeff Atwood on July 14, 2006 10:41 AM
Steve Bush

I'm not sure why you are griping here. First, there really isn't a "standard" regex syntax. Just a whole bunch of bastardized flavors, and arbitrarily picking the javascript flavor.

To me, the additions that Visual Studios makes (with C++ keywords, quoted strings, etc.) are very useful for searching through code. I'd much rather use ':i' for matching an identifier rather than '([a-zA-Z_$][a-zA-Z0-9_$]*)'

The use of braces {} to tag patterns rather than parenthesis () is pretty annoying, I'll admit.

In the meantime, I highly recommend picking up some freeware application like this one: http://weitz.de/regex-coach/
It's geared toward Perl regular expressions, but still very useful for debugging complex patterns

Steve Bush on July 14, 2006 11:05 AM
Jeff Atwood

First, there really isn't a "standard" regex syntax. Just a whole bunch of bastardized flavors, and arbitrarily picking the javascript flavor

There's no "standard" C++, or "standard" English, either. So we should just give up and stop trying? I say froozbah* to you!

':i' for matching an identifier

I have no problem with the shortcut additions. It's the wholesale abandonment of normal regex behavior and conventions that I have a problem with.

* This is a new word I created. Just because.

Jeff Atwood on July 14, 2006 11:26 AM
Jeff Atwood

is this just another example of MS not sticking to standards?

Not really; it's a case of them hewing too closely to their old, crazy standard from Visual C++ 2.0. Backwards compatibility kills, particularly when it's backwards compatibility with.. er.. nonsensical, obsolete stuff.

And, I suspect, a very low priority for this feature compared to other more mainstream improvements in the IDE.

Neil Enns

Still, you could wish someone had been a bit braver about scrapping the old to make way for the new.. it pains me to hear that developers at microsoft spent time bugfixing the old, weirdo VC++ regex syntax.

Jeff Atwood on July 14, 2006 11:42 AM

Hey Jeff (and assorted follow-up posters),

I'm the lead program manager for the team that owns editing and the find/replace dialog in Visual Studio. Our team agrees with your post :)

It is a very oddball regex syntax, and as best we can tell it comes from Visual C++ 2.0. We did want to add additional support for .NET 2.0-style regular expressions in the Visual Studio 2005 release, but unfortunately due to time pressures it didn't make the final list of features. We were able to make a number of bug fixes to the existing engine though, to give some improvement over VS 2003.

We do keep this on our list of things we want to fix. Ideally at some point we'll actually build in a nifty little extensibility point so you can wire up any regex engine you want for searches.

Thanks for the feedback!

Neil Enns
Lead Program Manager
Microsoft Visual Studio

Neil on July 14, 2006 12:15 PM
Adrian:

There's a better regex search replacement tool for VS2005 available at:

Download RegEx Find & Replace Replacement for Visual Studio 2005 1.0 Free - RegEx Find & Replace Replacement for Visual Studio 2005 is a free Visual Studio 2005 Add-In that solves two problems - Softpedia

Adrian on September 26, 2007 2:58 AM
Paulustrious

I believe the FR dialog should have "Regular Expression" and "Regular Regular Expression"

Paulustrious on December 27, 2007 10:15 AM
Sergey Vlasov

There is a new tool Regent (http://www.regexinference.com) that tries to infer search and replace regular expression from text example. It supports both Visual Studio regex syntax and ECMAScript/Perl syntax. Not a freeware though.

Sergey Vlasov on June 3, 2008 1:03 PM
Jon Galloway

You can do some cool stuff with regex capture groups in VS.NET Find / Replace, too:
http://weblogs.asp.net/jgalloway/archive/2003/05/24/7498.aspx

Jon Galloway on February 6, 2010 9:46 PM

Jeff, thanks for this post. Saved my butt.

Brandon on February 6, 2010 9:46 PM
Dave Black

Hi Jeff,

I know this is off the wall, but the correct way to perform your first example would be: "<[A-Z]+>" (minus the quotes), instead of "[A-Za-z]+". The '<' and '>' characters match the whole word only instead of the word *and* the individual characters in it. Certainly, less than obvious : )

What I'm trying to figure out is how to use a regex in the "Replace with" instead of a literal. I don't even know if this can be done...

Dave Black

Dave Black on March 5, 2010 6:58 AM
Dave Black

I should have added in my previous post that I'm trying to turn all uppercase params/variables into lowercase with a preceeding underscore...

Dave Black on March 5, 2010 7:58 AM
Shelia Smithson

Thanks for a very useful post. I was hoping to searh for particular search terms which had NOT been commented out.

To exclude comments from your regex search, use

^~(:b*')

which effectively means at the beginning of the line exclude any amount of white space (to allow for auto-indented comments) followed by the apostrophe comment character.

To find conditional stops that have not been commented out use

^~(:b*').*:b+Stop(:b+|\n)

Shelia Smithson on August 17, 2010 11:45 PM
Jeff Bevis

Curiously, VIM uses '\<' for beginning of word, '\>' for end of word, in its enormous language-parser regex syntax. So now there are at two instances of using the same (well, very close) symbols for the start/end word match.
(http://vimdoc.sourceforge.net/htmldoc/pattern.html#pattern)

Jeff Bevis on September 30, 2010 8:31 AM

[Mar 20, 2006] FrontPage Regular Expressions by Robert S. Robbins

3/20/2006 | Williamsport Web Developer Weblog

FrontPage 2003 added regular expressions to its Find and Replace tool. This is a big improvement and allows for more powerful code editing. Unfortunately, it requires a lot of trial and error to figure out its regular expression syntax which differs from UNIX style syntax.

One of the more useful regular expressions I've come up with is to replace my old method of referring to a form field in JavaScript with my new method which is more compatible with various web browsers. The old method would use something like document.forms["name"].elements["name"].value which would break if you change the form name. The better method is to use document.getElementById("name").value which doesn't even use the form name.

My FrontPage Regular Expression changes the syntax of the JavaScript:

Find: document.forms(.)*elements[
Replace: document.getElementById(

You must remember to change the closing bracket to a ) and to insert id attributes to your form fields if you did not use them.



Etc

FAIR USE NOTICE This site contains copyrighted material the use of which has not always been specifically authorized by the copyright owner. We are making such material available in our efforts to advance understanding of environmental, political, human rights, economic, democracy, scientific, and social justice issues, etc. We believe this constitutes a 'fair use' of any such copyrighted material as provided for in section 107 of the US Copyright Law. In accordance with Title 17 U.S.C. Section 107, the material on this site is distributed without profit exclusivly for research and educational purposes.   If you wish to use copyrighted material from this site for purposes of your own that go beyond 'fair use', you must obtain permission from the copyright owner. 

ABUSE: IPs or network segments from which we detect a stream of probes might be blocked for no less then 90 days. Multiple types of probes increase this period.  

Society

Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers :   Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy

Quotes

War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotesSomerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose BierceBernard Shaw : Mark Twain Quotes

Bulletin:

Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 :  Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method  : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law

History:

Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOSProgramming Languages History : PL/1 : Simula 67 : C : History of GCC developmentScripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-MonthHow to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

The Last but not Least


Copyright © 1996-2016 by Dr. Nikolai Bezroukov. www.softpanorama.org was created as a service to the UN Sustainable Development Networking Programme (SDNP) in the author free time. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License.

The site uses AdSense so you need to be aware of Google privacy policy. You you do not want to be tracked by Google please disable Javascript for this site. This site is perfectly usable without Javascript.

Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine.

FAIR USE NOTICE This site contains copyrighted material the use of which has not always been specifically authorized by the copyright owner. We are making such material available to advance understanding of computer science, IT technology, economic, scientific, and social issues. We believe this constitutes a 'fair use' of any such copyrighted material as provided by section 107 of the US Copyright Law according to which such material can be distributed without profit exclusively for research and educational purposes.

This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...

You can use PayPal to make a contribution, supporting development of this site and speed up access. In case softpanorama.org is down you can use the at softpanorama.info

Disclaimer:

The statements, views and opinions presented on this web page are those of the author (or referenced source) and are not endorsed by, nor do they necessarily reflect, the opinions of the author present and former employers, SDNP or any other organization the author may be associated with. We do not warrant the correctness of the information provided or its fitness for any purpose.

Last modified: September 12, 2017