"Simplicity is the ultimate sophistication" Leonardo Da Vinci
"Dealing with complexity is an inefficient and unnecessary waste of time, attention and mental energy. " Edward de Bono
Programming languages are something for Elite people. Frameworks generate hypes.
Libraries could be used but we shall use mega abstractions.
Is there any room for simplicity?
I have some questions:
Once upon a time long ago, before hypesters began taking mainstream pills.
IN a land long forgotten happy programmers developed complex software with simple tools.
They practiced their crafts from the basics.
Then one day a very enlightened group of people started inventing frameworks.
They thought that a framework that did everything could help you in faster development.
Soon after hipsters invaded and you had a framework that made other frameworks.
Or in Java terminology, you first need to build a factory that builds your classes before you can add 2+3.
What happened to proper programming?
What's wrong with using battle proof design patterns?
Why the heck are there so many programming languages, frameworks, libraries that do the same thing?
Why are people becoming web developers and not software engineers?
The following is a pamphlet, treat it likewise.
Tired of plain programming? Tired of your boss picking on you for not using the newest framework?
we've got good news for you. We've developed a new shiny framework called ToughJoyFax.js
Yes, you've figured it out. ToughJoyFax.js can do what you do in plain programming code in 5 lines in just 3 lines!
A 60% improvement! It's 1.5x faster than the OldStupidFramework.js and has less overhead!
And what's the most important part it's fully backed by Pear, MacroShaft and Goggles!
Come on and tell all your friends to join the bandwagon!
We have a special section on StackOverflow for those moments when you just can't figure out how to do it.
No, you really dont need to write pain old vanilla code.
Why would you even try proper programming and good old design patterns when you have ToughJoyFax.js ?
Dear creators of ToughJoyFax.js:
A friend of mine said he can do what you can do with ToughJoyFax.js in 50 lines of code!
How is this possible? Your tech support assured me that the 200 lines with ToughJoyFax.js is the shortest and fastest way possible!\
Dear ToughJoyFax.js developer:
No, you really have to understand that the 50 line plain code is different than our 200 line code with ToughJoyFax.js
Even if it does the same thing, trust us! It's different, it doesn't use our internal implementation and it's missing some of the coolness of updating the state on the fly.
You need to redraw the canvas 20 times a second. No, the refactor pattern is not needed at all!
DemiGod developer of ToughJoyFax.js
UPDATE Version 2
We're happy to inform you that after 12 months of hard work we've released ToughJoyFax.js version 2.
It brings new enhancements with it. Thanks to our internal team efforts we can now make the leap to the new Web 8.5.3
Due to changes in the way we think and because the interwebs is changing so fast we have made efforts to keep up with everything for you our dear users.
Some of our choices where not easy here is a list of the most notable changes.
Our code has been rewritten by oversea monkeys from scratch to better serve your needs. If you think Shakespeare was great, wait untill you read our documentation!
We've deprecated all API calls from the previous version. This way we want to test our true fans, those who will follow us to the end of the world.
We've also discovered 5 severe security issues in version 1.0 which have now been fixed by an external security firm who audited our code.
We will no longer support version 1.0 starting 30 days from today.
Please read our 200 page manual on how to upgrade your applications. It should only take a few weeks to rewrite all your code.
We hope you'll have restless nights learning it and cursing as we did when we developed it.
Don't forget to give it to your friends and tell your managers it's for their own good to upgrade to the newesr version!
3 years have passed since the initial release of our first version and we're now glad to announce version 3.0 alpha!
After further market analysis we have decided to stop the development.
We've moved the code to a github account and created a special community version 3.0 which you, the community will always maintain it!
We've only deprecated 50% of the API calls from version 2.0.
The number would have been higher and ranged between 70 %to 100%.
However due to the large number of e-mails we kept receiving and people imploring us not to change everything we had a rough decision ahead.
So we did what we do best, we flipped a coin and figured out that 50% of the code needs to be rewritten anyway.
Some of our best developers left the team during this process.
Some where kicked out for their radical ideas. This has been a though decision.
Can you believe some of our most radical developers?
They said that our framework is no different from any other!
They even claimed they could do what our framework does in fewer lines of code with zero overhead!
How can TravaillerLentement.JS be better than ours?
Yet we have to accept the facts that Ventosanzap.js performs better than our framework.
But it's only due to the fact that they've tested only 50% of our functionality!
They forgot that our framework is great and it doesn't matter if it's slow@
We thank all of you for your support!
And now back to reality.
The world goes on
"Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to build bigger and better idiots. So far, the universe is winning."
- Rick Cook
Still think it's funny?
No, it's the state of today's world.
By the time you've read this a new programming language came out.
2 new frameworks have been updated to a newer version.
A new library has been developed for something that already exists out there.
And of course 10 new security issues have been identified with old unmaintained code.
Ah and yes, a new person has reinvented the wheel claiming that his framework is better, new edge, faster, etc than the previous 100.
"Things evolve to become ever more complex — not more simple.
Those who have got used to the complexity no longer notice it and even add more elements, so increasing the complexity even further." Edward de Bono
What i've described earlier is just a way of making simple things complex.
All programmers should be required to have a copy of Edward De Bono's Simplicity book on their desk.
Reading most of his books and maybe even taking a CoRT course to improve thinking and creativity.
A way of making the software stack confusing for everyone involved.
Adding abstractions to something that is already exremely simple only makes it complex.
Long ago I believed that excessive frameworks added bloat but that using frameworks was also a great way to develop something.
College and work forced me to adopt the way of thinking that "frameworks simplify".
Up untill 2015~2016 I tried my best to use frameworks to "simplify".
But ended up spending a considerable amount of time to reimplement the simple in complicate ways due to the nature most frameworks work (talking about backend & frontend here).
I eventually realized that frameworks DO add bloat. They drown the programmers. They overcomplicate the hiring process. Oh, yo udon't know x, y z frameworks, sorry we want someone who does know all these things.
Frameworks are great for to be sure that everyone around the world that might work on a project knows a set of constraints, logic and understands what it's all about.
But frameworks have become an evil that can no longer be tamed. Because the moment you chose a framework you impact every single development and engineering decision for the future of your project.
Algorithms + Data Structures = Programs
So a Program is created by a unique combination of Altorithms and Data structures.
This is the essence of programming since the 1950's
A few quick questions to think about, try writing the answers on paper.
What happens if you design bad data structures, do you need to change your code too when you change the data structures?
If you design bad code but good data structures, do you need to change your datastructures with your code redesign?
What's the most important asset in the life of your product or business?
The truth is that these questions are difficult and depend upon context, environment, people, culture.
The one unifying answer is "data" is the most important asset.
If you ONLY have bad code, you can rewrite that.
If you have bad data structures then you need to change them AND change the code.
"There is often a much simpler way of doing things — if you make the effort to look for it. Simplicity does not just happen." Edward de Bono
To better comprehend the idea let's analyze a little more.
Imagine a table of employees in a SQL database (nope, no noSQL here).
It;s NOT normalized in any way. The naming conventions are weird, data is stored in duplicate ways.
Of course the best programmer will generate some code.
Later if one changes the datastructures then the code will also have to change once again.
Imagine you had a normalized database with a way to add new data anytime without adding new columns.
If you even have a bad programmer write code, a great programmer can rewrite the code and you won't have to touch the code.
To (mis)quote Linus Trovalds:
"git actually has a simple design, with stable and reasonably well-documented data structures. In fact, I'm a huge proponent of designing your code around the data, rather than the other way around, and I think it's one of the reasons git has been fairly successful […] I will, in fact, claim that the difference between a bad programmer and a good one is whether he considers his code or his data structures more important."
"I will, in fact, claim that the difference between a bad programmer and a good one is whether he considers his code or his data structures more important.
Bad programmers worry about the code. Good programmers worry about data structures and their relationships."
"Show me your flowcharts and conceal your tables, and I shall continue to be mystified. Show me your tables, and I won’t usually need your flowcharts; they’ll be obvious. "
Why you don't need mega frameworks
There are two ways of constructing a software design. One way is to make it so simple that there are obviously no deficiencies. And the other way is to make it so complicated that there are no obvious deficiencies.”
- C.A.R. Hoare
You do NOT need a framework to do your job.
No, unless you at least a few projects made in the the language of your choice using only the PURE builtin functions and standard libraries.
You don't even have to touch a framework. For if you start working with a framework before you understand the advanced intricacies of a language you will fail miserably.
You do NOT need a framework to do your job.
What you need is proper experience and knowledge. You may need a library or two but keep it at that.
Add a single call to a simple library function. Do this only if it would take you more than a few hours to program that specific function.
Frameworks move complexity around. You end up writing more code and come at the same code level than if you hadn't used a framework.
One of the most cited example of using a framework is :
But why waste time writing everything yourself, you're reinventing the wheel?
You can read more about my thoughts on reinventing the wheel in this post.
If you've never written a project in it's purest form in a plain programming languages by just using basic libraries you won't understand the abstractions behind how a framework actually works.
This means that every time you use a framework you spend time figuring out WHY simple things don't work how you expect them to behave.
When you use a framework you tend to do everything in the way the framework does it.
Simple things become complex and you end up not being able to see the forest for the trees.
Is this a fallacy ? Does the argument stand on itself?
"Simplicity is easy to use but can be hard to design. You may need some creativity." Edward de Bono
No framework can come close to good programming skills. By using a framework without understanding how the underlying system works you're doomed to create bad software.
Bad software creates a bad world. Think about the following question for a while:
It's quite simple. Newcomers to the web don't even bother learning how the system works.
link to being a true PROgrammer
Instead they jump the bandwagon of whatever new trend exists. A trend that might not exist 2-3 years from now.
But C programmers need to learn how the system works before they can even try to use a library or framework.
If a C programmer doesn't know how a pointer works or forgets to deallocate memory then all his or he projects are doomed.
Using a framework is pretending to know your tool and pretending to be cool by following the herd.
If you can't implement something that a framework does yourself then you are not simply pretending, you are babooing your way into life.
Companies are in dire need of software engineers,
Companies are in dire need of software engineers, Yet all they get is hipsters.
Why is this happening?
This is a dual problem, companies get what they ask for. They ask for people who have experience in hunderds of various frameworks and things. Yet they want the best people. This is virtually impossible on multiple levels:
It's economically impossible since a person who invests time learning a framework can't invest that time in something else.
It's better to have someone who knows how to work with the barebones of a programming language than someone who possesses knowledge about 10 different frameworks yet can't work with the bare minimum.
Take for example someone who is an ace in working with any scripting language. Give them a project in C and they'll stumble.
Ask them to do any devops work and most will not know where to start.
Take a C programmer who has Linux experience and ask them to learn a new programming language or framework, it won't be a problem.
More and more experienced software engineers are migrating away from frameworks and bloated API's to simple functions anyone can understand and maintain.
I call them Software Engineers because they are Engineers. They understand how the system works and behaves.
Coming from the low level CPU instructions, going through how the TCP/IP stack works with the operating system up to the higher level programming languages.
Having an proper understanding of everything is required before you can become a engineer.
In the software world most people start with webdevelopment and go down. They take a topdown approach.
This is fine if you'd think they will ever go down to learn the basics, but this never happens.
The programmer code debt is getting higher by the day and hiring a new programmer in 2018 is 10x as complex as it was 10 years ago.
This complexity is the cause of the software bloat complexity and abstractization of simple notions.
If it was enought to know a programming language 10-15 years ago now you need to master 3-5 programming languages, 5 frameworks and a great deal of bloatware.
Not mentioning specialized software which you need to know, software that exists only to fill certain bad engineering tasks.
This way people and companies spend tremendous amounts of energy and money in training. Training for things that change so often it's tragic to even think about.
We;re creating such a complex world that we don't need a global catastrophe to occur to wipe us out.
We just need to put all of our valuable data in a start-up;s data center which then fails.
It may be better to simplify a process rather than train people to cope with the complexity. Edward de Bono
I've taken a good look on how Elixir/Erlang works and I am sometimes amazed by the simplicity with which you can implement things.
You can do things which require an abstractization of 10 different tools and programming languages with only ONE programming language and maybe a few packages.
"There is always the possibility that there is a simpler way to do some- thing. Even if that is not always the case it is always worth investing some thinking time and creative effort in trying to find a simpler approach." Edward de Bono
Elixir and Phoenix
"Good design adds value faster than it adds cost."
- Thomas C. Gale
We're going to talk about Elixir. Analyzing the way it was built.
Everything in Elixir is modulable.
Take a look at the Phoenix Framework. It's a web framework built for Elixir.
Even though it's called a "framework" it;s actually an amalgam of extremely well written libraries.
This means that Phoenix was built by people who thought long about the data structures and layered everything out just right.
They don't try to reinvent the wheel nor do they try to use 100 different obscure frameworks to do the job.
What happens is that each functionality can be used stand alone and each library can be used in Elixir projects that don;t have ANYTHING to do with the Phoenix framework.
This is a proper example of how all libraries/frameworks should be built.
Phoenix is more like a proper library than a framework. It has the basics you need to build modern web apps.
Yet it doesn't includ everything nor forces you to adopt a certain mindset. You can use whatever library you want to add extra functionalities.
This is what I call great design.
I can use the Ecto and Plug packages in any project I like as long as I follow the Ecto guidelines and the Plug guidelines.
Furthermore, basic things like templates, documentation and testing are all incorporated into Elixir.
This means that you can use the same templating system for websites, json, TCP/IP, etc.
This article tries to express a deep concern I have about programming in general.
However, I could have just sent you to read http://motherfuckingwebsite.com/.
The post neo modern poettry might have inspired the same thoughts as this article.
About the blog design and future redesign
I've always been a fan of using lightweight tools to do the job.
It ended up using PureCSS and a few native JS implementations. No jquery no other big library.
The CSS side including the theme was using 38.1 KB while the js size ended up being somewhere around 58KB including websocket support from Phoenix.
Excluding ckeditor for the blog/page editor and highlight.js for the code highlighting.
A lightweight blog resulted which fulfilled it's job. I had already started a PureCSS design and I can say that I'm impressed. I will however be converting the blog to use a different CSS framework/library.
The choice comes from the fact that I want to expand the blog system to add more complex backend functionalities for which I want to use a unified frontend theme.
Now I know how easy it is to build lightweight dynamic websites that can get huge amounts of traffic
Always try to simplify everything you do especially if you provide an API or just need basic functionality.
Frameworks do have theyr benefits for fast protyping and building small scale apps. Whenever you need power, speed and extensibility try going after a lightweight library and do the job well.
You might enjoy these similar articles:
Be the first to comment!
Add a new comment
All comments are moderated and must adhere to the terms of service.