The Art in Software Development and Computer Programming

The Art in Software Development and Computer Programming

What precisely is Software Development, and why is it so hard? This is an inquiry that keeps on drawing in our musings. Is Computer programming advancement a building discipline? Is it is craftsmanship? Is it more like an art?

We feel that it is these things and none of them. Programming is an extraordinarily human undertaking, on the grounds that in spite of the majority of the innovative trimmings, we’re controlling minimal more than the contemplations in our heads. That is truly fleeting stuff. Fred Brooks put it rather expressively around 30 odd years prior.

The software engineer, similar to the artist, works just marginally expelled from unadulterated idea stuff. He constructs his mansions noticeable all around, from the air, making an effort of the creative energy. Hardly any media of creation are so adaptable, so natural to clean and modify, so promptly equipped for acknowledging amazing applied structures. (As we might see later, this very tractability has its own particular issues.)”

As it were, we developers are very fortunate. We get the chance to make whole universes out of the only thin air. Our own special universes, finish with our own laws of material science. We may get those laws wrong obviously, yet it’s as yet fun.

This awesome capacity includes some significant downfalls, in any case. We consistently confront the most unnerving sight known to an innovative individual: the clear page.

1. An inability to write

Authors confront the clear page, painters confront the void canvas, and software developers confront the vacant proofreader cushion. Maybe it’s not truly unfilled—an IDE may need us to indicate a couple of things first. Here we haven’t begun the undertaking yet, and right now we’re compelled to answer many inquiries: what will this thing be named, what registry will it be in, what kind of module is it, in what manner should it be ordered, et cetera.

The total purge supervisor cradle is much more dreadful. Here we have a boundless number of decisions of content with which to fill it.

So it appears we share a portion of similar issues with specialists and essayists:

  1. The most effective method to begin
  2. At the point when to stop
  3. Fulfilling the individual who dispatched the work

Authors have a name for challenges in beginning a piece: they call it Writer’s Block.

In some cases, an inability to write is a result of dread: Fear of going in the wrong bearing, of getting too far down the wrong way. Here and there it’s only a little voice in your mind saying “don’t begin yet”. Maybe your intuitive is attempting to reveal to you that you’re missing something critical that you require before you can begin.

How do other imaginative craftsmen break this kind of logjam? Painters portray; scholars compose a continuous flow. (Scholars may likewise do bunches of medications and get alcoholic, however, we’re not really pushing that specific approach.)

What at that point, is what might as well be called outlining?


Here and there you have to rehearse thoughts, just to check whether something works. You’ll draw it out generally. In case you’re not content with it, you’ll do it once more. Also, once more. All things considered, it sets aside no opportunity to do, and you can fold it up and discard it toward the end.

For example, there’s a pencil portray by Leonardo da Vinci that he utilized an examination for the Trivulzio equestrian landmark. The single section of paper contains a few brisk representations of various perspectives of the landmark: a profile of the stallion and rider without anyone else, a few perspectives of the base with the figures, et cetera. Despite the fact that the completed piece was to be thrown in bronze, da Vinci’s representations were just done in pencil, on an about piece bit of paper. These scribblings were unimportant to the point that they didn’t merit a different bit of paper! Yet, they filled their need in any case.

Pencil outlines make fine models for a figure or an oil painting. Post-It notes are fine models for GUI designs. Scripting dialects can be utilized to experiment with calculations before they’re recorded in something all the more requesting and lower level. This is the thing that we’ve traditionally called prototyping: a brisk, dispensable exercise that focuses on a specific part of the undertaking.

In programming improvement, we would prototype be able to get the points of interest in various distinctive territories:

  1. Another calculation, or a blend of calculations
  2. A part of a question demonstrate
  3. Communications and information stream between segments
  4. Any high-chance detail that requirements investigation

A somewhat extraordinary way to deal with outlining can be found in da Vinci’s Study of the Composition of the Last Supper. In this draw, you can see the beginnings of the position of figures for that acclaimed painting. The consideration isn’t put on any detail—the figures are rough and incomplete. Rather, da Vinci focused on center, adjust and stream. How would you mastermind the figures, position the hands and arms keeping in mind the end goal to get the adjust and stream of the whole piece to work out?

Now and again you have to model different parts of the entire to ensure that they function admirably together. Once more, think of the vital perspectives and dispose of insignificant points of interest. Make it simple for yourself. Focus on learning, not doing.

