A lot of people seem to think that programming in academia isn’t real world programming. While I agree that four years programming in academia solving theoretical problems in C or Matlab isn’t going to make you a rockstar in implementing RESTful web services in Java or .NET, I do think the core programming skills and principles carry over nonetheless.

In this post, I would like to highlight some of the differences I’ve noticed in my experiences with both so far.

One of the major differences in my experience between the two domains has been guidance. If I’m stuck on something in college, even if this is as trivial as figuring out the best practices, I can bounce ideas off my professors, and they understand that I’m learning by doing and are usually accommodating. An elegant solution is preferred over a hacked together solution, and you are encouraged to learn best practices doing it.

Now, I’m not talking about a programming assignment for class here. I’m talking about projects done under the guidance of a faculty advisor.

My experience in industry tells me that the some product is better than no product rule takes precedence over anything else. If you cannot figure out the most elegant way to do something, hack something together to have a working solution. If time and budget permit, you may have a chance to later go back and fix it, although sometimes you may not. You may have a mentor assigned to you, but he’s busy doing his stuff and will usually try to point you to something, and if it doesn’t help, and you are on your own to figure it out. If you ask TOO MUCH, you’re probably a bad hire.

Another difference I’ve discovered is documentation (comments in code). While programming in academia, if you do not document your code, someone’s going to get upset because they do not know the language you’re using and can’t figure out the algorithm, or just because you’re not following what has been taught in your courses. In industry, regrettably, no one has the time for extensive source code documentation. Maybe it’s just that I’m working under experienced professionals who know what the code does by just looking at ten lines out of a 500 lines class implementation, but such has been my experience. After all, were you hired to produce products and services or to write pre- and post-conditions for your methods?

I’m sure I’m not the only person who’s wished that this would change. For a developer, comments in source code are more helpful than external documentation any day.

Academic programming also tends to have evolving designs and architectures. Trial and error is better than something set in stone. A professor would rather work on an interesting problem than have meetings to discuss an architecture document. After all, wasn’t I supposed to have taken a software engineering class?

Programming in industry will always have written architecture, design and other documentation. If not, it’s probably not a real project.

I will admit that I’ve programmed more in an academic setting than in industry, but so far, I think there’s pros and cons with both, and both would do themselves a favor if they learned from each other.

UPDATE: I also posted this question on the stackexchange programmers community, and I received some very interesting answers. Here are some of them:

In a traditional undergraduate computer science program you learn just programming. But industry doesn’t want people who are just programmers, industry wants real software engineers. I know many job descriptions don’t seem to know the difference which only confuses the matter, but in the real world you need to be able to:

Gather and analyze requirements, when they aren’t directly given to you
Design and analyze architecture, with near endless possibilities
Create test plans and act on them, to evaluate and improve the quality of a system
Work collaboratively on a team, of people with different backgrounds and experience levels
Estimate and plan work, even if you don’t know exactly what to build
Communicate effectively with stakeholders, who have different needs that don’t necessarily align
Negotiate schedule, budget, quality, and features, without disappointing stakeholders

Oh yeah, and you also have to be able to write code too, but that’s, on average, only 40 – 60% of a software engineer’s time.

So, it’s not that freshly minted computer science undergrads don’t know how to program (many are in fact, very good programmers) – it’s that many of them don’t know how to do anything else!

University

(I call this scenario university, because programming as an actual computer scientist is also different than what you do while studying)
Your teacher gives you:

A well defined, isolated problem, the solution of which can be provided within a short and well defined time span and will be discarded afterward
A well defined set of tools that you were introduced to prior to assignment
A well defined measure for the quality of your solution, with which you can easily determine whether your solution is good enough or not

“Real World”

In this scenario:

The problem is blurry, complex and embedded in context. It’s a set of contradictory requirements that change over time and your solution must be flexible and robust enough for you to react to those changes in an acceptable time.
The tools must be picked by you. Maybe there’s already something usable in your team’s 10 year old codebase, maybe there’s some open source project, or maybe a commercial library or maybe you will have to write it on your own.
To determine whether the current iteration of your software is an improvement (because you’re almost never actually done in a software project), you need to do regression testing and usability testing, the latter of which usually means that the blurry, complex, contradictory, context-embedded requirements shift once again.

Conclusion

These things are inherently different to a point where there’s actually very little overlap. These two things work at to completely different levels of granularity. CS will prepare you for “real world” software development like athletics training would prepare an army for battle.

Academia is mainly focused on the “science of programming” thus studying the way to make efficient particular algorithm or developing languages tailored to make certain paradigms more expressive. Industry is mainly focused in producing things that have to be sold. It has to rely on “tools” that are not only the languages and the algorithms, but also the libraries, the frameworks etc.

