Review Goals 2018

1. Read 3 technical Books

I read Uncle Bobs “Clean Architecture”.
 

2. Improve the Chess Engine

I implemented the minor promotion (pawn to queen) 615-544-8550 , improved the code quality and added many unit tests. It however doesn’t beat me yet.
 

3. Certification C#

not done.
 

4. JavaScript or TypeScript Application

not done.
 

5. Learn ASP.NET MVC

I read “ASP.NET MVC 5 Pro” by Adam Freeman and implemented a web application using the technology.
 
 

Coding Resolutions 2019

1. Read 3 Technical Books

“Code Complete” by Steve McConnell, “Pattern of Enterprise Application Architecture” by Martin Fowlers, and one more that isn’t selected yet.
 

2. Improve Chess Engine

a) I improve the search algorithm (currently brute force min max is implemented), and (b) the engine needs to connect to a standard GUI.
 

3. Improve the Android Game “Levels It!”

I want to implement 20 new Levels and a new world.

The post Resolutions 2019 and Review 2018 first appeared on Hans Ulrich Wyss.

In this article I give a short introduction on how to code a chess engine. If you are interested have a look at the code of my chess engine on Github: MantaChessEngine.

Chess Engine Framework

The framework itself is very simple. It holds references to all the parts of the engine and lets the client access the methods required to play a game of chess. It also holds a reference to the board with its pieces.

I wanted to be able to let one instance of the engine play versus another instance of the engine with the same or with a different configuration. That way one could see how a certain search or evaluation strategy would do versus another.

And of course the engine needs to be easily testable!

Here is an overview of the main classes and interfaces used:

Board Representation

The board holds an array of chess pieces. It can get and set pieces and it can execute moves and take moves back. It knows the state of the board: it knows which player still has the right to do one of the castlings and it knows which pawn has the right to do en passant capture. The board holds a reference to the History object that contains a list of the previously executed moves and board states.

Searching for the Best Move

A chess engine needs to find the best move for one player. Lets say we want find the best move for white for the next 2 plies (1 ply = 1 move of one player). So first the MoveGenerator must find all possible moves for white and then for all those moves it must find all answers of black. Now the Evaluation must evaluate all the end positions. Note that all the moves are followed down to the maximum depth. Even if a queen gets lost after the first ply we still follow the moves to the maximum depth and only then evaluate at the end. The last step is to propagate the choices for each move of black and of white back to the first move. Now we have the best move or at least the best move for that particular algorithm.

Move Generator

The main method of the MoveGenerator is GetAllMoves(color). I implemented my engine as a king capture engine. This means that GetAllMoves() returns a list of all pseudo legal moves for one opponent. Pseudo legal means all the normal moves are included in the list that each chess piece can do. It even includes the moves where the own king is under attack. These illegal moves must not actually be played. These moves will be filtered out later when the evaluation of the position takes place.

There is however one situation where the MoveGenerator returns no moves: if the player has lost its king. As the game has ended already we do not follow all moves down to the maximum depth in this situation.

In my first implementation of the MoveGenerator I did it all in one class. It was easy to test but became astonishingly complicated with a deep nesting of ifs and switches. Then I refactored out the chess pieces Pawn 615-544-5451 , Bishop, Knight, Rook, Queen and King. They all know how they are allowed to move on the board.

Evaluation

The Evaluation calculates the score of the board. If the score is positive then white has the better position, if the score is negative black is better.

My simplest Evaluation was to just add up points for all pieces, positive for white, negative for black: Pawn 1, knight 3, bishop 3, rook 5, queen 9. If the king is missing it returns the score for a lost game.

My next Evaluation includes some position info of the piece. Pawns for instance get 1.2 points if they are in the center or the knight gets 1 point in the middle of the board and 0.95 at the border. The player with two bishops gets a bonus of 0.5 points.

I guess there could be more useful special cases like check gives extra points or a rook on open file which I have not tested yet.

Minimax Search

Lets have a look at the minimax algorithm that I used to search the best move (see image). In this example we search to the maximum depth of 2 plies. At “start” white can do two different moves: w1 and w2. As response to w1 black can do move b1 or b2, to answer w2 black can do b3 or b4. The Evaluation calculates the score of each end position. After move b1 it calculates the score 1, after b2 it calculates -1, and so on.