As we say in The Pragmatic Programmer, you should solidly have in your mind what you are doing before you do it. It’s not in the slightest degree critical to hit the nail on the head the first run through. It’s essentially critical to hit the nail on the head the last time.


Once in a while, the craftsman will outline out a more completed the process of looking piece, for example, Rembrandt’s portray for Abraham’s Sacrifice Of Isaac in 1635. It’s an unrefined outline that has the majority of the critical components of the last painting, all in generally the correct zones. It demonstrated the arrangement, the adjust of light and shadow, et cetera. The portray is exact, however not exact. There are no fine points of interest.

Media willing, you can begin with such a draw, where changes are snappy and simple to make, and after that paint directly finished best of it with the more lasting, less-lenient media to frame the last item.

To recreate that “paint over a portray” strategy in programming, we utilize a Tracer Bullet improvement. In the event that you haven’t perused The Pragmatic Programmer yet, here’s a snappy clarification of why we call it a Tracer Bullet.

There are two approaches to discharge a major big guns firearm. The primary path is to precisely gauge the separation to the objective, make up for wind speed and course, the heaviness of the law, et cetera, crunch every one of the numbers and give the requests to flame:

“Range 1000!”

whirr. click.

“Height 7.42!”

whirr. click.

“Azimuth 3.44” whirr. click.


Blast. Goodness misfortune, there. Missed.

“Range 2015!”

whirr. click.

“Height 9.15!”

and so forth…

When you’ve set up, checked and rechecked the numbers, and issued the requests to the snorts keeping an eye on the machine, the objective has since a long time ago moved.

In programming, this sort of approach can found in any technique that stresses arranging and reporting over delivering working programming. Prerequisites are for the most part finished before configuration starts. Plan and engineering, itemized in dazzling UML outlines, is immovably settled before any code is composed (probably that would make coders undifferentiated from the “snorts” who really discharge the weapon, unmindful of the objective).

Try not to misconstrue: in case you’re terminating an extremely immense rocket at a known, stable target (like a city), this works out simply extraordinary and is the ideal approach. In case you’re shooting at something more flexibility than a city, however, you require something that gives more ongoing criticism.


With tracer slugs, you just fill the magazine with phosphorus-tipped shots divided now and again. Presently you have dashes of light demonstrating to you the way to the objective ideal beside the live ammo.

For our product equal, we require a skeletally thin framework that does by nothing, yet does it from end to end, including regions, for example, the database, any middleware, the application rationale or business standards, et cetera. Since it is so thin, we can without much of a stretch move position as we endeavor to track the object. By viewing the tracer fire, we don’t need to figure the impact of the breeze, or absolutely know the area of the objective or the heaviness of the ammo. We watch the elements of the whole framework in movement and alter our mean to hit the objective under genuine conditions.

Similarly, as with the works of art, the critical thing isn’t the subtle elements, yet the connections, the obligations, the adjust, and the stream. With a demonstrated base—however thin it might be—you can continue with more noteworthy certainty towards the last item.


Up till now, we’ve discussed a temporarily uncooperative mind as it applies to you as a person. What do you do when the whole group has an aggregate instance of an inability to write? Groups that are simply beginning can rapidly end up noticeably incapacitated in the underlying disarray over parts, outline objectives, and prerequisites.

One successful approach to take care of business is to begin the undertaking off with a gathering wide, material plan session. Accumulate the majority of the engineers in a room and give sets of Lego squares, a lot of Post-It notes, whiteboards, and markers. Utilizing these, continue to discuss the framework you’ll be building and how you figure you should need to assemble it.

Keep the climate free and adaptable; this gets the group alright with change. Since this is low inactivity plan, anybody can contribute. It’s well inside any member’s aptitudes to stroll up to the whiteboard and move a PostIt-note or to get a couple of Lego pieces and rework them. That is not really valid for a CASE instrument or drawing programming: those apparatuses don’t loan themselves promptly to fast input, bunch cooperation.

Jim Highsmith offers us a most amazing recommendation: The most ideal approach to complete an undertaking speedier is to begin sooner. Impact through that inability to write, and simply begin.


Regardless of whether you’re utilizing models or tracer shots, exclusively or with a gathering, you’re working—not freezing. You’re becoming more acquainted with the subject, the medium, and the connection between the two. You’re warmed up and have begun filling that clear canvas.