This difference in “focus” is what makes a academic master in C practically unable to write a windows application (since we windows API are not in the C99 standard!), thus feeling as it is “unable to program”. But, in fact, he has all the capabilities to learn itself what he’s missing. Something that -without proper academic studies (not necessarily made in Academia)- is quite hard to find.

While I have been using IntelliJ for sometime now, I haven’t had a lot of success in configuring Tomcat to run through the IDE. I followed the steps on the official help page, but it didn’t seem to work with my Maven project. So I added a configuration descriptor to Tomcat to load the target directory of my Maven project each time it loads and when I want to run my code, I produce an exploded war through IntelliJ and then run Tomcat externally.

When I had to debug my code, I would print out debugging statements which would help me narrow down the places in my code where the bug was, and then I would just inspect it manually. Not really the best way to debug code, but I really didn’t have the time to integrate Tomcat into IntelliJ.

Last night, I had a NullPointerException in a Java Spring project I’ve been working on for a couple of months now, and this approach didn’t work, and I set out to integrate Tomcat with IntelliJ once and for all.

When I had first tried to integrate Tomcat with IntelliJ, I had followed the steps on the Jetbrains Wiki and that worked just how it was described, but when I tried to run or debug my Maven project through IntelliJ, it just would not work.

After a lot of Googling and Binging *wink*, I had found no single source that explained how this should be done, and I spent a major part of last night just playing with different combinations of the different settings and was finally able to set it up correctly (I hope). Now, I am able to run and debug Maven projects directly through Tomcat and trust me, life is better.

I’m not sure if there’s other people who’ve been through the same experience as I have, so I’ve decided to put together this guide. Hope someone who is in the same position as I was yesterday will get something out of it.

1. Add your Tomcat configuration to IntelliJ through Settings -> Application Servers -> Add. Both Tomcat Home and Tomcat Base Directory should be set to your tomcat installation directory (e.g. C:\Tomcat6.0.33)

Adding Tomcat 6 to IntelliJ Settings

2. Add a Run/Debug Configuration to your IntelliJ project.

Edit Run/Debug Configuration

3. Click the + and add a new Tomcat local default configuration. Give it a name and you can have it start your browser automatically and go to a startup page.

New Tomcat Configuration

4. On the Before Launch frame, check Make.

Check Make

5. Click the ellipses (….) button next to Build Artifact and check exploded war.

Exploded war Build

6. Similarly for Maven, click the ellipses (…) button next to Run Maven Goal and select package.

Maven Package

7. On the Deployment tab, in the Deploy at Server Startup section, add a new Exploded war Artifact.

Deploy at Server Startup

(Steps below show how to configure the IntelliJ debugger to connect to Tomcat)

8. On the Startup/Connection tab, Select Debug from the left pane and set the port to 8000.

Set Debug Port

9. Create two new environment variables (Directions here for *nix and Windows)

JPDA_ADDRESS=8000
JPDA_TRANSPORT=dt_socket

And you’re set. Now when you click Run or Build, you should see maven packaging the project and work it’s ‘magic’, and then Tomcat should run with the new app!

Maven doing its magic

While now it seems simple, this was not at all intuitive when I was first tried to set all this up. But now that I have got this set up, my workflow is a lot improved and I can go back to focusing on the code!

Alternatively, if you wanted to run your project outside of IntelliJ, you can put a configuration descriptor into your tomcat/conf/Catalina/localhost directory to automatically look in a directory and deploy it every time it starts. For my QEF project, I have a file qef.xml that looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<Context docBase="/programming/appQef/target/qef">
    <Manager className="org.apache.catalina.session.PersistentManager" maxInactiveInterval="600" saveOnRestart="false"/>
    <ResourceLink name="jdbc/qef" global="jdbc/qef" type="javax.sql.DataSource" />
    <ResourceLink global="config/machine" name="config/machine" type="java.lang.String"/>
    <ResourceLink global="config/envType" name="config/envType" type="java.lang.String"/>
    <ResourceLink global="config/envLocation" name="config/envLocation" type="java.lang.String"/>
</Context>

Now whenever I want to execute my program, I build an exploded war through IntelliJ and start Tomcat, which looks for the exploded war in the given directory and automatically deploys it.

Thanks to this and this, I was able to figure it all out. Thanks Matt and Piotr!

Hope this will help somebody out as well.

Paigow Game Play

Paigow Tutor

Paigow Gameplay with Hints

Paigotr Four Player Gameplay

The graphics for this game were created with the help of Ayushman Das, my 13 year old brother!

Paigow Lite Gameplay

Paigow Lite Help Tile

Paigow Lite in Game Hints

Paigow Lite Gameplay

The graphics for this game were created with the help of Ayushman Das, my 13 year old brother!