design-patterns « WordPress.com Tag Feed

2008 October 13 - Links for today

mga guy — Mon, 13 Oct 2008 05:43:51 +0000

jQuery

Jeffrey Jordan Way continues his series with Why Aren't You Using jQuery: PART 3

Tero Piirainen details usage of a jQuery Plugin To Scroll Content

Other

Jacob Gube's article outlining 15 Tools for Monitoring a Website’s Popularity

Matt Berseth continues his Site Traffic analysis tooling with Creating a Live Traffic Page from my PageView/Visit Database

Mike Foskett on a very nice Cross fading disjointed image rollover

Patterns & Practices

Omar Al Zabir diagrams An Agile Developer's workflow when SCRUM is used

Silverlight

Laurence Moroney updates some of his book samples from Introducing Silverlight 2 – Code updates for RC0/RTM

Adam J Cooper on Why I Abandoned Silverlight for ASP.NET MVC - really interesting read, well worth digesting in which he links to Shaun Wildermuth’s insightful article Silverlight and Line of Business Applications

The Silverlight SDK Team have released a doc detailing Silverlight Breaking Changes Between Beta 2 and Release (Updated Document)

Page Brooks on Sharing Code Between .NET and Silverlight Platforms

Jesse Liberty still has more to say following his dramatic finalisation in Data Binding – Margin Notes and Data Binding – Data Conversion

Mike Snow keeps churning them out with How to load a XAML Control From a File or String

Corey Schuman has an Video Slider update for RC0

Tim Heuer Hey, who took my Chiron? and if your not sure what he is talking about, it is definately worth reading :)

David Anson fixes a bug which was Just a little too eager with the clicking... [Updated binaries and source for MouseButtonClicker]

Rick Code on a Navigable Grid in Silverlight, supporting Page Navigation for List Controls such as Data Grid (RC0)

Martin Mihaylov on Page navigation and browser history in Silverlight

Bill Reiss details some Great freeware fonts for PathTextBlock and Silverlight

Tom breaks down the XPerf: A CPU Sampler

Rob Eisenberg announces Caliburn Alpha for WPF AND Silverlight is Here!

SQL

Jacob Sebastian on Understanding SQL Server SET Options 3 - SET ANSI_PADDING ON | OFF and UNPIVOT Example 2

Mika Wendelius on Data versioning in SQL Server using row versions

Brad McGehee on SQL Server 2008: The New Data Types

TDD

Roy Osherove announces the Art Of Unit Testing – Book done, Wiki ready

WPF

Sacha Barber's WPF Screen Saver

Josh Smith Showing an Ellipsis for Clipped Text in a ComboBox

Brian Noyes releases Composite WPF and WPF Data Binding slides and code from Day 2 at the Software Developers Network conference (aka SDC) in Netherlands

Paul Stovell on WPF: DelayBinding and WPF: Dependency Injection in XAML

Thomas Gerber gives us another bar control with the WPF OutlookBar control

Karl Shifflett reduces time to develop once more with Viewing Design Time Data in Visual Studio 2008 Cider Designer in WPF and Silverlight Projects

Jgoldb announces Fixes to WpfPerf Performance Profiling Tool

Colin Eberhardt has a really nice article on Bullet Graphs; A Custom Control - WPF vs. Windows Forms

Strategy Design Pattern

thegame28 — Sun, 12 Oct 2008 17:53:44 +0000


 
note: base class doTask(), perform some task
code has change frequently from derived classes.
- thats the problem bcoz when u have a inherited
classes that write there own code all the time, you have
maintenance problem. u need to change for many
generation of all inherited classes. designed to fix that spreading ur codes.
 

 
note: this algorithms place in algorithm variable,
run different code depending on object,
the idea is seperate , allow ur algo object inside var that
lets u supply different version
of doTask method. polymorphism. 
 
Has a inheritance, allows u to have algorithm.
<
<?php
/**
 * File name: Strategy.php
 * Created by: Charles Claver / charles.claver@gmail.com
 * Created Date: Sept 1, 2008
 *
 * Strategy Design Pattern
 *
 */
 
//interface GoAlgorithm
interface GoAlgorithm {
       public function go();
}
 
class GoByDrivingAlgorithm
{
  public function go()
  {
    echo "Now I'm driving.<br>";
  }
}
 
class GoByFlyingAlgorithm implements GoAlgorithm
{
  public function go() {
    echo "Now I'm flying.<br>";
  }
}
 
class GoByFlyingFastAlgorithm implements GoAlgorithm
{
  public function go()
  {
    echo "Now I'm flying fast.<br>";
  }
}
 
abstract class Vehicle
{
  private $goAlgorithm;
 
  function Vehicle() {
  }
 
  public function setGoAlgorithm ($algorithm)
  {
    $this->goAlgorithm = $algorithm;
  }
 
  public function go() {
        $this->goAlgorithm->go();
  }
}
 
class StreetRacer extends Vehicle
{
       public function StreetRacer() {
              $this->setGoAlgorithm(new GoByDrivingAlgorithm());
       }
}
 
class FormulaOne extends Vehicle
{
       public function FormulaOne() {
              $this->setGoAlgorithm(new GoByDrivingAlgorithm());
       }
}
 
class Helicopter extends Vehicle
{
       public function Helicopter() {
              $this->setGoAlgorithm(new GoByFlyingAlgorithm());
       }
}
 
class Jet extends Vehicle
{
       public function Jet() {
              $this->setGoAlgorithm(new GoByFlyingFastAlgorithm());
       }
}
 
//execute
$sr = new StreetRacer();
$fo = new FormulaOne();
$h = new Helicopter();
$j = new Jet();
 
$sr->go();
$fo->go();
$h->go();
$j->go();
 
?>

Command Pattern-2

Yahya KOÇ — Sun, 12 Oct 2008 10:43:25 +0000

Konuyla ilgili önceki yazılar:

Command Pattern-1

"Pdf Okuyucu" örneğimizi genişleterek devam ediyoruz.PdfPager adında sayfaları ileri-geri çevirmemize yardım eden bir sınıfımız vardı.Şimdi de sayfalar üzerinde not almamızı sağlayacak bir PdfWriter sınıfımız olsun.Bu sınıf yardımı ile sayfalar üzerinde not alabilelim ya da aldığımız önceki notları silebilelim.

Önce ReadCommand sınıfımızı hatırlayalım:
[sourcecode language="csharp"]
public class ReadCommand:ICommand
{
public PdfPager pdfPager { get; set; }
public char IslemTipi { get; set; }
public int Miktar { get; set; }

public void Execute()
{
pdfPager.Read(IslemTipi, Miktar);
}
public void Undo()
{
ChangeIslemTipi();
Execute();
}
public void Redo()
{
ChangeIslemTipi();
Execute();
}
public void ChangeIslemTipi()
{
IslemTipi = IslemTipi == '+' ? '-' : '+';
}
}
[/sourcecode]
Command arayüzünü hatırlayalım.
[sourcecode language="csharp"]
public interface ICommand
{
void Execute();
void Undo();
void Redo();
}
[/sourcecode]
Yeni komut sınıfımız olan WriteCommand sınıfımızda da IslemTipi alanına(not ekle,not sil) ihtiyacımız olacak.Undo ve Redo metodları da önce işlem tipini değiştirip sonra execute metodunu çağıracak.Öyleyse ortak kod bloklarımız var.Bu durumda arayüzü soyut sınıfa çeviriyoruz.Yeni command soyut sınıfımızı inceleyelim:
[sourcecode language="csharp"]
public abstract class Command
{
public abstract void Execute();
public void Undo()
{
ChangeIslemTipi();
Execute();
}
public void Redo()
{
ChangeIslemTipi();
Execute();
}
public void ChangeIslemTipi()
{
IslemTipi = IslemTipi == '+' ? '-' : '+';
}
public abstract char IslemTipi { get; set; }
}
[/sourcecode]
Şimdi de ReadCommad ve WriteCommand sınıfılarımızın son haline bakalım.
[sourcecode language="csharp"]
public class ReadCommand:Command
{
public PdfPager pdfPager { get; set; }
public override char IslemTipi { get; set; }
public int Miktar { get; set; }
public override void Execute()
{
pdfPager.Read(IslemTipi, Miktar);
}
}
[/sourcecode]
[sourcecode language="csharp"]
public class WriteCommand:Command
{
public override void Execute()
{
pdfWriter.PdfNotlariniYonet(IslemTipi,Not);
}
public override char IslemTipi { get; set; }
public string Not { get; set; }
public PdfWriter pdfWriter { get; set; }
}
[/sourcecode]
PdfPager sınıfında hangi sayfada olduğumuzu gösteren CurrentPageIndex adında bir alanımız vardı.Yeni sınıfımız PdfWriter için de hangi sayfaya not aldığımızı gösterecek böyle bir alana ihtiyaç var.Aslında CurrentPageIndex alanının bu iki sınıfa da ait olmadığını direk Book sınıfının bir özelliği olduğunu görüyoruz.Öyleyse bu özelliği, Book sınıfına taşıyoruz.

