elp Needed for SCJD Assignment Deliverable

[charlie zhang]

I was assigned to develop URLyBird hotel reservation system. The deliverable file I submitted named scjda-29796XXXX.jar. Below is the structure of this archive file.

code // this directory contains assignment source code
bin // this directory contains compiled classes from the code dir
dist // this directory contain the server.jar and client.jar, and
suncertify.properties
docs // this directory has the document and userguide
db-1x2.db // this is the database file
version.txt // JVM version
build.xml // ant build file
runme.jar // archives all the compiled classes located in the bin dir
config // this directory has files used only by ant build file

The Deliverables Execution requirement(instructions.html) says:
When you submit your assignment, each part (client and server) must be executable using a command of this exact form:
java -jar <path_and_filename> [<mode>]

I created server.jar and client.jar in the <dist> directory, and they could be run as
java -jar server.jar
java -jar client.jar

The Deliverables Packaging requirement says:

All elements of your submission must be packaged in a single JAR file. The JAR file must have the following layout and contents in its root:

1. The executable JAR containing the programs. This must be called runme.jar.

I am not exactly sure what this runme.jar is used for because the Deliverables Execution uses server.jar and client.jar which are located in the <dist> directory. I included all the compiled classes built from code directory into runme.jar, the system user could use this JAR file to launch the server and client by issuing commands(if the system user does not want to use server.jar and client.jar)

java suncertify.gui.CSRGUI [ network|alone]
java suncertify.server.CSRServerImpl


2. The original, unchanged database file that was supplied to you. Note that you must keep a copy of the original database file supplied to you, and this must be the file you submit. The marking process will expect the exact same data without any changes.

This is included in my scjda-29796XXXX.jar

3. A directory called code, containing all the source code and related parts of your project. You must create subdirectories within this to reflect your package structure and distribute your source files within those directories.

This is included in my scjda-29796XXXX.jar

4. A file called version.txt. This must contain pure ASCII (not a word processor format) indicating the exact version of JDK you used, and the host platform you worked on.

This is included in my scjda-29796XXXX.jar

5. A directory called docs.

This is included in my scjda-29796XXXX.jar

However, my submission failed. Below is the accessor comments I got from http://www.certmanager.net/sun_assignment/
Assessor Comments: Submission fails because it does not meet the exam specification. The requirements call for the applications to be contained in and invoked from a single file called runme.jar. This submission does not meet that requirement as defined in the "Deliverables" section of the Instructions.


I don't know what is wrong with my assignment deliverables(Maybe my understanding of the runme.jar is wrong). I would be greatly appreciated if you could help me in this regard.

Thanks,

Charlie

[peter wooster]

You can't have multiple executable jar files, you stated that you submitted a server.jar and client.jar. The requirements are that both the server and client must be able to run from a common jar file called "runme.jar" by running a commands like

java -jar runme.jar
java -jar runme.jar alone
java -jar runme.jar server

This file must have a manifest that specifies a single main method that can run both client and server.

[Stephen Bloch]

I just downloaded my SCJD assignment (Bodgitt & Scarper), and the instructions specify that there's ONE application, which runs as either server, client, or stand-alone depending on its command-line argument. I expect this is what they wanted in your assignment too.

[Dieskun Koper]

Hi Peter & Stephen,

My instructions said:

<quote>
When you submit your assignment, each part (client and server) must be executable using a command of this exact form:

java -jar <path_and_filename> [<mode>]

Your programs must not require use of command line arguments other than the single mode flag, which must be supported.
</quote>

Note that it says "programs", not "ONE program". In Charlie's case, each part (client.jar and server.jar) is executable using the command above (that is, java -jar client.jar [<mode>] and java -jar server.jar). If his instructions are like mine, I don't see what requirement he broke.

Regards,
Dies

[Matt Sheehan.]

Originally posted by Dieskun Koper:
Hi Peter & Stephen,

My instructions said:

<quote>
When you submit your assignment, each part (client and server) must be executable using a command of this exact form:

java -jar <path_and_filename> [<mode>]

Your programs must not require use of command line arguments other than the single mode flag, which must be supported.
</quote>

Note that it says "programs", not "ONE program". In Charlie's case, each part (client.jar and server.jar) is executable using the command above (that is, java -jar client.jar [<mode>] and java -jar server.jar). If his instructions are like mine, I don't see what requirement he broke.

Regards,
Dies

The spec also says:

The mode flag must be either "server", indicating the server program must run, "alone", indicating standalone mode, or left out entirely, in which case the network client and gui must run.

which definitely implies the use of one jar as well as this item from Packaging of Submissions:

The executable JAR containing the programs. This must be called runme.jar.

[Dieskun Koper]

Hi Matt,

If Charlie's application can be started as follows, I think it obeys what is mentioned in your first quote.

Server program:
java -jar server.jar server

Stand-alone mode:
java -jar client.jar alone

Network client and GUI:
java -jar client.jar

I think the only harder point to defend Charlie's interpretation is the "The" in your second quote. He did include a file called runme.jar, but it is not the (only) executable JAR that he included. I see no other indication that this "The executable JAR" refers to the same JAR mentioned in the section above it (Target Platform and Execution).

I don't think Charlie is going to be a better developer by putting a manifest file in his runme.jar and resubmitting it, so unless he cannot defend his submission, I hope he will make an appeal.

Regards,
Dies

[Nicholas Cheung]

In case there are any unclear areas, I feel we should better follow SUN's recommendation, even that might not be so good. Just some cases people mentioned before on 48-hour rule. You might also argue with SUN after you submit, and SUN marks your assignment as Auto Fail, however, in such sense, why don't we put ourselves out of these areas, if you already know there might be potential problems?