Let black choose its move. Black wants to have a score as low as possible, white wants as large as possible. In black’s move of course black can choose. From b1 or b2 it chooses b2 because the score is lower, from b3 or b4 black chooses b3 (circle in the image).

The chosen scores propagate back so that white can choose from. White knows its move w1 will score -1 and w2 will score 2. 2 is greater so white chooses w2.

I hope this short intro gave you an overview on how to code a chess engine and made you curious to have a look at the code of MantaChessEngine on github or even to start your own engine.

The post Intro on How to Write a Chess Engine first appeared on Hans Ulrich Wyss.

Recently I read this great book by Grant Cardone. To help myself and others to actually use the content I write down the three ideas that stood out the most for me. Here they are:

10X Goals and 10X Action

For some reason we humans underestimate the actions required to achieve a goal. It always takes longer and there are always more problems and obstacles than expected. In software development this is true for sure.

So what happens if you set a normal goal? You underestimate the actions required, you take some action and run into more trouble than you thought and you fall short of the goal. But it wasn’t a giant goal, it was just a normal one! The normal goal did not motivate you to take massive action.

That is why the 10X rule says that you should set goals for yourself that are 10 times bigger than what you would normally and you need to take 10 times the action that you originally thought you would need to achieve your goals.

The giant goal is supposed to motivate you to take massive action!

Fear tells you where to go and when

Fear is like a fire. Time is like oxygen. If you add oxygen to a fire it will burn stronger, if you remove the oxygen the fire extinguishes. Fear behaves very similar. If you fear and then wait and think about the fear will grow. If you act fast the fear loses its power over you. The fear does not need to go away. Fear is not a signal to stop. It is the signal to act.

Grant Cardone has this great saying that you should commit first and figure out the rest later. You should commit 100% first without knowing all the details. While working on it and taking massive action your creativity will kick in and help you in ways you didn’t think possible before.

Fear is an indicator in which direction to go and when to go.

Success

Success is important. You must never reduce success in your mind or in a conversation to something that does not matter. Anyone who minimizes the importance of success to your future has given up on his own chances of accomplishment. Success is vital!

Success must be approached from an ethical viewpoint. Success is your duty 615-544-9656 , obligation and responsibility! No one else is responsible for your success. You are! Success doesn’t happen to you, it happens because of you.

No one needs to fail if someone succeeds. Success is not a scarce resource. Success can be created without limit. There is no shortage of success.

The post The 3 Most Important Ideas from The 10X Rule by Grant Cardone first appeared on Hans Ulrich Wyss.

Fizzbuzz

Fizzbuzz is simple: Write a method that prints the number you put in except print “fizz” if the number is dividable by 3, and “buzz” if it is dividable by 5, and “fizzbuzz” if it is dividable by 3 and 5.

Simple Solution

The first solution that comes to mind would probably be something like this:

public class FizzBuzzer
{
    public static string Evaluate(int number)
    {
        if (number % 15 == 0)
        {
            return "fizzbuzz";
        }
        else if (number % 3 == 0)
        {
            return "fizz";
        }
        else if (number % 5 == 0)
        {
            return "buzz";
        }
        else
        {
            return number.ToString();
        }
    }
}

For this simple requirement this solution is completely fine. However what would you do if you wanted to be able to add new rules to the program without having to modify places where the exiting rules are coded?

Rule Interface: IRule

One could hide the behavior of a rule behind an interface. DoesApply() tells if the rule applies. Apply() applies the rule and executes it.

public interface IRule
{
    string Apply(int number);
    bool DoesApply(int number);
}

The implementation of this interface for the Fizz-rule looks like this:

public class FizzRule : IRule
{
    public bool DoesApply(int number)
    {
        return number % 3 == 0;
    }

    public string Apply(int number)
    {
        return "fizz";
    }
}

Basically the if part of the first solution has moved to DoesApply() and the “calculation” has moved to Apply().

How to Use the Rules

Now we could create a list with all the rules and apply the rules in a foreach loop.

public class FizzBuzzer
{
    private List<IRule> _rules;
    
    public FizzBuzzer()
    {
        _rules = new List<IRule>();
        _rules.Add(new FizzBuzzRule());
        _rules.Add(new FizzRule());
        _rules.Add(new BuzzRule());
        _rules.Add(new CatchAllRule());
    }