Book sınıfının son durumu şöyle:
[sourcecode language="csharp"]
public class Book
{
private readonly List commands = new List();
public readonly PdfPager pager=new PdfPager();
public readonly PdfWriter writer = new PdfWriter();
private int CurrentCommandIndex { get; set; }
public int CurrentPageIndex { get; set; }

public Book()
{
CurrentCommandIndex = -1;
writer.book = this;
pager.book = this;
}
public void Oku(char IslemTipi, int Miktar)
{
ReadCommand readCommand = new ReadCommand { IslemTipi = IslemTipi, Miktar = Miktar, pdfPager = pager};
commands.Add(readCommand);
CurrentCommandIndex++;
readCommand.Execute();
}
public void IslemleriGeriAl(int times)
{
for (int i = 0; i < times; i++)
{
commands[CurrentCommandIndex].Undo();
CurrentCommandIndex--;
}
}
public void IslemleriIleriAl(int times)
{
for (int i = 0; i < times; i++)
{
CurrentCommandIndex++;
commands[CurrentCommandIndex].Redo();
}
}
public void NotAl(char IslemTipi,string not)
{
WriteCommand writeCommand = new WriteCommand { IslemTipi = IslemTipi, Not = not, pdfWriter = writer };
commands.Add(writeCommand);
CurrentCommandIndex++;
writeCommand.Execute();
}
}
[/sourcecode]
PdfWriter sınıfımız:
[sourcecode language="csharp"]
public class PdfWriter
{
public Book book { get; set; }
readonly IDictionary NotList=new Dictionary();
public void PdfUzerineNotKaydet(string not)
{
NotList.Add(book.CurrentPageIndex,not);
}
public void PdfUzerineNotSil(string not)
{
FindAndDeleteNot(not);
}
private void FindAndDeleteNot(string not)
{
foreach(KeyValuePair pair in NotList)
{
if(pair.Value==not)
{
NotList.Remove(pair.Key);
break;
}
}
}
public void PdfNotlariniYonet(char IslemTipi, string not)
{
switch (IslemTipi)
{
case '+':
PdfUzerineNotKaydet(not);
break;
case '-':
PdfUzerineNotSil(not);
break;
}
}
}
[/sourcecode]
ve nihayet Musteri sınıfı:
[sourcecode langugae="csharp"]
public class Musteri
{
public static void Oku()
{
Book book = new Book();
book.CurrentPageIndex = 28;

book.NotAl('+',"deneme");
book.Oku('+', 5);
book.NotAl('+', "deneme2");
book.Oku('+', 7);
book.NotAl('+', "deneme3");
book.Oku('+', 8);
book.NotAl('-', "deneme");
book.IslemleriGeriAl(2);
int sayfaNumarasi = book.CurrentPageIndex;
}
}
[/sourcecode]

book.IslemleriGeriAl(2); satırına gelindiğinde sayfa numarası 48,book nesnesinin içinde yer alan writer nesnesi üzerinde tuttuğumuz NotList alanı: (33,deneme2),(40,deneme3) değerlerini gösterir.
book.IslemleriGeriAl(2); satırını da çalıştırdığımzıda önce book.NotAl('-', "deneme"); komutumuz tersine çalışıp sildiğimiz "deneme" notunu geri yazacağız.Sonra da book.Oku('+', 8); komutunu tersine çalıştırıp 8 sayfa geri gideceğiz.Son durumda sayfa numarası 40,book nesnesinin içinde yer alan writer nesnesi üzerinde tuttuğumuz NotList alanı: (33,deneme2),(40,deneme3),(48,deneme) değerlerini gösterir.

Temel iş mantığında hatalar,mantıksızlar olabilir.Sonuçta bu bir örnek.Önemli olan command pattern desenin işleyiş mantığını anlamak.
Tasarım desenleri ile alakalı bir kaç şey söylerek bu yazıyı tamamlamak istiyorum.Tasarım desenleri uygulanması zorunlu metodolojiler değildir.Çözüm getirdiği iddia edilen durumlar için uygunluğu daha önceden birçok kez tescil edilmiş,genelleşmiş yöntemlerdir.Her geliştiricinin kendine has durumları için kendine özel çözümleri,tasarım desenleri olabilir.Yazılımcının tasarım deseni ezberlemesi çok mantıksız ve gereksiz geliyor bana..Ben command Pattern'i ezbere bilmiyorum.Bu kodu yazdıktan sonra bile ezberimde değil.İhtiyacım olduğunda daha önceden yazılmış kodu inceleyerek kendi durumuma göre özelleştirip kullanıyorum.Bazı durumlarda "illa da tasarım deseni kullanarak yapacağım(overengineering)" diye basit bir kodu karmaşıklaştırmanın hiç bir anlamı yok.Yazılım geliştirme, deneme-yanılma yöntemine dayalı(heuristic) bir iştir.Yukarıda yazılan kod, yeni yeni deneme-yanılma yöntemleri kullanılarak daha iyi bir duruma getirilebilir.
Sağlıcakla kalın.

Command Pattern

Yahya KOÇ — Sat, 11 Oct 2008 22:53:55 +0000

Nesnelerimizin üzerinde çalışacak komutları birer nesne olarak sarmalıyoruz(Encapsulation).Yani metodlarımızı birer nesne haline getiriyoruz.Böylece çalıştırdığımız metodları ve parametlerini bir yerlerde saklamış oluyoruz.Bu komut nesnelerini, bir arayüz ya da soyut bir sınıftan türütüyoruz.Böylece örneğin "Run" gibi çok genel anlamı olan bir metod içerisinde farklı farklı işlemler yapabileceğiz.

Örneğin
[sourcecode language="csharp"]
public class EkleCommand:ICommand
{
public void Run()
{
//Veritabanına Ekle
}
}
public class UyarCommand:ICommand
{
public void Run()
{
//MailAt
}
}
public interface ICommand
{
void Run();
}
[/sourcecode]

Şöyle de bir kodumuz olsun
[sourcecode language="csharp"]
private readonly List commands = new List();
ICommand command1=new EkleCommand ();
ICommand command2=new UyarCommand();
commands.Add(command1);
commands.Add(command2);
.......
foreach(ICommand cmd in commands)
{
cmd.Run();
}
[/sourcecode]

Gördüğümüz gibi çalışacak komutlarımızı bir köşede saklıyoruz.Zamanı gelince de sırayla çalıştırabiliyoruz.Bu tür kullanım genelde içerisinde Undo-Redo metodları olan uygulamalar içindir.Örneğin Microsoft Word Geri Al(Ctrl+Z).....

Şöyle bir uygulama tasarlayalım.Bir Müşteri web sitemize girip Elektronik kitap üzerinde okuma yapabilsin.Sayfalar arasında dolaşabilsin.Sonra yaptığı işlemleri geri alabilsin.
Önce yazdığımız kodun sequence diagramına bakalım:

