Home > Development, Generic > Does tooling and language actually matters?

Does tooling and language actually matters?

We are developers. Software engineers. We struggle everyday with our creations, trying to make them better, faster, more reliable. But we work mostly with text. Programming didn’t change much in that matter – give me a notepad (or better Vim) and compiler and I can rule the world. But can I?

8 months ago I started working at one company in very niche software. Well, it may be actually pretty popular and it made (and continues to make) a lot of money to company that wrote it – that one I’m sure of. I’m working with slightly outdated version. 2-3 versions behind but I’m not sure. So what I do is write scripts to support business logic. And I write them in some C-like language made specifically for this program. It comes with built in functions that help to work with table data (like sorting, calculating values, selecting subsets etc.). But that’s about it. No IDE support, no intellisense, heck, not even easily accessible compiler! I can write those scripts directly inside software running them but the editor there offers less functionality than Notepad (literally! Not even ctrl+a support).

So can I rock the world with notepad? Well, I’m sure making it go round. Scripts are running fine. But at what price?

  • No TDD for me. No compiler, no external runtime environment – no way to run tests. Untested code leads to a lot of small issues in code (mine and others). And a lot of risk with each new feature, bugfix and refactor.
  • No easy compilation means I write a lot of lines of code before I check if they are even correct. Mess up parameter here and there, skip semicolon somewhere, typing mistake in function call – all easy to fix, but when you have dozen of those mistakes in hundred or so lines of code it takes time to fix them. And time is money. You want to know how my compile “shortcut” looks like? Ctrl-a, Ctrl-c, Alt-Tab, Alt-e, Enter, Ctrl-v, Ctrl-s. Seriously.
  • Deploy process is so hard to automate apparently that everyone tries to keep number of files low. 3k lines of code in single file? If you’re lucky. Usually you can easily hit 4k. And to share code, your file needs to be marked as include file. And then it's not able to run on its own. So most of the code gets copied and pasted around as fast solution for code share because no one bothers moving simple functions to shared libraries.
  • I've got so used to C# etc. that it hurts me when I need to create function header at top of the file because otherwise compiler will not recognize functions declared below place of usage. As a result we have long functions doing all kind of things since extracting function is so much trouble
  • Language as a whole is so exotic that there is no tooling support for refactor or anything. I use C# color syntax since it's the closest to script syntax
  • One could at least have good debugger to work easily with issues. No way. Turbo Pascal had better debugging tools and this was how many years ago? All code is thrown in one window, no distinction between files - so you have 10-20 thousand lines of code to work with. No watch - you need to select variable and click on a button to output it's value to output window (it's simple log window). Breakpoints are not even marked somehow readable - just by B letter to the left, over line number. Current execution line is indicated by => characters - try finding it in 10 000 lines. You will make small change to script (say - change one character) and restart debugging - all your breakpoints are lost. There is even no step over functionality. You have to step into each function call or set breakpoint at next line and let the code run.

And I could get few more points probably. So to sum it up - code quality is very low, code duplication is very high, no easy way to fix it. Working in such conditions is very hard, everything takes way more time than it should in decent working environment. And developers time is money. Business have to struggle with issues, waiting long before fix finally makes it to production - this cost even more money. And we're not talking about hundreds of dollars.

You could tell it's our fault - we could work with this and still make good code. We could extract shared code, refactor it. Create custom tools etc. But that takes an effort - you need to work hard to get simple things done. Things that any other popular language these days have already worked out in many ways - just pick solution that suits you best! And we, as developers, are lazy. We want things to be easy. We want work in 21st century conditions.

And I'm right now at year '95. Or maybe not even there...

About these ads
Categories: Development, Generic
  1. No comments yet.
  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.

%d bloggers like this: