Timur Guev:

The fact that the GetHashCode method returns the object address in a managed heap is a myth. This cannot be true because of its inconstancy. The garbage collector while compacting a hip shifts objects and thus changes all their addresses.

Till Microsoft releases their new Windows Terminal there is not much option for a decent command prompt tool in Windows. Forget about having a color theme and or multiple tabs in command windows, you won’t find the basic feature even things like copy/paste. Windows stuck with the same features set for command windows which were built more than 20 years back and not much enhancement made to it afterward. There is always a room for basic terminal windows with few more functionalities which match with those pimp terminals in MaxOS or Linux. I believe Cmder fills that room as I find every feature I expect from a terminal window. It has multiple tabs, can split screen into multiple panels, can run many Unix commands, comes with Git setup, and much more.

Cmder is a self-contained console emulator for Windows without any dependencies. Being a portable application, Cmder offers to run without any need to install on the machine. It is based on ConEmu with the major config overhaul, comes with many color schemes, amazing clink, and a custom prompt layout. If you are looking for a replacement for existing command windows with features like multiple tabs, custom color scheme, minimize to the system tray, etc. then you will love Cmder. Pick your shell you want to work with like Cmd, PowerShell, Bash, or Mintty, and run it using Cmder emulator as standard terminal experience.

If disk space is not the constraint, make sure you use full download options (108 MB) which also has Git for Windows.

Link:
Cmder

A .Net dynamic fake framework for creating all types of fake objects, mocks, stubs etc. Context-aware fluent interface guides the developer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

namespace FakeItEasyQuickstart
{
    using FakeItEasy;
    using NUnit; // any test framework will do

    public class SweetToothTests
    {
        [Test]
        public void BuyTastiestCandy_should_buy_top_selling_candy_from_shop
        {
            // make some fakes for the test
            var lollipop = A.Fake<ICandy>();
            var shop = A.Fake<ICandyShop>();

            // set up a call to return a value
            A.CallTo(() => shop.GetTopSellingCandy()).Returns(lollipop);

            // use the fake as an actual instance of the faked type
            var developer = new SweetTooth();
            developer.BuyTastiestCandy(shop);

            // asserting uses the exact same syntax as when configuring calls—
            // no need to learn another syntax
            A.CallTo(() => shop.BuyCandy(lollipop)).MustHaveHappened();
        }
    }
}

“The first step of any project is to grossly underestimate its complexity and difficulty.”

— Nicoll Hunt

It’s in our muscle memory. Press Ctrl+F in your favorite text editor to find something, provide find criteria, and hit the Find button. As always, we usually stick with the simple Find functionality of the text editor as it serves almost all of our basic search needs. But beneath Find dialog box, there is a powerful Find option, Use Regular Expressions which most seldom use.

Able to recall a correct regular expression when we need it most is rare. Which often leads to the hassle of googling regular expression and trying few failed attempts, and going back to simple Find. This is where following regular expressions cheatsheet comes handy for me.

Regular Expressions:

• Have foo anywhere and bar later in the same line

  .*foo.*bar

• Have foo at the beginning of the line

  ^\s{2,}foo

• Have foo at the beginning of the line and bar later in the same line

  ^\s{2,}foo.*bar

• Have foo in the commentted line

  .*//.*foo

• Have foo inside double quotes

  ^.*".*foo.*"

• Have foo at the beginning or end of the word

  ^.*".*\bfoo.*"

• Have foo at the end of the line

  foo\r?\n

• Have foo); at the end of the line

  foo\);\r?\n

• Have foo but not bar in the same line

  ^.*foo.*(?!bar)

• Have foo and { in the next line

  .*foo.*\r?\n.*{

Build by Jon Yablonski

A resource that provides guidance for designing ethically humane digital products through patterns focused on user well-being.

Dmitri Pavlutin:

… article covers the functions/methods naming good habits. Functions are the moving parts of the application, so having named them precisely increases the readability. The scope is to understand what the function does from its name, arguments list and the way it is invoked.

Far from over-touristed places in Mount Desert Island, Hemlock Bridge is a place for a quiet escape for photographers. Other than one or two souls hiking or wandering around on their bike, you will hardly find anyone asking about your camera or lens. This is the place where you can take your time to find your composition without any distraction. Though you have to hike with your camera gears for 40 mins to get to this place, but it is well worth it. My only suggestion to photograph at this place is to pick a cloudy or overcast day. Harsh direct light under those trees on bright and sunny day will ruin your composition.

eBook and Paperback version of the book is also available if you prefer any of these mediums.

Employing functional programming concepts can improve the quality of your code. Though using functional-programming-inspired features [in C#] is not the same as programming in a pure functional language, like Haskell. Or even a hybrid language but with stronger emphasis on the functional side, like F#.