    public string Evaluate(int number)
    {
        foreach (var rule in _rules)
        {
            if (rule.DoesApply(number))
            {
                return rule.Apply(number);
            }
        }
 
        return null;        
 }

Chain of Responsibility Pattern

However the constraint says no if and no loop. Lets use the Chain of Responsibility pattern to get rid of the loop.

SetNextHandler() is used to create the chain of concrete handlers and HandleRequest() uses the methods in IRules interface to either handle the request directly or pass it to the next handler.

public abstract class Handler : IRule
{
    Handler _nextHandler;

    public void SetNextHandler(Handler nextHandler)
    {
        _nextHandler = nextHandler;
    }

    public string HandleRequest(int number)
    {
        return DoesApply(number) ? Apply(number) : _nextHandler.HandleRequest(number);
    }

    // IRules interface
    public abstract string Apply(int number);
    public abstract bool DoesApply(int number);
}

Because the class hierarchy changed a bit the rules are renamed to handlers and derive from Handler. Here’s the FizzHandler as example.

public class FizzHandler : Handler
{
    public override bool DoesApply(int number)
    {
        return number % 3 == 0;
    }

    public override string Apply(int number)
    {
        return "fizz";
    }
}

Now we need to construct the objects which is done in the class FizzBuzzer. Here it is:

public class FizzBuzzer
{
    private Handler _firstHandler = null;

    public FizzBuzzer()
    {
        AddHandler(new CatchAllHandler());
        AddHandler(new BuzzHandler());
        AddHandler(new FizzHandler());
        AddHandler(new FizzBuzzHandler());
    }

    private void AddHandler(Handler previousHandler)
    {
        previousHandler.SetNextHandler(_firstHandler);
        _firstHandler = previousHandler;
    }

    public string Evaluate(int number)
    {
        return _firstHandler.HandleRequest(number);
    }
}

You can find the complete FizzBuzz solution on Github. 615-544-6650

The post How to Code Fizzbuzz Without If-Statements or Loops first appeared on Hans Ulrich Wyss.

Don’t criticize 615-544-0810 Telephone Area 800 Michigan region phone , condemn or complain!

Criticism is futile because it puts a person on the defensive and usually makes them strive to justify themselves. This is very true. You can easily observe how your mental reaction is to someone criticizing you. Do you feel good? Do you feel motivated to do better? Do you like the other person criticizing you? Try to observe others if you criticize them. How do they react? How is the mood of your conversation afterwards? In my experience citicism does not really lead to what you intended. Try it out yourself and observe!
 

Give honest and sincere appreciation!

This is exactly the opposite of the point above. Some time ago I had a boss who compliented me on my good work often. I cannot objectivly tell if my work was that good. However the result of the compliments was that I felt motivated to do even better. I wanted to conform and to keep conforming to my bosses top notch opinion of me. Have you experienced something similar? Instead of criticizing others try to appreciate the thing they did good and observe what happens.
 

Become genuinely interested in other people!

Be a good listener! Encourage others to talk about themselves! Let the other person talk about her/his favorite person – herself/himself. I remember a situation when I was talking about something I’m interested in and the other person was listening closely, asking a few questions here and there but not talking much – just listening. The result? It made me feel totally understood and appreciated. It made me like the other person! Have you experienced this? Try to be interested in other people and try to learn stuff from them and observe what happens.
 
Check out the book! It has lots of great insights!

The post How to Win Friends and Influence People – Dale Carnegie first appeared on Hans Ulrich Wyss.

My starting point was this solution from the unity forum which I adapted to my needs. Thanks for the code. Hopefully the improvement in this post is helpful for someone.

The basic idea is to have a language file for each language. A language file consists of keys and contents. The language files need to be stored in the Unity solution (in Unity Editor) in a folder called Resources. To configure the Unity game with a language the script loads the textfile from the resources, parses it and stores the texts and keys in a dictionary. To retrieve a localized text call GetText(key).

TextManager Class Definition

using UnityEngine;
using System.IO;
using System.Collections.Generic;
using System;
using Assets.Scripts;

public class TextManager : MonoBehaviour
{
    private static readonly IDictionary<string, string> TextTable = new Dictionary<string, string>();
    private static TextAsset _language;

Singleton Constructor

TextManager is a singleton. I wanted to make sure there is only one TextManager in the system and the resource file should only be read once. Note the private constructor and the method instance. DontDestroyOnLoad() makes sure the object is not destroyed when a new scene is loaded.