Öncelikle ICommand arayüzünü inceleyelim.
[sourcecode language="csharp"]
public interface ICommand
{
void Execute();
void Undo();
void Redo();
}
[/sourcecode]
Üç temel metodumuz var.Bunları uygulayabilecek farklı farklı command nesneleri oluşturabiliriz.
PdfPager adındaki sınıfımız sayfalar arasında geçiş yapmamıza yardım etsin.

[sourcecode language="csharp"]
public class PdfPager
{
public int CurrentPageIndex { get; set; }
public void Read(char IslemTipi, int Miktar)
{
switch (IslemTipi)
{
case '+':
IleriDogruCevir(Miktar);
break;
case '-':
GeriDogruCevir(Miktar);
break;
}
}
private void GeriDogruCevir(int miktar)
{
CurrentPageIndex+=( - 1 * miktar);
}
private void IleriDogruCevir(int miktar)
{
CurrentPageIndex+=miktar;
}
}
[/sourcecode]
PdfPager sınıfındaki Read metodu yardımıyla sayfalarımızı ileri yada geri çevirebiliyoruz.
Şimdi asıl işimizi görecek ReadCommand sınıfını inceleyelim:
[sourcecode language="csharp"]
public class ReadCommand:ICommand
{
public PdfPager pdfPager { get; set; }
public char IslemTipi { get; set; }
public int Miktar { get; set; }

Şimdi de Book ve Musteri sınıflarımıza bakalım.
[sourcecode language="csharp"]
public class Musteri
{
public static void Oku()
{
Book book = new Book();
book.pager.CurrentPageIndex = 28;
book.Oku('+', 2);
book.Oku('-', 1);
book.Oku('+', 11);
book.IslemleriGeriAl(3);
book.IslemleriIleriAl(2);
int sayfaNumarasi = book.pager.CurrentPageIndex;
}
}
public class Book
{
private readonly List commands = new List();
public readonly PdfPager pager=new PdfPager();
private int CurrentCommandIndex { get; set; }
public Book()
{
CurrentCommandIndex = -1;
}
public void Oku(char IslemTipi, int Miktar)
{
ReadCommand readCommand = new ReadCommand { IslemTipi = IslemTipi, Miktar = Miktar, pdfPager = pager};
commands.Add(readCommand);
CurrentCommandIndex++;
readCommand.Execute();
}
public void IslemleriGeriAl(int times)
{
for (int i = 0; i < times; i++)
{
commands[CurrentCommandIndex].Undo();
CurrentCommandIndex--;
}
}
public void IslemleriIleriAl(int times)
{
for (int i = 0; i < times; i++)
{
CurrentCommandIndex++;
commands[CurrentCommandIndex].Redo();
}
}
}
[/sourcecode]
Kitap sınıfımızda ICommand tipinde commands adında bir listemiz var.Çalışacak komutlarımızı burada tutuyoruz.(Stack de kullanılabilir).CurrentPageIndex müşterinin o anda okuduğu sayfa numarasını,currentCommandIndex o anda çalışan komut sırasını göstersin.
IslemleriGeriAl metodunda ICommand tipindeki komutlarımızın Undo metodunu çalıştırıyoruz. Böylece yapılan işlemi geri alabiliyoruz.Üç sayfa ileri gitmişsek üç sayfa geri gidiyoruz.Beş sayfa geri gitmişsek beş sayfa ileri gidiyoruz.
[sourcecode language="csharp"]
Book book = new Book();
book.pager.CurrentPageIndex = 28;
book.Oku('+', 2);
[/sourcecode]
Bu kod bloğu sonunda CurrentPageIndex 30'u gösterecektir.(İki sayfa ilerledik)
[sourcecode language="csharp"]
Book book = new Book();
book.pager.CurrentPageIndex = 28;
book.Oku('+', 2);
book.Oku('-', 1);
book.Oku('+', 11);
[/sourcecode]
Bu kod bloğu sonunda CurrentPageIndex 40'ı gösterecektir.(28+2-1+11)
[sourcecode language="csharp"]
book.IslemleriGeriAl(3);
[/sourcecode]
IslemleriGeriAl metodunda üç defa Undo işlemi çalışacaktır.Bu işlemler sırasında daha önce çalıştırdığımız son üç metodun işlem tipi değiştirilerek sonuca gidilecektir.
40-11+1-2=28 Tekrar başladığımız yere döndük.
[sourcecode language="csharp"]
book.IslemleriIleriiAl(2);
[/sourcecode]
IslemleriGeriAl metodunda üç defa Redo işlemi çalışacaktır.Daha önce çalıştırdığımız metodlardan kaldığımız sırada işlem tipi değiştirilerek sonuca gidilecektir.
En son 28.sayfada kalmıştık.
28+2-1=29
İşlemler sonucunda 29.sayfaya konumlandığımızı gördük.

Singletons in Python

lukef — Fri, 10 Oct 2008 18:23:26 +0000

So I've been getting back into python. I have always been a dabbler when it comes to scripting languages. I mean, every chance I get I try to convince whichever employer I am working for that they are good to have around, but alas it doesn't always work out perfectly.

Anyhow, I started writing a little mail checker application for gnome, something that there are 100's of, sure, but something that I think has never been done well enough for me to use them. When handling application-wide configuration for said application, I thought "Singleton!". So I browsed the web, condensed what was what, and came up with the following snippet.

It is based heavily off a code snippet i found on activestate code [link]. I guess I just prettied it up a little and swapped a few things about.

It's not thread safe, in this instance, so you'll want to read the comments for a pointer on implementing locking.

Here is the basic template code:

class Singleton(object):

    __instance = None            # single instance
    __test = ""

    def __new__(cls, *args, **keywords):
        return cls.getInstance(cls, *args, **keywords)

    def __init__(self):
        pass

    @classmethod
    def getInstance(cls, *args, **keywords):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls, *args, **keywords)
        return cls.__instance

    # attribute accessors
    def get_test(self):
        return Singleton.__instance.__test

    def set_test(self, test):
        Singleton.__instance.__test = test

    test = property(get_test, set_test)

2008 October 10 - Links for today

mga guy — Fri, 10 Oct 2008 08:03:41 +0000

ASP.Net

A work colleague pointed me at Lightweight Test Automation Framework for ASP.NET Samples today. Looks promising but got me thinking again about UI functionality testing. So I started wondering if you could use jQuery to write a bunch of functionality tests for any kind of pages? i.e. Load a page, have jQuery check for expected page elements, manipulate given elements and check form / page interaction. I may even get time to try that out one day.

jQuery

Dave M Bush on jQuery - The Man, The Myth, The Legend

Casey Charlton points out a jQuery Gotcha - Functions in Events

Patterns & Practices

Dave M Bush again with Friday Books - Agile Software Development with Scrum and Automatic Implementation of Interfaces

pbielicki reckons Premature optimization is the root of all evil - not only in the Agile world

Kevin Hazzard presents A Survey of Popular .NET Inversion of Control Containers with slide decks and code :) thanks Kevin.

Other

David Yack discusses the .NET 3.5 Enhancements Training Kit

Mike Wasserman has done a bunch of work on Multitouch applications with a web cam??? source code also available

