[root] /weblog /design




login:

password:

title search:




 

Mon Jun 16 02:16:12 HKT 2008

design



(google search) (amazon search) second
download here

Wed Jun 25 09:59:02 HKT 2008 From /weblog/design/exception

problem of using exception for control flow


Other than harder to read, this approach is easier to have side effect, consider the following case:

// Code which fail
public String service() {
try {
// a lot of other code....
return getRecord();
} catch (SQLException re) {
return "defaultRecord";
}
}

private String getRecord() throws SQLException {
PreparedStatement ps = getConnection().prepareStatement("select something from sometable");
try {
final ResultSet rs = ps.executeQuery();
try {
if (rs.next())
return rs.getString(1);
else
throw new NotFoundException();
} finally {
rs.close();
}
} finally {
ps.close();
}

// definition of NotFoundException, analog to IOException and FileNotFoundException
public final class NotFoundException extends SQLException {....}


The idea is, for any database problem, just return default value. However, if someone change the interface of NotFoundException to

public final class NotFoundException extends RuntimeException {....}

Then it break service() silencely :-/ Some to it is better to have


// Code which fail
public String service() {
try {
// a lot of other code....
return getRecord() == null ? "defaultRecord" : getRecord();
} catch (SQLException re) {
// proper exception handling
}
}

private String getRecord() throws SQLException {
PreparedStatement ps = getConnection().prepareStatement("select something from sometable");
try {
final ResultSet rs = ps.executeQuery();
try {
if (rs.next())
return rs.getString(1);
else
return null;
} finally {
rs.close();
}
} finally {
ps.close();
}



(google search) (amazon search)



Mon Jun 16 02:16:12 HKT 2008 From /weblog/design

scalability


There are two key primary ways of scaling web applications which is in practice today.
1) “Vertical Scalability” - Adding resource within the same logical unit to increase capacity. An example of this would be to add CPUs to an existing server, or expanding storage by adding hard drive on an existing RAID/SAN storage.
2) “Horizontal Scalability” - Adding multiple logical units of resources and making them work as a single unit. Most clustering solutions, distributed file systems, load-balancers help you with horizontal scalability.

Scalability can be further sub-classified based on the “scalability factor”.
1) If the scalability factor stays constant as you scale. This is called “linear scalability“.
2) But chances are that some components may not scale as well as others. A scalability factor below 1.0 is called “sub-linear scalability“.
3) Though rare, its possible to get better performance (scalability factor) just by adding more components (i/o across multiple disk spindles in a RAID gets better with more spindles). This is called “supra-linear scalability“.
4) If the application is not designed for scalability, its possible that things can actually get worse as it scales. This is called “negative scalability“.

http://www.royans.net/arch/2007/09/22/what-is-scalability/

Report of building web application with 55k pageload with rail - http://shanti.railsblog.com[..]mongrels-handled-a-550k-pageview-digging

XMPP a IM protocol about scalability - http://www.process-one.net[..]icle/the_aol_xmpp_scalability_challenge/

Excellent presentation and resources of making you website more scalable - http://www.scribd.com[..]9/Real-World-Web-Performance-Scalability

(google search) (amazon search)


Thu Jun 12 01:09:18 HKT 2008 From /weblog/design

API design guideline


This is a message from a management blog, but I think the arguement is also apply API design. In fact, I think most critical difference of good and bad API is knowing which small detail is important and which is not - http://www.goodproductmanager.com[..]er.com/2007/11/08/sweat-the-small-stuff/

Design tips:
http://www.artima.com/weblogs/viewpost.jsp?thread=142428
http://openide.netbeans.org/tutorial/api-design.html
http://www.cincomsmalltalk.com[..]gView?showComments=true&entry=3258158706
http://today.java.net[..]its-of-highly-profitable-developers.html
http://www.infoq.com/news/2007/08/why-api-design-matters

About Compatibility issues
http://wiki.eclipse.org/Evolving_Java-based_APIs

A blog of using interfaces-vs-abstract-classes
http://hoskinator.blogspot.com[..]6/04/interfaces-vs-abstract-classes.html

XOM design overview - http://www.xom.nu/designprinciples.xhtml#d0e309

You need to identify the business value but not pick any tools/design just because it is cool - http://myarch.com/what-is-good-soa

A lot of links here - http://kasparov.skife.org/blog-live/src/api-design-refs.writeback http://discuss.joelonsoftware.com/default.asp?design.4.527465

An introduction of good OSS project to study their source - http://techkriti.wordpress.com[..]com/2007/06/28/learning-from-the-source/

CCCCDPIPE - http://blog.objectmentor.com/articles/2007/08/02/which-came-first

Discussion of why getting feedback quick is important - http://blog.objectmentor.com[..]u-dont-know-until-you-take-the-next-step

