My kids share a very basic laptop, on which I installed Avast! free version as the anti-virus solution (with which I am generally very pleased). However, whilst playing with the gadgets, one of the kids managed to get the machine into the SafeZone, and there it seemed stuck: both “Switch back” and “Turn off SafeZone” briefly exit but immediately return to the SafeZone.

I found that others have had this problem, but the suggestions I found did not help in my case. I really didn’t want to un-install and re-install Avast, and so I hunted around a bit for an alternative fix. Here’s what I found.

The problem may be at least partly due to the SafeZone Browser not being part of the free version.

My solution requires being able to successfully enter Windows Safe Mode (e.g. F8 during boot), and so might not help everyone. Therefore you might also like to take a look at the other articles I found on the Avast forum and on TechArena.

Some of the suggestions did not help in my case as the laptop in question is very basic, and does not appear to have a virtualisation setting in the BIOS (e.g. F2 during boot).

For me, the problem appeared to be due to the Avast Gadget installed in the Windows SideBar on a Windows 7 machine.

Steps:

Boot into Windows SafeMode (perhaps with Networking, if you wish to use your Web Browser).

Open Windows Explorer (e.g. <Windows>+E).

Navigate to the directory / folder

C:\Users\<YourProfile>\AppData\Local\Microsoft\Windows Sidebar\

noting that AppData will be hidden by default.

Open the file

Settings.ini

in Notepad. (Also, make a copy of this file, just in case.)

Search for a

[Section <N>]

with a mention of

aswSidebar.gadget

Note the number, and delete the entire section.

Now look in the

[Root]

section, and delete just the line

Section<K>=”<N>”

If <K> is not the last value, the other entries may need to be renumbered to keep the sequence contiguous (but I don’t know).

Now you should be able to restart the machine, and it should be ‘cured’.

Here’s are example extracts from my file:

[Root]
Section0="2"
Section1="4"
Section2="5"
Section3="6"
Section4="7"

[Hashes]
; ...

[Section 2]
; ...

[Section 4]
; ...

[Section 5]
; ...

[Section 6]
; ...

[Section 7]
PrivateSetting_GadgetName="C:%5CProgram%20Files%5CWindows%20Sidebar%5CShared%20Gadgets%5CaswSidebar.gadget"
PrivateSetting_GadgetOpacity="95"
PrivateSetting_GadgetSize="large"
executed="True"
PrivateSetting_GadgetDropLocationX="1206"
PrivateSetting_GadgetDropLocationY="374"

The lines in red were the ones I deleted. (I also deleted a line from the [Hashes] section, but that reappeared.)

Eventually, I decided to have a bit of a dig around in the system.

Here’s my suggestion:

• Open regedit: enter “regedit” into the search box on the Start button’s pop-up dialog
• Navigate to the key <HKEY_LOCAL_MACHINE\SOFTWARE\Classes\DVD\shell\play\command>
• Note that <(Default)> is set to “%ProgramFiles(x86)%\Windows Media Player\wmplayer.exe” /prefetch:4 /device:DVD “%L”
• Take a look instead at <HKEY_LOCAL_MACHINE\SOFTWARE\Classes\DVD\shell\PlayWithVLC\command>
• Note that <(Default)> is set to “C:\Program Files (x86)\VideoLAN\VLC\vlc.exe” –started-from-file dvd://%1
• Copy the latter value into the former entry

This can alternatively be achieved via a registry import. Copy the following into a file called, say, <VLC_for_DVD.reg>:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\DVD\shell\play\command]
@="\"C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe\" --started-from-file dvd://%1"

(That’s for a 64-bit Windows 7 system; you may need to adjust that for 32-bit systems, or other editions of Windows.)

Double click on the file’s icon to import the values into the registry.

For reference, my search revealed the following suggested partial solutions

• Open VLC
• From the Tools menu select Preferences
• Select the Interface page (if not already selected)
• Scroll down to find the Set up associations… button, and click it
• Select all or any required extensions
• Save

and

• From the Start button, select Control Panel
• [if list view] Select AutoPlay
• [if category view] Select Hardware and Sound, and then AutoPlay
• Select VLC in the combobox for DVD movie
• set AutoPlay for all media devices as preferred

