Simplify Your Software Development: A Smart Approach to Building Flexible Ecosystems that Prioritize Customer Experience.
Traditionally all the approaches come at a significant investment of time, money and skill, and are always focused on reducing complexity, often at the cost of customer experience and flexibility. At the same time, internal as well as external change is constant and inevitable within every organisation. So how do you build software ecosystems that remain core to what the business needs and at the same time add value for the customers when everything is constantly changing? You do it the smart way, integration via abstraction.
Like so many other people in South Africa, the unreliability of our power grid have forced me into taking the plunge and investing in an inverter with a lithium backup battery.
I used a raspberrypi to retrieve modbus data from the SunSynk inverter via a custom RS485 RJ45 to USB cable, logged the data into a MySQL table via a Nodejs app, and then used Grafana to display the data in a custom dashboard.
I have been coding for almost three decades, in a multitude of languages. The last decade has been spent in PHP, jQuery & Bootstrap. Pretty traditional web development stuff. This has worked well, but there are now better and more modern tech stacks out there. It is time for a change, so I am going to document my journey into the brave new world that is Nuxt, Vue & Node.js
This journey will be documented over a series of posts. In order to make it easy to follow I will tag them all with #lourneytonuxt
But before we dive into the technicalities, let’s get to the elephant in the room. Why Nuxt?
Coding a new feature is like running a marathon by doing a lot of short sprints.
The mistake we as developers often make is trying to achieve too much in one go. We try to complete all the work in the spec in one go, i.e. we disappear into a dark hole and only resurface once we are done. There is several reasons why this is a bad idea.
Only revealing what you have worked on when it is done means you cannot incorporate any feedback into your work while you code, which in turn means you will be re-doing a lot of it.
The longer you wait to release code the higher the chance that something external has changed that will result in you having to change some of what you have done.
Working in isolation means no collaboration, which in turn reduces innovation.
The best way to go is to release lots of small incremental changes (the sprint) instead of going all the way (the marathon) before releasing the code. This way you get feedback quickly, and should you be going off track you can get on the right patch quickly.
Divide your task into small chunks, and do these one at a time. Not only will you be able to better measure progress, but you will be able to collaborate much better, and the instant feedback will result in a much better result. This approach will also make it much easier for the person having to review, merge and release your code into the bigger product set.
How often have you though that you could quickly add a new feature to your system? If you ask me, the answer is many times.
How often did it turn out to be quick? For me, none so far.
Adding a new feature quickly implies the following assumptions:
You know exactly what you want the actual requirement is
You know exactly what needs to be done
You know exactly how this will impact the rest of the system
Most of the time at least one of these assumptions are wrong, more than often two or even three. This means a job that you thought would take a day turns into a week or even two.
Another seriously delaying factor is the dreaded scope creep. Often business wants more once they see what you have done. This can be managed, but what is far harder to control is the internal force that drives the top developers. We always want to over deliver, which means we keep adding more and more as we code, causing our own scope creep.
My rules to manage this is simple:
Rule 1. Write down exactly what you want to accomplish
Rule 2. Write down exactly how you are going to accomplish it
Rule 3. Stick to the two rules above, no matter what
If you decide halfway along that it would be a good idea to add X, Y or Z features, don’t. Resist all temptation. Refer to the rules above if confused. Only once your new feature is done can you consider doing more, but now you can step back and consider the bigger picture before you dive back into the code.
Bugs slipping into code is inevitable, no matter how carefully we code and test. I have created many bugs in my day, and still make the odd mistake to this day. It is how you respond to your bugs that matter.
If you know there is a bug in your code, own up & fix it. If there is a chance that it has gotten out to live sites then patch & release a fix. If something on the customer side got affected by the bug then make the customer aware and sort it out. Not disclosing creates an atmosphere of mistrust, as the customer is bound to find out eventually.
If you work as part of a team, there is no debate here. Make sure your team knows what is going on. They cannot have your back if they are in the dark.
When I started my career in software development over two decades ago there was no such thing as a specialist coder.
Programmers as we were called in those days were required to do a mix of jobs. Gather business requirements, design the solution, code it and get it implemented. This included the graphic design, the end user training, etc. This attitude of “do it all” has served me well in my career. I have seldom been unable to solve any technical obstacle myself.
Today it is very different. Most developers specialize in front-end, back-end (server side) or ux (suer experience). Graphic design has diversified just as much.
How often have you seen a new mobile app or website being promoted? I guess pretty often. It seems everyone is a website designer or mobile app developer these days.
This is all fine, until your app hits the big time, then things goes wrong pretty quickly.
First, your server runs into performance issues because you built your app so fast you did not have time to do performance testing, or even design for performance. Then you start throwing more developers at the problem, but quickly realise that 9 developers cannot make a baby in one month.
Most CRUD (create, read, update & delete) operations follows the same pattern of code.
There is a controller that drives the main functions, a list view (using the awesome datatables plugin) to show a table of data and a edit popup screen to create or modify the record. Then there is a delete and optional enable/disable function, together with maybe some additional tabs on the edit screen.
How hard can it be to combine all this into a code generator?