Bulding Startup knowledge

Recently, I become very interested in Startup companies and Entrepreneurship.

Becoming a successful Entrepreneur is my life Mission.

I HAVE got MY Entrepreneur Magazine’s membership to be in touch with startups news. Listening to Podcasts, reading books about it. References 

Books

• The Lean Startup
• The Innovators DeliMMA
• The Power of Habit
• The Wisdom of Failure
• Big Bang Disruption
• The Start-Up of You
• Thinking Fast & Slow
• The Four Steps to the Epiphany
• Built To Sell

Podcast

·         ssHear Startups By Alex Blumberg. Is my most favorite podcast

• ThisWeekIn: Startups - twice a week (usually Tuesday and Friday): one-hour episodes with startup founders hosted by Jason Calacanis and Tyler Crowley
•  Founder Stories on TechCrunch TV - Half an hour interviews hosted by Chris Dixon

 Blogs 

• Essays by Paul Graham - simply brilliant!
• TechCrunch - 100 news a day in startup space
• Edwin Chen's Blog - always cool posts on data analysis, machine learning and computational linguistics
• Fred Wilson's AVC
• Chad Dickerson's blog - CTO of Etsy
• Hacker News
• How To Make It As a First Time Entrepreneur - inspiring stories by the founder & CEO of Yipit
• Startup Lessons Learned - The Lean Startup methodology from Eric Ries
• Startups Open Sourced
• The Startup Daily - short entrepreneurship books recommendations once a day
• Signal vs. Noise - one of my role model companies 37signals in their own words
• Matt Cutts - head of webspam at Google - SEO and 30-day challenges, rarely updated
• Chris Dixon's blog - founder of Hunch
• Both Sides of the Table - enterpreneur and VC Mark Suster's insights
• OnStartups - articles by Dharmesh Shah
• Techmeme - curated articles on technology
• Jessica Mah Meets World - founder of inDinero.com
• Blog :: Joseph Perla - former CTO of Turntable
• Founder Diaries by Mick Hagen - founder of Zinch 

Combining Predicates in c#

Today, I was looking for a way to combine 2 or more predicates, We have found an MSDN post about it HERE. It explains 3 different ways to combine predicates using LINQ expressions. .

But, Can we make it simple and cool?

I guess it's time to use our creativity skills.

Think about it we just need to merge lambda expressions. In order to merge lambda expressions we always use &&/!!, so Can we do the same here?

Here's our solution below:

static void Main(string[] args)
{
    Func<Car, bool> theCarIsRed = c => c.Color == "Red";
    Func<Car, bool> theCarIsCheap = c => c.Price < 10.0;
    Func<Car, bool> theCarIsLuxury = c => c.Model == "Audi";
    Func<Car, bool> theCarIsRedOrCheap =    c =>     theCarIsRed(c)
                                                                             && theCarIsCheap(c)
                                                                             || theCarIsLuxury(c);

    List<Car> cars = new List<Car>();
    cars.Add(new Car { Color = "Red", Price = 7 });
    cars.Add(new Car { Color = "Yellow", Price = 90, Model= "Audi" });
    cars.Add(new Car { Color = "Red", Price = 11, Model = "Toyota" });
    cars.Add(new Car { Color = "Red", Price = 60, Model = "Audi" });
    Console.WriteLine("available options: " + cars.Where(theCarIsRedOrCheap).Count());
    Console.ReadLine();
}
class Car
{
    public string Color { get; set; }
    public long Price { get; set; }
    public string Model { get; set; }
}

Conclusion
Combining predicates means combining lambda expressions.  

MVVM and WPF Common Problems for Beginners

    For the past 3 years, I have been using Windows Presentation Foundation(WPF) and Model View ViewModel(MVVM). At the beginning I preferred having everything in code behind because It's simple, you feel more productive and finish the screen in less time. But it doesn't follow the open/close principal. The code becomes very complex when fix defects, add or change user requirements, difficult to test, business logic and controls manipulation are mixed up. Having everything in the code behind is decreasing my productivity in the long term.
   
If you are beginner in WPF and MVVM, don't expect it will be smooth trip. you will struggle at the beginning, you will have a bad moments where you are trying to investigate the binding problems. Be patient and believe that you can make it. This means you have decided to suffer now, and be more productive later.

Here's some MVVM guidelines  

1. Reduce or eliminate your code-behind(Doesn't mean code behind breaks MVVM )
2. Bind all of your UI inputs/outputs to your ViewModel
3. Implement INotifyPropertyChanged on your ViewModel
4. Put your view behavior into the ViewModel
5. Do not put any view state into the model
6. When testing, treat ViewModel as the Real UI
7. Avoid events.  Use commands instead

Here's a list of some problems and a simple way to get over it

Case 1: Passing information to a user control that has It's own View model.
Solution: Instead of creating a dependency property at the user control code-behind and bound it at the parent window XAML, you can simply bound the DataContext property of the user control to the parent window view model property.

Case 2: Communication between different View models
Solution: Based on the complexity of your view models. If it's compels you can use the messenger/mediator pattern. If you can merge them into a single view model and bound and use it instead, this will save you a very big headache.

Case: Having a reference to the UI control at the view model and set the focus if needed.
Solution:

1. You can learn about the attached behavior and create your own behavior class in order to set the focus on any control.
2.  If your case is simple, and you would like to set the focus on a  specific control, pass the control itself as a command parameter to the view mode using. Make sure to use the Dispatcher begin invoke method if you would like to change any control properties at the model view level. this will put your code at the ui thread queue. 

To Be Continue.

Conclusion
Using MVVM and WPF is one of the bnest ways to separate your business logic and user controls manipulation. You have a hard time to get through it at the beginning. Once you are comfortable with it, you will love it and feel like converting all of your old code-behind code to the view model.