Our Confusion with Software

Our brief period of computer technology has witnessed a unique phenomenon of human history. In all this time software has been almost unimaginably bad and poses a danger to humanity. Imagine a psychosis of incredible proportions in which the people of earth have endured software programs largely dangerous to life because of the unremitting unreliability. Software developers, architects and their managers have delivered products to customers. The new relations between time, money, labor and materials create a set of conditions in which reliable, useful and solidly engineered software continues to elude our brightest minds. Continue reading

Posted in problems, software, software development, stories, Uncategorized | Leave a comment

Thinking in Code

When writing software, I believe the most productive developers actually think in code. They imagine concepts and easily translate them into the coding language of choice. They have the languages and tools so ingrained that they don’t have to bother thinking about such mundane topics. They can focus on the problem and code a solution. For them, their coding language of choice actually lives as a language.

That some programmers produce ten times the code of others raises several interesting observations. While I haven’t seen a study confirming this factor of ten, I believe the validity of this approximation. Continue reading

Posted in analysis, code reading, software, software development, techniques | Leave a comment

Code Reviews: A Discussion



Code reviews illustrate a crying need for a skill that does not appear to have much traction in the software industry. The absence of code reading skillsĀ in schools has created armies of developers unable to comprehend simple code. And, AFAIK, no classes exist to teach this important skill in industry either.

Developers commonly spend at least 90% of their time reading code rather than writing code. Debug time gets included in reading code because searching for bugs definitely involves code reading. Continue reading

Posted in analysis, code reading, code review, interview, java, problems, readings, stories, techniques, test | Tagged , , | Leave a comment

Easy Py Messaging

The advent of inexpensive but powerful single board computers such as Raspberry Pi, Arduino and others opens the possibly of connecting many of these boards to perform tasks cheaply and conveniently.

Traditionally clusters and grids of computers were relegated to tasks such as big data, heavy science applications and web services. While clusters and grids of these boards certainly has an appeal, the “normal” Maker can use networked boards as an everyday convenience.

Applications around the house that include such mundane tasks as lighting controls, yard monitoring, security concerns, media servers, and more could be connected together to create an easier interface for monitoring and control. Continue reading

Posted in 0MQ, arduino, distributed systems, linux, messaging, python, raspberry pi, raspbian, software, techniques, Uncategorized, zeromq | Leave a comment

Functional Refactoring for JavaScript

Functional programming often centers around machinery and not core principles. Functional programming is not about monads, monoids, or zippers. It is primarily about writing programs by composing generic reusable functions.

This article is about applying functional thinking when refactoring JavaScript code. Continue reading

Posted in functional, javascript, node.js, refactor, software, techniques | Leave a comment

The Actual Cost of Duplicated Code

I’ve attemptedĀ to find studies detailing the cost of duplicate code within projects. We can all spout the problems these clones produce, but can we quantify the cost from actual studies of real projects? Apparently not.

One pundit suggests the if our code base has 20% duplicated code, then eliminating it would reduce maintenance costs by 20%.

This ignores multiple key points. Consider the cost of actually removing that code and properly accessing that one and only one non-clone. Can you properly disentangle that code from its surrounding web without considerable effort? Will all those test cases work properly? How can you ensure you have not introduced dependency bugs? For the clones in multiple repositories, how should your build system handle that one and only one copy? Your QA should perform complete regressions tests on this code. The overall effort involves a significant amount of work! Continue reading

Posted in clone, software | Tagged , , , | Leave a comment

Complexity for JavaScript

The control of complexity control presents the core problem of software development. The huge variety of decisions a developer faces on a day-to-day basis cry for methods of controlling and containing complexity.

Cyclomatic complexity as defined by Thomas McCabe in 1976, has long provided the primary tool for measuring complexity. However, node.js/JavaScript contains programming and semantic structures that confound this traditional complexity definition. Continue reading

Posted in javascript, software | Tagged , , , , | Leave a comment