In any case, we have one extra issue that the painters don’t have. We confront not one clear canvas for every task, but rather hundreds. Thousands, perhaps. One for each new module, each new class, each new source document. What would we be able to do to handle that variety of clear of canvases? The Extreme Programming[Bec00] idea of Test First Design can help.

The primary test you should compose—before you even compose the code—is an agonizingly straightforward, almost insignificant one. It appears to do nothing. Perhaps it just instantiates the new class, or basically calls the one routine you haven’t composed yet. It sounds so basic, thus idiotic, that you may be enticed not to do it.

The favorable position to the beginning with such a paltry testis, to the point, that it enables fill in the clear canvas without confronting the diversion of attempting to compose creation code. By simply composing this exceptionally basic test, you need to get a specific level of the framework set up and answer the dozen or so regular startup questions: What do I call it? Where do I place it in the advancement tree? You need to add it to variant control, and potentially to the assemble and additionally discharge methods. All of a sudden, an extremely basic test doesn’t look so basic any longer. So disregard the flawless rationale of the normal you are going to compose and get the one-line test to assemble and work first. Once that test passes, you would now be able to continue to fill in the canvas—it’s not clear any longer. You’re not composing anything starting with no outside help, you’re simply including a couple of schedules. . .

2. At the point when to Stop

We share another issue with painters: knowing when to stop. You would prefer not to stop rashly; the undertaking won’t yet be finished.But in the event that you don’t stop in time, and continue adding to it pointlessly, the sketch winds up noticeably lost in the paint and is destroyed.

There’s just a single way evade either trap: criticism. Before you even begin a specific undertaking, you need to have an approach to verify that you’re finished. For instance:

A….                                                                                      is done when. . .

Task                                                                                   Customer acknowledges

Advancement                                                                Passes practical tests

Module                                                                             Passes unit tests

Bug settle                                                                        Test that already flopped now passes

Meeting                                                                            objective for meeting accomplished

Report                                                                               Deliver precisely what’s required

Talk                                                                                     Done when gathering of people tosses spoiled natural product

Paper                                                                                 You are as yet perusing this, correct?


We had a customer once who appeared to have some trouble in the meaning of “done” with respect to code. In the wake of drudging for quite a long time and weeks on a tolerably complex bit of programming, Matthew (not his genuine name) gladly declared the Code Was Done. He went ahead to clarify that it didn’t generally create the right yield. Goodness, and once in a while, the code would crash for no obvious reason. Be that as it may, it’s finished. Tragically, unrealistic reasoning alone doesn’t enable us to get working programming out to clients.

It’s anything but difficult to blunder on the opposite side of the fence as well—have you at any point seen an engineer make a profession of one little module? Have you at any point done that? It can occur for any number of political reasons (“despite everything I’m taking a shot at XYZ, so you can’t reassign me yet”), or perhaps we simply experience passionate feelings for some especially rich piece of code. Be that as it may, rather than improving the code and better, we really run a tremendous danger of destroying it totally. Each line of code not composed is right—or possibly, ensured not to fall flat. Each line of code we compose, well, there are no certifications. Every additional line conveys some danger of disappointment, conveys an extra cost to look after, archive, and educate a newcomer. When you duplicate it out, any piece of code that isn’t totally vital acquires a shockingly expansive cost. Perhaps enough to execute the venture.

How at that point, would we be able to advise when it’s a great opportunity to stop?


Knowing when to stop is particularly hard when you can’t see the entire thing that you’re taking a shot at. Wall painting, for example, takes an uncommon eye. Incorporate programming improvement, you may just ever observe the one little bit of detail that you’re taking a shot at. On the off chance that you watch wall painting painters very close, it’s very hard to observe that the sprinkle of paint they’re dealing with is somebody’s hand or eyeball. On the off chance that you can’t see the 10,000-foot view, you won’t have the capacity to perceive how you fit in.

The contrary issue is far more detestable—assume you’re the solitary engineer on a venture of this size. Most muralists are basically painting dividers, yet any individual who’s at any point painted their home can disclose to you that roofs are a considerable measure harder than dividers, particularly when the roof is referred to covers 5,000 square feet and you need to lie on your back 20 meters over the floor to paint it. So what did Michelangelo do when wanting to paint the Sistine Chapel? A similar thing you ought to do when looked like a major errand. Michelangelo partitioned his painting into boards: discrete, unsupported zones, each of which recounts a story. Be that as it may, he did as such reasonably painstakingly, with the end goal that the boards display these attributes:

  • High attachment
  • Low coupling
  • Conceptual trustworthiness

