Domain doldrums

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.


After after

Enough levels in the self-build brings more workflows. Code is only a small part of the picture. Imagining the process is more return than scrolling and dozing. The usual host is a load balancer forwarding to any server. Even that request gets unpacked by several devices, all monitored, before the exception reaches our neat console.

A part of programming is the engineering of a good repro. There are the surface answers, only assumptions, that won’t stand to scrutiny. There are suppositions strengthened by evidence, substantiated theories, and a logical presentation of facts. Honing explanation is a skill, even as you sink blearily into a different world of proprietary: the custom software of the workplace.

At some point, I need to accept the inevitable and embrace the state of things. Not as they could be, but as they are. Enough of time has been spent indoctrinated to loyal intangibles. Yet thought is that very product, some abstraction out of neuronal impulse, and I am left to wrestle against ideological ghosts.

Named layers

My fundamental fear has been learning process and method above basic technologies. Mentally, I draw an invisible line between to-be-learned and resistant-thereby. The second is usually domain-specific, a raft of organic hierarchies, patched pieces above first steps. Following history from beginnings plots a graph of growing skill. Yet its maintenance is not met with the same ardor, because someone else is its laborer.

I think we first chose programming to build things, new things, and fresh things. We did not sign up to delve thorny, scattered paths, to rebuild thought models and expired paradigms. First because case studies in code use more of the language than “Hello world,” and second it is boring. But we do not grow humans for study: we can only analyze, observe, and dissect. The advantage of programs is we do not have to wait for them to crash; we can instrument, breakpoint, and inject.

I guess the only solution is to build super-set programs: programs to generate the programs you would write, if only to be faced with an abstract modeling problem that would only theoretically be applied to create some feature-rich subset.

Daughter data

I thought what we would present as a table when we showed it to our children. Would we show the Windows default, sterile fields and Next buttons? It’s easier to brainstorm when the data is fun. If we can take things seriously while presenting a whimsical view, then we’re only a step away from the grail. Data and rules can dictate fortunes, but the mechanics are buried in namespace classes, compiled far from their source.

It’s hard to embrace a specialty. I want to learn everything; I want to learn nothing. I want to learn Windows; I want to learn OpenBSD. I like the idea of free software; my work is produced otherwise. There is no middle ground in business; there are only requirements, budgets, and time. Or is every domain the same, and we dreamed of something else?

You can’t dismiss software like you can an idea. Sweat equity bears fruit, a market, and revenue. We move and progress; purity becomes technical debt. It’s the graveyard shift on else-one’s code.

Reading docs on company time

The Help Viewer has good stuff on T-SQL, and I started looking through the query reference. It feels strange that SELECT can both initialize variables and do other things. Well, everything about SQL feels foreign. I have yet to see a tutorial that starts with

PRINT N'Hello world';

Maybe every author wants to avoid teaching SQL as an imperative language. I would treat it like Excel and VBA, except the first-class interface is the code part and not the data cells. Or it’s heresy to think so because databases need normalization and a careful design. Our edifice of persistence is a waterfall because no one wants to memorize ALTER. Yet intuition demands I master it.

System of a down

A sufficiently large backlog might take a year of grinding, and a query to view them finished might be the window and scrollbar of that length’s glory. It’s hard to imagine repeating that for another nine, all plus and minus. But it’s still writing code, and when home is a haven then work is the place to get things done.

It’s more difficult to piece puzzles. That’s not all the fault of cubes and commute: lack of optimization guarantees inefficient activity. Lazing for a TV movie, surfing anything, and writing saps time for learning. And in the business of software, learning – or producing – cannot be ignored.

I’m still seeking a way to reconcile this. Maybe apply statistics as SQL queries. Write apps to help others learn what you wish you could. Make wistful, bittersweet implementations, a paean to _why, somber silence in the ever after.

Prod paradise

It’s happened quicker in the past weeks than ever, but we switch database contexts between faux- and front-facing systems without much issue – and then records get mangled from passed-over queries. Fortunately, the involved details were only string flags and not critical messages. Every Thanksgiving, a stuffed table and every Christmas a spare disk.

I need a rapid SQL context. Somewhere to cut my teeth thereby. A place to let loose with rapid and ready. I want to treat it like a programming language, FizzBuzz with SELECTs. But it’s a declarative language without a standard library. All I mean is, if we learn by writing programs, a waterfall of frozen droplets is hard to make at once. We show a view of build 132, a single PNG.

Inquiry and incompetence

This is an incredulous dichotomy and put me in the hot seat. Such is a culture of open transmission that not asking for help is the worse action; innovation is welcomed with an initial investment of trust capital and business sense; and both are past events that launched us forward. Sufficiently complex systems have primitives which can be surveyed with StackOverflow, but their process can only be communicated among, within the tribe.

The default timebox is twenty minutes; after that, you need to ask for help. Digging your head in the sand is considered bad. Ask your mentor; ask your cube-mates; that’s why you’re all cloistered together. It’s a new concept for me. And not with an inbox salvo, but a push-leg, neck-turn sweep, a casual visit with time-saving implications.

Acting within the system means learning its efficiency and its defects. At this early stage, pushing tickets is the game. It’s a fair exchange, patches for productivity. It also keeps me grateful.

Failed to decrypt ConfigurationProvider

The build can pass and all DLLs can be present, but launching the web project brings an error on the config. The <EncryptedData> section might work for one setting but not for the following <appSettings> element. The key is not to put the referenced files in C:\Users\<username> path. Possibly IIS does not have permissions to do things there.

Moving the config files to C:\some-folder made it work. This was not discovered by me but by a workmate, whose persistence and intuition make him very skilled. This was one of those problems that could not be easily found via StackOverflow. The fundamental process that begins this fault cascade starts with creating the TFS workspace in %USERPROFILE%.

Reinvention by convenience

Database primitives for lock control allow a form of concurrent effort, a safe layer beneath ideas. I still think of databases as more filesystem than memory, a persistence addressable by an algebraic language. Whatever is shuttled in cache is treated on the web side, objects shuffling between values per fetch. We don’t read too deeply, but invent more. We don’t build on the research, but stuff pigeons in the same hole.

We strive for hard problems, but search for easy answers. We desire meaning in labor, but wish for green tests. We fatigue ourselves over records and truth, but our knowledge stagnates. Whose dreams are we building; whose name lies outside the edifice?

The hardest thing is to craft our vision of our surroundings. We have to accept a measure of oblivion. We are fortunate: things do not rain down on us from outside, threatening foundations. Our preservation has not waxed against a crucible; we fall in love with the new. You can imagine the easy rot that could set in like this; you need to fight it.