Also, if you make everything being seperated, then what's the point for having the mode flag?

Nick

[Paul Bourdeaux]

I don't think Charlie is going to be a better developer by putting a manifest file in his runme.jar and resubmitting it, so unless he cannot defend his submission, I hope he will make an appeal.

Actually, it can help make him, and the rest of us, better developers. Part of the development process includes listening to the customer's needs, and adhering to the requirements agreed upon in the contract. If Charlie's instructions read the same as mine (and I am fairly certain they do, as Sun has used the same package format for quite some time), then the executable jar must be called runme.jar, and it must be able to be run according to the format the Peter mentioned in an above. Much of the testing is done automatically, and if the executable is not when it is expected to be, then this part of the process breaks down.

For the record, I hope Charlie does not have to resubmit, or at least is allowed to resubmit without having to pay again. Good Luck.

[Dieskun Koper]

Hi Nick,

The point with some "unclear areas", is that some of us don't realize they were unclear until we failed. In my case, I never really considered the 48 hrs rule an "unclear area". I thought it was clearly not a requirement. My accessor did not agree at first, but eventually Sun replied that it was not a requirement and I passed.
I assume Charlie did not realize the ambiguity in the Deliverables section until he got his result.

Also, if you make everything being seperated, then what's the point for having the mode flag?

That is a very good question. I have a few more:
Why does the database interface include methods that we don't need (delete, create)? I implemented them as NOPs and passed. So what was the point of having them in the interface in the first place?
Why does the database file have space-padded fields while the instructions speak of null-terminated fields?

[Dieskun Koper]

Hi Paul,

Although I agree listening to a customer's needs is an important part of any development process, this is not what makes Sun Certified Java developers. You will not find any such objective in Sun's descriptions of this exam.
My customers do not speak English and this was my first time to work with requirements in English. If I were to make a mistake and interpret "The executable JAR" as "An executable JAR" and add two more executable JARs, I don't think that would say anything about my Java developing skills.

But my instructions were a little different than what Peter quoted, so my point of view is different.

Regards,
Dies

[Nicholas Cheung]

For 48-hour rule problem, as this has been discussed many many times, I suppose you should realize it before you do the submission. As someone has said he got auto-fail after missing this implementation, and thus, if we do not implement this, we already know there might be a potential problem. Just you simply decide to put it away, and fight with SUN.

In fact, most of the issues were discussed here. For myself, I have checked with all related areas by searching through this forum, before I did the submission. To play safe, I have changed some of my codes to make sure that I will not get auto-fail at least. Personally, I feel that, there is no point that you know there might be some problems, but you still decide to ignore them, submit the assignment, and fight with SUN for 2+ weeks. As different accessors will have different point of view, and SUN in fact has the rights to fail you as well (no matter how strong reasons we thought we had). Still, why take such risks if the changes are just minimal or do not affect the overall infrastructure much?

For those other questions, if the accessors are lazy, they might not discover them easily (like space padding as if they don't check the file with a hex editor, or create/delete methods as we don't provide any means for them to access and the auto program might be difficult to detect whether there are real implementation for these methods except checking whether they are exist in the "target" class, like Data.java), however, obviously, we know the accessors will need to run the programs, and this issue is too obvious.

Nick

[Dieskun Koper]

Hello Nick,

I did not know the 48 hrs rule was discussed many times before. I did not know Terry also got an auto-failure for it in March last year until Andrew sent me the URL of the thread. If I had, I probably would have implemented it to be safe.
I did change my application several times to prevent other potential problems I read about once I joined Javaranch.
But I did not read every thread. You are saying I should have? Every developer has to read every message on Javaranch's SCJD group and if they don't and get an auto-failure it is their own fault and they should accept that?

I don't know why Charlie submitted the application the way he did, he did not gave any details. But to assume that he did it on purpose even though he knew it could lead to auto-failure is something I will not do.

[Paul Bourdeaux]

Hi Dies,

If I were to make a mistake and interpret "The executable JAR" as "An executable JAR" and add two more executable JARs, I don't think that would say anything about my Java developing skills.

I agree, but if you are developing an application that is meant to interact with existing applications, the way your application is executed is very important.

Basically, we have been given a project (our assignment), and the project must follow a very specific executable format so that it can be executed by a preexisting application (the automated testing process). If we change the executable format, either by design or by mistake, we are not fulfilling the requirements of the project.

Although I disagree with Sun giving Charlie an automatic failure for his submission, the instructions are actually pretty clear in this regard. (The bolded words were added by me)

All elements of your submission must be packaged in a single JAR file. The JAR file must have the following layout and contents in its root:

The executable JAR containing the programs. This must be called runme.jar.

Automatic Failures
As noted at the beginning of this document, where this document uses the word "must" an absolute requirement is being described. If you fail to adhere to such a requirement, your assignment will be failed automatically, and without further evaluation. It is therefore imperative that you pay close attention to any statement using the word "must" in this document.

[Nicholas Cheung]

But I did not read every thread. You are saying I should have?

For other certs, like SCJP or SCWCD, I feel that's fine because there might be just one-off questions, however, for SCJD, in fact, for myself, when I encountered any design issues, before I make any decisions or ask a question, I will first search around it, and I keep tracking on these issues. As if I failed in the exam, I cannot get a refund.

What I wanna tell is, try your best to minimize your risk, at the same time, maximize your score, and knowledge and experiences gain.

Nick