Slashdot Mirror

Slashback tonight brings you updates to previous stories on computer-class cheating, Smoothwall, AIBO hacking, the Open Source Directory, and the fate of Loki's CVS. Read on below for the details! Jon Masters was one of the many to write in after recent articles about automated cheat-detection employed in undergraduate CS classes to catch plagiarists. "Hi, cheat detection is hardly new. For example The University Of Nottingham have developed an automated marking/plagarism detection system as part of their CourseMaster software. Personally I don't agree with automated assessment in general, however plagarism detection can be useful."

From the email I've gotten on it, it seems like a whole passel of schools have at least a homegrown solution to CS cheats.

Perhaps the cute dog will end up changing Sony's stance? CodeMonkey555 writes "Here is a story that chronicles Sony's little foray into the DMCA with a hacker who added software for the Aibo robot."

It's nice to see that publications like SciAm are following the results and consequences of the DMCA.

Care to help edit an online software reference? SteveMallett writes "We at Open Source Directory (OSD) have opened the directory to volunteer editors now that we've given app authors and maintainer's a good chance to start and/or maintain their own listings.

Those interested may wish to visit our volunteer page which outlines what we're looking for. Don't worry. We're not that picky. The outline includes guidelines and tips for being a volunteer. Unlike dmoz, which has volunteer editors, we _will_ delete unupdated or neglected editor work in accordance to our Social Contract.

We hope that editors will help fill in the missing apps, take over those listings that they can do a better job of or have become neglected, and find those diamonds in the rough."

See our earlier post about the project if you're not sure what this is about.

Yes, someone has to read all those emails. kcurtis writes "Boston.com's tech site has this AP article about the large response to the Court's request for comment on the MS case's proposed settlement."

Now all they need is a trowel with an emblazoned smiley. enigma48 writes "Looks like the C'T article a little while ago about Smoothwall prompted some changes after all. Juergen Schmidt even gets a little credit. Shadow passwords are now in, but it looks like the ppp secrets file is still open (they describe it as being a "non-vulnerability"). A-patchin' I will go, a-patchin' I will go..."

So you don't have to stop playing your games ... Scott Draeker of Loki has some encouraging words for those who thought the announced (upcoming) closure of Loki would mean the loss of Loki's code and community. Draeker sent word of this a few days ago, but here are more details.

He writes:

"We have prepared tarballs of the public CVS, FAQs, mailing list archives, demos and Loki_Update which will be available for people to host. That's exactly what's going on with icculus.org.

The official repository will be hosted by the SEUL group at MIT. Once that site is set up we'll point the loki domains that direction. They'll also be adding some Loki projects to public CVS which were never completed."

kcurtis points to this CNN story about using cameras to scan people walking in the streets and matching them to mug shots. I'm no privacy freak, but this would be a bit unnerving. What if I happen to look like some murderer or DMCA offender?" This is the same technology that Superbowl attendees were unknowingly subjected to as well. Not to worry -- you're considered innocent until matched by face-recognition software. Yep, this is a duplicate story - naughty Tim!

kcurtis writes "According to the Boston Globe article, a federal judge is refusing to reveal the identities of 23 chat room users accused by a bankrupt dot-com of posting critical messages to drive its stock price down. About time."

This "dynamic content" thing doesn't seem to be going away, does it? Web sites need to get smarter to handle the types of content that at least some people want to see on them these days, and the coders and designers behind them need the tools to make them so. Accordingly, Gavin Bong crafted this review of Web Development with JSP, which may be one of the tools you need.

Web Development with JSP author Duane K. Fields and Mark A.Kolb pages 543 publisher Manning rating 8.5 reviewer Gavin Bong ISBN 1884777996 summary Comprehensive coverage of JSP1.1. Suitable for beginning to intermediate Java developers.

Prologue

Before I proceed with the review, I feel obligated to respond to Jayakrishnan's review of Core Servlets and JSP and Slashdot readers' comments.

I share the sentiments of most people that the use of JSP scriptlets (Model 1) is bad practice. The mantra, "Thou shalt not mix HTML and Java code," should be tattooed onto every JSP developer's forehead. And as the author and readers have suggested, either choose a Model 1.5 (JSP or custom tags with JavaBeans) or Model 2 (MVC) to implement moderate- to high-complexity Web applications.

However, I believe that the authors of this first generation of JSP books need to inform the populace of what JSP is fully capable of (warts and all) -- in order for developers to appreciate the other paradigms. And beyond that, these authors must then educate on how not to use JSP. And I believe that will be the difference between a complete JSP book and an incomplete one.