HTH

Here I describe some of my own programming style preferences that I have not seen described elsewhere.

Delimiting Comments with Blocks

Sometimes it is possible to surround the scope of a comment with braces:

//here's a comment
{
  statement one;
  statement two;
}

However, this is not always possible. It may not be possible, for instance, if the sequence of statements includes declarations.

Limiting the Scope of Variables

Code might be clearer if the scope of variables is kept as short as possible. This is particularly applicable to temporary variables containing intermediate values.

int dist2;
{
  int temp_x2 = x * x;
  int temp_y2 = y * y;
  dist2 = temp_x2 + temp_y2;
  // [scope of temp_x2 and temp_y2 ends here]
}

Again, this is not always possible. For example, if the main variable is a constant, it can not be declared and defined separately in C++.

Multiple Exit Points

Usually, I prefer to have only a single return statement in a function.

Sometimes it is convenient also to have a return statement at the beginning of a function (perhaps checking some pre-conditions). In that case it is still clear what is happening in the code, and in this case the return might be preferable to a long conditional with its additional indentation.

On rare occasions, it may be genuinely clearer and simpler to have multiple exit points throughout the body of a function. In this case, the presence of these should be stated at each end of the function body:

int my_function (int x)
{
  // <multiple exit points>
  // ...
  return 0;
  // ...
  return f(x);
  // ...
  // <multiple exit points>
}

These comments should be included whether or not the return statements have an expression (i.e. whether or not the function has void return type).

Similarly, if a loop body contains exit or skip points, that should also be clearly marked:

for (int i = 0; i < x; ++ i)
{
  // <has break>
  // ...
  if (condition)
  {
    break;
  }
  // ...
  // <has break>
}

Likewise for ‘continue’, or even ‘return’ from inside a loop within a function body.

Switch Fall-through

Usually, each case of a switch statement will have its own break.

I like to ensure that even the final case has a break. If another case is appended, it is then less likely that the required break will be forgotten.

If it is intended that the body of one case should be executed after that of the previous case, then this should be highlighted by a comment. This will clarify the intent, and will prevent ‘hyper-correction’ of the code (when someone adds a break that they assume was forgotten).

switch (var)
{
case 1:
  // ...
break;
case 2:
  // ...
// <fall-through>
case 3:
  // ...
break;
}

Beware that when you save the sources from the GUI, hand-edited files may be reorganised. For example, in many cases element siblings are rearranged into a sorted order. (Also beware that hand-edited files are not automatically re-loaded by the GUI; you must do this explicitly.)

Here I make some suggestions for trying to keep BitRock sources readable.

Comments

In most places, comments will be preserved.

Use XML-style comments to help explain sections of the installer. These may even be viewed in the GUI when you “edit the XML code”.

<!-- use comments to provide additional information or explanation -->

Blocks

There are places where a group can be used. Often this marks a semantic boundary, is associated with control flow, or allows a compound construct in a context where a simple construct is expected.

However, a block could also be used to help delimit the scope of a comment.

For example:

<actionList>
  <!-- Write the configuration files -->
  <writeFile ... />
  <writeFile ... />
  <writeFile ... />
  <!-- Write the sample files -->
  <writeFile ... />
  <writeFile ... />
  <writeFile ... />
</actionList>

might be more clearly re-written

<postInstallationActionList>
  <actionGroup>
    <!-- Write the configuration files -->
    <actionList>
      <writeFile ... />
      <writeFile ... />
      <writeFile ... />
    </actionList>
  </actionGroup>
  <actionGroup>
    <!-- Write the sample files -->
    <actionList>
      <writeFile ... />
      <writeFile ... />
      <writeFile ... />
    </actionList>
  </actionGroup>
</postInstallationActionList>

although this is obviously more verbose. Such grouping is reflected in the GUI, which could make the tree-view of the project more manageable.

Even without comments, it may be clearer to group related items (parameters, actions,…) in this way.

Child or Attribute?

In BitRock elements, properties may often be expressed either as a child or as an attribute.

For example

<setInstallerVariable name="versionMajor">
  <value>1</value>
</setInstallerVariable>

is equivalent to

