Application development, for me, was the veneer of the front-end: the endless debate over frameworks, arguments for usability, and a kind of crafting zeal for single-line statements. But actually none of that matters and is rewritten every few years anyway.
What is most important to business is the sales they captured, the clients they won, and all the metrics between. History is written by the victors, and data is that lifeblood. There is no harder reality than the belief in electric persistence, meanings in tables as magnetic bits on a platter. To value it as they do is to align yourself to another realization.
You can’t be useful to anyone if you do not value data: yours, ephemeral pieces, disposable, not worth an app to lay over – of course it will seem meaningless. If everything is a permutation of structs, romancing the kernel is Narcissus and the pool. Your Echo is real and needs you to live in the technology of our times.
Even 16 GB is exhausted at the boundary between client and server: a localhost with requests on a page, toward a microservice tenant, though the latter is inside a Visual Studio instance and appears pretty simple. In the space between theory and hard problems are bugs, repeat events, an emergent property of asynchronous sends. Here it is not the paper or the book, but observed phenomena bubbling from end-user to developer. This is the land of race conditions and head scratching.
Being reproducible is the name of the game. It has to be demonstrable to QA, to fellow devs, and to anyone watching. Getting there is a form of creativity, skipping validations and hard-coding trial-and-error runs. All that time spent poring over a needle gives experience for the haystack. Then you wish for twice the RAM.
The Repository pattern is to take a class and stuff all your raw SQL statements therein, snippets organized as methods. Moving away from it felt like sublimation: that is, to expose those same calls as service endpoints. If it’s useful in private, surely it could be useful to others elsewhere.
I am a little divided in what to speak, because so much of it is in language and libs. Others can dance the line with owned opinions declared, but those same bits expose more than is wont. Maybe twenty-minute topics will help; I need to catch up on dates.
A single Pomodoro won’t change the world, but a mountain of them makes a useful index. If a tiny thing is learned in a fraction’s span, I think a multiple of it is a karmic dividend.
I have a chance to put my mark on a thing, originally labored over by a leaving man, to pursue other dreams. For this I put for three and some nausea, because I had wanted hard drives, a firewall, and a board full of PCI NICs. But I have gotten to thinking of work as life, that I would be remiss in admitting less than the zeal of those higher, whose life goals and mine are aligned along a result-oriented stream.
Today I was looking at a modern pic and tearing up, because this place is a rollercoaster: you hate everything one moment, and dream for showing your capability the next. You shuffle forward in numbness and swipe twice. Then I made a promise for us: I would keep the fragile and vulnerable here, so that you could see us as humans. After, for want of chewing over tablet-light, choosing a post on algorithms.
It used to be I was inventing new things daily. Now I plan to print and plan: pencils and sketches, boxes and notes, desk checks and mental introspection. If I can avoid reflection, maybe I will achieve a notion of speed.
I used to have so much pride in not having documentation. Just look at the code, I would say. It’s short enough. And it was, being scripts and all – but what do I think as I wade through namespace classes, gazing blearily at peeked file after file? I wish there were documentation: someone to hand-hold me through all of this, a pretty-print manual with a nice font, a guide – something to bookmark, like hidden gems in MSDN. I guess if you need it, write it.
Writing pseudocode after the fact is like chewing your food. The eyes skip everything. Typing the explanation gives time to digest. There is design up-front, which everyone knows and few do. Documenting legacy code forces me to think clearly. Maybe outlines are useful solely to constrain a storm into lines. Some system of organization after the draft helps.
I have not written serious code in a while. Any period of longer than a week for a working programmer is an eternity. I’m close to grabbing RATFOR or starting C. Anything to be wrestling with off-by-ones, mentally turning sludge into beliefs – surety in subtraction, knowing how the loop terminates.
Laying out a spreadsheet for which URL hits which database table, I realized methods were mostly SQL statements with a mapping to objects. Our browsers hit web apps serving persistence, even as file writes are perpetually saved games and level loads. Caching is memory, but each user is a brief flit of packets. We are less concerned with data structures and more concerned with the structure of data.
If we bow to the notion of serialized tables and a language to query them, life is smoother. We use the abstractions laid out for us. Someone is working on libraries for our future problems. Vendors will help us get there. In an ecosystem this perfect, it’s disconcerting to feel dissatisfied.
Maybe at higher levels, the ownership of strings is important. Naming is creating; persuasion is coding. Complex figures require an apology; debugging is reasoning from the stack trace. We don’t toss bones, but we still look for patterns.
Business is a means of selling capability. Whether it is present or absent, word-of-mouth begins the assurance of paper. Technology strives to fulfill expectations, requirements heretofore unannounced and invisible, given form by mind and vision. We are forever instruments to this or the other, means to ends, because our interface is built for inward scrutiny.
In a land of developers, the buck stops with you. There is no outsource vendor and no meat-sack backup. Your brain, your team’s brains – you’re it. The business could slow down by each missed milestone. Regardless of your ideology, profits start from promises. This is the moment to gear up, buckle down, and treat work as a second life.
I wish I could feel the same with each side project. Glimmers of enthusiasm flicker between bouts of apathy. I don’t know which language to use; everyone is advancing with free search and open source.
Diving into foreign code is the worst-first method to chase down an end-user bug. If the framework allows, it is better to investigate as the analysts and support do: the process is a black box sitting on a remote machine, and reported observations rely on visible strings. For them, the business domain is law; the system must adhere to mental expectations. Taking on these shoes is a form of convenient empathy.
Reproducing the issue is a form of simulation. At least a repeatable one helps with verification and acceptance. Or our explanations are muddled, those the final pieces after a collection of conditionals and exceptions. Did you notice the messages they see are usually the last thing typed? We were too busy writing the function from top to bottom.
I fancy printing source and pawing at it, but legacy has cruft and the toner would dry. Each ticket is a tiny test, each day an investment, and performance is somewhere tracked by starts and closes. It’s okay to be slow; just don’t be late.
It’s a long path between code and end-user. Scaling outside the cloud takes more hours than a useful lifetime. Maybe it’s better to join a convoy than pontificate by the wayside. Having been born on the earth, too far to grasp whichever pieces heaven missed, I’m forced to think between project-oriented learning and first-principles learning. The window for self-directed investment seems to be closing.
On the other hand, it should be possible to provide value without compromising my own. The end product might not be the best possible, but if it serves purpose with less icing, I think it will be alright. I guess with free software – or even open-source software – the use case broadens with the usefulness.
Someday I would like to post iterations on inventions, refactoring old projects to fit new tech, spurring forward created ideas to each next aim. A life of this is not bad. I need to make it so.
Intermittent errors traced by the breadcrumbs of table rows, like chasing after a theoretical particle by etchings on plate: only a persistent observance could start the thread after it. Though busy, the issue is always – as ever – to solve in a sane span, without a blindsiding change, a small convenient for easy review.
Even with global search, diving into the code is a morass of constant confusion. Not being able to execute a stack trace any-which-where is frustrating. I’m not sure where this expectation stemmed, except perhaps from early ease when “Hello world” could be scrutinized by gdb.
Debugging is about reproducing the issue. All I’m left with is output and faith. Can I not simulate the universe, pause at breakpoints, and inspect state by discrete forwards? Here the mess broke, and here it did not; by satisfied patch and early lunch, we satisfy a teaspoon of doubt.