    private TextManager() { }

    private static TextManager _instance;
    public static TextManager instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = GameObject.FindObjectOfType<TextManager>();

                // Tell unity not to destroy this object when loading a new scene!
                DontDestroyOnLoad(_instance.gameObject);
            }

            return _instance;
        }
    }

Awake to Destroy Additional Instances

When during the game you switch from a scene that does not have TextManager in its GameObjects list to a scene with TextManager then a new GameObject is created and the Awake() method is called on it. So if you use DontDestroyOnLoad() you would add another TextManager to the currently instanciated GameObjects. To make sure we only have one TextManager the implementation of Awake() destroys all additional TextManagers.

    void Awake()
    {
        if (_instance == null)
        {
            // If I am the first instance <a href="https://phonelookupbase.ca">Phone Number Trace</a> , make me the Singleton
            _instance = this;
            DontDestroyOnLoad(this);
            SetDefaultLanguage();
        }
        else
        {
            // If a Singleton already exists and you find
            // another reference in scene, destroy it!
            if (this != _instance)
                Destroy(this.gameObject);
        }
    }

Set the Default Language

Persistence.GetLanguage() returns the name of the language that the player has configured. It just reads a value from the PlayerPrefs. If the code is running for the first time we try to set the language that is set in the operating system. Definitions.GermanName, Definitions.EnglishName and Definitions.DefaultLanguages are constant strings. Persistence.SetLanguage() sets a value in the PlayerPrefs.

public static void SetDefaultLanguage()
    {
        string language = Persistence.GetLanguage();
        if (language == "")
        {
            var osLanguage = Application.systemLanguage;
            if (osLanguage == SystemLanguage.German)
            {
                language = Definitions.GermanName;
            }
            else if (osLanguage == SystemLanguage.English)
            {
                language = Definitions.EnglishName;
            }
            else
            {
                language = Definitions.DefaultLanguage;
            }
            
            Persistence.SetLanguage(language);
        }

        SetLanguage(language);
    }

Load the Text File from the Resources

The method SetLanguage() loads the language text file in memory and calls LoadLanguage().

    public static void SetLanguage(string langFilename)
    {
        // Load a asset by its AssetName.
        // The text file must be located within 'Resources' subfolder in Unity ('Assets/Resources' in Visual Studio).
        TextAsset newLanguage = Resources.Load(langFilename) as TextAsset;
        if (newLanguage == null)
        {
            Debug.LogError(String.Format("No valid asset file."));
        }
        else
        {
            LoadLanguage(newLanguage);
            _language = newLanguage;
        }
    }

Parse the Text File to Create the Dictionary

LoadLanguage() parses the language text file and stores all entries in a dictionary. For the expected file format see below.

    
    private static void LoadLanguage(TextAsset asset)
    {
        TextTable.Clear();

        var lineNumber = 1;
        using (var reader = new StringReader(asset.text))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                int firstSpaceIndex = line.IndexOf('=');
                if (firstSpaceIndex > 0)
                { 
                    var key = line.Substring(0 <a href="https://whocallmenow.com/phone/6155445221">615-544-5221</a>  <a href="http://aiw-roi.com/phone/area/900.html">Telephone Area 900</a> , firstSpaceIndex);
                    var val = line.Substring(firstSpaceIndex + 1);

                    if (key != null &amp;&amp; val != null)
                    {
                        var loweredKey = key.ToLower();
                        if (TextTable.ContainsKey(loweredKey))
                        {
                            Debug.LogWarning(String.Format(
                                     &quot;Duplicate key '{1}' in language file '{0}' detected.&quot;, asset.text, key));
                        }
                        TextTable.Add(loweredKey, val);
                    }
                }
                else
                {
                    Debug.LogWarning(String.Format(
                         &quot;Format error in language file '{0}' on line {1}. Each line must be of format: key=value&quot;,
                          asset.text, lineNumber));
                }

                lineNumber++;
            }
        }
    }

Retrieve the Localized Text

This is the implementation that retrieves the localized text from the dictionary.

    public string GetText(string key)
    {
        string result = "";
        var loweredKey = key.ToLower();

        if (TextTable.ContainsKey(loweredKey))
        {
            result = TextTable[loweredKey];
        }
        else
        {
            Debug.LogWarning(String.Format("Couldn't find key '{0}' in dictionary.", key));
        }

        return result;
    }
}