<setInstallerVariable>
  <name>versionMajor</name>
  <value>1</value>
</setInstallerVariable>

I tend to use the former to declare, define or initialise an important symbol (parameter, variable, function,…), and the latter for ordinary assignments and for temporary, local or minor symbols. This tends to be useful when searching the sources.

Compound Rules

The evaluation logic for a rule list may be expressed in a sibling as, e.g.

<ruleEvaluationLogic>or</ruleEvaluationLogic>
<ruleList>
  <compareText logic="equals" text="" value="${verMajor}"/>
  <compareText logic="equals" text="" value="${verMinor}"/>
  <compareText logic="equals" text="" value="${verPatch}"/>
</ruleList>

but this may also be expressed on an attribute of a rule group

<ruleList>
  <ruleGroup ruleEvaluationLogic="or">
    <ruleList>
      <compareText logic="equals" text="" value="${verMajor}"/>
      <compareText logic="equals" text="" value="${verMinor}"/>
      <compareText logic="equals" text="" value="${verPatch}"/>
    </ruleList>
  </ruleGroup>
</ruleList>

I tend to use the latter, even though it’s a little more verbose, as siblings tend to get separated (sometimes even if the tag names are alphabetically close). The latter will always keep the related logic together.

Function Names

It is possible to define common actions in functions. I tend to name my functions with ‘function’ as a prefix, and to place my functions in a file named closely to the function’s name.

This helps distinguish user-defined functions from any built-in functionality.

Platform + Architecture Detection (for Folders)

The <folder/> construct takes a <platforms/> child, but only with a limited range of values.

Amongst the values are

• linux — meaning ”any” Linux
• linux-x64
• windows — meaning ”any” Windows

but not

• linux-x86
• windows-x86
• windows-x64

However, the <folder/> construct can also accept <ruleList/> which can accept <platformTest/> (see the BitRock knowledge base for the full list of platforms).

Even that does not accept

• linux-x86

Therefore, it is possible to express the various platforms as follows

Linux x86 and x86-64

<folder name="...">
  <platforms>linux</platforms>
</folder>

Linux x86

<folder name="...">
  <platforms>linux</platforms>
  <ruleList>
    <platformTest type="linux"/>
    <platformTest negate="1" type="linux-x64"/>
  </ruleList>
</folder>

Linux x86-64

<folder name="...">
  <platforms>linux-x64</platforms>
</folder>

Windows x86 and x86-64

<folder name="...">
  <platforms>windows</platforms>
</folder>

Windows x86

<folder name="...">
  <platforms>windows</platforms>
  <ruleList>
    <platformTest type="windows-x86"/>
  </ruleList>
</folder>

Windows x86-64

<folder name="...">
  <platforms>windows</platforms>
  <ruleList>
    <platformTest type="windows-x64"/>
  </ruleList>
</folder>

Architecture Detection (for Folders)

It is possible to combine these to express achitectures as follows.

x86 and x86_64 (Linux or Windows)

<folder name="...">
  <platforms>linux windows</platforms>
</folder>

x86 (Linux or Windows)

<folder name="...">
  <platforms>linux windows</platforms>
  <ruleList>
    <ruleGroup ruleEvaluationLogic="or">
      <ruleList>
        <ruleGroup ruleEvaluationLogic="and">
          <ruleList>
            <platformTest type="linux"/>
            <platformTest negate="1" type="linux-x64"/>
          </ruleList>
        </ruleGroup>
        <ruleGroup ruleEvaluationLogic="and">
          <ruleList>
            <platformTest type="windows-x86"/>
          </ruleList>
        </ruleGroup>
      </ruleList>
    </ruleGroup>
  </ruleList>
</folder>

x86_64 (Linux or Windows)

<folder name="...">
  <platforms>linux windows</platforms>
  <ruleList>
    <ruleGroup ruleEvaluationLogic="or">
      <ruleList>
        <platformTest type="linux-x64"/>
        <platformTest type="windows-x64"/>
      </ruleList>
    </ruleGroup>
  </ruleList>
</folder>

Downloading, installing and running any software carries a risk, so

