It’s spring time now
And the early morning birds tweet
Songs of optimism and hope
Marching into the dawn with beautiful feet
My store-front window has dated
With winter’s fashion trends
The time of protest, anger and distrust
Seemed to have come to an (un)expected end
Let me dress up my mannequins
With the colours of neighbouring outlets
For my patrons have stopped paying with clicks
Opting for next door’s sonnets
Let me drape its head with quotes
Appropriated from contexts generally unseen
Maybe it will give an appearance nouveau
And get the world to notice me
Let me give its lips a smile and song
Something that may now be hard to do
Because I’d learnt the winter dance and songs so well
And now once again I have to become something new
Yet if I don’t dress it up in seasonal vogue
They may not come inside to see
The apparel sewn by the deepest parts
The doubts and fears and hurts in polychromatic tapestry
But the more my offering changes
To match the song of the birds
The less space left inside the store
To display the original song my heart once heard
The song of freedom and beauty
The melody of glorious things unseen
The secret things that have remained hidden
Because I’ve buried them within
So let me finish dressing my mannequin
To cash in on cryptic social currency
Before it’s time to learn summer’s song
In another escape from social redundancy
The Spring Framework is great in how it provides an opinionated way to structure our applications, and because so many people are using it, it’s easy for new developers to quickly familiarise themselves with the codebase.
For those who have written unit tests in Go, the stripped down nature of the language might have produced some inconvenient duplication and seeming messiness in each test. For example, if you have a test for creating a new item, adds a generated identifier and saves in an in-memory data-store, it may look as follows:
One of the things that is most punted about with the Go language is its ease of understanding the code that has been written. The language was built to be as simple as possible, and features that the maintainers deem to be superfluous are left out. Like generics. Some view this as a disadvantage though, as it takes and increased number of key strokes and lines of code to achieve what may have been achieved by a 1 line lambda anonymous function in other languages.
Go as a language is relatively young, compared to older and more ubiquitous languages such as Java, C#, Ruby and Python. The great thing about a new language is that developers aren’t bound to patterns of writing code that may have become entrenched in other languages due to the familiarity of the most common frameworks in those languages. For example, in a simple Java Spring Web application, one has the controllers, the JPA repositories, entities, and the if-else statements in between representing the application logic. The difficulty about a relatively new language is that there isn’t a commonly agreed upon way to do things, making everyone a potential proselyte, tossed back and forth between the waves of various newly evangelized dogma.
For you fashioned my inmost being; you knitted me together in my mother’s womb. I thank you because I am awesomely made, wonderfully; your works are wonders —I know this very well. – Dawid Ben Yishai
Watching a child grow up is an interesting thing. Seeing them learn about the world around them, and unconsciously form the personality within them, can leave one enchanted by the spell of God’s providence working in the macro and minute details of the world.
2018 has been an interesting year from a personal and professional point of view. It’s like that Charles Dickens line in the opening of A Tale of 2 Cities:
It was the best of times, it was the worst of times, it was the age of wisdom, it was the age of foolishness, it was the epoch of belief, it was the epoch of incredulity, it was the season of Light, it was the season of Darkness, it was the spring of hope, it was the winter of despair, we had everything before us, we had nothing before us, we were all going direct to Heaven, we were all going direct the other way.
For most developed countries, a strong bureaucracy (i.e. a well functioning state) came before democracy. The exception to this is the United States of America. This is the claim made by Yoshihiro Francis Fukuyama in his 2014 book Political Order and Political Decay.
Over the past little while, I have increasingly found myself having the responsibility in making and advising on technology architectural decisions for various organisations. When working on small and simple use-cases, these decisions are normally about the technology stack of a single application and the structure of that application. But when working within larger enterprises, complexity changes the scope of the decision making from one application to multiple systems interacting with each other.
When creating software applications, separating our code into smaller, simpler units helps in maintaining the codebase, making it easier to understand and thus quicker to make future changes.