Shahar Y presents an article on Measure String Size In Pixels (C#)

Possibly the best collection of geek related cartoons ever

Tina Holmboe illuminates with XHTML — myths and reality

37 Signals with an extremely simple, effective and important exert on getting stuff done with a line I simply love - Be an Executioner

Silverlight

Laurence Moroney explains Why don't Beta 2 sites work on RC0

Seema Ramchandani on XPerf: A CPU Sampler for Silverlight

Jesse Liberty goes into Custom Controls – The Dénouement

Manish Dalal offers stealth paging in the datagrid.

Mike Snow keeps 'em comin' with Text Wrapping and Line Breaks in TextBlocks and How to Display Special Characters in XAML

While Jeff Handley posts a follow up to yesterdays post Tab Navigation in a Popup, Take 2

SQL

Possibly the best book ever on Database Design (Place tongue firmly in cheek)

and Alex Kozak delves into The Bejeweled Puzzle in SQL

UX

Peter Durand does a great job of an Edward Tufte Redux

The guys at BulletProofBox have written up an excellent article on Web-Based Rich Text Editors Compared

David Engfer lets it all out with a Case Study of Poor Web Usability and Design

WPF

WindowsClient.Net present What's New for Performance Profiling Tools for WPF

Todd Miranda Builds a Custom GridLength Animation

Dr WPF examines FrameworkElement vs. FrameworkContentElement

Sacha Barber – I think I love you, how shallow I am, it really is all about the candy - WPF : Sticky Notes ListBox

Rudi Grobler - Validation in WPF using PostSharp/AOP

Laurent Bugnion on Converting and customizing XAML to PNG with server-side WPF

Adam Kinney looks at WPF Effects and Transitions Library Applied

Karl Shifflett gives us a Cool Usage Tip For XAML Power Toys

Software Engineer - 2 to 3 Years - Java, J2EE - Zenith Software - Bangalore

Talentty — Fri, 10 Oct 2008 05:30:57 +0000

Zenith Software - Bangalore

Our world-class software solutions and support services are tailored to your unique requirements. We do this by leveraging a decade of experience partnering organizations across the world. Our offshore model delivers maximum benefits to our clients.

Located in Bangalore, Zenith Software is an established company with the nimbleness and agility of a growing organization. Over 10 dedicated development centers for clients stand testimony to this fact.

Designation: Software Engineer

Experience: 2 - 3 Years

Skill Sets Required:

Good Communication
Core Java
J2EE, MVC Architecture, Design Patterns
Struts / Spring / Hibernate
EJB
MySQL / Oracle / SQL Server

Please mail your resumes to harshan@zenithsoft.com

This Job is posted in http://www.zenithsoft.com/ for more details visit http://www.zenithsoft.com/Openings%20in%20IT%20Services.html

2008 October 09 - Links for today

mga guy — Thu, 09 Oct 2008 06:38:36 +0000

ASP.Net

Bertrand Le Roy on New AJAX Support For Data-Driven Web Apps

CSS

Dmitry illustrates How to Add Drop Shadows to Menus or Windows with CSS

jQuery

Stan Lemon introduces jGrowl “jGrowl is a jQuery plugin that raises unobtrusive messages within the browser, similar to the way that OS X's Growl Framework works” with an update also available - jGrowl 1.1.1

Other

Smashing Magazine illuminates with Adobe Illustrator Tutorials - Best Of: Part 2
Paul Stovell with more on Bindable LINQ: Dependencies and Architecture: Five tips for Low Friction Projects
Ramky asks What are the Good Qualities of a Developer??
Tim Ferris reprints 2600’s article: From Tesla Motors to the “Patriot Hack” - Martin Eberhard on Protecting Your Privacy Online

Patterns & Practices

Shawn Burke gets truly TLA rich with MEF 'n IoC
Patrick Smacchia explains Some Unexpected Code Dependency Issues in NDepend
Matt grommes continues a really good series in My First Agile Project Part 6: The First End Of Our Project

Silverlight

Kirk Allen Evans on Hosting Silverlight in a SharePoint Webpart
Andy Nogueira's Thoughts on the application of Siverlight and its direction…
Corey Schuman's Overview of Databinding in Silverlight
Laurence Moroney on running Silverlight RC0 and Beta 2 Side by Side: Question of the Day
Mike Snow shows us How to Dynamically Load a Silverlight Control within another Silverlight Control
David Hill’s first in a series of articles on Silverlight Navigation - Part 1
Jonas Follesø on Efficient testing in Silverlight 2 using tags

SQL

Kevin Kline makes a large claim indeed with How to Improve Application and Database Performance up to 40% in One Easy Step
Chad Miller continues with SQL Server PowerShell Extensions (SQLPSX) Part 2
Brian Walker guides with SQL Server database design disasters: What not to do

UX

Janko Jovanovic another great article on Building better web forms: Validation best practices

WPF

John Bowen details Syntax for Nested Attached Properties
Josh Smith on Binding to (Validation.Errors)[0] without Creating Debug Spew
Pavan Podila notes Generic.xaml must have a build action of Page
Rudi Grobler documents Learning PRISM – Getting Started… and Validation in WPF using PostSharp/AOP

2008 October 08 - Links for today

mga guy — Wed, 08 Oct 2008 08:59:37 +0000

ASP.Net

Suprotim Agarwal's Top 5 ASP.NET AJAX Articles You Must Read

C#

Matthew Podwysocki gives us a HUGE list of resources at Richmond Code Camp 2008.2 - Functional C# Recap

Vani Kulkarni does a nice job showing How to create and display funnel charts on a web page with C# and ASP.NET.

jQuery

Dave Ward on Using jQuery to enhance ASP.NET AJAX progress indication

Other

Joe Stagner reckons Artinsoft Aggiorno fixes your web pages with the software available at http://www.aggiorno.com/ - there is a free version for IE8 too

Kevin Pang notes the 10 Programming Proverbs Every Developer Should Know

Lindsey Lake is having a Love Affair With Woopra which looks totally awesome by the way, she also presents some Typography Essentials - Free Fonts, Tools and Tutorials and How to Use CSS Sprites With Son of Suckerfish Drop Downs and Even More Obscure Photoshop Essentials! The Free Photoshop Brushes Edition

Patterns & Practices

Shivprasad Koirala presents a fair body of work with .NET Design Pattern Interview Questions Part 4, Part 3, Part 2 and Part 1

Silverlight

Peter Bromberg has been sneakily doing a whole series on Doing Data with Silverlight 2 Silverlight 2 RC0. Part VIII : Using the Threadpool, Part VII: Custom Binary Serialization, Part VI: A Generic Request WebService, Part V: Realtime StockQuotes / Scrolling Display, Part IV: Browser / Cookie Interaction, Part III: Extract and decompress resources from your SilverLight xap file on demand, Part II: Data via ASMX and WCF web service, WebClient, and other modalities and Part I: Data and Databinding with Silverlight 2. Along with articles on Silverlight Cross-Domain / ClientAccessPolicy File checker and Silverlight: Dynamically add "favorites" bookmark link to Page Peter has been once seriously busy wee bee. Keep 'em coming Peter. We can't get enough :)

Karen Corby on the Silverlight HTTP Networking Stack – Part 1 (Site of Origin Communication)

Yavor Georgiev and his take on Databinding and the SyndicationFeed class

Rob Houweling has a couple of nifty articles on Creating a sketch application in Silverlight - Part 2, Saving the sketch on the server and Authentication in Silverlight using ASP.NET FormsAuthentication

Laurence Moroney with some pretty good reasons as to the how and why you might want to DeepZoom your Office Documents!

Martin Mihaylov presents his findings on The ProgressBar control in Silverlight 2

Karl Shifflett announces XAML Powertoys 3.1.0.2 with Silverlight support

Jonas Folleso and his YouCard, DiveLog and WebcamPOC updated for Silverlight 2 RC0

Bill Reiss announces Latest version of Silverlight Streaming helper classes and SLSExplorer and updates on a Breaking change to font embedding for Silverlight 2 RC0 and also gives a possible fix if you have Updated to Silverlight RC0 and now it's broke? Cheers Bill.

Koen Zwikstra announces Silverlight Spy updated

SQL

Michael Coles and his take on A Google-like Full Text Search

Brian Knight's Parameterizing SSRS Reports - SQL School Video

Samuel Vanga discusses Disabling a Trigger for a Specific SQL Statement or Session

Matt Berseth presents v0.2 of his Visit/PageView Cube - Creating a Hierarchy for the Source Dimension

UX

Glen Stansberry summarises 20 Excellent AJAX Effects You Should Know

Smashing Magazine look at Retro and Vintage In Modern Web Design

WPF

Robbe Morris WPF - XAML Change Binding Attributes At Runtime

