Are you interested in automated testing? If so, become a member of the Java Testing Society!

The Way of the Pro

Workers in suits

Enterprise developers are serious professionals. They don’t waste their time for creating silly things. They leave this to the hipster developers.

Enterprise developers write software which keeps our society running. They are the backbone of the modern society, and they know it.

Enterprise developers claim that they aren’t driven by money. They are driven by “professionalism” and the will to solve “hard” problems.

Even though enterprise developers claim that money isn’t important to them, they expect to be paid well. Everyone around them seems to be making shitloads of money, and they only want their share of the cash. This feels natural to them. It is how business works.

You must be wondering how you can join the brotherhood of enterprise developers and become a respected member of your community. You can start your journey by following this simple rule:

Use the right technologies!

Technology Evaluation Guide for Enterprise Developers

Because enterprise developers are professionals, they have strict rules for selecting the best tools for the job. These rules are:

Rule One: Use Java

This is the most fundamental rule of the brotherhood of enterprise developers. Enterprise developers know that Java is the best language for writing complex applications which have a long lifespan.

A true enterprise developer loves Java because of the following reasons:

  • Java has been around for ages and everyone is using it.
  • Java has many great IDEs which make the life of a developer so much easier.
  • Java has a very strong ecosystem and there is a library for pretty much everything you have to do.
  • A developer can choose between Java EE and Spring Framework. This gives them the possibility to choose the best tool for the job.
  • Big vendors have great products which help developers to write enterprise applications with Java.

These are all great benefits but the biggest benefits of Java are stability and backwards compatibility.

Everyone knows that hipster developers have to rewrite their application once a year because they use immature and unstable technologies. Enterprise developers don’t suffer from this problem, and they are proud of it.

Rule Two: Use Stable Frameworks and Libraries

Because enterprise developers build systems which must serve their users at all times, they use only battle-tested frameworks and libraries. These frameworks and libraries are often a bit old, but they are proven to work.

That is the only thing what matters when you are building a system which must be available at all times.

Enterprise developers know that adopting new technologies is a very risky strategy. They know that adopting new technologies can be a career-ending mistake, and that is a risk they don’t want to take.

It is better to stick with familiar tools. These tools might have a few bugs and other problems but the enterprise developers are very good at implementing workarounds for these problems. This makes their code less brittle and more stable.

After all, everyone knows that true professionals write stable code. They don’t take risks just because they want to have the latest toys (like hipsters do).

Rule Three: Favor Commercial Products of Big Vendors

Big vendors spend millions of dollars for creating great products which help developers to write highly scalable applications. These products include application servers, business intelligence products, databases, and integration platforms.

Enterprise developers should use these products because of the following reasons:

  • Big vendors have experienced architects and large QA departments. In other words, commercial products are written by using good engineering practices, and they have less bugs than open source products.
  • Big vendors offer commercial support (and consulting) which ensures that all problems are solved ASAP.
  • These products offer stability which is important for the customers of enterprise developers.

An enterprise developer might use open source libraries and frameworks for trivial tasks but when it is time to do some heavy lifting, a responsible developer will always use a commercial product.

Rule Four: XML Is the Universal Language of APIs and Integration

When it comes to APIs and integration, XML is the enterprise developer’s weapon of choice. XML is the best tool for the job because of the following reasons:

  • XML is a proven standard and that is why many commercial (and open source) products have first class support for it.
  • XML can be processed by machines and read by humans. This is a huge benefit over other proprietary file formats because it makes debugging problems so much easier.
  • The structure of a XML document can be specified by using XML schema. This means that it is easy to validate XML documents and ignore invalid data.

Also, Java programming language has a first class support for both reading and creating XML documents, and because all enterprise developers love Java, using XML is a no-brainer to them.

Rule Five: Use Relational Databases

Real enterprise developers use only relational databases because of the following reasons:

  • Relational databases have been around for decades and this makes them very mature. This is very important when you are building systems which must be reliable.
  • Relational database vendors can provide high level commercial support which is crucial for big corporations. This guarantees that possible problems are solved ASAP.
  • Relational databases have good administration tools, and a great support for analytics and business intelligence. This will keep the DBAs happy and ensure that the management has access to the information they need.
  • Relational databases have ACID transactions. This guarantees that database transactions are processed reliably.
  • Relational databases have a schema which specifies the structure of the database and enforces referential integrity.