Someone saying that routines is the greatest invention in CS, I agree - http://www.codinghorror.com/blog/archives/001129.html

(google search) (amazon search)


Mon Jun 02 23:56:06 HKT 2008 From /weblog/design/security

nohup



(google search) (amazon search)



Sun Jun 01 23:43:50 HKT 2008 From /weblog/design/security

crack


Discussion of crack protection - http://discuss.joelonsoftware.com/default.asp?design.4.579670 http://www.focusoncode.com/exe-packers-crypters-and-compressors/ , introduce tools - http://www.pelock.com/

Ten Immutable Laws of Security
Law #1: If a bad guy can persuade you to run his program on your computer, it's not your computer anymore
Law #2: If a bad guy can alter the operating system on your computer, it's not your computer anymore
Law #3: If a bad guy has unrestricted physical access to your computer, it's not your computer anymore
Law #4: If you allow a bad guy to upload programs to your website, it's not your website any more
Law #5: Weak passwords trump strong security
Law #6: A computer is only as secure as the administrator is trustworthy
Law #7: Encrypted data is only as secure as the decryption key
Law #8: An out of date virus scanner is only marginally better than no virus scanner at all
Law #9: Absolute anonymity isn't practical, in real life or on the Web
Law #10: Technology is not a panacea

http://www.microsoft.com[..]s/security/essays/10imlaws.mspx?mfr=true

(google search) (amazon search)


Wed May 28 17:47:28 HKT 2008 From /weblog/design

dsl


A paper show the evolution of a DSL - http://www.mockobjects.com/files/evolving_an_edsl.ooplsa2006.pdf

A stock trading order example of DSL - http://debasishg.blogspot.com[..]05/designing-internal-dsls-in-scala.html

What is the difference between API / DSL if we don't write a parser for our language? From Martin Fowler's blog - http://martinfowler.com/bliki/DslReadings.html , it is mentioned:
Piers Cawley makes the point that a key characteristic of DSLs is their narrow focus on a domain.
I think this is a very good summary, usually if most of the APIs are getXXX() , setXXX(), loadXXX() , createXXX() ........ Then we mostly design APIs that expose low level detail to the API user to work on, which, is work but user probably work nicer if we can come up with language like API that allow users to do their work in more descriptive level.

I think if API design like that usually it will reduce the code duplication, what ever real duplication or conceptual duplication. It probably already apply "Tell, don't ask" style - http://c2.com/cgi/wiki?TellDontAsk

A discussion about applying "Tell, don't ask" which lead to message passing architecture - http://beautifulcode.oreillynet.com[..]07/10/do_messages_want_to_be_asynchr.php

One good sample with explaination - http://hamletdarcy.blogspot.com[..]-it-really-domain-specific-language.html http://nat.truemesh.com/archives/000727.html

Few links - http://dreamhead.blogbus.com/logs/17667876.html

(google search) (amazon search)


Sat May 24 15:35:35 HKT 2008 From /weblog/design

style


Discussion of style of writing code, like always have valuable for return value, and use return for parameter check - http://www.beust.com/weblog/archives/000308.html


(google search) (amazon search)


Sat May 24 15:30:34 HKT 2008 From /weblog/design

reference


Contain discuss about if value object should be immutable or it is still ok - http://c2.com/cgi/wiki?ValueObject

(google search) (amazon search)



Fri May 23 18:44:43 HKT 2008 From /weblog/design/concurrency

lock


10-ways-to-reduce-lock-contention-in-threaded-programs - http://www.thinkingparallel.com[..]ce-lock-contention-in-threaded-programs/

Discussion about lock the form and prevent 2 user edit it in the same time and currupt the object, what is the possible drawback. - http://www.dcmanges.com[..]-optimistic-locking-isnt-a-silver-bullet

(google search) (amazon search)


Wed May 14 11:22:16 HKT 2008 From /weblog/design

interface


Arguement of overuse interface, I trend to support - http://blog.sidu.in[..]ramming-to-interfaces-strikes-again.html

A very long discussion related, Test-friendly, but not caller-friendly? - http://www.nabble.com[..]ring-your-development--t2039307i120.html

Comparison of interface vs. abstract class - http://blogs.sun.com[..]ry/api_design_interfaces_versus_abstract

(google search) (amazon search)


Tue May 06 14:25:04 HKT 2008 From /weblog/design/interview

Donald Knuth


Donald Knuth on Multi-Core, Unit Testing, Literate Programming, and XP:

I also must confess to a strong bias against the fashion for reusable code. To me, "re-editable code" is much, much better than an untouchable black box or toolkit. I could go on and on about this. If you’re totally convinced that reusable code is wonderful, I probably won’t be able to sway you anyway, but you’ll never convince me that reusable code isn’t mostly a menace...


http://www.artima.com/forums/flat.jsp?forum=276&thread=229705

(google search) (amazon search)


