I recently completed a ten-week software engineering internship at Micro Focus in Newbury, Berkshire. I learned a lot, and thought I would write a blog post about it!
What I Did
Working with six other interns and two regular developers, I developed a viewer and editor for data files mostly produced by COBOL programs. We worked in Java, and created a (Swing) GUI, as well as a command-line interface, and a web interface.
I worked on nearly every aspect of the program, including the different interfaces. The part of the program over which I had most influence, though, was the search component. Specifically, I designed and wrote most of the code behind the parsing, validation, and evaluation of search queries.
I might write I wrote a blog post about how I implemented it, but it was very flexible and enabled the user to make complex, nested search queries.
What I Learned
The most noticeable effect of spending seven and a half hours every day programming in Java for ten weeks was an increased fluency with the language. But more specifically, I became more comfortable with things including:
- Arranging a GUI in Swing
- Manipulating strings
- Parsing command line arguments and search queries
- Using Eclipse's debugging features and unit testing
I also learned what a pain SVN and continuous integration can be!
One of the biggest impressions I came away with was that the most important and difficult part of software development is not writing the individual methods and implementing the individual algorithms to do what you want them to do (as tricky as that can get at times): it's designing the system in an extensible, maintainable, and readable way. We interns were given more or less free rein to design and implement the program how we liked. Most of us had never designed a program of this scale, and after a few weeks we found that several parts of the program (which worked, and had seemed fine at first while we only had a few features) needed refactoring to remain readable and allow for new features. I learned a lot about modularisation, but also that it's important to think hard before making important code design decisions!