Although some hipsters claim that NoSQL databases are a good choice for solving certain problems, enterprise developers know that NoSQL databases are only toys. They cannot understand why anyone would want to use a “database” which doesn’t have a schema and doesn’t support ACID transactions.

That sounds like a recipe for disaster.

Everyone knows that information is the most valuable property of any business, and relational databases help to keep that information safe. That is why enterprise developers use them.

Nobody Ever Got Fired for Buying IBM

The most important rule of the brotherhood is:

Avoid risks at all cost.

You want to look professional. You want to be known as a developer who masters complex enterprise technologies, and more importantly, you want to convince your customers that using these technologies will make them safe.

If you really want to protect your customers, you will follow these rules at all times.

These rules will protect you from being wrong and help you to build a reputation as an enterprise developer who understands that a real professional doesn’t experiment with someone else’s money.

About the Author

Petri Kainulainen is passionate about software development and continuous improvement. He is specialized in software development with the Spring Framework and is the author of Spring Data book.

About Petri Kainulainen →

8 comments… add one

  • I like your blogposts, but I think that this developer “categorizations” is too black and white to be true.

    Reply
    • You are right.

      I have noticed that a typical developer is somewhere between the pro (enterprise developer) and the hipster. Also, often the pros and hipsters aren’t nearly as fanatic as I described.

      So, why did I wrote this blog post in the first place? Well, I wrote a similar blog post about hipster developers and I wanted that enterprise developers get their share of the fun too.

      Reply
  • Somewhat tongue-in-cheek, Petri?

    I agree in principle with this, but differ on some details.

    • I’m primarily a Linux/Java guy, but recognise that there are other mainstream enterprise platforms out there (.NET for example)
    • Major proven open source projects like many of the Apache projects are as good a choice as commercial. Usually better, in my experience. The key is industry acceptance and support.
    • JSON should never replace XML completely, but it has a proven place in the Enterprise developer’s toolkit
    • Almost always RDBMS is the best choice, but occasionally it isn’t.
    • You have to take risks sometimes, but take small risks with big payoffs (this follows the statement above)

    Note: I modified the comment so that the arguments are shown as a list – Petri

    Reply
    • Sean,

      I agree with you. Looks like you figured out that this blog post shouldn’t be taken too seriously (although it has some truth in it).

      Reply
  • April Fool’s day is tomorrow, isn’t it?

    Reply
    • Yes.

      Reply
  • “An enterprise developer might use open source libraries and frameworks for trivial tasks but when it is time to do some heavy lifting, a responsible developer will always use a commercial product.”

    I hope you’re just kidding with this post. “big vendors” generally use Open Source libraries and frameworks and bundle them in a “commercial product” then given them a nice name and put nice buzzwords to selling them to the business people, but in the end, behind the scenes there it is: Open Source.
    If you want to go for pure commercial products, better to move to .NET, as Java ecosystem is just the Open Source one.

    “Although some hipsters claim that NoSQL databases are a good choice for solving certain problems, enterprise developers know that NoSQL databases are only toys”
    Toys? A good developer (not hipster or enterprise) knows when one solution is better than other. You just have to be kidding with this post.

    Enterprise developer?? What is a developer working on google, facebook, twitter, linkedin and alike? Are they Hipsters? Must be, because they are not using all the “Big Vendors” stuff?

    Reply
    • I thought that my fourth “rule” would make it clear that this blog post is a joke. On the other hand, I am (painfully) aware of the fact that some developers probably agree with everything I wrote.

      “big vendors” generally use Open Source libraries and frameworks and bundle them in a “commercial product” then given them a nice name and put nice buzzwords to selling them to the business people, but in the end, behind the scenes there it is: Open Source.

      Although I prefer using open source, there are situations when it makes sense to select a commercial product. For example, if your employer has signed a strict service-level agreement, you have three options:

      1. Use an open source product and pray that it has an active community who is willing to help you for free. Remember that the SLA specifies how fast you have to solve possible problems (or pay compensation to your customers).
      2. Use an open source product and buy commercial support for it.
      3. Use a commercial product from a big vendor who has first class support.

      When you think about these options, it is clear that the management prefers the third option (and I cannot really blame them).

      Although I would like to select the second option, I also think that the person whose ass is on the line makes the final call. That is how business (and life) works.

      Reply

Leave a Comment