Fri May 02 01:58:22 HKT 2008 From /weblog/design

messaging


Why should you combine Reliable Messaging with Distributed Caching

http://www.theserverside.com[..]MessagingDistributedCaching/article.html

(google search) (amazon search)


Tue Apr 29 01:46:55 HKT 2008 From /weblog/design/interview

Bjarne Stroustrup


Nice message cover DSL, IDE, multiple dispatch, message passing, and more

http://msdn2.microsoft.com/en-us/magazine/cc500572.aspx

(google search) (amazon search)



Sun Apr 06 01:23:28 HKT 2008 From /weblog/design

date


Date handling look simple but easy to fail in trap. Even worst is this is easy to have bad data which hard to fix. Here is an example - http://blogs.msdn.com/jensenh/archive/2005/11/23/496246.aspx

One tip for testing application with time dependence, treat it as random - http://googletesting.blogspot.com[..]pot.com/2008/04/tott-time-is-random.html

(google search) (amazon search)


Mon Mar 31 01:09:56 HKT 2008 From /weblog/design

distribute


A very nice blog that discuss why is Distributed so Hard:

In one sentence, here's why: humans are notoriously bad at keeping "self" distinct from "other". Egomania, projection (transference), and enmeshment are well-known symptoms of this problem. OK, so I hear you saying, "yeah, but what does this have to do with programming?" It certainly seems absurd to suggest that if we are bad at something we know the most about (our "selves"), how could we possibly say that we have a good approach for the programming analogues - objects, modules, etc.

http://www.artima.com/weblogs/viewpost.jsp?thread=46706

An paper introduct why space base design is better than n-tier design - http://www.google.com[..]0The%20End%20of%20Tier-based%20Computing

Some key research of google for distributed computation - http://www.infoq.com/news/2007/06/google-scalability

Someone think we are not yet (per Oct 2007) have good language support for distibuted computing - http://kasparov.skife.org/blog/2007/10/11/

A blog contain a lot distributed computing information - http://www.highscalability.com/

How Wikipedia manage their site - http://dammit.lt/uc/workbook2007.pdf

Google tutorial for Design Distributed System - http://code.google.com/edu/parallel/dsd-tutorial.html

http://en.wikipedia.org/wiki/Distributed_hash_table

(google search) (amazon search)


Thu Mar 27 11:29:05 HKT 2008 From /weblog/design

immutable


"A similar pattern is that with objects that you need to open before usage and make sure that they are closed on usage completion."

http://digerati-illuminatus.blogspot.com[..]2/initialize-pattern-and-open-close.html

Discussion of various approach that implement immutable class - http://discuss.joelonsoftware.com/default.asp?design.4.601499

(google search) (amazon search)



Tue Mar 18 01:25:24 HKT 2008 From /weblog/design/exception

Handle exception at event


To prevent no one notice there is problem

What the code is trying to do is make sure is that any exception thrown is brought to the attention of the user. I’ve been looking at a few approaches to help catch and handle these exceptions without the developer having to explicitly catch them at the UI level.
You can create your own EventQueue, and have it catch uncaught exceptions when dispatching methods

http://www.magpiebrain.com[..]2004/07/21/catching-uncaught-exceptions/

(google search) (amazon search)



Wed Jan 30 11:05:55 HKT 2008 From /weblog/design

write shy code


Writing shy code is just a small start at preventing the introduction of bugs, but it really helps. Just as in the real world, good fences make good neighbor - as long as you don't peek through them.

http://www.computer.org/software/homepage/2003/s1const.htm
http://www.pragmaticprogrammer.com/ppllc/papers/1998_05.html

Other than that, there is also security risk if you show too much to other - http://www.indicthreads.com[..]_or_objects_java_security_problem_1.html

An example of why passing Map around is wrong and show solution of that example - http://antagonisticpleiotropy.blogspot.com[..]spot.com/2008/01/hashmap-temptation.html

(google search) (amazon search)


Mon Jan 28 14:50:51 HKT 2008 From /weblog/design/pattern

criticism


Suggest use to take a fresh look of original "pattern language" - http://perl.plover.com/yak/design/ , in his opinions, it is more about separate design to difference groups than create reusable design.

Some more... http://www.relevancellc.com[..]007/5/17/design-patterns-are-code-smells http://www.codinghorror.com/blog/archives/000899.html

Some say pattern should be language feature ... http://www.codinghorror.com/blog/archives/000308.html

Closely related, there are no golden rules and silver bullet, Design Pattern can help us in some design problem and provide some design suggestion. However, we need to know what it good for and bad for
http://jchyip.blogspot.com/2008/01/gefn.html
http://jchyip.blogspot.com[..]est-practice-vs-pattern-vs-standard.html
http://jchyip.blogspot.com[..]ndard-approach-does-not-necessarily.html

(google search) (amazon search)