Technology Research Highlights: C5, YIIHAW, and MemJet

Dan Vanderboom — Tue, 07 Oct 2008 19:31:11 +0000

When I’m not designing or writing code, I’m usually doing some kind of research. Looking for new gadgets, toys, technologies, groundbreaking research, or following my favorite blogs and podcasts. Because I haven’t been highly focused on any single project lately, I thought I’d share some of the more interesting things I’ve come across.

Peter Sestoft, C5 Generics Collection Library, and YIIHAW

Peter Sestoft is a brilliant professor at the very old (founded 1479) Copenhagen IT University in Denmark, which actually has a student body consisting of a female majority (59%)! I discovered Sestoft’s works while doing research for some new, more powerful collection class I was working on (Tree<T> and Set<T>). He was featured on Channel 9 back in January on a show primarily about the C5 Collection Library.

C5 Generics Collection Library

The C5 Collection Library is an extremely powerful and well-designed library, based on earlier Java and Smalltalk collection library designs, and completely blows away the standard collection classes delivered as part of the .NET Framework. An earlier version was covered well in a Dr. Dobb’s article, but to summarize: C5 is interface-based, provides convenient but hard-to-implement functionality (such as persistent sorted collections and sublist views), provides useful abstractions such as lists, sets, bags, priority queues, double-ended queues, stacks, dictionaries, and optimizes access of these data structures for asymptotic complexity.

Unless you’re an expert—as with encryption—if you find yourself creating your own complex data structures, chances are you’re going to do it wrong. So it’s nice to know that the mathematical experts have taken the time to very carefully design and construct a wide assortment of useful data structures for the rest of us to use, complete with unit tests. And the best part, in the spirit of true science, C5 has a very liberal open source license, so it can be used in open source and commercial software alike. It’s reportedly being used by the military, video game shops, web server software, and more.

Sestoft and his colleagues have the excellent habit of providing copious documentation: a book’s worth, in fact! It can be found online here.

I think it’s an excellent candidate for being included in the .NET Framework itself, and I highly recommend that you check it out the next time you need a fancy data structure and are tempted to write it yourself, and to consider for optimizing performance of existing code that relies heavily on data structures (which is almost everywhere).

Getting the fundamentals right is probably the hardest thing to do. It’s easy (and tempting) to build as tall as we can, but getting a firm foundation in place is much more important. That’s why the C5 Collections Library is so amazing. So what are you waiting for? Go download it!

YIIHAW Is an Intelligent and High-performing Aspect Weaver

What really gets me excited is Sestoft’s YIIHAW, a high-performance static aspect weaver for .NET.

Aspect Oriented Programming (AOP) is a paradigm for addressing cross-cutting concerns in software. That is, logic that operates orthogonally to business logic, such as logging, security, configuration, and more. There are a number of open source aspect weavers available today, and they generally fall into two camps: static or compile-time weavers, and dynamic or runtime weavers.

While incredibly useful, several factors have kept AOP from entering the mainstream. For one, a good set of tools hasn’t yet emerged to enable easy debugging of aspects. When we step through lines of code in Visual Studio, the debugger has no way of knowing if or when some other injected piece of code should pick up the thread of execution, since weaving isn’t a natively recognized and supported activity within the debugger.

Another hindrance is performance: aspect weavers typically inject logic (called advices) in the form of method calls at the beginning and/or ending of existing methods (the locations are called join points) which are selected with special selector statements (called pointcuts). The typical trick, as I just alluded to, is to include a new method in the class (called an introduction) and then insert method invocation statements at the beginning and end of the methods to be modified. This isn’t a big deal in many cases, but in performance-critical sections of calls, the additional method calls and the stack manipulations that accompany them prevent these techniques from being practical in performance-critical scenarios.

Data structures play a pivotal role in high-performance algorithms, of course, and Sestoft’s experience in building the C5 Collections Library provided the perfect context in which to consider how some of the specific features of his data structures might adversely affect performance. For example: his collections fire events to inform any interested parties that a collection had an item inserted, deleted, or modified in some other way, eliminating the need for defining specialized collections that trigger specific actions outside of that collection (see my article on a Tree<T> structure I created that makes use of this).

If the C5 library could start with the basic, slimmed down, super high-performant data structures, and then “weave in” aspects to include features such as event notifications only when needed, the problem might be solved. The problem with the typical approach, however, is that insertion of method calls provides as much or more overhead than the simple checks to activate those features to begin with (if not null, then invoke event), so he knew he’d have to go with a different approach.

After evaluating the capabilities and performance number of existing open source aspect weavers, they were all found to be inadequate, and the YIIHAW thesis project was born. You can find the fascinating thesis (which I just finished reading) here. In a nutshell, YIIHAW employs an advanced technique called advice inlining, in which CIL instructions are woven directly into their target methods. There are a surprising number of challenges to this approach, including the need to convert the original methods RET (return) instructions to jumps, remapping jump addresses, updating the method stack size, and much more. The students who worked on this thesis (Rasmus Johansen and Stephan Spangenberg), under Sestoft’s direction, did a masterful job of overcoming all of these challenges, the result of which is a highly-capable static aspect weaver with no performance penalty!

This is truly amazing, and it enables aspects to be woven into an assembly repeatedly: one for feature A, another for feature B, etc., all with the assurance of type safety and performance equivalent to writing the code by hand with all features included in the first place.

Another positive of YIIHAW thesis is the light it shines on CIL instructions, their organization and function. The advice inlining techniques provide a great tutorial for those wanting a deeper understanding of how to manipulate things at the CIL level. Many who have attempted AOP have either not considered this approach, or else turned away from this path due to the complexity and challenge. Not so with the YIIHAW team, who faced the problem head on and accomplished something great as a result. The fantastic Mono.Cecil library, despite being poorly documented, is used for analysis and manipulation of CIL code, and several other ideas came to mind as I saw how this tool was put to use.

My only criticism of their application of this technology for the generation of specialized data structures at compile time is that you may find yourself needing different versions of the same data structure in different parts of your application. In a class that performs analysis of visual data for extracting spatial cues, you may need a Tree with as little overhead as possible (i.e., no event notifications, no serialization capability), and in the user interface, you may need another Tree with those additional characteristics. By making a single decision at weave time, your options will be limited.

There’s also the issue of supporting the debugging process, which can’t be dismissed lightly. But YIIHAW has gone to extreme measures to overcome some of AOP’s largest obstacles; and in addition to interceptions (weaving logic into existing methods), YIIHAW also supports introductions (adding new types and members), and typestructure modifications (changing a class’s base class, or making a class implement an interface).

Overall, YIIHAW’s potential is huge, and I believe that it won’t be long before the tooling catches up to the point where AOP becomes a mainstream approach to complex cross-cutting systems problems, simplifying designs and the engineering process overall.

Memjet Printer

Color printing is about to get a whole lot faster. At 60 pages per minute (ppm), the Memjet printer, developed by Kia Silverbrook, a prolific inventor with over 1400 patents. Check out the YouTube video to see it in action.

I’ve seen a lot of speculation that Memjet is a hoax, and a technological leap forward this large certainly warrants skepticism. However, the technology was written about in a very respectable science magazine, one of my favorites: Scientific American, in June 2007. It’s also been covered in several articles by PC Magazine, for example in May 2007, which mentions the Memjet appearing at the 2007 Global Ink Jet Printing Conference. (Talk about specific conferences!)

The print heads are page-width, so they don’t have to move back and forth across the page. The “MEM” in Memjet stands for microelectromechanical, and refers to the fabrication process that involves CMOS chips on a silicon wafer for precision layout.

With ink spraying at 900 million 1-2 picoliter drops per second, drop size small enough to dry within a second, and an estimated price tag under $200 (compared to the comparable HP Edgeline at $16,000), waiting around for long documents to print will soon be a thing of the past for everyone. The first devices are expected to appear in 2009.

Using The 'curb cuts' Principle to reboot computing