Secondly, JSP Model 1 has been often described as "servlets lite." It is a good paradigm for prototyping servlets. For example, SOAP4J (IBM's SOAP framework) was released using a JSP scriptlet to dispatch SOAP RPC invocations. The software has since been donated to the Apache group and in the latest public release; the aforementioned JSP scriptlet is now a servlet.

So on that note, let me begin the review.

Topics covered

The book starts with a survey of precursor technologies to JSP in Chapter 1 and quickly moves into the real subject matter. It is clear from the start, that this book is written with the Java programmer in mind. I'd say that only the first five chapters are useful reading for a JSP page designer. Concepts like "How to setup a JSP/Servlet engine?", "Incorporating applets with tag," JDBC, JNDI, and EJB are either relegated to the Annexes or lightly mentioned before detailed treatment follows. The authors only cite HTML and Java as prerequisites but it's more accurate to say that readers also need to have some knowledge of core J2EE services like servlets. Here's a tip: have the JSP v1.1 and Servlets v2.2 specifications within close reach when reading the book.

The book covers all the core JSP topics; here's a sampling:

1. JSP and JavaBeans
The book provides a very readable introduction to JavaBeans for those unfamiliar with it. This is required reading for those implementing the Model 1.5 architecture. However, features specific to visual-oriented beans are not covered. Page designers should specifically devour Chapter 5 on JSP bean tags. The two notable samples provided are:

• CachedRowSet Bean - An example of paging through results using the JDBC 2.0 RowSet interface.
• JDBC Transaction Processing - An example of maintaining a JDBC transaction across several JSP pages using a Database Connection Bean and JSP implicit objects.

2. JSP Performance/Scalability
Performance and scalability issues are discussed accross several chapters. The authors attribute JSP's performance to servlet performance, which is tied to JVM server memory. No rule of thumb on sizing JVM server memory is given, but a tip is offered on how to use the serializable interface to estimate the size of Java objects that will be placed in the session object.

Session migration over multiple load-balanced machines is touched upon lightly but no technical details were offered. I would have liked to see a practical example on session persistence coupled with a use case of load balancing a JSP website. It's unfortunate also that the authors didn't think that database connection pooling warrants a practical example.

3. Multithreading
Throughout the book, readers are reminded to be aware of thread safety issues when dealing with shared resources (e.g. JDBC Connections). This tip is offered: "Examine all static variables & objects whose scope is session or application."

4. Exception Handling
A comprehensive coverage on how to handle exceptions in a JSP web application is provided and covers these areas:

• Error pages in JSP
• Null properties in JavaBeans
• Undefined values in Database tables
• Handling exceptions in servlets (JSP Model 2)

5. JSP Web application architectures
In Chapter 8, the page centric architecture (Model 1) is compared to a servlet centric one (Model 2). A discussion on the servlet RequestDispatcher interface culminates with a sample, that demonstrates how a servlet dictates application flow; relegating JSP pages to provide only presentation services, when called upon. A more complicated sample using this architecture is developed in Chapter 9.

6. Deployment
The book provides complete information on WAR files and Deployment Descriptors.

7. Three chapters of code samples
One full chapter is dedicated to a sample implementation of a real world example of a faq-o-matic tool. Also provided are two chapters of code snippets for Web-based functionality like form handling, cookie management and JSP's marriage with Javascript.

8. Custom tags
The last two chapters are dedicated to this very unique feature of JSP and in it they provide sample custom tags for content substitution and translation, coverage on how to package taglibs and more advanced techniques incorporating Java reflection in custom tag helper classes.

Weaknesses

The book comes with eight pages of errata - mainly spelling/naming errors in the code. I think publishers need to ensure that code be proofread as diligently as the prose. Fortunately the book has a Web site (taglib.com) with a link to a Web-based public forum.

The JSP API in Annex E is presented in the same style as Oreilly's Java in a nutshell book. A UML diagram would have been nice.

And finally, just like in the Core Servlets and JSP book; there's no mention of i18n or security. But this is probably a moot point since you gain i18n features directly from the Java language itself and the "contentType" @page directive attribute. Security of a JSP application is largely dictated by the Servlet/JSP engine configuration (albeit you can plug in your own authentication/encryption schemes) and would be better covered in a book dedicated to system administration and other deployment issues.

Is it worth buying?

It is important to mention that this book covers JSP 1.1 and Servlet 2.2, the production release of each technology. Recently JSP 1.2 and Servlet 2.3 have both entered the Proposed Final Draft stage. So the question is: should you wait for a new edition? My suggestion is: go buy the ebook version (in PDF) from Manning's website. And at a price of $16.50, that's a steal.

In terms of content, the book offers good value in its coverage of deployment issues, different JSP architectures and not forgetting some really good material on custom tags/taglibs. And by advocating an MVC styled development architecture; everyone from your JSP page designers, JavaBean/servlet developers and DBAs will be less coupled - and your code more maintainable.

Table of contents

• Chapter 1: Introduction
• Chapter 2: Fundamentals
• Chapter 3: Programming JSP scripts
• Chapter 4: Actions and implicit objects
• Chapter 5: Using JSP Components
• Chapter 6: Developing JSP Components
• Chapter 7: Working with databases
• Chapter 8: Architecting JSP applications
• Chapter 9: An example JSP Project
• Chapter 10: Deploying JSP applications
• Chapter 11: Performing common JSP tasks
• Chapter 12: JSP by example
• Chapter 13: Creating custom tags
• Chapter 14: Implementing advanced custom tags
• Annex A: Running the reference implementation
• Annex B: Incorporating Java applets
• Annex C: JSP resources
• Annex D: JSP syntax reference
• Annex E: JSP API reference

Besides the PDF version, you can also purchase this book at Fatbrain.

This "dynamic content" thing doesn't seem to be going away, does it? Web sites need to get smarter to handle the types of content that at least some people want to see on them these days, and the coders and designers behind them need the tools to make them so. Accordingly, Gavin Bong crafted this review of Web Development with JSP, which may be one of the tools you need.

Web Development with JSP author Duane K. Fields and Mark A.Kolb pages 543 publisher Manning rating 8.5 reviewer Gavin Bong ISBN 1884777996 summary Comprehensive coverage of JSP1.1. Suitable for beginning to intermediate Java developers.

Prologue

Before I proceed with the review, I feel obligated to respond to Jayakrishnan's review of Core Servlets and JSP and Slashdot readers' comments.

I share the sentiments of most people that the use of JSP scriptlets (Model 1) is bad practice. The mantra, "Thou shalt not mix HTML and Java code," should be tattooed onto every JSP developer's forehead. And as the author and readers have suggested, either choose a Model 1.5 (JSP or custom tags with JavaBeans) or Model 2 (MVC) to implement moderate- to high-complexity Web applications.

However, I believe that the authors of this first generation of JSP books need to inform the populace of what JSP is fully capable of (warts and all) -- in order for developers to appreciate the other paradigms. And beyond that, these authors must then educate on how not to use JSP. And I believe that will be the difference between a complete JSP book and an incomplete one.

Secondly, JSP Model 1 has been often described as "servlets lite." It is a good paradigm for prototyping servlets. For example, SOAP4J (IBM's SOAP framework) was released using a JSP scriptlet to dispatch SOAP RPC invocations. The software has since been donated to the Apache group and in the latest public release; the aforementioned JSP scriptlet is now a servlet.

So on that note, let me begin the review.

Topics covered

The book starts with a survey of precursor technologies to JSP in Chapter 1 and quickly moves into the real subject matter. It is clear from the start, that this book is written with the Java programmer in mind. I'd say that only the first five chapters are useful reading for a JSP page designer. Concepts like "How to setup a JSP/Servlet engine?", "Incorporating applets with tag," JDBC, JNDI, and EJB are either relegated to the Annexes or lightly mentioned before detailed treatment follows. The authors only cite HTML and Java as prerequisites but it's more accurate to say that readers also need to have some knowledge of core J2EE services like servlets. Here's a tip: have the JSP v1.1 and Servlets v2.2 specifications within close reach when reading the book.

The book covers all the core JSP topics; here's a sampling:

1. JSP and JavaBeans
The book provides a very readable introduction to JavaBeans for those unfamiliar with it. This is required reading for those implementing the Model 1.5 architecture. However, features specific to visual-oriented beans are not covered. Page designers should specifically devour Chapter 5 on JSP bean tags. The two notable samples provided are:

• CachedRowSet Bean - An example of paging through results using the JDBC 2.0 RowSet interface.
• JDBC Transaction Processing - An example of maintaining a JDBC transaction across several JSP pages using a Database Connection Bean and JSP implicit objects.

2. JSP Performance/Scalability
Performance and scalability issues are discussed accross several chapters. The authors attribute JSP's performance to servlet performance, which is tied to JVM server memory. No rule of thumb on sizing JVM server memory is given, but a tip is offered on how to use the serializable interface to estimate the size of Java objects that will be placed in the session object.

Session migration over multiple load-balanced machines is touched upon lightly but no technical details were offered. I would have liked to see a practical example on session persistence coupled with a use case of load balancing a JSP website. It's unfortunate also that the authors didn't think that database connection pooling warrants a practical example.

3. Multithreading
Throughout the book, readers are reminded to be aware of thread safety issues when dealing with shared resources (e.g. JDBC Connections). This tip is offered: "Examine all static variables & objects whose scope is session or application."

4. Exception Handling
A comprehensive coverage on how to handle exceptions in a JSP web application is provided and covers these areas:

• Error pages in JSP
• Null properties in JavaBeans
• Undefined values in Database tables
• Handling exceptions in servlets (JSP Model 2)

5. JSP Web application architectures
In Chapter 8, the page centric architecture (Model 1) is compared to a servlet centric one (Model 2). A discussion on the servlet RequestDispatcher interface culminates with a sample, that demonstrates how a servlet dictates application flow; relegating JSP pages to provide only presentation services, when called upon. A more complicated sample using this architecture is developed in Chapter 9.

6. Deployment
The book provides complete information on WAR files and Deployment Descriptors.

7. Three chapters of code samples
One full chapter is dedicated to a sample implementation of a real world example of a faq-o-matic tool. Also provided are two chapters of code snippets for Web-based functionality like form handling, cookie management and JSP's marriage with Javascript.

8. Custom tags
The last two chapters are dedicated to this very unique feature of JSP and in it they provide sample custom tags for content substitution and translation, coverage on how to package taglibs and more advanced techniques incorporating Java reflection in custom tag helper classes.

Weaknesses

The book comes with eight pages of errata - mainly spelling/naming errors in the code. I think publishers need to ensure that code be proofread as diligently as the prose. Fortunately the book has a Web site (taglib.com) with a link to a Web-based public forum.

The JSP API in Annex E is presented in the same style as Oreilly's Java in a nutshell book. A UML diagram would have been nice.

And finally, just like in the Core Servlets and JSP book; there's no mention of i18n or security. But this is probably a moot point since you gain i18n features directly from the Java language itself and the "contentType" @page directive attribute. Security of a JSP application is largely dictated by the Servlet/JSP engine configuration (albeit you can plug in your own authentication/encryption schemes) and would be better covered in a book dedicated to system administration and other deployment issues.

Is it worth buying?

It is important to mention that this book covers JSP 1.1 and Servlet 2.2, the production release of each technology. Recently JSP 1.2 and Servlet 2.3 have both entered the Proposed Final Draft stage. So the question is: should you wait for a new edition? My suggestion is: go buy the ebook version (in PDF) from Manning's website. And at a price of $16.50, that's a steal.

In terms of content, the book offers good value in its coverage of deployment issues, different JSP architectures and not forgetting some really good material on custom tags/taglibs. And by advocating an MVC styled development architecture; everyone from your JSP page designers, JavaBean/servlet developers and DBAs will be less coupled - and your code more maintainable.

Table of contents

• Chapter 1: Introduction
• Chapter 2: Fundamentals
• Chapter 3: Programming JSP scripts
• Chapter 4: Actions and implicit objects
• Chapter 5: Using JSP Components
• Chapter 6: Developing JSP Components
• Chapter 7: Working with databases
• Chapter 8: Architecting JSP applications
• Chapter 9: An example JSP Project
• Chapter 10: Deploying JSP applications
• Chapter 11: Performing common JSP tasks
• Chapter 12: JSP by example
• Chapter 13: Creating custom tags
• Chapter 14: Implementing advanced custom tags
• Annex A: Running the reference implementation
• Annex B: Incorporating Java applets
• Annex C: JSP resources
• Annex D: JSP syntax reference
• Annex E: JSP API reference

Besides the PDF version, you can also purchase this book at Fatbrain.

You want to code all day (or as long as you can stand), whether from home or in an office environment that suits you, with the right soda in the fridge, and friendly coworkers to ask questions when the going gets tough. You want a job in a field that will keep you interested for more than the first orientation meeting, and one that lets your skills be useful -- right down to your favorite programming language. Gavin Bong contributed this review of Programming Interview Exposed: Secrets to Landing Your Next Job, a book designed to lead interviewees for programming positions into the jobs they want.

Programming Interview Exposed author John Mongan and Noah Suojanen pages 272 publisher John Wiley & Sons rating 8/10 reviewer Gavin Bong ISBN 0471383562 summary A book to help developers achieve success in their technical interviews.

Introduction

Many people consider an interview a Kafkaesque experience, where all your skills (technical and social) come under the microscope. My toughest interview was one where I sat in a conference room faced with five hungry interviewers and "How many lines of code have you written in your career?" was considered small talk.

The promise

This book will not teach you how to handle small talk, but still may do wonders for you in your next interview. The author's promise, that reads: "If you work on learning to solve not just the specific problem we present, but the types of problems, you'll be able to handle anything they throw at you," is certainly ambitious, but they've succeeded admirably in my opinion.

General overview of book

Chapters 1 and 11 are short and sweet, but impart important lessons on how to negotiate offers, preparing for open-ended questions like "What are your career goals?" and generally convincing the employer that you can fit into their culture. Appendix A's coverage of writing technical resumes is brief but sufficient. Their bottom-line message is: craft a resume to sell your skills; don't write an autobiography.

The rest of the book comprises a review of common programming questions you may face, as well as a selection of puzzles that appear regularly in technical interviews.

The secrets summarized

The authors' secrets to technical interview success can be summarized as follows:

1. Make sure you master the programming language that the job asks for.
2. Practice solving problems and study heuristic methods.
3. Master common data structures like linked lists, strings, trees & graphs.
4. Be conversant in programming paradigms like recursion and Big O notation. And depending on the area of expertise that the interviewer is looking for, brush up on topics like concurrency, networking and database concepts.

Let's dissect these bullet points one by one

(1) The authors expect the interviewee to master every feature of the language that the job calls for, including the quirky and obscure ones. Personally, I think that knowing the core elements plus the specific features that the employer is looking for is more than enough. For example, in the Java paradigm; multithreading would be considered core, while knowing JNDI would be a speciality. But take note that an interview is not something you study for. It's not like a certification exam. You certainly need a couple of projects using that language under your belt to be absolutely prepared.

In interviews where you can choose the programming language, the authors caution against using lesser languages like Javascript or Visual Basic. But my opinion is that -- if it's used appropriately, and within the bounds of the job description -- any of these should be fine.

(2) G. Polya once said "Experience in solving problems and experience in watching other people solving problems must be the basis on which heuristic is built." The authors have kept to this spirit and included a generous number of challenging puzzles to exercise your brain. This is no coincidence, as both authors graduated from Stanford, where Polya once taught. Solutions are provided, but more importantly they've also included descriptions of the thought processes that underlies them. And by the way, the types of puzzles listed here probably wouldn't be out of place in a MENSA exam or the U.S. Computing Olympiad.

The authors also offer practical suggestions on how to solve problems, such as "Think out loud by explaining what you're doing," and "If you're stuck, consider looking at a specific/general example of the problem."

(3) The book offers one full chapter on linked lists. The author is justified in this, as linked lists can be operated upon by a multitude of operations. And each operation can usually be coded with a minimal number of lines of code. Ignore this advice at your peril.

(4) From experience, the authors have found that if you don't put down a particular skill in your resume; questions on those topics will not generally arise. So by setting the right expectations; you'll be able to get through the interview with fewer tangled nerves. But general programming knowledge questions like "What does it mean to be a 32 bit OS?" or "What is the difference between C++ and Java?" should be expected. Chapter 10 offers a healthy sample of them.

Weakness

One of the strengths of this book is that it focuses fully on the topic at hand which is "programming interviews" and never gets sidetracked. However it does have its weaknesses, in that there's very little mention of the high possibility of questions on component programming models (EJB,COM/COM+,CORBA). I think component-based software development (using off-the-shelf components) is the future of our industry (whether open or closed source) and companies are not interested in creating software from scratch. Also missing from the book is any mention of localization or internationalization of software.

Is it worth buying?

At 272 pages, this book can easily be skimmed in one sitting. But its value will not be apparent until you start solving the included problems/puzzles yourself and understanding the pattern of interview questions. This book is not a magic bullet that will guarantee you success in every technical interview, but having a rough estimate of what you will face is certainly better than being surprised.

Who is the target audience?

This book is especially relevant to recent computer science graduates who are just entering the industry. It may also be useful to technical recruiters and software managers (who assume the role of interviewers) who want to get some insights into the interview processes used by other companies. It might not be appropriate for people from other technical disciplines like system administrators or DBAs. Seasoned programmers may still get some benefit from the book although you've probably had first-hand experience with most of the questions/problems posed in the book.

Table of contents

• Chapter 1: The Job Application Process
• Chapter 2: Approaches to Programming Problems
• Chapter 3: Linked Lists
• Chapter 4: Trees and Graphs
• Chapter 5: Arrays and Strings
• Chapter 6: Recursion
• Chapter 7: Other Programming Topics
• Chapter 8: Counting, Measuring and Ordering Puzzles
• Chapter 9: Graphical and Spatial Puzzles
• Chapter 10: Knowledge Based Questions
• Chapter 11: Non-Technical Questions
• Appendix A: Resumes

Purchase this book at FatBrain.