These are things we can gain from.


What is union? As utilized here, union alludes to the board’s concentration and lucidity of reason. In the Sistine Chapel roof, each board recounts a solitary Old Testament story—totally, however with no incidental components.

In programming, the Unix order line apparatus’ theory of little, sharp devices (“complete a certain something and do it well”) is one case. Each device is barely centered around its essential assignment. Low attachment happens when you have mammoth “director” classes that endeavor to do an excessive number of different things on the double.


Coupling is identified with orthogonality[HT00]: inconsequential things ought to stay, all around, random. Following the protest arranged guideline of epitome counteracts unintended coupling, however, there are as yet different approaches to fall into the coupling trap. Michelangelo’s boards have low coupling; they are for the most part independent; there are no cases of figures coming to from one board into the following, for example. Why is that imperative?

On the off chance that you take a gander at one of the boards that depict holy messengers skimming about the atmosphere of paradise, you’ll see that one of the heavenly attendants is turning his back to, and coasting far from, alternate blessed messengers. You’ll additionally see that said holy messenger isn’t wearing any jeans. He’s somewhat distinctly “mooning” alternate holy messengers.

There is unquestionably a story that clarifies the exposed tail of the mooning holy messenger, yet for the time being how about, we expect that the Pope found the mooning heavenly attendant and requested that it be supplanted. On the off chance that the boards weren’t autonomous, at that point the substitution of one board would involve supplanting some adjoining boards too—and in the event that you needed to utilize distinctive shades on the grounds that the firsts weren’t accessible, possibly you need to supplant the following arrangement of boards that were in a roundabout way influenced. Give a bad dream a chance to start. However, the way things are, the boards are autonomous so the culpable heavenly attendant (who was clearly on Spring Break) could have been effectively supplanted with a less harsh picture and whatever is left of the task would stay unaffected.


Yet, in spite of that freedom, there is applied trustworthiness—the style, the topics, the inclination, entwine everything. In programming languages, Smalltalk has theoretical uprightness, so does Ruby, so does C. C++ doesn’t: it tries to be an excessive number of things without a moment’s delay, so you get an ungainly marriage of ideas that don’t generally fit together well.

The trap at that point is to partition up your work while keeping up an all-encompassing uprightness; each Sistine Chapel board is a different bit of craftsmanship, finish unto itself, yet together they recount an intelligible story.

For our activities, we have a few strategies we have to use the code, including measured quality, decoupling, and orthogonality. At the venture level, consider architecting the undertaking as a gathering of numerous little applications that cooperate. These associating applications may just utilize a system association or even level records, or a heavier-obligation part innovation, for example, Enterprise Java Beans (EJB).


Up to this point, we’ve focused in part on an undertaking in space, yet there is another exceptional import measurement that we have to address quickly—time. In the time measurement, you have to utilize cycles to part up a task.

As a rule, you would prefer not to go more than half a month without a certifiable deliverable. Longer than that presents too substantial of a criticism hole—you can’t get the input rapidly enough in to follow up on it. Cycles should be short and standard keeping in mind the end goal to give the most helpful input.

The other essential thing about cycles is that there is no such thing as 80% done. You can’t get 80% pregnant—it’s a Boolean condition. We need to get to the position where we just ship what truly works, and have the group concede to the importance of words like “done”. In the event that a component isn’t done, spare it for the following cycle. As the cycles are short, that is not very far away.

In time or space, an input is basic. For singular bits of code, it is imperative to have skillful unit tests that will give that input. Be careful with reasons, for example, “goodness, that code’s excessively entangled, making it impossible to test.” If it’s excessively confusing, making it impossible to test, at that point it legitimately takes after that the code is excessively muddled, making it impossible to compose! On the off chance that the code is by all accounts excessively confused, making it impossible to test, that is a notice sign that you have a poor plan. Refactor the code to make it simple to test, and you’ll not just enhance the criticism circle (and the future extensibility and viability of the framework), you’ll enhance the plan of the framework itself.

3. Fulfilling the Sponsor