slger — Mon, 06 Oct 2008 18:06:59 +0000

summary:

curb cuts for wheelchairs also guide blind persons into street crossings and prevent accidents for baby strollers, bicyclists, skateboarders, and inattentive walkers. The "curb cuts" principle is that removing a barrier for persons with disabilities improves the situation for everybody. This hypothesis suggests erasing the line that labels some technologies as assistive and certain practices as accessibility to maximize the benefits for future users of all computer-enabled devices. This paradigm requires a new theory of design that recognizes accessibility flaws as unexplored areas of the design space, potential harbingers of complexity and quality loss, plus opportunities for innovation in architectures and interfaces. Besides the general acceptance of computing curb cuts as a social good at an acceptable price, the traditional computing culture will benefit from a dose of understanding of the technology communities, institutions and visionaries that drive a vibrant world of persons who overcome disabilities.

Background:

As I lost vision due to myopic degeneration, My computer use modes switched to audio. I was swept into a world of rich information resources and innovative mobile devices that rejuvenated my personal interests in computing. Learning to use assistive technology while studying the practices of accessibility motivated me to write my personal experiences in the "As Your world changes" blog. I seek to create a framework of concepts that integrate the lessons and techniques of what is customarily considered deficient abilities into the mainstream of computing for the betterment of all based on the "curb cuts" principle. The physical world 'curb cut' analogy flows over into computing in the following ways.

1. End Users benefit from alternative and new uses of computing.

So-called assistive technologies today expand the way computers are used in an essential sense, incidently overcoming some human deficiencies. Better designed ways of using only a keyboard without a mouse offers power shortcuts to everybody. Consistent displays in high contrast modes offer more relaxing viewing that cut the glare that causes natural photosensitivity and mental stress across a wide range of eyesight conditions. Text to speech from screen readers offers eyes-free reading of long web pages for audio adapted multi-tasking individuals while also providing GUI interactions for the visually impaired. Digital talking books and newspapers will eventually be available commodities for sighted readers as they have been for years to qualified print-disabled individuals.

Because there is now an artificial line that views such technologies ass assistive rather than normal options, products are designed for or against certain users. Emphasis on the GUI has restricted advances in speech-enabled applications with the potential for many new innovations and wider markets. Studies on the plasticity of the brain suggest that more satisfying and productive use of computers flows from integration of visual, audio, and tactile modes of processing information.

Erasing the artificial lines and labels of assistive as separate and remedial technology offers a chance to revitalize the visual dominated modes of computing that no longer apply within a marketplace of diverse hardware and software components. Integration of so-called assistive technologies and accessibility practices will show the flaws of products developed only for an assumed fully enabled user.

2. Accessibility concerns lead into productive unexplored design regions.

Accessibility and usability are well defined if underused principles of product quality. The 'curb cuts' principle suggests that a defect with respect to these qualities is in a poorly understood or unexplored area of a design. Often a problem that presents only a little trouble for the expected "normal" user is a major hassle or show stopper for those with certain physical or cognitive deficiencies. However, those flaws compound and often invisibly reduce productivity for all users. Increasingly, these deficiencies arise from ambient environmental conditions such as glare, noise, and potential damage to users or devices.

Moreover, these problems may also indicate major flaws related to the integrity of a design and long term maintainability of the product. An example is the omission of Headings on an HTML page that makes it difficult to find content and navigation divisions with a screen reader. This flaw usually reveals an underlying lack of clarity about the purpose and structure of the website and page. Complexity and difficult usability often arise from missing and muddled use cases. Attitudes opposing checklist standards often lead to perpetuating poor practices such as the silly link label "click here".

The 'curb cuts' principle leads toward a theory of design that requires remedy of accessibility problems not as a kindness to users nor to meet a governmental regulation but rather to force exploration through difficult or novel parts of the design terrain. The paradigm of "universal design" demands attention to principles that should influence requirements, choice of technical frameworks, and attention to different aesthetics and other qualities. For example, design principles may address where responsibilities lie for speech information to a user, thus questioning whether alternative architectures should be considered. Applying this principle early and thoroughly potentially removes many warts of the product that now require clumsy and expensive accessibility grafts or do-overs.

Just as the design patterns movement grew from the architectural interests of Christopher Alexander, attention to universal design should help mature the fields for software and hardware. The "curb cuts" principle motivates designers to think beyond the trim looking curb to consider the functionality to really serve and attract ever more populations of end users.

3. The social value of curb cuts ennobles computing.

Computer professionals are often shocked when they see how difficult their products are to use, reaching levels of excruciating pain for persons with disabilities. Professional pride is a motivating factor for many individuals attracted to the computing field, e.g. women and games that truly enhance their views of human potential and relationships.

The market motive is obvious with many millions of persons with disabilities to be included in the mainstream rather than being totally excluded or segregated into the higher priced rehabilitation industrial complex. Especially as the U.S. population ages, the social services are simply not there to smooth their transition and maintain their purchasing influence. Services of all kinds work more efficiently with fewer exceptions due to individuals requiring special processing.

There are so many genuinely innovative products designed by the blind, e.g. a screenless Linux PDA that rivals the Kindle with book, news, and RSS access and reading. An international open source project driven by energetic Australians is producing a free screen reader for global use with synthetic voices in dozens of languages. A standard camera-phone can now read menus and transactions items, even currency. A $5 audio device is being designed to bridge the literacy gap in impoverished societies. some people are also drawn into a futuristic world of open source hardware for designing gadgets that will speak what they are doing, how to use them, and their location, orientation, and other physical properties.

for many The social good of enabling equal access to computing is an attractor to a field renowned for nerds and greed. Social entrepreneurs offer an expansive sense of opening doors to not only education and entertainment but also employment, that now stands around 20% for disabled persons. Many innovative nonprofit organizations take advantage of copyright exemptions building libraries and technology aids for alternatives to print and traditional reading.

The computing curb cuts principle can motivate professionals, services, and end users to achieve the potential beauty and magic of computing in everyday life, globally, and for everybody who will eventually make the transition into some form of sensory, motor, or mental deficiency. But, first, mainstream computing must open its knowledge and career paths to encompass the visionaries and advances now segregated. All too often persons with disabilities are more advanced, diversified, and skill full in ways that could benefit not yet disabled people.

The "curb cuts" metaphor offers a compelling and, well, concrete way of motivating new attitudes toward computing. Walk down any American street and the reminders are at each intersection. Every computer professional will be on the hook to deliver universally usable products, not wait three years as happened with iTunes and only under legal threats, as may come soon with Google's Chrome and Google Book Search or the Amazon and Target websites. Failing to universally design a computing product is as much a social menace as a missing or poorly designed concrete curb. The computing curb cut provides a metaphor to tell the public about new ways for improving their lives and the value of innovations that will follow from obliterating the artificial border with accessibility.

<img src="http://www.ada.gov/images/flaredramp1.jpg" ALT="curb cut schematic from ADA.gov"

Notes and References on the 'Curb Cuts' principle

'Universal Design' paradigm (from Wikipedia) integrates concepts from physical, architectural, and information design. Detailed principles (from NCSU design center) include equitable use, flexibility, simplicity, intuitiveness, tolerance for error, low physical effort,... A chronology of inventions for electronic curb cuts illustrates how hearing, seeing, and learning disabilities have influenced the modern communications world. Universal design as a business principle (from Lowes corporation) brings the principles into everyday life.
The 'curb cut' symbolism is widely used in the accessibility world, e.g. 'curbcuts.net', an accessibility consultancy . The site kindly provides a guide to concrete curb cuts . Background on accessibility in the context of "curb cuts" covers the essential role of considering the full range of human abilities in design. Analysis of the "curb cut" metaphor in computing suggests many problems in its usage.
'curb cuts' are technically complex as described in the A.D.A. guidelines on curb ramps .
Mark Guzdial's blog on principles of computing introduces many of the issues of professional soul searching and educational concerns that motivate the "rebooting computing" movement lead by NPS Professor Peter Denning Beneblog from Benetech.org on 'Technology meets Society' illustrates non-profit effectiveness and innovation..
Innovative assistive tools for visually impaired users include:
Use the Controversy Discovery Engine to search for articles on accessibility and usability. Use terms like "curb cut" then choose controversy synonyms and forms of support to drill down into the Analytic Web.
Listen to this post (mp3)

