Stefan Mischook
February 14, 2005
In a nutshell:
When people surf the web, they have no time or patience to read long blocks of text – keep your writing simple and short.
Some basic tips:
- Use bullets to emphasize major points.
- Keep paragraphs about 7-10 words wide.
- Use lots of white space – give your pages lots of ‘breathing room’.
- Don’t do stupid things like having paragraphs that are all in italics or all bold.
- Make sure your text color is easy to read. For example: dark blue text on a black background is hard to read!
- Keep your text alignments consistent: don’t center align titles on one page, and then shove your titles to the left on another.
Basic writing tips:
- Keep sentences short and again, to the point. Tip: remove unnecessary words.
- Write as you would speak. This could be a problem if you’re a babbling fool … 🙂
- Read over what you have written 3 times.
– –
I can recommend three great books on writing well:
Writing in Bullets: by Kim Long
A good little book that will teach you how to use bullets effectively – there’s more to it than you think.
On Writing Well: by William Zinsser
A classic book on the subject. Not so specialized as Writing in Bullets, it tackles writing from a global perspective.
The Elements of Style: by William Strunk Jr
Another classic. This book gets into the details of writing where you learn about things like:
- Form
- Commonly misused words and expressions
- Basic rules of composition
- And plain old good advice like: omit needless words
Sometimes it can be a little dry, but the book is packed full of great stuff – get it! Actually, you should get all these books – it’s not like they’re expensive!
CIAO,
Stefan Mischook
read more
February 14, 2005
It’s common to hear a lot of talk in the Java community about the importance of:
- scalability
- re-usability
- maintainability
These are important goals (often never reached in real projects btw,) but I wonder why no one ever talks about something that should be considered at least as important: understandability.
Some people might say that understandability would fall under the maintainability category. After all, for code to be maintainable, it should be easy to understand … right? Unfortunately in the real world, Java folk (seems to me) must have forgotten this all too important rule of good programming.
No, not another XML document!
These days, to get even the simplest of Java applications going, you need to do a lot of plumbing work which often includes setting up property files …
When I start filling in XML property and descriptor files, it feels like filling in acquisition forms to buy a new pen … I get this nagging feeling that I’ll have to fill out the XML files in triplicate and get them ok’d by 3 different people.
–
It shows that Java has been designed by huge corporations in a committee process (JCP) – Java ‘feels’ like a big giant corporation!
In it’s youth, Java was nimble language full of possibility and optimism. But like hippies from the 60’s, over time the oppression of corporate reality has turned this spritely language into a pedantic sloth.
So what’s next?
I don’t know what the next big language is going to be. But I do know it will be a scripting language that will:
- Have dynamic typing.
- Have a rapid feedback loop – thus not compliled.
Stefan Mischook
read more
February 13, 2005
Hibernate In Action (Christian Bauer & Gavin King) Manning 2005
Beware: this is big time Java-nerd stuff – not for web designers.
– –
One of the most difficult and time consuming elements of coding most business applications involves the persistence layer. This is particularly the case when object oriented (OO) approaches are used.
While OO programmers tend to think in terms of software objects with properties and behaviors, the truth of the matter is that at some point stuff needs to be loaded and saved in a database.
Anyone who has ever had to write their own object-relational (OR) persistence layer (I have), soon comes to realize that it is an area fraught with peril.
Why use Hibernate?
Hibernate is perhaps the most popular OR persistence framework for Java around today (although there are a number of lighter frameworks available). The authors of Hibernate In Action are part of the core team that developed Hibernate. Diving into the book quickly reveals that the authors know their stuff.
The Details:
The opening chapter (Understanding Object Relational Persistence) presents a detailed overview of pretty much all the main issues one is likely to encounter when it comes to OR persistence. The discussion is lucid and sets the tone for understanding why Hibernate is an attractive solution. The authors also spend some time highlightting why one might NOT want to use OR mapping, which I also found useful.
Sunsequent chapters get you up running relatively quickly so you can see the framework in action. As the book progresses more detailed examples are used to illustrate the potential of the framework, and also some of the limitations.
Conclusion:
Frankly I found the level of detail to be a little tough for a first read, but was pleased to know that the meat was there if I needed to get back to it.
Aside from this minor criticism I found the book to be a relatively entertaining read (7 out of 10) although you probably would need to have an interest in the subject.
All in all a strong book well worth acquiring if you are interested in evaluating the Hibernate framework.
Review by Richard Mischook
You can read more Java book reviews here.
read more
February 13, 2005
DHTML Utopia Modern Web Design Using JavaScript & DOM
First thing I have to say is that I like their (I guess you can call it,) catch-phrase:
‘Create Killer Websites using the power of modern Javascript’
🙂
The pros:
- In the introduction, a section with the title: ‘Whither XHTML’ – here we see Real-World thinking. Basically the author explains why using XHTML does not make sense now.
- Chapter 1 is a good overview of code (HTML, CSS) and how it should be applied in web design today.
- Chapter 2: A good intro the DOM – but it moves fast.
- Chapter 8: A cool section on XMLHTTP: XMLHTTP is a way to ‘talk’ to the server via JavaScript, that makes for a Flash like exchange of data between a web page and server – that means no page refresh.
The cons:
- After chapter 2, I started to fall asleep – and I’m a big nerd!
- Not a knock on the book itself, but most of the stuff described in the book is not worth using (most of the time,) since about 10% of the people out there have JavaScript shut off. That means you can’t count on your JavaScript for anything – so all the JavaScript you use has to be non-essential.
Conclusion:
If you know how to program, and you want to get into the cutting edge DOM scripting world, this is a reasonably good book.
You can read about more JavaScript books here.
CIAO,
Stefan Mischook
read more
February 13, 2005
In this article I am going to look as some of the practices that are promoted by the Web Standards movement, practices that cost web designers (and their clients,) time and money for no real practical advantage.
CODE VALIDATION: validating your web pages.
Web Standards zealots advocate checking of code against an ‘engine’ (W3C validator ) to verify that your code is not breaking any Web Standards rules. This is fine, but it should be the ‘icing on the cake’ and not the focus.
Before you validate using the W3C validator (who’s engine does not reflect most of the browsers being used,) you should ‘validate’ your code against the target market – Internet Explorer and then (a distant 2nd) FireFox.
THE ORDER OF REAL-WORLD VALIDATION:
- Check against Internet Explorer – the most used browser.
- Check against FireFox.
- Check against the w3c validator: if you have time to burn.
read more
February 11, 2005
One of the disturbing mindsets in software development and web design today, is the sacrifice of practical concerns in favor of theoretical constructs.
Case in point:
Recently a young friend of mine (who is studying computer engineering,) told me an interesting story about a class project where each student had to produce a piece of software … the results, and the professors reaction to the results, are interesting.
Sad but true:
When all things were said and done, only one student was able to produce a working application. The irony was that this student got a failing grade because his code did not meet certain theoretical constructs!
The above example illustrates a problem in the way many programmers think: putting theory over practicality.
With that failing grade, the professor has sent the wrong message to his students: that results are not as important as being true to the theory. And people wonder why so many Java projects fail…
Why theory over practicality is total bull:
- Broken but theoretically correct software, doesn’t pay the bills.
- Theories are constantly revised; so don’t be to quick to marry them.
I think the first point is self evident, so let’s look at the 2nd point and consider one of the fundamental theories of modern software development: inheritance.
At one time in the distant past (5 years ago,) design-by-inheritance was the theoritically correct method of software development. At some point though, people began to discover that inheritance had its’ problems and now (in many cases,) design-by-interface* is the preferred method.
Theories change
The shift from design-by-inheritance to design-by-interfaces is but one example of how theories are constantly updated to reflect practical realities.
If anything is consistent of about software development, it’s that theories change. So don’t sacrifice practical application today, to satisfy some theoretical construct that may very well be discredited tomorrow.
–
Stefan Mischook
1. ‘bull’ is a technical term that conveys a complex meaning in a terse and well understood format.
2. In Java, interfaces are classes void of method implementations.
read more
February 10, 2005
What will you find on Killersite’s blog?
- Web design tips, articles and tutorials.
- Video tips and tutorials.
- Podcast: mp3’s of me yapping about things related to web design.
- Newsletter archives
- Probably a bunch of other stuff too.
What you won’t find on the blog:
- Talk about how my cat is doing.
- Other misc. rants that should only be shared with my girlfriend.
CIAO!
Stefan Mischook
read more
February 9, 2005
The Web Standards movement has created a ‘culture of hacks’ to compensate for browser incompatibilities (OK, mostly IE) and this is a bad idea.
Before anyone attempts to tell me that the Web Standards community does not promote the use of hacks, please refer to just about every book written on Web Standards based web design.
Why were hacks promoted?
In a nutshell: those who promoted them are inexperienced … in other words: green. It is simply bad practice to rely on broken aspects of a technology in an attempt to make things work – any programmer worth his salt knows this. And that is exactly what many/most hacks rely on – broken aspects of Internet Explorer.
–
Anecdote: I’ve often had to ‘slap-down’ young-pup programmers (just a few years out of school,) when they’ve tried to introduce into the code base, what would be the equivalent of CSS hacks.
–
CSS hacks are a recipe for disaster that I’ve been predicting for a while, a disaster that seems to be happening: it looks as though IE7 will be breaking CSS hacks and thus, the Web Standards myth of forward compatibility.
I’ve used a hack: I’m a god-curse hypocrite:
Yes, I’m guilty of ‘following the pack’ and I’ve used a single CSS hack (child of div hack) but I used it in a minimal way – should the hack fail (and it will in IE7,) my layouts will still work though the pixels will shift a little.
The real problem occurs when you start using many hacks or if your hacks should fail, your website’s usability will be severely compromised.
If you have to use hacks, use them very delicately.
The hack-free cross browser compatible solution:
When you’re critical of something, you should try to present alternatives … and my alternative to using brittle CSS hacks:
Use a IE conditional comments, Microsoft intelligent solution to cross browser coding.
I know, I know … Microsoft coming up with an intelligent solution!?
🙂
Stefan Mischook (a.k.a: The Web Design Heretic )
read more
February 8, 2005
Amidst all the nerd talk, it’s rare that you actually get a concise explanation of the ultimate purpose of the Web Standards … so I’ve decided to state it here for those who may be interested:
The raison d’être for the Web Standards: to simplify the web design work-flow.
Keep that in mind when you are doing your web design work; if you find you’re getting caught up in details that will not have any practical impact on the project’s success … you must learn to think (and work,) outside of the Web Standards box.
I’m not saying to forget the Standards (heaven forbid,) all I’m suggesting is that you remember that your ultimate goal is to build quality websites as quickly as possible.
Case in point: The use of IE conditional comments.
Instead of using questionable CSS hacks to make your web pages work in both IE and Standards compliant browsers (FireFox etc,) it is better to use a the non-standard IE conditional comments.
Why?
IE conditional comments are forward and backward compatible (in Internet Explorer,) and will not break functionality in the other browsers – thus you can safely use them to isolate CSS code for IE.
Conclusion:
IE conditional comments are NOT part of the Web Standards (that’s for sure!) but they offer a better solution than the hodgepodge of widely touted and soon to be breaking CSS hacks.
Yes, we are thinking and working outside of the Web Standards box … but by golly, it works better!
The web heretic. (a.k.a.: Stefan Mischook)
read more
February 8, 2005
Mini video tutorial on HTML link tags now online.
Running time: 7:37
Link: HTML link tag video tutorial
read more
