All the pieces are here but the most important one: You. Your mind is the missing piece that makes the magic. Nothing
compares to the human mind for ability to synthesize, understand, and create. What you read and even the
best advice is just a voice in the wind; real results come from adjusting the ideas to fit your situation.
This is all just words until you live it.
Intermediate: Learn Java
Programming on Udemy
Intermediate: Using Eclipse
Reference: Java at TutorialPoint covers
all the various language features, if you already know what you're looking for.
You should understand the following before moving on to a project:
- Variables, conditions, functions, loops
- Packages, imports, classes, methods, interfaces, inheritance, static, public/private
- Java Collections API: List, Set, Map, SortedSet; ArrayList, HashSet, HashMap, TreeSet
- File IO: Reading and writing text files
- Exceptions and exception handling
You've learned Java and now you want to do a project. Now what?
A project should demonstrate that you can, at minimum, take data entry
from a user, save it, pull it back up later, modify it, resave it, and
report on it or retrieve a list of it. That's kind of a boring way to
think about software, though, so - add your own spice. What topics are
interesting to you? What would be fun or intruiging to work on?
It's great if you can create software for real users. If not, at least
create software you find interesting. You'll be living with the idea for
quite a while, so it helps if you're curious or passionate about the topic.
You'll be learning about a ton of new things during your project. This
page links you to many resources for user interface design, database design and SQL,
HTML and front-end web, and so on. You'll need to self-teach many of these
topics, using resources that fit how you learn and what you want to know. You won't
need everything on this page, of course, but I can't guess which direction you'll
go with it, so I provided a variety.
Here's roughly what the project experience will involve.
- Design doc
- User interface / screen planning
- Database planning and creation
- Application coding
- Testing and improvements
- Demos and Portfolio
Click to see the steps in more detail.
Idea and Design Doc
- Come up with an idea.
- Figure out who the target audience is - what kind of users.
- Decide if you're making it for web or mobile or desktop use.
- Start a design document where you write down your idea. You'll add to it in the steps below.
- Brainstorm a list of features. Write them down.
- Sort the features into "version 1", "version 2", "version someday". Keep version 1 small and focused.
Write the v1, v2, etc lists into the document.
- Brainstorm and draw pictures of the user interface (buttons, navigation, data) that will be on screen.
- Figure out how users will add, edit, save, and delete data.
- Figure out any validation rules and where to show error messages.
- Draw the screens on paper or whiteboard. Take pictures and drop the images into the document.
- List out the scenarios a user would typically be trying to accomplish. These will be test cases later.
- Determine the data model and plan out the SQL database tables, or file-based storage. Write it down.
- Come up with some fake test data that fits the data model. See if it tells you everything you
need to know as a user to walk through the screens. Include some invalid cases that should trigger
- Create a database user for your application with a simple password that you're not using anywhere else.
It'll end up in plain text in your code.
- Create the SQL script that creates the database tables.
- Create the SQL script that adds some valid fake data to the tables. It should be a separate script.
- Switching focus to the application code, figure out how to make an empty but working
application with simple menu or navigation from the first screen to any secondary screens.
- Stub out the panels or portions of the screen for your overall layout.
- Revisit your design document. Does everything still make sense? Do you have any new questions?
- List out the coding tasks for each feature. Break it down into small milestones you can mark off a list.
- Gradually work feature by feature and get each one working. This will take a while.
- Test as you go, and don't get too scattered as you work. Make small, consistent steps.
- Revisit your design document as needed, improving it and reflecting on how the software is
all coming together.
- Pause periodically mid work and examine the code. Is it well organized? Is there anything you're
really motivated to improve, to make it easier to maintain and change?
- Take the time to do some of this code refactoring.
Testing and Polishing
- When it's "done" take a step back and rest. You'll need a fresh mind before you can test.
- Do a low-risk demo to a friend. It'll give you a sense of completion and relax your focus.
- Come back fresh and run through all the user scenarios and test carefully. Make notes of any
issues, but don't try to fix bugs while you're testing. Test as completely as you can, and then
switch back to fixes.
- Test, fix, test, fix, test fix.
- Demo to a friend.
- Finish up your design doc and answer any remaining questions.
- Demo to a mentor or professional peer.
- Put together screenshots and code examples of key pieces as a portfolio for interviews. You
can use powerpoint or google slides for this, but plan to get them printed on paper for interviewing
(no computer slowness or failure during an interview).
- Ensure the software can be packaged and run on a different computer. This may be significant
extra work, but adds professional polish.
You may be ready to interview before you fully complete your project.
That's fine! This is about the learning journey, not the destination of a finished project.
In fact, many paid software development roles never see the "end" of a project; the
software just keeps getting improvements year after year. So talk with LaunchCode about
interviewing after you've had some project experience and feel ready.
Project Management and Technical Resources
The other sections of this page can be found via the Table of Contents above. They're
separated into individual pages for easier scrolling.