2008 October 06 - Links for today

mga guy — Mon, 06 Oct 2008 09:36:56 +0000

ASP.Net

Omar Al Zabir - Create REST API using ASP.NET MVC that speaks both Json and plain Xml and Best practices for creating websites in IIS 6.0

C#

Daniel Grunwald helps us out with Weak Events in C#

jQuery

Rick Strahl laments the fact there is No Empty Selector in jQuery

OK So this one isn't just jQuery but it is predominantly and it's really a great list of jQuery resources so who's gonna quibble (I don't get a chance to say that word often enough, note to self, use the word quibble more in every day conversation :)).

Other

Paul Stovell's introduction to Bindable LINQ: Getting Started

Steve Michelotti introduces us to the Enterprise Library Validation Application Block with ASP.NET MVC

Stephen Forte announces a change to WCF and WF in Get Ready for Dublin

Roy Osherove list of tools and frameworks you should care about: Agile Testing tools List

Smashing magazine gives us 7 Version Control Systems Reviewed

Patterns and Practices

Shivprasad koirala presents his overview of Agile Development Part 2

Silverlight

Lee's take on Changing Foreground of cells that are modified in DataGrid

Bill Reiss seems to be happier with font outlining in the latest SL2 release and says so in Finally, outlining text in Silverlight good enough for now

Martin Mihaylov brings more datagrid goodness with DataGrid and row details in Silverlight 2

David Anson sets out on Preserving access to Silverlight 2's generic.xaml resources [SilverlightDefaultStyleBrowser updated for the Silverlight 2 RC!]

Jeff Wilcox produces a great article on the Microsoft Silverlight Unit Test Framework which is available at the MSDN Code Gallery

SQL

Robert Sheldon discusses Using Powershell to Generate Table-Creation Scripts

Jacob Sebastian on Recursive CTE and Ordering of the hierarchical result

TDD

Jason Yip gives his hint with Test enough to be confident vs Complete testing in time

UX

Jacob Gube brings us his 30 Beautifully Blue Web Designs

Jared Spool points us at browsewr compatibility development with Browser Compatibility: Asked & Answered

WPF

Brian Noyes presents Understanding Routed Events and Commands In WPF

Thomas Gerber presents his implementation of a WPF Explorer Bar

Tamir Khason reports on Free MS Expression video training and SILVERLIGHT BIDI CONTROLS LIBRARY RC0 AND MOVEMENT FROM BETA 2 TO RC0

Jaime Rodriguez details the WPF pixel shader effects library on Codeplex.

Adam Kinney does a WPF Effects Library Interview with David Teitlebaum and details some other effects Left out of the interview

Decorator Pattern

denniszeng2008 — Mon, 06 Oct 2008 08:09:58 +0000

Once you know the techniques of decorating, you’ll be able to give your (or someone else’s) objects new responsibilities without making any code changes to the underlying classes.

Design Principle: Classes should be open for extension, but closed for modification.

So the key point is find out the varies and then encapsulate them.

Q: How can I make every part of my design follow the Open-Closed Principle?

A: Usually, you can’t. Making OO design flexible and open to extension without the modification of existing code takes time and effort. In general, we don’t have the luxury of tying down every part of our designs (and it would probably be wastefu). Following the Open-Closed Principle usually introduces new levels of abstraction, which adds complexity to our code. You want to concentrate on those areas that are most likely to change in your designs and apply the principles there.

Be careful when choosing the areas of code that need to be extended; applying the Open-Closed Principle EVERYWHERE is wasteful, unnecessary, and can lead to complex, hard to understand code.

Inherience ------------------code reuse!!!

The Decorator Pattern: attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

Okay, so we’re subclassing the abstract class Beverage in order to have the correct type,
not to inherit its behavior. The behavior comes in through the composition of decorators with
the base components as well as other decorators.

Yes, if we rely on inheritance, then our behavior can only be determined statically at
compile time. In other words, we get only whatever behavior the superclass gives us or that we
override. With composition, we can mix and match decorators any way we like... at runtime.

And as I understand it, we can implement new decorators at any time to add new
behavior. If we relied on inheritance, we’d have to go in and change existing code any time we
wanted new behavior.

I just have one more question. If all we need to inherit is the type of the component,
how come we didn’t use an interface instead of an abstract class for the Beverage class?
Sue: Well, remember, when we got this code, Starbuzz already had an abstract Beverage class.
Traditionally the Decorator Pattern does specify an abstract component, but in Java, obviously,
we could use an interface. But we always try to avoid altering existing code, so don’t “fix” it if
the abstract class will work just fine.

public class LowerCaseInputStream extends FilterInputStream {
public LowerCaseInputStream(InputStream in) {
super(in);
}
public int read() throws IOException {
int c = super.read();
return (c == -1 ? c : Character.toLowerCase((char)c));
}
public int read(byte[] b, int offset, int len) throws IOException {
int result = super.read(b, offset, len);
for (int i = offset; i < offset+result; i++) {
b[i] = (byte)Character.toLowerCase((char)b[i]);
}
return result;
}
}

//base on super class we create some new functions

Observer Pattern - Design Patterns

denniszeng2008 — Sun, 05 Oct 2008 13:34:02 +0000

OO Principles :

Encapsulate what varies.

vary1: The number of observers may change. === use Composition and interface to encapsulate this change
vary2: The number of subject 's states may change. ===

a. You can pull or push the data. === pull: use the get***() method to get the data. push: the publisher send the data via function parameters: update(object ***);

