Chetan's web scribblings! » .Net

Design is a contexual process

Chetan — Wed, 30 Jun 2010 09:41:19 +0000

(Though following is written from point of view of software designer, ideas are valueable to any engineering designer.)

Software design is creative process. Design involves significant mental efforts towards creating new ideas or using existing ones for a purpose. Software does not exist before you design it. You, as a designer, play a role of The God. You make decisions about structure and behaviour of software-to-be-constructed.

Design is more of an invention and less of a discovery. As a creator, you may take guidance from other experienced creators or knowledge-base, but you must never forget that your design is primarily your creation and it is up to you to make final decisions about it during specific project, and be accountable for it as a designer.

And design is done, by definition, before construction. Note that design may be for a system, for a subsystem, for a component, for a class, for a method or for any other element. Sometimes you first construct software, then learn from software construction and then design a better one. Still, this better design will be meaningful only if it is implemented. In the most basic sense, designs are created for implementations. That is where painters are luckier than building architect. Both draw pictures of some sort. But architect’s drawing is called design as it is intended to be implemented. This essential property of design that, it is intended to be implemented, is called feasibility of design. Every design must be feasible to sufficient degree.

Any design can be subjectively judged for quality from judgement of how easily design can be implemented in a context. Obviously, judge’s skill and knowledge about both construction and design comes into picture. This make design evaluation two-folds.

1. Design must be fit for purpose sufficiently in a context or in other words, design must be sufficiently easy (ignore inherent complexities) to use for constuction for a context.
2. Design’s quality attributes may easily become subjective in practical situation of a specific project.

Overall, design is very context-sensitive activity. If you do not understand context of design, then you may end up taking inappropriate design decisions. Let us try to see what kind of contextual information you need to do good design.

Purpose: If you are not purposeful, either you will come up with design which will not serve its purpose or design will not allow constructors to produce software with proper quality attributes. Without purpose, you will not have any yardstick to measure success of design. This usually means your clarity about software developement lifecycle objectives.

Business: Beyond knowing verticals, you should be clear about your customer’s business and his expectations in context of a specific project.

Design Tools and Processes: Beyond knowing modelling platform e.g. UML & tools in combination with methodologies e.g. OOAD, you need to know contextual application to specific project after tweaking generic ideas.

Construction Platform: If you do not have good contextual information about construction platform, you may end up doing less feasible design.

Organization Platform: You will work for yourself or somebody else. Make sure you know ways of working within your organization or your project team or your immediate-colleagues team in such a way that your personal context is aligned with organizational context.

Any other project specific contextual information: This one is toughest, and this is what makes each project unique. This is where your creativity, communication and analytical abilities are tested. No matter what, each project has this and you have to unconver this context.

Summary in nutshell: Design is a contexual process.

You can utilize guidance from articles, knowledgebase, best practices, patterns, frameworks, consltants etc but finally, you have to apply all guidance according to your understanding of your context as a designer. You do not have to apply all generic things as they are. In a hindsight, you must have kept your brain on while you have applied generic ideas to your specific project!

New features of C# 3.0

Chetan — Wed, 30 Jun 2010 09:37:10 +0000

Look at simple source code to learn few of new features of C# 3.0.

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
28
29
30
31
32
33
34
35
36
37