• ensure that you have an anti-virus tool, but don’t rely on it totally (there are always new viruses and other malware not yet in your anti-virus tool’s table of signatures)
• ensure that you also have anti-spyware
• beware website clones (look at the URL)
• remember that a program does not need to be a virus to be harmful; you simply do not know what a program will do when you run it before you run it

in particular

• just because a program claims to be virus-free, adware-free, spyware-free doesn’t mean it actually is
• if you’re looking for anti-virus solutions, beware that some malware even poses as anti-virus software; so take special care when choosing anti-virus software
• beware that “free to download” is not always “free to use”; often a “free download” is trial evaluation software which is feature and/or time-limited; if it’s open-s0urce, that’s a good sign

Sometimes there is a huge variety of packages available

• compare the features; there may be a list or comparison available on Wikipedia;
  (for example, for text editors, there is this list and this comparison)
• see if the developer recommends other related packages or projects; that is often a good sign

and gauge whether the website (and products) are

• well-established
• well-regarded
• professional-looking, including grammar and spelling; a website need not look like a commercial website, but poor design and sloppy language on the website give you some indication that there will also be a lack of the care taken with the source code
• well-linked or referenced from elsewhere

Then ensure that plenty of resources are available in addition to the software itself, such as:

• documentation (online HTML and offline PDFs)
• forum or mailing list (or use Stack Overflow)
• compatibility with commercial offerings’ file formats (read and write)
• cross-platform availability
• ease of installation; availability and thoroughness of the uninstaller
• papers on best practice
• theoretical papers on algorithms

these characteristics are important for gauging ease of use of the tools, but also the legitimacy of the website.

• The developers of the software tend to be directly interested in producing a high-quality, well thought-out tool; it is often s0mething that they will be using themselves.
• Open-s0urce, means that the code is open to scrutiny, criticism, review and update.
• Likewise, the documentation is usually available for scrutiny. All technical details and capabilities are published.
• Being free shows a pure honest motive for development, and also encourages widespread adoption.
• Usually, the software will be developed by a reasonably large community of developers. Usually, the development remains active.
• Often, the software is supported by a community of users and developers through an open forum or mailing list.

There is very little you need to buy. I know of few areas where there’s not an excellent free tool available as an alternative to a commercial one. In many cases, the best of the free, open-source tools are actually superior in stability and functionality to the industry-standard commercial tool.

Computing

Stack Overflow
Programmers
Superuser
Computer Science Theory
Code Puzzles
Code Review

TeX and LaTeX
Linux and Unix
Web
Webmaster

Mathematics / Numerate

Math Overflow
Maths [Meta] [Math Overflow versus Maths]
Statistics

Science

Physics

English

English
Writers

Other

Mapping
Bicycles
Games
Images

More

Stack Exchange
Area 51

Proposed

Maths Software

Theoretical Computing
Computation
Code Review
Cryptography
Game Theory

Theoretical Physics
Astronomy

Linguistics

Puzzles
How Stuff Works

The following, in a file called <wc_find_grep.sh>:

#!/bin/bash

### Find and Grep for Working Copies

### $1 = start directory
### $2 = file glob
### $3 = string pattern

if [ "$3" == "" ] ; then
 echo "working-copy find and grep"
 echo "syntax: ./wc_find_grep \${start_dir} \${file_glob} \${string_pattern}"
else
 find "$1" -regextype posix-extended \
 -regex ".*(\.svn)" \
 -prune -or \
 -iname "$2" \
 -exec grep --with-filename --line-number "$3" \{\} \;
fi

may be used to find strings within files with names matching a certain pattern, using a command

./wc_find_grep.sh . "filename_glob" "string_regex"

(You may need to type

chmod a+x wc_find_grep.sh

to ensure that the script has appropriate execution attributes.)

Similarly, the simpler lines, in a file called <wc_find.sh>:

#!/bin/bash

### Find for Working Copies

### $1 = start directory
### $2 = file glob

if [ "$2" == "" ] ; then
 echo "working-copy find"
 echo "syntax: ./wc_find \${start_dir} \${file_glob}"
else
 find "$1" -regextype posix-extended \
 -regex ".*(\.svn)" \
 -prune -or \
 -iname "$2" \
 -print
fi

may be used to perform just the filename search.

(Or, you might prefer to have both functions in the same script.)