Text File Format

The language files are expected to have this format:
English.txt:

firstkey=first english text
key2=another english text

German.txt:

firstkey=erster deutscher Text
key2=Noch ein deutscher Text

The keys need to be the same in all language files.

German Umlauts
To make sure the german umlauts (äöü) are properly displayed I set the encoding of the text file to UTF-8. For instance use Notepad++ and you find the Encoding in the menu.

Unity 3d

Add the TextManager to the list of GameObjects in Unity. You only need to add it to the scene that is loaded first. The way we defined the constructor and the Awake() method the TextManager will always be there and exactly once.

To get localized text use this line of code:

TextManager.instance.GetText("key");

So that’s it. Happy coding! 🙂

The post Localization TextManager for Unity3d first appeared on Hans Ulrich Wyss.

Here’s a quick review of the goals of 2017:

1. Deploy and maintain “Level It!”. It is deployed and I developed the second release with several improvements. See Level It!
   page
2. Chess engine that beats me. I developed the engine however it does not beat me yet. See Manta Chess Engine on Github
3. Read “Pattern of Enterprise Application Architecture”. I did not read it.
4. Run a coding dojo. Over the past year I ran five dojos.
5. Bonus: Implement another mobile game. I did not start this.

My Programming Skills Goals 2018

1. Read 3 technical Books

Probably those are going to be: Uncle Bobs “Clean Architecture” https://phonelookupbase.ca , “Code Complete”, Martin Fowlers “Pattern of Enterprise Application Architecture”.

2. Improve my chess engine

(a) Implement promotion (pawn to queen), (b) improve the search algorithm (currently brute force min max is implemented), and (c) it needs to connect to a standard GUI.

3. Certification C#

I have to check whether this certificate is still available and if it really makes sense. But I sharpen my C sharp skills this year. It could also be done via Pluralsight courses or something similar.

4. JavaScript or TypeScript Application

Recently I decided that I want to learn more about web development. An important piece of this is JavaScript. So my goal is to write a small game in JavaScript.

5. Learn ASP.NET MVC

As Part of the web development idea I want to learn ASP.NET MVC. This includes the Book “ASP.NET MVC 5 Pro” by Adam Freeman and implementing a web application using the technology.

So these are my programming skills tasks for this year’s free time. To get this done I intend to get up earlier so I can get an hour of activities done before work.

puttygen download windows 615-544-5148

The post Review 2017 and Resolutions 2018 first appeared on Hans Ulrich Wyss.

Introduction

With a regular expression you can find patterns in a string. For instance you can find certain keywords in a text or you can find specific formatted pattern (like email addresses, phone numbers, or hex numbers) in a text.

A regular expression represents a state machine which is used to parse a text to find matches. For most programming languages there are regex engines that are able to use regular expressions and find matches in a text.

Developing and Testing Regexes

When I develop a regular expression I find it very helpful to draw the state machine of the regex. Check out this Website which does exactly that. By the way all regex statemachine diagrams below were generated by this regex tool.

To test a regex I use this very helpful regex test tool. You can enter the regex and the text and see immediately while you type where the matches are.

Literal Characters

Lets say the regex is “ca” and the text is “dog, car, cat”. The engine starts at the “d” of “dog” of the text to try to match the “ca” of the regex. It finds the first match at the “ca” of “car”. As the regex is finished it starts over and tries to match again the “ca” of the regex in the text continuing at the next character in the text. After the space it finds the next match at “ca” of “cat”. This was the last match so we are done having found 2 matches.

The state machine is very simple. It only has one state.

Escaping