Presently comes the critical step. Up until this point, we’ve discussed issues that have basic, direct answers. Sort out your framework along these lines; dependably have great unit tests; search for and apply criticism to enhance the code and the procedure; and so on. In any case, now we’re going into the substantially more unverifiable landscape—managing individuals. Specifically, managing the support: the individual or people who are paying to influence this task to happen. They have objectives and desires all their own, and most likely don’t comprehend the innovation with which we make the work. They may not know precisely what they need, but rather they need the undertaking to turn out flawless at last.

This must be the craftsman’s most exceedingly terrible bad dream. The individual paying for the picture is likewise sitting for it, and says just “Influence me To look Good”. The way that the sitter is sovereignty who orders a very much oiled guillotine doesn’t help. Sounds quite near the position we wind up in as we compose programming, isn’t that right?

How about we take a gander at it from the sitter’s perspective. You commission a craftsman to paint you. What do you get? Maybe a customary, if fairly level looking representation, for example, da Vinci’s Portrait of Ginevra Benci in 1474. Or on the other hand perhaps the reasonable, frequenting face of Vermeer’s Girl With a Pearl Earring. What about the crude (and topless) look of Matisse’s Seated Figure, the wild and broke Portrait of Picasso by Juan G

These are pictures, all understandings of a typical thing—a human face. All of which accurately actualize the prerequisites, yet all of which won’t fulfill the customer.


Each of these works of art catches the substance of a man, not only the frame. More than basic photos, each work of art looks underneath the surface to catch something that the camera can’t. As developers, we should do a similar thing, just we tend to call it reflection.

The expression “necessities gathering” suggests that prerequisites are essentially lying about, prepared to be gathered up and dealt with. That is similar to a basic photo, in that it just analyzes the self-evident, surface level components. With a specific end goal to copy the painter, we have to go past what’s requested. We have to make the mischievous inquiries to enable the customer to find what’s extremely required.

Frameworks Thinking[Sen90] recommends soliciting a base from five “whys” past the first. The great case includes a manufacturing plant floor where the advisor sees a little puddle of oil on the floor. He gets some information about it, who protests and barks a request to the cleaning group to get here and tidy up the oil. However, the advisor holds on: why is the oil there? The supervisor says it’s the cleaning team’s blame. In any case, where did the oil originate from?

A touch of researching and more than five “why” addresses later, incidentally an excessively cost-cognizant obtaining specialist got it on instances of O-ring seals for the overhead pipes. The issue was, the rings were the wrong size—that is the reason they were such an arrangement. What appeared like a cost investment funds were in certainty costing a lot of cash in different ways.

We used to be drawn closer to build up a mind-boggling, undertaking level information preparing framework that mailroom staff would use to facilitate, sort, and track approaching installment checks before their dissemination to the right office. The organization’s present manual method was mistake inclined and temperamental; checks were being lost or misrouted to the jail office.

What’s the genuine prerequisite here? A favor framework to sort and index mail for the sole motivation behind conveying it to the correct address? Gee. Appears as though there’s now a framework set up that handles that kind of thing. So rather than a pleasant, fat, year-long contract, we advised the organization to utilize an alternate postal address for every division. Give the Post Office a chance to do the arranging, ideally without opening the pieces and losing the checks.

Prerequisites are once in a while basic, and shouldn’t be fully trusted. Keep in mind, a representation is something beyond a photo.

Customary way of thinking

Indeed, even stories about necessities may require further examination.

There’s a magnificent story of innovation and specialists gone wild, building up the Fisher Space Pen. The story goes that the U.S. Government burned through a huge number of dollars of citizen’s cash building up a space pen—a pen that the space explorers could take to the moon that would work in the cruel states of weightlessness, extraordinary warmth and chilly. Innovation races to the safeguard, and builds up a wonderful pen that can record upside in a bubbling can.

The Russians, by examination, chose to utilize a pencil.

A superb story of a wrong arrangement, with the exception of one little issue. It’s not valid. Both the Russian and the U.S. space explorers utilized pencils at, to begin with, yet there was a threat of the leads breaking and shorting out electric parts, and the wood of the pencil itself was ignitable too. In an unadulterated oxygen environment, that is an extremely terrible thing. The Fisher enterprise understood this and, at its own cost, composed the Fisher Space Pen, which it at that point sold to NASA at a sensible cost. After the lamentable Apollo One fire, NASA made the Fisher pens required.

Fisher tuned in to the genuine prerequisite, even before the customer knew it. In time, NASA came to understand that they were correct. It was a suitable utilization of high-innovation to take care of an undeniable issue.