update(observerable o, object arg); (use such method you can utilize push and pull at the same time. o is the sender of message, and arg is the message. You can directly get the message from arg, or use the get***() methods of o the retrieve the information you want.

2.Favor composition over inheritance.

The Observer Pattern use composition to compose any number of observers with their subjects, These relationship aren't set up by some kind of inheritance hierarchy, NO! They are set up at runtime by composition.

3.Program to interfaces, not implementations.

4.Strive for loosely coupled design between object that interact.

When two objects are loosely coupled, they have little knowledge about each other.

Then only one thing the subject know about the other is that it implements a certain interface.

We can add observers at any time.

We never need to modify the subject to add new types of observers.

we can reuse subjects and observers indepentently of each other.

Changes to either subjects or observers will not affect the other.

Loosely coupled design allows us to design flexible OO systems that can handle changes because they minimize the interdependency between objects.

The subjects and observers connect upon interface, which use composition. In observers , they (has a)(dependency) subject, and subjects only know the knowledge about the interface, and call the method in the interface with aware of the implementation of the interface.

Observer Pattern:

Designs a one to many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

Java buildin Observer Pattern:

java.util.observerable a class

java.util.observer a interface

Make use of these two struct can help you. But there are also dark side!

ActionListener & EventHandler , they are all use observer pattern.

Point:

Patterns just make well use of the OO principles!

Wrapping Session State

aidenleech — Sat, 04 Oct 2008 16:23:43 +0000

A good design practise when developing an ASP.NET application that uses Session state is to wrap up access to your session variables. This means they are accessed from a single location and avoids scattered access to hardcoded variable names that float around your application.

public sealed class SessionManager

{

private SessionManager()

{}

public static int UserID

{

get { return HttpContext.Current.Session["UserID"] != null ? (int)HttpContext.Current.Session["UserID"] : 0

; }

set { HttpContext.Current.Session["UserID"] = value; }

}

I have researched whether this is thread-safe and found it to be fine. The get accessors on the static properties access the internal Session object that belongs to the current Context, protected by the ASP.NET framework. Each user on your application will access their own Session object and the properties will not share the same values.

Using Enum To Implement Singleton Pattern

Duy Do — Fri, 03 Oct 2008 19:10:18 +0000

In the previous post Singleton Pattern: When and How to use it effectively, we have 4 ways to implement Singleton Pattern. Today, I share with you another way to implement it with Enum. This way was provided by Joshua Bloch in his 2nd Effective Java book.

public enum Singleton {
	INSTANCE;
	public void foo() {
		System.out.println("FOO");
	}
}

This approach is functionally equivalent to the public field approach, except that it is more concise, provides the serialization machinery for free, and provides an ironclad guarantee against multiple instantiation, even in the face of sophisticated serialization or reflection attacks. While this approach has yet to be widely adopted, a single-element enum type is the best way to implement a singleton.

Big thank to Ruben, who let me know.

2008 October 03 - Links for today

mga guy — Fri, 03 Oct 2008 08:18:23 +0000

C#

I got this link from a good colleague of mine who pointed me at Steven van Deursen's Introducing CuttingEdge.Conditions.A library that helps developers to write pre- and postcondition validations and more here - really useful stuff, Cheers Rich and Steven.

jQuery

DotNetSlackers keep on going with their series on JQuery, the very very basics - Lesson 4

Patterns & Practices

Kevin Hazzard points us at A Survey of Popular .NET Inversion of Control Containers

Other

Greg Low on Presenting at Large Events (Lessons learned)

What with Live Mesh causing a few security holes and by-passes and subsequently being blocked by companies, I got recommended syncplicity for folder synching. Gotta be worth a look. See the PCWorld article for more and a comparison with other similar sites.

The great wee CMS that is Umbraco is now even easier to learn now thanks to the video tutorials just released.

A really important message from Sitepoint in an interview by Kevin Yank with Derek Featherstone, Accessibility is More Than Compliance

I would want to find a way to have every web developer and designer experience what various people with disabilities would experience through whatever means, and in person if possible. Because that experience of seeing people and experiencing what shortcomings there are in our work when a person with a disability is using them … that’s a transformative experience

Silverlight

Tim Heuer on Installing Silverlight RC0 Offline and some hardcore media stuff in MediaStreamSource sample for Silverlight a piece of the Silverlight runtime that removes the influence of a media file's container, giving developers direct access to APIs for manipulating encoded elementary audio and video streams and Silverlight and Web Service Errors

Jesse Liberty with more on his Dependency Properties – Precedence series

Jeff Paries’ film strip gallery - really, check this one out.

Mike Snow on How to Apply Styles in Silverlight – Part I

Bill Reiss announces Hello! Silverlight 2 coming to a bookstore near you

Mark Smith posts his demos from his 2-day binding + network Silverlight2 training in Boston

SQL

Jacob Sebastian TSQL Lab 20 - Performing recursive updates using a BOTTOM to TOP recursive CTE

TDD

Ben Scheirman presents a great tip on Using Extension Methods to Clean Up Tests

Tim Barcz follows on from his great post yesterday to discuss a really fundamental yet basic Testing Pre-Requisite - Care About Your Code - once more, I completely agree Tim, nicely put.

UX

Nathan Moody gives a great look at pressure based input with From the Labs: Microsoft Surface + Nintendo Wii Mashup

Dmitry Fadeyev reckons we should Forget the Wireframes, Throw Away Your Boxy Layouts — Design BIG! and I love this post on Manage Focus Effectively Using Contrast. It definitely aids in guiding the user to key pieces of information, now we just need to figure out what they actually want highlighted and not necessarily what we think they want :)

Jared Spool on Conducting Usability Tests in the Wild

Anthony J. Zinni rounds up AMAZING WEBSITES TEN: SEPTEMBER 2008

WPF

Rudi Grobler on Binding to enum’s

Rajesh Pillai continues with Simple WPF BarChart (Horizontal and Vertical) - Part II

2008 October 01 - Links for today

mga guy — Wed, 01 Oct 2008 07:55:32 +0000

Other

Michael C Kennedy on Unit Testing Coming to a Workflow Near You

Zakir Hoosen on Extension classes

Patterns & Practices

Bill Kratochvil on the MEF & CompositeWPF under one roof

Jeremy D Millar has a great rant on how Separate Assemblies != Loose Coupling

David Hayden embelishes on the Decorator Pattern

SQL

MAK over at Sql Server Central continues his DBA Bread and butter series

Ron Dameron on Why This SQL Server DBA is Learning Powershell

Silverlight

Lawrence Moroney on How to use Silverlight RC0 and some code updates for his Silverlight 2 book.

Mike Snow goes multi blog postal again withposts on MessageBox is now Available in Silverlight 2, How to Popup a Browser Window and How to Enable and Disable Controls.

Jesse Liberty delves into the Dependency Property System – Deeper Dive Part 1

Pete Brown details 3d Rendering with Texture Mapping in Silverlight – Quake

Mike Hillberg has twitchy fingers with A Comparable DataTrigger

Bart Czernicki brings us his Silverlight 2 (RC0 / RTM) - Dynamic Assembly Loading Fix

Jeff Wilcox reckons If you can do it in JavaScript, you can do it in managed Silverlight .NET code

David shows us his Silverlight Stock Portfolio

Shawn Wildermuth has New Information on WebClient in Silverlight 2

Harsh Bardhan at DotNetCurry gives us a Step By Step guide on Using Silverlight to Access a WCF Service Hosted In a Console Application

Tim Heuer details some Silverlight multi-file upload controls and patterns

priti_sisodia at Codeplex highlights Using Custom Fonts in Silverlight

Martin Mihaylov gets my vote with his Voting Control code

Peter McGrattan's on his Silverlight 2 RC0 Polling Duplex Evolution (also check out Silverlight 2 WCF Polling Duplex Support - Part 3: The Client)

Gerard LeBlanc has a lovely page turner at Turn the page!

WPF

Jani Järvinen helps us Getting Up and Running with the Composite UI Application Block for WPF

2008 September 30 - Links for today

mga guy — Tue, 30 Sep 2008 07:51:52 +0000

Patterns & Practices

Brad Abrams has written a really good Simple Introduction to Extensible Applications with the Managed Extensions Framework - well worth checking out.

Silverlight

Mike Snow has been really busy once more with multiple posts since the release of RC0, including How to Implement a Password Box, How to Implement a Combobox, How to Implement a Progress Bar and Main Game Loop Revisited!

Pete Brown also goes with multiple posts with Silverlight 2 Per-Frame Rendering Callback – CompositionTarget.Rendering Event and Building Facebook Applications with Silverlight 2

Jesse Liberty points out that Isolated Storage – Might Be Easier Than You Think

Manish Dalal helps out with usage of ComboBox in DataGrid

Matt Serbinski on Silverlight and Drupal: Syndication

Chris Anderson on Building a Framework for Silverlight Line-Of-Business Applications

Karl Shifflett brings us another update on XAML Power Toys 3.0.0 Released - Code Name: Refactored

Delay goes over Maintaining pretenses with the layout system [LayoutTransform functionality updated for Silverlight 2!]

The Expression Blend Team gives us an update with Silverlight 2 RC compatible Deep Zoom project templates

Matthias Shapiro follows up on yesterday with Color Picker In Action (In The Silverlight Particle Project)

Adam Kinney lets us know about 3D Views for WPF from Xceed

Oh and there is a new MS Arts and technology site to inspire next web based projects.

SQL

Nidal Arabi on SQL Server Analysis Services - Dimensional Modeling Concepts

Joe Webb goes over Using Covering Indexes to Improve Query Performance

Jacob Sebastian brings us TSQL Lab 15 - Another PIVOT Query Example

TDD

Littletutorials request you use Thought Driven Development - don’t pass the responsibility of thinking to the process. It will not do it for you - love the trucks and bridge bits and would definitely consider certifying as an abile consultant :)

UX

Jared Spool on Asking Participants to “Pretend” in User Studies and a great data visualization from SmartMoney.com

WPF

Finally for today Rajesh Pillai shows us his Simple WPF Bar Chart Control