public class Book
{
//Auto implemented properties
public string Name { get; set; }
public int ID { get; set; }
}
public class AllLINQ
{
public static void ShowAll()
{
//Collection Initializer and Implicitly Typed Local Variables using 'var'.
//Note how List is created and filled in one line of source code.
var Books = new List<Book> { new Book { Name = "Learn C#", ID = 1 },
new Book { Name = "Learn .Net", ID = 2 },
new Book { Name = "Power Electronics", ID = 3 } };
//LINQ
var BooksQuery = from book in Books
//calling extesion method
where book.IsLearningSeries()
//Anonymous Type
select new { FetchedBook=book, TimeStamp=System.DateTime.Now };
foreach (var SearchedResult in BooksQuery)
{
Console.WriteLine(" Searched at : " + SearchedResult.TimeStamp);
Console.WriteLine(" Book Name : " + SearchedResult.FetchedBook.Name + ",
Book ID = " + SearchedResult.FetchedBook.ID);
}
}
}
public static class Extensions
{
//Extension Method for Book class. Note 'this' against parameter.
public static bool IsLearningSeries(this Book b)
{
return b.Name.Contains("Learn");
}
}

C# and .Net Delegates

Chetan — Wed, 30 Jun 2010 09:11:26 +0000

Please read following simple source to know more about delegates in C# and .Net. Note that this article is for people who wants to learn by looking at simple sample source code without reading too much weed.

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

using System;
namespace Delegates
{
class Program
{
//Following is delegate capable to refer to method taking two int para and returning int.
delegate int SimpleDelegate(int i, int j);//SimpleDelegate is a type
int Subtract(int i, int j) { return i - j; }
static int Sum(int a, int b) { return a + b; }
static void Main()
{
int res;
SimpleDelegate dlgt;
Program p = new Program();

dlgt = Sum;//Assign static method reference.
res = dlgt(20, 10);//Invoke delegate. Equivalent to Sum(20, 10)
Console.WriteLine("n1. Result : " + res);

dlgt = p.Subtract;//Assign non-static method reference. Need object.
res = dlgt(20, 10);//Invoke delegate. Equivalent to p.Subtract(20, 10)
Console.WriteLine("n2. Result : " + res);

dlgt = delegate(int i, int j) { return i * j; };//assign anonymous method
res = dlgt(20, 10);//Invoke delegate
Console.WriteLine("n3. Result : " + res);

//lambda exression: X => Y
//X is list of input, Y can be expression.
dlgt = (i, j) => i / j;//assign using lambda expression
res = dlgt(20, 10);//Invoke delegate
Console.WriteLine("n4. Result : " + res);

//Action<> is generic delegate taking N type-para.
//Action can only refer to method taking N para of specified types and returning void.
Action<int, int> print = (i, j) => Console.WriteLine("n5. Remainder : " + i % j);
print(20, 10);

//Predicate<> is generic delegate taking 1 type-para.
//Predicate can only refer to method taking 1 parameter of specified type and returning bool.
Predicate<int> IsFive = i => i == 5;
Console.WriteLine("n6. Result : " + IsFive(20));

//Func<> is generic delegate taking N type-para.
//Func can only refer to method taking N-1 para of specified type and returning value of Nth type.
Func<int, int> f1 = i => i + 1;
Console.WriteLine("n7. Result : " + f1(20));

//Comparison<> is generic delegate taking 1 type-para.
//Comparison can only refer to method taking 2 para of same type and returning int.
//Method must return -ve, 0 or +ve as a result of comparison
Comparison<int> comp = (i, j) => i < j ? -1 : (i > j ? 1 : 0);
Console.WriteLine("n8. Result : " + comp(20, 10));

//Converter<> is generic delegate taking 2 type-para.
//Converter can only refer to method taking 1 para of first type
// and returning converted result of second type.
//Following converts string to bool.
Converter<string, bool> convert = s => Convert.ToBoolean(s);
Console.WriteLine("n9. Result : " + (convert("true") == true ? "Conversion done" : "???"));

Console.ReadLine();
}
}
}

Example of Code Snippet for Visual Studio

Chetan — Tue, 29 Jun 2010 11:05:41 +0000

Ever wondered how to write code snippet? Have a look at these simple example code snippets – these are specially for people who learn by looking!

You have to place these code snippets (basically XML) into file with .snippet extension. Then you can put all your snippet files into appropriate directory. This directory can be loaded into VS from Tools>Code Snippets Manager>Add. Enjoy!

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

version="1.0" encoding="utf-8"?>
xmlns="http://NewtonicaOnline.com/VS/CodeSnippet">
Format="1.0.0">
>
>Copy Right - crc>
>Adds copyright comment>
>Chetan Panchal>
>http://www.NewtonicaOnline.com>
>crc>
>
>Expansion>
>
>
>
>
>
>Descr>
>Replace with brief description of file content.>
>Brief description>
>
>
Language="CSharp" Kind="any">

// (C) Copyright 2008, Chetan Panchal, All rights reserved, http://www.NewtonicaOnline.com
// Description: $Descr$$end$]]>
>
>
>
Format="1.0.0">
>
>Console.WriteLine Surrounds>
>Surrounds selection with Console.WriteLine>
>Chetan Panchal>
>http://www.NewtonicaOnline.com>
>cws>
>
>SurroundsWith>
>
>
>
>
Editable="false">
>SystemConsole>
>SimpleTypeName(global::System.Console)>
>
>
Language="CSharp" Kind="method body">

>
>
>
Format="1.0.0">
>
>Console.ReadLine>
>Inserts Console.ReadLine()>
>Chetan Panchal>
>http://www.NewtonicaOnline.com>
>cr>
>
>Expansion>
>
>
>
>
Editable="false">
>SystemConsole>
>SimpleTypeName(global::System.Console)>
>
>
Language="CSharp" Kind="method body">

>
>
>
>

Programmers need these!

Chetan — Tue, 20 Apr 2010 05:58:56 +0000

Large monitor, or if possible – two of them!

Reasonably fast PC
(compiler, IDE, browser and db server etc to go fast)

As much RAM as possible
(PC should not slow down due to lack of RAM when RAM could be expanded)

Reasonably fast internet connection
(Not to watch movies, but to view self-learning videos etc)

Good keyboard and mouse
(Keys must not be stuck, standard KB design, working mouse clicking etc)

Great chair and table

Peaceful environment

Latest Development support tools
(IDEs, DBs, ORMs, Components, Libraries, etc)

Freedom to wear casuals

Freedom to have tea/coffee etc at table

Top features of Visual Studio 2010 and .Net 4 (not all, only which apealed to me)

Chetan — Fri, 16 Apr 2010 06:22:12 +0000

Better Ajax (e.g. ClientID in webforms, clean HTML emission)
Better Entity Framework
Better WCF, WF and WPF (specially DataGrid in WPF)
Covariance and Contravariance
Code Contracts
Charting in ASP.Net
Dynamic Language Runtime and dynamic keyword in C#
Generate code element from usage
Improved Intellisense and Code navigation
Managed Extensibility Framework
Memory-mapped files
Multi-Monitor
MVC (Area and Asynch controller)
Named and optional argument in C#
Office programmability
One-click Deployment
Profiling, Debugging and IntelliTrace
Routing
Silverlight Capability
Text templates
Type equivalence
Visualization Tools
XSLT Profiling & Debugging and XSD Designer

Find and remove root cause!

Chetan — Sat, 06 Feb 2010 08:50:47 +0000

If you ever, ever, put a claim to correct to fullest any situation, I repeat, any situation, then make sure that you find and remove root cause of the problem. Do not just remove symptom(s).

Here is minor, obvious, excogitated, concocted, devised example.
Imagine your best friend. He is having high temperature.
Would you try to cure him by making him take bath in cold water? Would you?!!

Think, buddy, think! Then act!

Visual Studio Tip

Chetan — Fri, 03 Apr 2009 11:59:57 +0000

If you are normal, you must be loving Intellisense in source editor in visual studio. You press ‘.’, and you get help.

It is good, with one bad side effect. When intellisense window is opened, you cannot see source code beneath it. So, sometimes when you need to see that part of source code, you have to close intellisense window, look at source code, and open intellisense window again.

Do not blame microsoft, as they have provided a solution. Just press ‘Ctrl’ when intellisense window is open. Try it now.

Instance Failure

Chetan — Fri, 03 Apr 2009 11:52:25 +0000

If you are successful in getting visual studio barking at you with error message “instance failure”, there is a very good chance that you have used \\ in your connection string in configuration file. Replace all \\ with \ and you should be okay.

I learnt it hard way!

New features of C# in simple source code

Chetan — Mon, 31 Dec 2007 20:58:00 +0000

New features of C# in simple source code