Obviously, there’s dependably the improper arrangement: designing for its own purpose. It just so happens, we happen to have a tale of this case also.

There was this organization that had built up a complex camcorder that could container and tilt, searching for a subject in its field of view. A superb, innovative arrangement looking for an issue. In time, the organization sold this innovation to an administration official to help take pictures for driving licenses. You’d go into the authorizing office and grab a chair before the machine, which would hum and snap, granulate and spin until the point when it had bolted onto your face. The glimmer would fire, and in almost no time your finished driver’s permit would be prepared.

One day, 58-year-old Fred grumbled that the lovely 20-year-old blonde young lady on his permit simply didn’t look much like him.

The organization and the administration office kinda scratched their heads; they didn’t know what the issue was. Issues like Fred’s were flying up finished, yet other at that point getting a bundle consecutively, there didn’t appear to be an example to it. At last, the police began to whine—and got very steamed—when they began seeing driver’s licenses that highlighted radiating, toon smiley faces rather than a photograph.

They found that the innovation had gone astray: sometimes, the camera wouldn’t get a bolt, and would essentially proceed to crush and hum, looking everywhere throughout the space for the subject. Following a couple of minutes of viewing the camera painstakingly investigate the roof and windows, people like Fred would get exhausted and stray. The following driver comes in, and with a twist of snaps and buzzes, the camera would snap their photo—and connect it with the past driver’s permit.

Presently the workplace staff made sense of before long what the issue was, however, they had no criticism way to the designers. They realized that once the machine escaped adjusting, they’d get terrible licenses throughout the day. So one sharp client made sense of that one could draw a glad face with marker on a bit of white paper, stick that over the seat, and the machine would joyfully snap the photo.

The genuine necessities were disregarded in the hurry to be astute, with typically poor comes about.


So how would you discover what’s in the customer’s head? At The Pragmatic Programmer’s workplaces, we utilize “extraordinary hardware” (picture a 1950’s frantic researcher’s lab loaded with humming vacuum tubes, arcing Jacob’s Ladders, and cranial inserts). On the off chance that that doesn’t work, or in case we’re out in the field where wellbeing and security confinements keep us from utilizing our “uncommon gear”, we turn to the antiquated strategy for making inquiries, both of the customer and of ourselves.

What is the client’s level of modernity? What is the setting in which the product is utilized? Ongoing on the production line floor? In an existence basic framework? For a home basic need list? What is the lifetime of the application? Unused after one week from now, or do you have to stress over the year-2038 bug? What are the dangers? Not only the advancement or specialized dangers but rather what are the support’s dangers in going up against this task?

The most ideal approach to get these inquiries replied, obviously, is to dependably include the clients as you come. Look for visit input to ensure you hear stories about anybody making smiley faces when it happens.Maintain short cycles with visit conveyances, and work with the genuine clients straightforwardly however much as could be expected. Client delegates, (for example, an administrator, chief or executive) by and large aren’t as an agent as we’d all get a kick out of the chance to think.

In our unending hurry to hop in and begin coding to the primary perfect thought we run over, we risk getting secured to a crazy thought too soon. Rather, attempt to develop rise: Allow the answer forget itself where you can. Some portion of an engineer’s activity is to give a fruitful ground in which thoughts can develop. This implies having code that is lithe: code that backings quick reassembly so you can give things a shot. Code that is anything but difficult to refactor, or that utilizations adaptable arrangement and add metadata to encourage fast—yet dependable—change, reinforced by a solid security net of finish amendment control and skilled unit tests.

Does the greater part of this truly work?

Truly, it does. We’ve done it effectively, we know other individuals who’ve done it effectively. It’s parcel of work, and it’s a great deal of diligent work, and in spite of our best aims, it may even now not be a win because of variables outside our ability to control. So for what reason do we waste time with everything?

Since, as Brooks stated, we software engineers make. We can make striking works with minimal more than the effort of the creative energy. For what reason do we do it? We do it for the joy of watching them demonstrate it off to others, of watching them use in novel ways we’d never envisioned. For the excite of watching millions on a large number of dollars in exchanges move through your application, sure about the outcomes. For the delight of building and being a piece of a group, and for the fulfillment of realizing that you began with a clear canvas and created a gem. What’s more, in the event that you’ve gone to all that inconvenience, we figure you should “sign your work”. You ought to be glad for it.

It is, after all, a work of art.

Leave a Reply

Your email address will not be published. Required fields are marked *