In the previous regex the characters we wanted to match “normal” letters. Lets consider we want to find “(” in a text. As “(” has a special meaning in regexes we need to escape it. So the regex is “\(“.

Quantifiers

There are symbols that define how many times the previous character (or group) must occur. * means the previous character must occur 0 or more times. For instance the regex “a*” matches “”, “a”, “aa”, …
The quantifier refers to the previous characcter (or group). “abc*” matches “ab”, “abc”, “abcc” …

Regex	Statemachine	Description
“abc*”		0 or more times

Another quantifier is “+”. It means 1 or more times, ie. “abc+” matches “abc”, “abcc”, “abccc”, it does not match “ab”.

Regex	Statemachine	Description
“abc+”		1 or more times

“?” means 0 or 1 time, ie. “abc?” matches “ab” and “abc”.

Regex	Statemachine	Description
“abc?”		0 or 1 times

“{}” indicates a minimum and maximum occurrence of the preceding character. “abc{3}” matches “abccc”
“abc{2,3}” matches “abcc” and “abccc”.

Regex	Statemachine	Description
“abc{2,3}”		Min 2, max 3 times

Character Groups

Character groups are written in square brakets []. The text matches to any of the characters in the group, ie. “[abc]” matches “a” or “b” or “c”.

The regex elements can be combined, see some examples in the table below.

Regex	Statemachine	Description
“a[bc]+”		matches “ab”, “ac”, “abb”, “abc”, “acc”, “acb”,… “abbbcccbbc” …
“[a-f]”		Character range matches “a”, “b”, “c”, “d”, “e” or “f”.
“[^a]”		Negation matches any character but “a”.

Grouping

In (…) you can group parts of characters together, see table below.

Regex	Statemachine	Description
“(ab)*”		matches “”, “ab”, “abab”, ..
“(ab)|(1)”		matches to “ab” or “1”.
“(ab)+|(1)”		The grouping combined with quantifier. Example matches with “ab” 615-544-5408 , “abab”, “ababab”, “1”.

Word Boundary

Example with Statemachine

Let the regex be “\b0x[0-9a-f]+\b” and the text “add(0x1ff0, var)”. The regex engine take the first part of the regex “\b” and starts to try to find a match in the text. At the beginning we have a word boundary so the match starts. The next part of the regex is “0x”. The text continues with “a” of “add” which is no match. So we are looking for a word boundary again. It finds the match after the braket. Here is a word boundary and it finds a match for the “0x”. It goes to the next character in the text “1” and the next part of the regex “[0-9a-f]” and checks if they match. They do. The next character in the text is “f”. The next part of the regex is a word boundary or another “[0-9a-f]”. The engine tries to find the longest match possible. The “f” matches. This goes on until there is a word boundary at the “,”. The regex ends. So the engine found “0x1ff0” and after that no other matches are found.

The point is the engine is processing the regex starting at the beginning of the regex then walks character by character through the text. If it finds a match it goes to the next character of the regex. If this regex-character does not match the text then the engine starts again at the beginning of the regex and continues at the place in the text where it left off.

Anchor

The regex “^abc” anchors the match to the start of the text. In other words: to match the text must start with “abc”.
The regex “abc$” anchors the match to the end of the text. In other words: to match the text must end with “abc”.
 

Shortcodes

Here are some often used shortcodes:

Modifier

Modifiers change the meaning of the regex or parts of the regex.
In some regex dialects the modifier “m” is before or after the regex, ie “/regex/m” or “m/regex/”.
In .net modifiers can have a beginning and an ending, ie. “(?m)regex(?-m)regex_without_m”. The modifier applies to the regex part after (?m) and before (?-m). The (?-m) is optional. Often used modifiers are:
 

Pitfalls

Note that there are several different regex dialects and different engine implementations. Some features are even dependent upon your environment (locale). Check the manual of your engine for details.

The post Regex Jumpstart Tutorial first appeared on Hans Ulrich Wyss.

Simple!

#define private public

I googled it and found that apparently this is a common technique in unit testing. Wonderful! 615-544-7338

The post #define private public first appeared on Hans Ulrich Wyss.

try
{
    string name = null;       
    int length = name.Length; // bug
}
catch (Exception ex) // why is this bad?
{
    // logging...
    Console.WriteLine(ex.Message + ": " + ex.StackTrace);
}

Why is this catch (Exception ex) a problem?

There is a bug in the try block. If the bug is just logged you are unlikely to notice there is a bug. You probably do not read all the logs all the time.

To be able to fix the bug you need to actually notice there is a bug. One way to do this is to let the program crash in case of a bug. Do not hide the bug PuTTY 615-544-5418 , expose it!

Do not catch all exceptions but only catch specific expected exceptions.
Of course do not catch the NullReferenceException as this would again hide the bug.

The post Why is “catch (Exception ex)” a problem? first appeared on Hans Ulrich Wyss.